How to use captureException in Nuxt on Cloudflare

[remihuigen]

Very happy with the Cloudflare Nitro plugin as introduced in #15597, that captures unhandled errors 👍

But I'm not clear on how we can use Sentry.captureException (or other methods for that matter)... The docs show this example, but that will not work

import * as Sentry from "@sentry/nuxt";
try {
  aFunctionThatMightFail();
} catch (err) {
  Sentry.captureException(err);
}

Ive tried this approach but with explicitly initializing sentry, but that does not work either, at least not is a cloudfalre environment (it does work on node)

import * as Sentry from '@sentry/nuxt'
import { getSampleRates } from '~/config/sentry'

export const useSentry = () => {
	const sentry = Sentry
	const {
		sentry: { dsn, environment, enabledServer, enabled }
	} = useRuntimeConfig()

	if (!Sentry.isInitialized()) {
		console.log('Initializing useSentry...')
		
		const sampleRates = getSampleRates(environment ?? 'prod')
		const { sampleRate, tracesSampleRate } = sampleRates

		sentry.init({
			enabled: enabledServer && enabled,
			dsn,
			sampleRate,
			tracesSampleRate,
			environment: import.meta.dev ? 'dev' : environment
		})
	}

	return { sentry, captureException: sentry.captureException.bind(sentry) }
}

Any help would be welcome!

[remihuigen]

@s1gr1d Maybe you have some insight into the matter? Thanks :)

[s1gr1d]

Hi, using the exported methods like captureException should work as well. Can you maybe provide a small reproduction example?

The docs for setting up the plugin can be found here: https://docs.sentry.io/platforms/javascript/guides/cloudflare/frameworks/nuxt/

Make sure that you deleted the sentry.server.config.ts file and that node compatibility is enabled. Can you maybe share some logs you get at startup (debug: true)?

[remihuigen]

I try to make a reproduction tomorrow. I believe I have followed the docs exactly; so im not using a sentry.server.config.ts

What types of logs are you looking for, anything specific?

Basically I'm doing this in my setup

// config/sentry.ts
import type { Mode } from '~~/shared/types/primitives'
import type { ModuleOptions } from '@sentry/nuxt/module'

/**
 * Full Sentry configuration object with sensitive data
 */
export const sentryConfig = {
	enabled: process.env.SENTRY_ENABLED === 'true',
	enabledClient: process.env.SENTRY_CLIENT_ENABLED === 'true',
	enabledServer: process.env.SENTRY_SERVER_ENABLED === 'true',
	sourceMapsEnabled: process.env.SENTRY_SOURCE_MAPS_ENABLED === 'true',
	dsn: process.env.SENTRY_DSN,
	projectId: process.env.SENTRY_PROJECT_ID,
	org: process.env.SENTRY_ORG,
	project: process.env.SENTRY_PROJECT,
	projectKey: process.env.SENTRY_PROJECT,
	authToken: process.env.SENTRY_AUTH_TOKEN,
	environment: process.env.MODE as Mode
}

/**
 * The sentry config for Public Runtime Config
 */
export const sentryPublicConfig = {
	enabled: sentryConfig.enabled,
	enabledClient: sentryConfig.enabledClient,
	dsn: sentryConfig.dsn,
	environment: sentryConfig.environment
}

/**
 * Sentry module options
 */
export const sentryModuleOptions = {
	org: sentryConfig.org,
	project: sentryConfig.project,
	authToken: sentryConfig.authToken,
	sourcemaps: {
		disable: !sentryConfig.sourceMapsEnabled
	}
} satisfies ModuleOptions

// nuxt.config.ts

export default defineNuxtConfig({
	compatibilityDate: '2025-12-16',

	modules: ['@sentry/nuxt/module'],

	nitro: {
		preset: 'cloudflare_module',
		cloudflare: {
			deployConfig: true,
			nodeCompat: true
		}
	},

	sourcemap: sentryConfig.sourceMapsEnabled ? { client: 'hidden', server: true } : false,

	sentry: {
		...sentryModuleOptions
	},

	runtimeConfig: {
		sentry: sentryConfig,

		public: {
			sentry: sentryPublicConfig,
		}
	},
})

// sentry.client.config.ts
import {
	browserTracingIntegration,
	captureConsoleIntegration,
	init,
	replayIntegration
} from '@sentry/nuxt'

import { getSampleRates, ignoreErrors } from './config/sentry'

const config = useRuntimeConfig()

const { environment, dsn, enabledClient, enabled } = config.public.sentry

init({
	// If set up, you can use your runtime config here
	enabled: enabledClient && enabled,
	dsn,
	environment,

	integrations: [
		browserTracingIntegration(),
		replayIntegration(),
		captureConsoleIntegration({ levels: ['error', 'warn'] })
	],
	...getSampleRates(environment),

	ignoreErrors
})

// server/plugins/sentry.ts
import { sentryCloudflareNitroPlugin } from '@sentry/nuxt/module/plugins'
import { getSampleRates, ignoreErrors } from '../../config/sentry'

export default defineNitroPlugin(
	sentryCloudflareNitroPlugin(() => {
		const {
			sentry: { dsn, environment, enabledServer, enabled }
		} = useRuntimeConfig()

		const sampleRates = getSampleRates(environment ?? 'prod')

		const { sampleRate, tracesSampleRate } = sampleRates

		return {
			enabled: enabledServer && enabled,
			dsn,
			environment: import.meta.dev ? 'dev' : environment,
			requestDataOptions: {
				allowedSearchParams: true,
				allowedHeaders: true
			},
			sampleRate,
			tracesSampleRate,
			ignoreErrors
		}
	})
)

And lastly I have a server util for usage in server routes. Tried some different things to get this working (with initializing, without), but no luck so far.

// server/utils/sentry.ts
import * as Sentry from '@sentry/nuxt'
import { getSampleRates } from '../../config/sentry'

export const useSentry = () => {
	const sentry = Sentry
	const {
		sentry: { dsn, environment, enabledServer, enabled }
	} = useRuntimeConfig()

	if (!Sentry.isInitialized()) {
		console.log('Initializing useSentry...')
		const sampleRates = getSampleRates(environment ?? 'prod')
		const { sampleRate, tracesSampleRate } = sampleRates

		sentry.init({
			enabled: enabledServer && enabled,
			dsn,
			sampleRate,
			tracesSampleRate,
			environment: import.meta.dev ? 'dev' : environment
		})
	}

	return { sentry, captureException: sentry.captureException.bind(sentry) }
}

My end goal here is to do something like

import { useSentry } from '~~/server/utils/sentry'
export default defineEventHandler((event) => {
	try {
		throw new Error('Error for Sentry to capture')
	} catch (error) {
		useSentry().captureException(error)
	}
	
	return {
		message: 'Sentry test error has been sent.'
	}
})

[s1gr1d]

I created a minimal reproduction here (it's very minimal, I'm not using a lot of settings here): https://github.com/s1gr1d/nuxt-cloudflare-18587
Maybe you can use this as a base for your reproduction. However, captureException works in this case.

And regarding useSentry(): Is there a specific reason you want to use it like this and not with a regular import from @sentry/nuxt?

[remihuigen]

Thanks for the effort. Did some testing based on your repro, which led me to two errors on my side (one related to sampling rates, one related to an early return statements before captureException was called)

As for why we are using useSentry(), two reasons:

• naming convention
• wrapping sentry in a server utility makes Nuxt auto import is, eliminating the need to import is every route handler