= async () => {
- return workflowStepWithSentry(this._instanceId, this._options, async () => {
- return startSpan(
- {
- op: 'function.step.do',
- name,
- attributes: {
- 'cloudflare.workflow.timeout': config?.timeout,
- 'cloudflare.workflow.retries.backoff': config?.retries?.backoff,
- 'cloudflare.workflow.retries.delay': config?.retries?.delay,
- 'cloudflare.workflow.retries.limit': config?.retries?.limit,
- [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.faas.cloudflare.workflow',
- [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: 'task',
- },
- },
- async span => {
- try {
- const result = await userCallback();
- span.setStatus({ code: 1 });
- return result;
- } catch (error) {
- captureException(error, { mechanism: { handled: true, type: 'cloudflare' } });
- throw error;
- } finally {
- this._ctx.waitUntil(flush(2000));
- }
+ return startSpan(
+ {
+ op: 'function.step.do',
+ name,
+ scope: scopeForStep,
+ attributes: {
+ 'cloudflare.workflow.timeout': config?.timeout,
+ 'cloudflare.workflow.retries.backoff': config?.retries?.backoff,
+ 'cloudflare.workflow.retries.delay': config?.retries?.delay,
+ 'cloudflare.workflow.retries.limit': config?.retries?.limit,
+ [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.faas.cloudflare.workflow',
+ [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: 'task',
},
- );
- });
+ },
+ async span => {
+ try {
+ const result = await userCallback();
+ span.setStatus({ code: 1 });
+ return result;
+ } catch (error) {
+ captureException(error, { mechanism: { handled: true, type: 'auto.faas.cloudflare.workflow' } });
+ throw error;
+ } finally {
+ this._ctx.waitUntil(flush(2000));
+ }
+ },
+ );
};
return config ? this._step.do(name, config, instrumentedCallback) : this._step.do(name, instrumentedCallback);
@@ -183,7 +163,29 @@ export function instrumentWorkflowWithSentry<
get(obj, prop, receiver) {
if (prop === 'run') {
return async function (event: WorkflowEvent, step: WorkflowStep): Promise {
- return obj.run.call(obj, event, new WrappedWorkflowStep(event.instanceId, ctx, options, step));
+ setAsyncLocalStorageAsyncContextStrategy();
+
+ return withIsolationScope(async isolationScope => {
+ const client = init({ ...options, enableDedupe: false });
+ isolationScope.setClient(client);
+
+ addCloudResourceContext(isolationScope);
+
+ return withScope(async scope => {
+ const propagationContext = await propagationContextFromInstanceId(event.instanceId);
+ scope.setPropagationContext(propagationContext);
+
+ try {
+ return await obj.run.call(
+ obj,
+ event,
+ new WrappedWorkflowStep(event.instanceId, ctx, options, step),
+ );
+ } finally {
+ ctx.waitUntil(flush(2000));
+ }
+ });
+ });
};
}
return Reflect.get(obj, prop, receiver);
diff --git a/packages/cloudflare/test/handler.test.ts b/packages/cloudflare/test/handler.test.ts
index ddd4b0010ec0..97e93199ea31 100644
--- a/packages/cloudflare/test/handler.test.ts
+++ b/packages/cloudflare/test/handler.test.ts
@@ -305,7 +305,7 @@ describe('withSentry', () => {
expect(captureExceptionSpy).toHaveBeenCalledTimes(1);
expect(captureExceptionSpy).toHaveBeenLastCalledWith(error, {
- mechanism: { handled: false, type: 'cloudflare' },
+ mechanism: { handled: false, type: 'auto.faas.cloudflare.scheduled' },
});
});
@@ -545,7 +545,7 @@ describe('withSentry', () => {
expect(captureExceptionSpy).toHaveBeenCalledTimes(1);
expect(captureExceptionSpy).toHaveBeenLastCalledWith(error, {
- mechanism: { handled: false, type: 'cloudflare' },
+ mechanism: { handled: false, type: 'auto.faas.cloudflare.email' },
});
});
@@ -784,7 +784,7 @@ describe('withSentry', () => {
expect(captureExceptionSpy).toHaveBeenCalledTimes(1);
expect(captureExceptionSpy).toHaveBeenLastCalledWith(error, {
- mechanism: { handled: false, type: 'cloudflare' },
+ mechanism: { handled: false, type: 'auto.faas.cloudflare.queue' },
});
});
@@ -1027,7 +1027,7 @@ describe('withSentry', () => {
expect(captureExceptionSpy).toHaveBeenCalledTimes(1);
expect(captureExceptionSpy).toHaveBeenLastCalledWith(error, {
- mechanism: { handled: false, type: 'cloudflare' },
+ mechanism: { handled: false, type: 'auto.faas.cloudflare.tail' },
});
});
@@ -1102,7 +1102,7 @@ describe('withSentry', () => {
expect(captureExceptionSpy).toHaveBeenCalledTimes(1);
expect(captureExceptionSpy).toHaveBeenLastCalledWith(error, {
- mechanism: { handled: false, type: 'cloudflare' },
+ mechanism: { handled: false, type: 'auto.faas.cloudflare.error_handler' },
});
expect(errorHandlerResponse?.status).toBe(500);
});
diff --git a/packages/cloudflare/test/request.test.ts b/packages/cloudflare/test/request.test.ts
index ad323e3c5b5a..d6d0de5824a1 100644
--- a/packages/cloudflare/test/request.test.ts
+++ b/packages/cloudflare/test/request.test.ts
@@ -192,7 +192,7 @@ describe('withSentry', () => {
expect(captureExceptionSpy).toHaveBeenCalledTimes(1);
expect(captureExceptionSpy).toHaveBeenLastCalledWith(error, {
- mechanism: { handled: false, type: 'cloudflare' },
+ mechanism: { handled: false, type: 'auto.http.cloudflare' },
});
});
diff --git a/packages/cloudflare/test/workflow.test.ts b/packages/cloudflare/test/workflow.test.ts
index c403023fb525..2ca2ccd28e46 100644
--- a/packages/cloudflare/test/workflow.test.ts
+++ b/packages/cloudflare/test/workflow.test.ts
@@ -1,4 +1,5 @@
/* eslint-disable @typescript-eslint/unbound-method */
+import { startSpan } from '@sentry/core';
import type { WorkflowEvent, WorkflowStep, WorkflowStepConfig } from 'cloudflare:workers';
import { beforeEach, describe, expect, test, vi } from 'vitest';
import { deterministicTraceIdFromInstanceId, instrumentWorkflowWithSentry } from '../src/workflows';
@@ -96,7 +97,8 @@ describe.skipIf(NODE_MAJOR_VERSION < 20)('workflows', () => {
expect(mockStep.do).toHaveBeenCalledTimes(1);
expect(mockStep.do).toHaveBeenCalledWith('first step', expect.any(Function));
- expect(mockContext.waitUntil).toHaveBeenCalledTimes(1);
+ // We flush after the step.do and at the end of the run
+ expect(mockContext.waitUntil).toHaveBeenCalledTimes(2);
expect(mockContext.waitUntil).toHaveBeenCalledWith(expect.any(Promise));
expect(mockTransport.send).toHaveBeenCalledTimes(1);
expect(mockTransport.send).toHaveBeenCalledWith([
@@ -161,7 +163,8 @@ describe.skipIf(NODE_MAJOR_VERSION < 20)('workflows', () => {
expect(mockStep.do).toHaveBeenCalledTimes(1);
expect(mockStep.do).toHaveBeenCalledWith('first step', expect.any(Function));
- expect(mockContext.waitUntil).toHaveBeenCalledTimes(1);
+ // We flush after the step.do and at the end of the run
+ expect(mockContext.waitUntil).toHaveBeenCalledTimes(2);
expect(mockContext.waitUntil).toHaveBeenCalledWith(expect.any(Promise));
expect(mockTransport.send).toHaveBeenCalledTimes(1);
expect(mockTransport.send).toHaveBeenCalledWith([
@@ -232,8 +235,10 @@ describe.skipIf(NODE_MAJOR_VERSION < 20)('workflows', () => {
expect(mockStep.do).toHaveBeenCalledTimes(1);
expect(mockStep.do).toHaveBeenCalledWith('sometimes error step', expect.any(Function));
- expect(mockContext.waitUntil).toHaveBeenCalledTimes(2);
+ // One flush for the error transaction, one for the retry success, one at end of run
+ expect(mockContext.waitUntil).toHaveBeenCalledTimes(3);
expect(mockContext.waitUntil).toHaveBeenCalledWith(expect.any(Promise));
+ // error event + failed transaction + successful retry transaction
expect(mockTransport.send).toHaveBeenCalledTimes(3);
// First we should get the error event
@@ -267,7 +272,7 @@ describe.skipIf(NODE_MAJOR_VERSION < 20)('workflows', () => {
expect.objectContaining({
type: 'Error',
value: 'Test error',
- mechanism: { type: 'cloudflare', handled: true },
+ mechanism: { type: 'auto.faas.cloudflare.workflow', handled: true },
}),
],
},
@@ -376,11 +381,11 @@ describe.skipIf(NODE_MAJOR_VERSION < 20)('workflows', () => {
expect(mockStep.do).toHaveBeenCalledTimes(1);
expect(mockStep.do).toHaveBeenCalledWith('sometimes error step', expect.any(Function));
- expect(mockContext.waitUntil).toHaveBeenCalledTimes(2);
+ // One flush for the error event and one at end of run
+ expect(mockContext.waitUntil).toHaveBeenCalledTimes(3);
expect(mockContext.waitUntil).toHaveBeenCalledWith(expect.any(Promise));
- // We should get the error event and then nothing else. No transactions
- // should be sent
+ // We should get the error event and then nothing else. No transactions should be sent
expect(mockTransport.send).toHaveBeenCalledTimes(1);
expect(mockTransport.send).toHaveBeenCalledWith([
@@ -421,4 +426,41 @@ describe.skipIf(NODE_MAJOR_VERSION < 20)('workflows', () => {
],
]);
});
+
+ test('Step.do span becomes child of surrounding custom span', async () => {
+ class ParentChildWorkflow {
+ constructor(_ctx: ExecutionContext, _env: unknown) {}
+
+ async run(_event: Readonly>, step: WorkflowStep): Promise {
+ await startSpan({ name: 'custom span' }, async () => {
+ await step.do('first step', async () => {
+ return { files: ['a'] };
+ });
+ });
+ }
+ }
+
+ const TestWorkflowInstrumented = instrumentWorkflowWithSentry(getSentryOptions, ParentChildWorkflow as any);
+ const workflow = new TestWorkflowInstrumented(mockContext, {}) as ParentChildWorkflow;
+ const event = { payload: {}, timestamp: new Date(), instanceId: INSTANCE_ID };
+ await workflow.run(event, mockStep);
+
+ // Flush after step.do and at end of run
+ expect(mockContext.waitUntil).toHaveBeenCalledTimes(2);
+ expect(mockTransport.send).toHaveBeenCalledTimes(1);
+
+ const sendArg = mockTransport.send.mock.calls[0]![0] as any;
+ const items = sendArg[1] as any[];
+ const rootSpanItem = items.find(i => i[0].type === 'transaction');
+ expect(rootSpanItem).toBeDefined();
+ const rootSpan = rootSpanItem[1];
+
+ expect(rootSpan.transaction).toBe('custom span');
+ const rootSpanId = rootSpan.contexts.trace.span_id;
+
+ // Child span for the step.do with the custom span as parent
+ const stepSpan = rootSpan.spans.find((s: any) => s.description === 'first step' && s.op === 'function.step.do');
+ expect(stepSpan).toBeDefined();
+ expect(stepSpan.parent_span_id).toBe(rootSpanId);
+ });
});
diff --git a/packages/core/src/build-time-plugins/buildTimeOptionsBase.ts b/packages/core/src/build-time-plugins/buildTimeOptionsBase.ts
index 5c40d53174c1..e43160cc03ab 100644
--- a/packages/core/src/build-time-plugins/buildTimeOptionsBase.ts
+++ b/packages/core/src/build-time-plugins/buildTimeOptionsBase.ts
@@ -257,6 +257,13 @@ interface ReleaseOptions {
*/
name?: string;
+ /**
+ * Whether the plugin should inject release information into the build for the SDK to pick it up when sending events (recommended).
+ *
+ * @default true
+ */
+ inject?: boolean;
+
/**
* Whether to create a new release.
*
diff --git a/packages/core/src/client.ts b/packages/core/src/client.ts
index 88fab9107874..75a0d5ed49d2 100644
--- a/packages/core/src/client.ts
+++ b/packages/core/src/client.ts
@@ -415,10 +415,9 @@ export abstract class Client {
env = addItemToEnvelope(env, createAttachmentEnvelopeItem(attachment));
}
- const promise = this.sendEnvelope(env);
- if (promise) {
- promise.then(sendResponse => this.emit('afterSendEvent', event, sendResponse), null);
- }
+ // sendEnvelope should not throw
+ // eslint-disable-next-line @typescript-eslint/no-floating-promises
+ this.sendEnvelope(env).then(sendResponse => this.emit('afterSendEvent', event, sendResponse));
}
/**
@@ -879,12 +878,11 @@ export abstract class Client {
if (this._isEnabled() && this._transport) {
return this._transport.send(envelope).then(null, reason => {
DEBUG_BUILD && debug.error('Error while sending envelope:', reason);
- return reason;
+ return {};
});
}
DEBUG_BUILD && debug.error('Transport disabled');
-
return resolvedSyncPromise({});
}
diff --git a/packages/core/src/eventProcessors.ts b/packages/core/src/eventProcessors.ts
index 3bebe71b9316..ca41e5ee2a03 100644
--- a/packages/core/src/eventProcessors.ts
+++ b/packages/core/src/eventProcessors.ts
@@ -3,7 +3,7 @@ import type { Event, EventHint } from './types-hoist/event';
import type { EventProcessor } from './types-hoist/eventprocessor';
import { debug } from './utils/debug-logger';
import { isThenable } from './utils/is';
-import { SyncPromise } from './utils/syncpromise';
+import { rejectedSyncPromise, resolvedSyncPromise } from './utils/syncpromise';
/**
* Process an array of event processors, returning the processed event (or `null` if the event was dropped).
@@ -14,24 +14,33 @@ export function notifyEventProcessors(
hint: EventHint,
index: number = 0,
): PromiseLike {
- return new SyncPromise((resolve, reject) => {
- const processor = processors[index];
- if (event === null || typeof processor !== 'function') {
- resolve(event);
- } else {
- const result = processor({ ...event }, hint) as Event | null;
+ try {
+ const result = _notifyEventProcessors(event, hint, processors, index);
+ return isThenable(result) ? result : resolvedSyncPromise(result);
+ } catch (error) {
+ return rejectedSyncPromise(error);
+ }
+}
+
+function _notifyEventProcessors(
+ event: Event | null,
+ hint: EventHint,
+ processors: EventProcessor[],
+ index: number,
+): Event | null | PromiseLike {
+ const processor = processors[index];
+
+ if (!event || !processor) {
+ return event;
+ }
+
+ const result = processor({ ...event }, hint);
+
+ DEBUG_BUILD && result === null && debug.log(`Event processor "${processor.id || '?'}" dropped event`);
- DEBUG_BUILD && processor.id && result === null && debug.log(`Event processor "${processor.id}" dropped event`);
+ if (isThenable(result)) {
+ return result.then(final => _notifyEventProcessors(final, hint, processors, index + 1));
+ }
- if (isThenable(result)) {
- void result
- .then(final => notifyEventProcessors(processors, final, hint, index + 1).then(resolve))
- .then(null, reject);
- } else {
- void notifyEventProcessors(processors, result, hint, index + 1)
- .then(resolve)
- .then(null, reject);
- }
- }
- });
+ return _notifyEventProcessors(result, hint, processors, index + 1);
}
diff --git a/packages/core/src/index.ts b/packages/core/src/index.ts
index ef61364ab3f0..b971aa8b43a3 100644
--- a/packages/core/src/index.ts
+++ b/packages/core/src/index.ts
@@ -124,6 +124,7 @@ export { captureFeedback } from './feedback';
export type { ReportDialogOptions } from './report-dialog';
export { _INTERNAL_captureLog, _INTERNAL_flushLogsBuffer, _INTERNAL_captureSerializedLog } from './logs/exports';
export { consoleLoggingIntegration } from './logs/console-integration';
+export { createConsolaReporter } from './integrations/consola';
export { addVercelAiProcessors } from './utils/vercel-ai';
export { _INTERNAL_getSpanForToolCallId, _INTERNAL_cleanupToolCallSpan } from './utils/vercel-ai/utils';
export { instrumentOpenAiClient } from './utils/openai';
@@ -131,7 +132,12 @@ export { OPENAI_INTEGRATION_NAME } from './utils/openai/constants';
export { instrumentAnthropicAiClient } from './utils/anthropic-ai';
export { ANTHROPIC_AI_INTEGRATION_NAME } from './utils/anthropic-ai/constants';
export type { OpenAiClient, OpenAiOptions, InstrumentedMethod } from './utils/openai/types';
-export type { AnthropicAiClient, AnthropicAiOptions, AnthropicAiInstrumentedMethod } from './utils/anthropic-ai/types';
+export type {
+ AnthropicAiClient,
+ AnthropicAiOptions,
+ AnthropicAiInstrumentedMethod,
+ AnthropicAiResponse,
+} from './utils/anthropic-ai/types';
export type { FeatureFlag } from './utils/featureFlags';
export {
@@ -404,7 +410,11 @@ export type { Stacktrace, StackParser, StackLineParser, StackLineParserFn } from
export type { PropagationContext, TracePropagationTargets, SerializedTraceData } from './types-hoist/tracing';
export type { StartSpanOptions } from './types-hoist/startSpanOptions';
export type { TraceparentData, TransactionSource } from './types-hoist/transaction';
-export type { CustomSamplingContext, SamplingContext } from './types-hoist/samplingcontext';
+export type {
+ TracesSamplerSamplingContext,
+ CustomSamplingContext,
+ SamplingContext,
+} from './types-hoist/samplingcontext';
export type {
DurationUnit,
InformationUnit,
diff --git a/packages/core/src/integrations/captureconsole.ts b/packages/core/src/integrations/captureconsole.ts
index e491efedd83f..d5d34bd554aa 100644
--- a/packages/core/src/integrations/captureconsole.ts
+++ b/packages/core/src/integrations/captureconsole.ts
@@ -65,7 +65,7 @@ function consoleHandler(args: unknown[], level: string, handled: boolean): void
addExceptionMechanism(event, {
handled,
- type: 'console',
+ type: 'auto.core.capture_console',
});
return event;
diff --git a/packages/core/src/integrations/consola.ts b/packages/core/src/integrations/consola.ts
new file mode 100644
index 000000000000..cdae9efa17dc
--- /dev/null
+++ b/packages/core/src/integrations/consola.ts
@@ -0,0 +1,312 @@
+import type { Client } from '../client';
+import { getClient } from '../currentScopes';
+import { _INTERNAL_captureLog } from '../logs/exports';
+import { formatConsoleArgs } from '../logs/utils';
+import type { LogSeverityLevel } from '../types-hoist/log';
+
+/**
+ * Options for the Sentry Consola reporter.
+ */
+interface ConsolaReporterOptions {
+ /**
+ * Use this option to filter which levels should be captured. By default, all levels are captured.
+ *
+ * @example
+ * ```ts
+ * const sentryReporter = Sentry.createConsolaReporter({
+ * // Only capture error and warn logs
+ * levels: ['error', 'warn'],
+ * });
+ * consola.addReporter(sentryReporter);
+ * ```
+ */
+ levels?: Array;
+
+ /**
+ * Optionally provide a specific Sentry client instance to use for capturing logs.
+ * If not provided, the current client will be retrieved using `getClient()`.
+ *
+ * This is useful when you want to use specific client options for log normalization
+ * or when working with multiple client instances.
+ *
+ * @example
+ * ```ts
+ * const sentryReporter = Sentry.createConsolaReporter({
+ * client: myCustomClient,
+ * });
+ * ```
+ */
+ client?: Client;
+}
+
+export interface ConsolaReporter {
+ log: (logObj: ConsolaLogObject) => void;
+}
+
+/**
+ * Represents a log object that Consola reporters receive.
+ *
+ * This interface matches the structure of log objects passed to Consola reporters.
+ * See: https://github.com/unjs/consola#custom-reporters
+ *
+ * @example
+ * ```ts
+ * const reporter = {
+ * log(logObj: ConsolaLogObject) {
+ * console.log(`[${logObj.type}] ${logObj.message || logObj.args?.join(' ')}`);
+ * }
+ * };
+ * consola.addReporter(reporter);
+ * ```
+ */
+export interface ConsolaLogObject {
+ /**
+ * Allows additional custom properties to be set on the log object.
+ * These properties will be captured as log attributes with a 'consola.' prefix.
+ *
+ * @example
+ * ```ts
+ * const reporter = Sentry.createConsolaReporter();
+ * reporter.log({
+ * type: 'info',
+ * message: 'User action',
+ * userId: 123,
+ * sessionId: 'abc-123'
+ * });
+ * // Will create attributes: consola.userId and consola.sessionId
+ * ```
+ */
+ [key: string]: unknown;
+
+ /**
+ * The numeric log level (0-5) or null.
+ *
+ * Consola log levels:
+ * - 0: Fatal and Error
+ * - 1: Warnings
+ * - 2: Normal logs
+ * - 3: Informational logs, success, fail, ready, start, box, ...
+ * - 4: Debug logs
+ * - 5: Trace logs
+ * - null: Some special types like 'verbose'
+ *
+ * See: https://github.com/unjs/consola/blob/main/README.md#log-level
+ */
+ level?: number | null;
+
+ /**
+ * The log type/method name (e.g., 'error', 'warn', 'info', 'debug', 'trace', 'success', 'fail', etc.).
+ *
+ * Consola built-in types include:
+ * - Standard: silent, fatal, error, warn, log, info, success, fail, ready, start, box, debug, trace, verbose
+ * - Custom types can also be defined
+ *
+ * See: https://github.com/unjs/consola/blob/main/README.md#log-types
+ */
+ type?: string;
+
+ /**
+ * An optional tag/scope for the log entry.
+ *
+ * Tags are created using `consola.withTag('scope')` and help categorize logs.
+ *
+ * @example
+ * ```ts
+ * const scopedLogger = consola.withTag('auth');
+ * scopedLogger.info('User logged in'); // tag will be 'auth'
+ * ```
+ *
+ * See: https://github.com/unjs/consola/blob/main/README.md#withtagtag
+ */
+ tag?: string;
+
+ /**
+ * The raw arguments passed to the log method.
+ *
+ * When `message` is not provided, these args are typically formatted into the final message.
+ *
+ * @example
+ * ```ts
+ * consola.info('Hello', 'world', { user: 'john' });
+ * // args = ['Hello', 'world', { user: 'john' }]
+ * ```
+ */
+ args?: unknown[];
+
+ /**
+ * The timestamp when the log was created.
+ *
+ * This is automatically set by Consola when the log is created.
+ */
+ date?: Date;
+
+ /**
+ * The formatted log message.
+ *
+ * When provided, this is the final formatted message. When not provided,
+ * the message should be constructed from the `args` array.
+ */
+ message?: string;
+}
+
+const DEFAULT_CAPTURED_LEVELS: Array = ['trace', 'debug', 'info', 'warn', 'error', 'fatal'];
+
+/**
+ * Creates a new Sentry reporter for Consola that forwards logs to Sentry. Requires the `enableLogs` option to be enabled.
+ *
+ * **Note: This integration supports Consola v3.x only.** The reporter interface and log object structure
+ * may differ in other versions of Consola.
+ *
+ * @param options - Configuration options for the reporter.
+ * @returns A Consola reporter that can be added to consola instances.
+ *
+ * @example
+ * ```ts
+ * import * as Sentry from '@sentry/node';
+ * import { consola } from 'consola';
+ *
+ * Sentry.init({
+ * enableLogs: true,
+ * });
+ *
+ * const sentryReporter = Sentry.createConsolaReporter({
+ * // Optional: filter levels to capture
+ * levels: ['error', 'warn', 'info'],
+ * });
+ *
+ * consola.addReporter(sentryReporter);
+ *
+ * // Now consola logs will be captured by Sentry
+ * consola.info('This will be sent to Sentry');
+ * consola.error('This error will also be sent to Sentry');
+ * ```
+ */
+export function createConsolaReporter(options: ConsolaReporterOptions = {}): ConsolaReporter {
+ const levels = new Set(options.levels ?? DEFAULT_CAPTURED_LEVELS);
+ const providedClient = options.client;
+
+ return {
+ log(logObj: ConsolaLogObject) {
+ // eslint-disable-next-line @typescript-eslint/no-unused-vars
+ const { type, level, message: consolaMessage, args, tag, date: _date, ...attributes } = logObj;
+
+ // Get client - use provided client or current client
+ const client = providedClient || getClient();
+ if (!client) {
+ return;
+ }
+
+ // Determine the log severity level
+ const logSeverityLevel = getLogSeverityLevel(type, level);
+
+ // Early exit if this level should not be captured
+ if (!levels.has(logSeverityLevel)) {
+ return;
+ }
+
+ const { normalizeDepth = 3, normalizeMaxBreadth = 1_000 } = client.getOptions();
+
+ // Format the log message using the same approach as consola's basic reporter
+ const messageParts = [];
+ if (consolaMessage) {
+ messageParts.push(consolaMessage);
+ }
+ if (args && args.length > 0) {
+ messageParts.push(formatConsoleArgs(args, normalizeDepth, normalizeMaxBreadth));
+ }
+ const message = messageParts.join(' ');
+
+ // Build attributes
+ attributes['sentry.origin'] = 'auto.logging.consola';
+
+ if (tag) {
+ attributes['consola.tag'] = tag;
+ }
+
+ if (type) {
+ attributes['consola.type'] = type;
+ }
+
+ // Only add level if it's a valid number (not null/undefined)
+ if (level != null && typeof level === 'number') {
+ attributes['consola.level'] = level;
+ }
+
+ _INTERNAL_captureLog({
+ level: logSeverityLevel,
+ message,
+ attributes,
+ });
+ },
+ };
+}
+
+// Mapping from consola log types to Sentry log severity levels
+const CONSOLA_TYPE_TO_LOG_SEVERITY_LEVEL_MAP: Record = {
+ // Consola built-in types
+ silent: 'trace',
+ fatal: 'fatal',
+ error: 'error',
+ warn: 'warn',
+ log: 'info',
+ info: 'info',
+ success: 'info',
+ fail: 'error',
+ ready: 'info',
+ start: 'info',
+ box: 'info',
+ debug: 'debug',
+ trace: 'trace',
+ verbose: 'debug',
+ // Custom types that might exist
+ critical: 'fatal',
+ notice: 'info',
+};
+
+// Mapping from consola log levels (numbers) to Sentry log severity levels
+const CONSOLA_LEVEL_TO_LOG_SEVERITY_LEVEL_MAP: Record = {
+ 0: 'fatal', // Fatal and Error
+ 1: 'warn', // Warnings
+ 2: 'info', // Normal logs
+ 3: 'info', // Informational logs, success, fail, ready, start, ...
+ 4: 'debug', // Debug logs
+ 5: 'trace', // Trace logs
+};
+
+/**
+ * Determines the log severity level from Consola type and level.
+ *
+ * @param type - The Consola log type (e.g., 'error', 'warn', 'info')
+ * @param level - The Consola numeric log level (0-5) or null for some types like 'verbose'
+ * @returns The corresponding Sentry log severity level
+ */
+function getLogSeverityLevel(type?: string, level?: number | null): LogSeverityLevel {
+ // Handle special case for verbose logs (level can be null with infinite level in Consola)
+ if (type === 'verbose') {
+ return 'debug';
+ }
+
+ // Handle silent logs - these should be at trace level
+ if (type === 'silent') {
+ return 'trace';
+ }
+
+ // First try to map by type (more specific)
+ if (type) {
+ const mappedLevel = CONSOLA_TYPE_TO_LOG_SEVERITY_LEVEL_MAP[type];
+ if (mappedLevel) {
+ return mappedLevel;
+ }
+ }
+
+ // Fallback to level mapping (handle null level)
+ if (typeof level === 'number') {
+ const mappedLevel = CONSOLA_LEVEL_TO_LOG_SEVERITY_LEVEL_MAP[level];
+ if (mappedLevel) {
+ return mappedLevel;
+ }
+ }
+
+ // Default fallback
+ return 'info';
+}
diff --git a/packages/core/src/integrations/mcp-server/errorCapture.ts b/packages/core/src/integrations/mcp-server/errorCapture.ts
index 544d61cf71ad..2ba401c93d08 100644
--- a/packages/core/src/integrations/mcp-server/errorCapture.ts
+++ b/packages/core/src/integrations/mcp-server/errorCapture.ts
@@ -36,7 +36,7 @@ export function captureError(error: Error, errorType?: McpErrorType, extraData?:
captureException(error, {
mechanism: {
- type: 'mcp_server',
+ type: 'auto.ai.mcp_server',
handled: false,
data: {
error_type: errorType || 'handler_execution',
diff --git a/packages/core/src/logs/console-integration.ts b/packages/core/src/logs/console-integration.ts
index a69d406a659c..6c967499800f 100644
--- a/packages/core/src/logs/console-integration.ts
+++ b/packages/core/src/logs/console-integration.ts
@@ -6,21 +6,13 @@ import { SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN } from '../semanticAttributes';
import type { ConsoleLevel } from '../types-hoist/instrument';
import type { IntegrationFn } from '../types-hoist/integration';
import { CONSOLE_LEVELS, debug } from '../utils/debug-logger';
-import { isPrimitive } from '../utils/is';
-import { normalize } from '../utils/normalize';
-import { GLOBAL_OBJ } from '../utils/worldwide';
import { _INTERNAL_captureLog } from './exports';
+import { formatConsoleArgs } from './utils';
interface CaptureConsoleOptions {
levels: ConsoleLevel[];
}
-type GlobalObjectWithUtil = typeof GLOBAL_OBJ & {
- util: {
- format: (...args: unknown[]) => string;
- };
-};
-
const INTEGRATION_NAME = 'ConsoleLogs';
const DEFAULT_ATTRIBUTES = {
@@ -89,17 +81,3 @@ const _consoleLoggingIntegration = ((options: Partial = {
* ```
*/
export const consoleLoggingIntegration = defineIntegration(_consoleLoggingIntegration);
-
-function formatConsoleArgs(values: unknown[], normalizeDepth: number, normalizeMaxBreadth: number): string {
- return 'util' in GLOBAL_OBJ && typeof (GLOBAL_OBJ as GlobalObjectWithUtil).util.format === 'function'
- ? (GLOBAL_OBJ as GlobalObjectWithUtil).util.format(...values)
- : safeJoinConsoleArgs(values, normalizeDepth, normalizeMaxBreadth);
-}
-
-function safeJoinConsoleArgs(values: unknown[], normalizeDepth: number, normalizeMaxBreadth: number): string {
- return values
- .map(value =>
- isPrimitive(value) ? String(value) : JSON.stringify(normalize(value, normalizeDepth, normalizeMaxBreadth)),
- )
- .join(' ');
-}
diff --git a/packages/core/src/logs/utils.ts b/packages/core/src/logs/utils.ts
new file mode 100644
index 000000000000..c30bfd75530b
--- /dev/null
+++ b/packages/core/src/logs/utils.ts
@@ -0,0 +1,39 @@
+import { isPrimitive } from '../utils/is';
+import { normalize } from '../utils/normalize';
+import { GLOBAL_OBJ } from '../utils/worldwide';
+
+type GlobalObjectWithUtil = typeof GLOBAL_OBJ & {
+ util: {
+ format: (...args: unknown[]) => string;
+ };
+};
+
+/**
+ * Formats the given values into a string.
+ *
+ * @param values - The values to format.
+ * @param normalizeDepth - The depth to normalize the values.
+ * @param normalizeMaxBreadth - The max breadth to normalize the values.
+ * @returns The formatted string.
+ */
+export function formatConsoleArgs(values: unknown[], normalizeDepth: number, normalizeMaxBreadth: number): string {
+ return 'util' in GLOBAL_OBJ && typeof (GLOBAL_OBJ as GlobalObjectWithUtil).util.format === 'function'
+ ? (GLOBAL_OBJ as GlobalObjectWithUtil).util.format(...values)
+ : safeJoinConsoleArgs(values, normalizeDepth, normalizeMaxBreadth);
+}
+
+/**
+ * Joins the given values into a string.
+ *
+ * @param values - The values to join.
+ * @param normalizeDepth - The depth to normalize the values.
+ * @param normalizeMaxBreadth - The max breadth to normalize the values.
+ * @returns The joined string.
+ */
+export function safeJoinConsoleArgs(values: unknown[], normalizeDepth: number, normalizeMaxBreadth: number): string {
+ return values
+ .map(value =>
+ isPrimitive(value) ? String(value) : JSON.stringify(normalize(value, normalizeDepth, normalizeMaxBreadth)),
+ )
+ .join(' ');
+}
diff --git a/packages/core/src/utils/aggregate-errors.ts b/packages/core/src/utils/aggregate-errors.ts
index f472e5b9968b..16d100d60c09 100644
--- a/packages/core/src/utils/aggregate-errors.ts
+++ b/packages/core/src/utils/aggregate-errors.ts
@@ -99,10 +99,9 @@ function aggregateExceptionsFromError(
}
function applyExceptionGroupFieldsForParentException(exception: Exception, exceptionId: number): void {
- // Don't know if this default makes sense. The protocol requires us to set these values so we pick *some* default.
- exception.mechanism = exception.mechanism || { type: 'generic', handled: true };
-
exception.mechanism = {
+ handled: true,
+ type: 'auto.core.linked_errors',
...exception.mechanism,
...(exception.type === 'AggregateError' && { is_exception_group: true }),
exception_id: exceptionId,
@@ -115,10 +114,8 @@ function applyExceptionGroupFieldsForChildException(
exceptionId: number,
parentId: number | undefined,
): void {
- // Don't know if this default makes sense. The protocol requires us to set these values so we pick *some* default.
- exception.mechanism = exception.mechanism || { type: 'generic', handled: true };
-
exception.mechanism = {
+ handled: true,
...exception.mechanism,
type: 'chained',
source,
diff --git a/packages/core/src/utils/anthropic-ai/index.ts b/packages/core/src/utils/anthropic-ai/index.ts
index 563724d98c5c..a771dff4c75d 100644
--- a/packages/core/src/utils/anthropic-ai/index.ts
+++ b/packages/core/src/utils/anthropic-ai/index.ts
@@ -27,7 +27,6 @@ import { buildMethodPath, getFinalOperationName, getSpanOperation, setTokenUsage
import { ANTHROPIC_AI_INTEGRATION_NAME } from './constants';
import { instrumentStream } from './streaming';
import type {
- AnthropicAiClient,
AnthropicAiInstrumentedMethod,
AnthropicAiIntegration,
AnthropicAiOptions,
@@ -304,7 +303,7 @@ function instrumentMethod(
/**
* Create a deep proxy for Anthropic AI client instrumentation
*/
-function createDeepProxy(target: T, currentPath = '', options?: AnthropicAiOptions): T {
+function createDeepProxy(target: T, currentPath = '', options?: AnthropicAiOptions): T {
return new Proxy(target, {
get(obj: object, prop: string): unknown {
const value = (obj as Record)[prop];
@@ -332,11 +331,11 @@ function createDeepProxy(target: T, currentPath = '
* Instrument an Anthropic AI client with Sentry tracing
* Can be used across Node.js, Cloudflare Workers, and Vercel Edge
*
- * @template T - The type of the client that extends AnthropicAiClient
+ * @template T - The type of the client that extends object
* @param client - The Anthropic AI client to instrument
* @param options - Optional configuration for recording inputs and outputs
* @returns The instrumented client with the same type as the input
*/
-export function instrumentAnthropicAiClient(client: T, options?: AnthropicAiOptions): T {
+export function instrumentAnthropicAiClient(client: T, options?: AnthropicAiOptions): T {
return createDeepProxy(client, '', options);
}
diff --git a/packages/core/src/utils/spanUtils.ts b/packages/core/src/utils/spanUtils.ts
index b6761c9930e7..89ecc6872efb 100644
--- a/packages/core/src/utils/spanUtils.ts
+++ b/packages/core/src/utils/spanUtils.ts
@@ -17,7 +17,7 @@ import type { SpanStatus } from '../types-hoist/spanStatus';
import { addNonEnumerableProperty } from '../utils/object';
import { generateSpanId } from '../utils/propagationContext';
import { timestampInSeconds } from '../utils/time';
-import { generateSentryTraceHeader } from '../utils/tracing';
+import { generateSentryTraceHeader, generateTraceparentHeader } from '../utils/tracing';
import { consoleSandbox } from './debug-logger';
import { _getSpanForScope } from './spanOnScope';
@@ -77,6 +77,15 @@ export function spanToTraceHeader(span: Span): string {
return generateSentryTraceHeader(traceId, spanId, sampled);
}
+/**
+ * Convert a Span to a W3C traceparent header.
+ */
+export function spanToTraceparentHeader(span: Span): string {
+ const { traceId, spanId } = span.spanContext();
+ const sampled = spanIsSampled(span);
+ return generateTraceparentHeader(traceId, spanId, sampled);
+}
+
/**
* Converts the span links array to a flattened version to be sent within an envelope.
*
diff --git a/packages/core/src/utils/traceData.ts b/packages/core/src/utils/traceData.ts
index aa335dbd37bd..325e45a038e0 100644
--- a/packages/core/src/utils/traceData.ts
+++ b/packages/core/src/utils/traceData.ts
@@ -9,8 +9,8 @@ import type { Span } from '../types-hoist/span';
import type { SerializedTraceData } from '../types-hoist/tracing';
import { dynamicSamplingContextToSentryBaggageHeader } from './baggage';
import { debug } from './debug-logger';
-import { getActiveSpan, spanToTraceHeader } from './spanUtils';
-import { extractTraceparentData, generateSentryTraceHeader, TRACEPARENT_REGEXP } from './tracing';
+import { getActiveSpan, spanToTraceHeader, spanToTraceparentHeader } from './spanUtils';
+import { generateSentryTraceHeader, generateTraceparentHeader, TRACEPARENT_REGEXP } from './tracing';
/**
* Extracts trace propagation data from the current span or from the client's scope (via transaction or propagation
@@ -58,7 +58,7 @@ export function getTraceData(
};
if (options.propagateTraceparent) {
- const traceparent = _sentryTraceToTraceParentHeader(sentryTrace);
+ const traceparent = span ? spanToTraceparentHeader(span) : scopeToTraceparentHeader(scope);
if (traceparent) {
traceData.traceparent = traceparent;
}
@@ -75,22 +75,7 @@ function scopeToTraceHeader(scope: Scope): string {
return generateSentryTraceHeader(traceId, propagationSpanId, sampled);
}
-/**
- * Builds a W3C traceparent header from the given sentry-trace header.
- *
- * Why parse that header and not create traceparent from primitives?
- * We want these two headers to always have the same ids. The easiest way to do this is to take
- * one of them as the source of truth (sentry-trace) and derive the other from it.
- *
- * Most importantly, this guarantees parentSpanId consistency between sentry-trace and traceparent
- * in tracing without performance (TwP) mode, where we always generate a random parentSpanId.
- *
- * Exported for testing
- */
-export function _sentryTraceToTraceParentHeader(sentryTrace: string): string | undefined {
- const { traceId, parentSpanId, parentSampled } = extractTraceparentData(sentryTrace) || {};
- if (!traceId || !parentSpanId) {
- return undefined;
- }
- return `00-${traceId}-${parentSpanId}-${parentSampled ? '01' : '00'}`;
+function scopeToTraceparentHeader(scope: Scope): string {
+ const { traceId, sampled, propagationSpanId } = scope.getPropagationContext();
+ return generateTraceparentHeader(traceId, propagationSpanId, sampled);
}
diff --git a/packages/core/src/utils/tracing.ts b/packages/core/src/utils/tracing.ts
index 0310cc8640e6..aa5a15153674 100644
--- a/packages/core/src/utils/tracing.ts
+++ b/packages/core/src/utils/tracing.ts
@@ -102,6 +102,17 @@ export function generateSentryTraceHeader(
return `${traceId}-${spanId}${sampledString}`;
}
+/**
+ * Creates a W3C traceparent header from the given trace and span ids.
+ */
+export function generateTraceparentHeader(
+ traceId: string | undefined = generateTraceId(),
+ spanId: string | undefined = generateSpanId(),
+ sampled?: boolean,
+): string {
+ return `00-${traceId}-${spanId}-${sampled ? '01' : '00'}`;
+}
+
/**
* Given any combination of an incoming trace, generate a sample rand based on its defined semantics.
*
diff --git a/packages/core/test/lib/client.test.ts b/packages/core/test/lib/client.test.ts
index 6a7d0af22857..b7767a7e6c58 100644
--- a/packages/core/test/lib/client.test.ts
+++ b/packages/core/test/lib/client.test.ts
@@ -1833,15 +1833,13 @@ describe('Client', () => {
});
});
- test('event processor sends an event and logs when it crashes', () => {
- expect.assertions(3);
-
+ test('event processor sends an event and logs when it crashes synchronously', () => {
const options = getDefaultTestClientOptions({ dsn: PUBLIC_DSN });
const client = new TestClient(options);
const captureExceptionSpy = vi.spyOn(client, 'captureException');
const loggerWarnSpy = vi.spyOn(debugLoggerModule.debug, 'warn');
const scope = new Scope();
- const exception = new Error('sorry');
+ const exception = new Error('sorry 1');
scope.addEventProcessor(() => {
throw exception;
});
@@ -1850,7 +1848,7 @@ describe('Client', () => {
expect(TestClient.instance!.event!.exception!.values![0]).toStrictEqual({
type: 'Error',
- value: 'sorry',
+ value: 'sorry 1',
mechanism: { type: 'internal', handled: false },
});
expect(captureExceptionSpy).toBeCalledWith(exception, {
@@ -1865,6 +1863,117 @@ describe('Client', () => {
);
});
+ test('event processor sends an event and logs when it crashes asynchronously', async () => {
+ vi.useFakeTimers();
+
+ const options = getDefaultTestClientOptions({ dsn: PUBLIC_DSN });
+ const client = new TestClient(options);
+ const captureExceptionSpy = vi.spyOn(client, 'captureException');
+ const loggerWarnSpy = vi.spyOn(debugLoggerModule.debug, 'warn');
+ const scope = new Scope();
+ const exception = new Error('sorry 2');
+ scope.addEventProcessor(() => {
+ return new Promise((_resolve, reject) => {
+ reject(exception);
+ });
+ });
+
+ client.captureEvent({ message: 'hello' }, {}, scope);
+
+ await vi.runOnlyPendingTimersAsync();
+
+ expect(TestClient.instance!.event!.exception!.values![0]).toStrictEqual({
+ type: 'Error',
+ value: 'sorry 2',
+ mechanism: { type: 'internal', handled: false },
+ });
+ expect(captureExceptionSpy).toBeCalledWith(exception, {
+ data: {
+ __sentry__: true,
+ },
+ originalException: exception,
+ mechanism: { type: 'internal', handled: false },
+ });
+ expect(loggerWarnSpy).toBeCalledWith(
+ `Event processing pipeline threw an error, original event will not be sent. Details have been sent as a new event.\nReason: ${exception}`,
+ );
+ });
+
+ test('event processor sends an event and logs when it crashes synchronously in processor chain', () => {
+ const options = getDefaultTestClientOptions({ dsn: PUBLIC_DSN });
+ const client = new TestClient(options);
+ const captureExceptionSpy = vi.spyOn(client, 'captureException');
+ const scope = new Scope();
+ const exception = new Error('sorry 3');
+
+ const processor1 = vi.fn(event => {
+ return event;
+ });
+ const processor2 = vi.fn(() => {
+ throw exception;
+ });
+ const processor3 = vi.fn(event => {
+ return event;
+ });
+
+ scope.addEventProcessor(processor1);
+ scope.addEventProcessor(processor2);
+ scope.addEventProcessor(processor3);
+
+ client.captureEvent({ message: 'hello' }, {}, scope);
+
+ expect(processor1).toHaveBeenCalledTimes(1);
+ expect(processor2).toHaveBeenCalledTimes(1);
+ expect(processor3).toHaveBeenCalledTimes(0);
+
+ expect(captureExceptionSpy).toBeCalledWith(exception, {
+ data: {
+ __sentry__: true,
+ },
+ originalException: exception,
+ mechanism: { type: 'internal', handled: false },
+ });
+ });
+
+ test('event processor sends an event and logs when it crashes asynchronously in processor chain', async () => {
+ vi.useFakeTimers();
+
+ const options = getDefaultTestClientOptions({ dsn: PUBLIC_DSN });
+ const client = new TestClient(options);
+ const captureExceptionSpy = vi.spyOn(client, 'captureException');
+ const scope = new Scope();
+ const exception = new Error('sorry 4');
+
+ const processor1 = vi.fn(async event => {
+ return event;
+ });
+ const processor2 = vi.fn(async () => {
+ throw exception;
+ });
+ const processor3 = vi.fn(event => {
+ return event;
+ });
+
+ scope.addEventProcessor(processor1);
+ scope.addEventProcessor(processor2);
+ scope.addEventProcessor(processor3);
+
+ client.captureEvent({ message: 'hello' }, {}, scope);
+ await vi.runOnlyPendingTimersAsync();
+
+ expect(processor1).toHaveBeenCalledTimes(1);
+ expect(processor2).toHaveBeenCalledTimes(1);
+ expect(processor3).toHaveBeenCalledTimes(0);
+
+ expect(captureExceptionSpy).toBeCalledWith(exception, {
+ data: {
+ __sentry__: true,
+ },
+ originalException: exception,
+ mechanism: { type: 'internal', handled: false },
+ });
+ });
+
test('records events dropped due to `sampleRate` option', () => {
expect.assertions(1);
@@ -2159,7 +2268,7 @@ describe('Client', () => {
expect(mockSend).toBeCalledTimes(1);
expect(callback).toBeCalledTimes(1);
- expect(callback).toBeCalledWith(errorEvent, 'send error');
+ expect(callback).toBeCalledWith(errorEvent, {});
});
it('passes the response to the hook', async () => {
diff --git a/packages/core/test/lib/integrations/captureconsole.test.ts b/packages/core/test/lib/integrations/captureconsole.test.ts
index 2fe971710a07..8da7c6570d74 100644
--- a/packages/core/test/lib/integrations/captureconsole.test.ts
+++ b/packages/core/test/lib/integrations/captureconsole.test.ts
@@ -328,7 +328,7 @@ describe('CaptureConsole setup', () => {
expect(someEvent.exception?.values?.[0]?.mechanism).toEqual({
handled: true,
- type: 'console',
+ type: 'auto.core.capture_console',
});
});
@@ -352,7 +352,7 @@ describe('CaptureConsole setup', () => {
expect(someEvent.exception?.values?.[0]?.mechanism).toEqual({
handled: true,
- type: 'console',
+ type: 'auto.core.capture_console',
});
});
@@ -376,7 +376,7 @@ describe('CaptureConsole setup', () => {
expect(someEvent.exception?.values?.[0]?.mechanism).toEqual({
handled: false,
- type: 'console',
+ type: 'auto.core.capture_console',
});
});
});
diff --git a/packages/core/test/lib/integrations/consola.test.ts b/packages/core/test/lib/integrations/consola.test.ts
new file mode 100644
index 000000000000..66830fb75e06
--- /dev/null
+++ b/packages/core/test/lib/integrations/consola.test.ts
@@ -0,0 +1,303 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { getClient } from '../../../src/currentScopes';
+import { createConsolaReporter } from '../../../src/integrations/consola';
+import { _INTERNAL_captureLog } from '../../../src/logs/exports';
+import { formatConsoleArgs } from '../../../src/logs/utils';
+import { getDefaultTestClientOptions, TestClient } from '../../mocks/client';
+
+// Mock dependencies
+vi.mock('../../../src/logs/exports', () => ({
+ _INTERNAL_captureLog: vi.fn(),
+}));
+
+vi.mock('../../../src/logs/utils', async actual => ({
+ formatConsoleArgs: vi.fn(((await actual()) as any).formatConsoleArgs),
+}));
+
+vi.mock('../../../src/currentScopes', () => ({
+ getClient: vi.fn(),
+}));
+
+describe('createConsolaReporter', () => {
+ let mockClient: TestClient;
+
+ beforeEach(() => {
+ vi.clearAllMocks();
+
+ // Create a test client with enableLogs: true
+ mockClient = new TestClient({
+ ...getDefaultTestClientOptions({ dsn: 'https://username@domain/123' }),
+ enableLogs: true,
+ normalizeDepth: 3,
+ normalizeMaxBreadth: 1000,
+ });
+
+ vi.mocked(getClient).mockReturnValue(mockClient);
+ });
+
+ afterEach(() => {
+ vi.restoreAllMocks();
+ });
+
+ describe('reporter creation', () => {
+ it('should create a reporter with log function', () => {
+ const reporter = createConsolaReporter();
+
+ expect(reporter).toEqual({
+ log: expect.any(Function),
+ });
+ });
+ });
+
+ describe('log capturing', () => {
+ let sentryReporter: any;
+
+ beforeEach(() => {
+ sentryReporter = createConsolaReporter();
+ });
+
+ it('should capture error logs', () => {
+ const logObj = {
+ type: 'error',
+ level: 0,
+ message: 'This is an error',
+ tag: 'test',
+ date: new Date('2023-01-01T00:00:00.000Z'),
+ };
+
+ sentryReporter.log(logObj);
+
+ expect(_INTERNAL_captureLog).toHaveBeenCalledWith({
+ level: 'error',
+ message: 'This is an error',
+ attributes: {
+ 'sentry.origin': 'auto.logging.consola',
+ 'consola.tag': 'test',
+ 'consola.type': 'error',
+ 'consola.level': 0,
+ },
+ });
+ });
+
+ it('should capture warn logs', () => {
+ const logObj = {
+ type: 'warn',
+ message: 'This is a warning',
+ };
+
+ sentryReporter.log(logObj);
+
+ expect(_INTERNAL_captureLog).toHaveBeenCalledWith({
+ level: 'warn',
+ message: 'This is a warning',
+ attributes: {
+ 'sentry.origin': 'auto.logging.consola',
+ 'consola.type': 'warn',
+ },
+ });
+ });
+
+ it('should capture info logs', () => {
+ const logObj = {
+ type: 'info',
+ message: 'This is info',
+ };
+
+ sentryReporter.log(logObj);
+
+ expect(_INTERNAL_captureLog).toHaveBeenCalledWith({
+ level: 'info',
+ message: 'This is info',
+ attributes: {
+ 'sentry.origin': 'auto.logging.consola',
+ 'consola.type': 'info',
+ },
+ });
+ });
+
+ it('should capture debug logs', () => {
+ const logObj = {
+ type: 'debug',
+ message: 'Debug message',
+ };
+
+ sentryReporter.log(logObj);
+
+ expect(_INTERNAL_captureLog).toHaveBeenCalledWith({
+ level: 'debug',
+ message: 'Debug message',
+ attributes: {
+ 'sentry.origin': 'auto.logging.consola',
+ 'consola.type': 'debug',
+ },
+ });
+ });
+
+ it('should capture trace logs', () => {
+ const logObj = {
+ type: 'trace',
+ message: 'Trace message',
+ };
+
+ sentryReporter.log(logObj);
+
+ expect(_INTERNAL_captureLog).toHaveBeenCalledWith({
+ level: 'trace',
+ message: 'Trace message',
+ attributes: {
+ 'sentry.origin': 'auto.logging.consola',
+ 'consola.type': 'trace',
+ },
+ });
+ });
+
+ it('should capture fatal logs', () => {
+ const logObj = {
+ type: 'fatal',
+ message: 'Fatal error',
+ };
+
+ sentryReporter.log(logObj);
+
+ expect(_INTERNAL_captureLog).toHaveBeenCalledWith({
+ level: 'fatal',
+ message: 'Fatal error',
+ attributes: {
+ 'sentry.origin': 'auto.logging.consola',
+ 'consola.type': 'fatal',
+ },
+ });
+ });
+
+ it('should format message from args when message is not provided', () => {
+ const logObj = {
+ type: 'info',
+ args: ['Hello', 'world', 123, { key: 'value' }],
+ };
+
+ sentryReporter.log(logObj);
+
+ expect(formatConsoleArgs).toHaveBeenCalledWith(['Hello', 'world', 123, { key: 'value' }], 3, 1000);
+ expect(_INTERNAL_captureLog).toHaveBeenCalledWith({
+ level: 'info',
+ message: 'Hello world 123 {"key":"value"}',
+ attributes: {
+ 'sentry.origin': 'auto.logging.consola',
+ 'consola.type': 'info',
+ },
+ });
+ });
+
+ it('should handle args with unparseable objects', () => {
+ const circular: any = {};
+ circular.self = circular;
+
+ const logObj = {
+ type: 'info',
+ args: ['Message', circular],
+ };
+
+ sentryReporter.log(logObj);
+
+ expect(_INTERNAL_captureLog).toHaveBeenCalledWith({
+ level: 'info',
+ message: 'Message {"self":"[Circular ~]"}',
+ attributes: {
+ 'sentry.origin': 'auto.logging.consola',
+ 'consola.type': 'info',
+ },
+ });
+ });
+
+ it('should map consola levels to sentry levels when type is not provided', () => {
+ const logObj = {
+ level: 0, // Fatal level
+ message: 'Fatal message',
+ };
+
+ sentryReporter.log(logObj);
+
+ expect(_INTERNAL_captureLog).toHaveBeenCalledWith({
+ level: 'fatal',
+ message: 'Fatal message',
+ attributes: {
+ 'sentry.origin': 'auto.logging.consola',
+ 'consola.level': 0,
+ },
+ });
+ });
+
+ it('should map various consola types correctly', () => {
+ const testCases = [
+ { type: 'success', expectedLevel: 'info' },
+ { type: 'fail', expectedLevel: 'error' },
+ { type: 'ready', expectedLevel: 'info' },
+ { type: 'start', expectedLevel: 'info' },
+ { type: 'verbose', expectedLevel: 'debug' },
+ { type: 'log', expectedLevel: 'info' },
+ { type: 'silent', expectedLevel: 'trace' },
+ ];
+
+ testCases.forEach(({ type, expectedLevel }) => {
+ vi.clearAllMocks();
+
+ sentryReporter.log({
+ type,
+ message: `Test ${type} message`,
+ });
+
+ expect(_INTERNAL_captureLog).toHaveBeenCalledWith({
+ level: expectedLevel,
+ message: `Test ${type} message`,
+ attributes: {
+ 'sentry.origin': 'auto.logging.consola',
+ 'consola.type': type,
+ },
+ });
+ });
+ });
+ });
+
+ describe('level filtering', () => {
+ it('should only capture specified levels', () => {
+ const filteredReporter = createConsolaReporter({
+ levels: ['error', 'warn'],
+ });
+
+ // Should capture error
+ filteredReporter.log({
+ type: 'error',
+ message: 'Error message',
+ });
+ expect(_INTERNAL_captureLog).toHaveBeenCalledTimes(1);
+
+ // Should capture warn
+ filteredReporter.log({
+ type: 'warn',
+ message: 'Warn message',
+ });
+ expect(_INTERNAL_captureLog).toHaveBeenCalledTimes(2);
+
+ // Should not capture info
+ filteredReporter.log({
+ type: 'info',
+ message: 'Info message',
+ });
+ expect(_INTERNAL_captureLog).toHaveBeenCalledTimes(2);
+ });
+
+ it('should use default levels when none specified', () => {
+ const defaultReporter = createConsolaReporter();
+
+ // Should capture all default levels
+ ['trace', 'debug', 'info', 'warn', 'error', 'fatal'].forEach(type => {
+ defaultReporter.log({
+ type,
+ message: `${type} message`,
+ });
+ });
+
+ expect(_INTERNAL_captureLog).toHaveBeenCalledTimes(6);
+ });
+ });
+});
diff --git a/packages/core/test/lib/integrations/eventFilters.test.ts b/packages/core/test/lib/integrations/eventFilters.test.ts
index d78b59ede112..a107efe17719 100644
--- a/packages/core/test/lib/integrations/eventFilters.test.ts
+++ b/packages/core/test/lib/integrations/eventFilters.test.ts
@@ -256,7 +256,7 @@ const USELESS_EXCEPTION_EVENT: Event = {
values: [
{},
{
- mechanism: { type: 'onunhandledrejection', handled: false },
+ mechanism: { type: 'auto.node.onunhandledrejection', handled: false },
},
],
},
diff --git a/packages/core/test/lib/integrations/mcp-server/mcpServerErrorCapture.test.ts b/packages/core/test/lib/integrations/mcp-server/mcpServerErrorCapture.test.ts
index bd5af090b0d9..210b303b29bf 100644
--- a/packages/core/test/lib/integrations/mcp-server/mcpServerErrorCapture.test.ts
+++ b/packages/core/test/lib/integrations/mcp-server/mcpServerErrorCapture.test.ts
@@ -24,7 +24,7 @@ describe('MCP Server Error Capture', () => {
expect(captureExceptionSpy).toHaveBeenCalledWith(error, {
mechanism: {
- type: 'mcp_server',
+ type: 'auto.ai.mcp_server',
handled: false,
data: {
error_type: 'tool_execution',
@@ -40,7 +40,7 @@ describe('MCP Server Error Capture', () => {
expect(captureExceptionSpy).toHaveBeenCalledWith(error, {
mechanism: {
- type: 'mcp_server',
+ type: 'auto.ai.mcp_server',
handled: false,
data: {
error_type: 'transport',
@@ -56,7 +56,7 @@ describe('MCP Server Error Capture', () => {
expect(captureExceptionSpy).toHaveBeenCalledWith(error, {
mechanism: {
- type: 'mcp_server',
+ type: 'auto.ai.mcp_server',
handled: false,
data: {
error_type: 'protocol',
@@ -72,7 +72,7 @@ describe('MCP Server Error Capture', () => {
expect(captureExceptionSpy).toHaveBeenCalledWith(error, {
mechanism: {
- type: 'mcp_server',
+ type: 'auto.ai.mcp_server',
handled: false,
data: {
error_type: 'validation',
@@ -88,7 +88,7 @@ describe('MCP Server Error Capture', () => {
expect(captureExceptionSpy).toHaveBeenCalledWith(error, {
mechanism: {
- type: 'mcp_server',
+ type: 'auto.ai.mcp_server',
handled: false,
data: {
error_type: 'timeout',
@@ -104,7 +104,7 @@ describe('MCP Server Error Capture', () => {
expect(captureExceptionSpy).toHaveBeenCalledWith(error, {
mechanism: {
- type: 'mcp_server',
+ type: 'auto.ai.mcp_server',
handled: false,
data: {
error_type: 'tool_execution',
diff --git a/packages/core/test/lib/utils/aggregate-errors.test.ts b/packages/core/test/lib/utils/aggregate-errors.test.ts
index 01ede6d9186a..fa11fd22f7c8 100644
--- a/packages/core/test/lib/utils/aggregate-errors.test.ts
+++ b/packages/core/test/lib/utils/aggregate-errors.test.ts
@@ -160,6 +160,26 @@ describe('applyAggregateErrorsToEvent()', () => {
expect(event.exception?.values?.[event.exception.values.length - 1]?.mechanism?.type).toBe('instrument');
});
+ test('should assign a defualt mechanism type for the root exception', () => {
+ const fakeAggregateError = new FakeAggregateError(
+ [new Error('Nested Error 1'), new Error('Nested Error 2')],
+ 'Root Error',
+ );
+
+ const exceptionFromError = (_stackParser: StackParser, ex: Error): Exception => {
+ return { value: ex.message, type: ex.name };
+ };
+
+ const event: Event = { exception: { values: [exceptionFromError(stackParser, fakeAggregateError)] } };
+ const eventHint: EventHint = { originalException: fakeAggregateError };
+
+ applyAggregateErrorsToEvent(exceptionFromError, stackParser, 'cause', 100, event, eventHint);
+
+ expect(event.exception?.values?.[event.exception.values.length - 1]?.mechanism?.type).toBe(
+ 'auto.core.linked_errors',
+ );
+ });
+
test('should recursively walk mixed errors (Aggregate errors and based on `key`)', () => {
const chainedError: ExtendedError = new Error('Nested Error 3');
chainedError.cause = new Error('Nested Error 4');
diff --git a/packages/core/test/lib/utils/traceData.test.ts b/packages/core/test/lib/utils/traceData.test.ts
index 37764cfc94a3..379103a8a48c 100644
--- a/packages/core/test/lib/utils/traceData.test.ts
+++ b/packages/core/test/lib/utils/traceData.test.ts
@@ -15,7 +15,6 @@ import {
import { getAsyncContextStrategy } from '../../../src/asyncContext';
import { freezeDscOnSpan } from '../../../src/tracing/dynamicSamplingContext';
import type { Span } from '../../../src/types-hoist/span';
-import { _sentryTraceToTraceParentHeader } from '../../../src/utils/traceData';
import type { TestClientOptions } from '../../mocks/client';
import { getDefaultTestClientOptions, TestClient } from '../../mocks/client';
@@ -349,34 +348,3 @@ describe('getTraceData', () => {
expect(traceData.traceparent).toMatch(/00-12345678901234567890123456789099-[0-9a-f]{16}-00/);
});
});
-
-describe('_sentryTraceToTraceParentHeader', () => {
- it('returns positively sampled traceparent header for sentry-trace with positive sampling decision', () => {
- const traceparent = _sentryTraceToTraceParentHeader('12345678901234567890123456789012-1234567890123456-1');
- expect(traceparent).toBe('00-12345678901234567890123456789012-1234567890123456-01');
- });
-
- it('returns negatively sampled traceparent header for sentry-trace with negative sampling decision', () => {
- const traceparent = _sentryTraceToTraceParentHeader('12345678901234567890123456789012-1234567890123456-0');
- expect(traceparent).toBe('00-12345678901234567890123456789012-1234567890123456-00');
- });
-
- it('returns negatively sampled traceparent header for sentry-trace with no/deferred sampling decision', () => {
- const traceparent = _sentryTraceToTraceParentHeader('12345678901234567890123456789012-1234567890123456');
- expect(traceparent).toBe('00-12345678901234567890123456789012-1234567890123456-00');
- });
-
- it.each([
- '12345678901234567890123456789012--0',
- '-12345678901234567890123456789012-0',
- '--1',
- '0',
- '1',
- '',
- '00-12345678901234567890123456789012-1234567890123456-01',
- '00-12345678901234567890123456789012-1234567890123456-00',
- ])('returns undefined if the sentry-trace header is invalid (%s)', sentryTrace => {
- const traceparent = _sentryTraceToTraceParentHeader(sentryTrace);
- expect(traceparent).toBeUndefined();
- });
-});
diff --git a/packages/core/test/lib/utils/tracing.test.ts b/packages/core/test/lib/utils/tracing.test.ts
index ea41190f3bb3..c950679a21be 100644
--- a/packages/core/test/lib/utils/tracing.test.ts
+++ b/packages/core/test/lib/utils/tracing.test.ts
@@ -1,5 +1,10 @@
import { describe, expect, it, test } from 'vitest';
-import { extractTraceparentData, propagationContextFromHeaders, shouldContinueTrace } from '../../../src/utils/tracing';
+import {
+ extractTraceparentData,
+ generateTraceparentHeader,
+ propagationContextFromHeaders,
+ shouldContinueTrace,
+} from '../../../src/utils/tracing';
import { getDefaultTestClientOptions, TestClient } from '../../mocks/client';
const EXAMPLE_SENTRY_TRACE = '12312012123120121231201212312012-1121201211212012-1';
@@ -177,3 +182,20 @@ describe('shouldContinueTrace', () => {
expect(result).toBe(false);
});
});
+
+describe('generateTraceparentHeader', () => {
+ test('returns a traceparent header with the given ids and positive sampling decision', () => {
+ const traceparent = generateTraceparentHeader('12345678901234567890123456789012', '1234567890123456', true);
+ expect(traceparent).toBe('00-12345678901234567890123456789012-1234567890123456-01');
+ });
+
+ test('returns a traceparent header with the given ids and negative sampling decision', () => {
+ const traceparent = generateTraceparentHeader('12345678901234567890123456789012', '1234567890123456', false);
+ expect(traceparent).toBe('00-12345678901234567890123456789012-1234567890123456-00');
+ });
+
+ test('no sampling decision passed, creates a negatively sampled traceparent header', () => {
+ const traceparent = generateTraceparentHeader('12345678901234567890123456789012', '1234567890123456');
+ expect(traceparent).toBe('00-12345678901234567890123456789012-1234567890123456-00');
+ });
+});
diff --git a/packages/deno/package.json b/packages/deno/package.json
index 8b34ebcc838e..ec80eef93401 100644
--- a/packages/deno/package.json
+++ b/packages/deno/package.json
@@ -24,6 +24,7 @@
"/build"
],
"dependencies": {
+ "@opentelemetry/api": "^1.9.0",
"@sentry/core": "10.11.0"
},
"scripts": {
@@ -42,7 +43,7 @@
"lint:es-compatibility": "es-check es2022 ./build/esm/*.js --module",
"install:deno": "node ./scripts/install-deno.mjs",
"test": "run-s install:deno deno-types test:unit",
- "test:unit": "deno test --allow-read --allow-run --no-check",
+ "test:unit": "deno test --allow-read --allow-run --allow-env --no-check",
"test:unit:update": "deno test --allow-read --allow-write --allow-run -- --update",
"yalc:publish": "yalc publish --push --sig"
},
diff --git a/packages/deno/src/index.ts b/packages/deno/src/index.ts
index 12bcedc35270..5f987b4459aa 100644
--- a/packages/deno/src/index.ts
+++ b/packages/deno/src/index.ts
@@ -101,3 +101,4 @@ export { normalizePathsIntegration } from './integrations/normalizepaths';
export { contextLinesIntegration } from './integrations/contextlines';
export { denoCronIntegration } from './integrations/deno-cron';
export { breadcrumbsIntegration } from './integrations/breadcrumbs';
+export { vercelAIIntegration } from './integrations/tracing/vercelai';
diff --git a/packages/deno/src/integrations/globalhandlers.ts b/packages/deno/src/integrations/globalhandlers.ts
index 0e3639a7472d..ae66a28068c4 100644
--- a/packages/deno/src/integrations/globalhandlers.ts
+++ b/packages/deno/src/integrations/globalhandlers.ts
@@ -61,7 +61,7 @@ function installGlobalErrorHandler(client: Client): void {
originalException: error,
mechanism: {
handled: false,
- type: 'error',
+ type: 'auto.deno.global_handlers.error',
},
});
@@ -110,7 +110,7 @@ function installGlobalUnhandledRejectionHandler(client: Client): void {
originalException: error,
mechanism: {
handled: false,
- type: 'unhandledrejection',
+ type: 'auto.deno.global_handlers.unhandledrejection',
},
});
diff --git a/packages/deno/src/integrations/tracing/vercelai.ts b/packages/deno/src/integrations/tracing/vercelai.ts
new file mode 100644
index 000000000000..c400babf0d64
--- /dev/null
+++ b/packages/deno/src/integrations/tracing/vercelai.ts
@@ -0,0 +1,45 @@
+/**
+ * This is a copy of the Vercel AI integration from the cloudflare SDK.
+ */
+
+import type { IntegrationFn } from '@sentry/core';
+import { addVercelAiProcessors, defineIntegration } from '@sentry/core';
+
+const INTEGRATION_NAME = 'VercelAI';
+
+const _vercelAIIntegration = (() => {
+ return {
+ name: INTEGRATION_NAME,
+ setup(client) {
+ addVercelAiProcessors(client);
+ },
+ };
+}) satisfies IntegrationFn;
+
+/**
+ * Adds Sentry tracing instrumentation for the [ai](https://www.npmjs.com/package/ai) library.
+ * This integration is not enabled by default, you need to manually add it.
+ *
+ * For more information, see the [`ai` documentation](https://sdk.vercel.ai/docs/ai-sdk-core/telemetry).
+ *
+ * You need to enable collecting spans for a specific call by setting
+ * `experimental_telemetry.isEnabled` to `true` in the first argument of the function call.
+ *
+ * ```javascript
+ * const result = await generateText({
+ * model: openai('gpt-4-turbo'),
+ * experimental_telemetry: { isEnabled: true },
+ * });
+ * ```
+ *
+ * If you want to collect inputs and outputs for a specific call, you must specifically opt-in to each
+ * function call by setting `experimental_telemetry.recordInputs` and `experimental_telemetry.recordOutputs`
+ * to `true`.
+ *
+ * ```javascript
+ * const result = await generateText({
+ * model: openai('gpt-4-turbo'),
+ * experimental_telemetry: { isEnabled: true, recordInputs: true, recordOutputs: true },
+ * });
+ */
+export const vercelAIIntegration = defineIntegration(_vercelAIIntegration);
diff --git a/packages/deno/src/opentelemetry/tracer.ts b/packages/deno/src/opentelemetry/tracer.ts
new file mode 100644
index 000000000000..801badefa19f
--- /dev/null
+++ b/packages/deno/src/opentelemetry/tracer.ts
@@ -0,0 +1,110 @@
+import type { Context, Span, SpanOptions, Tracer, TracerProvider } from '@opentelemetry/api';
+import { SpanKind, trace } from '@opentelemetry/api';
+import {
+ SEMANTIC_ATTRIBUTE_SENTRY_OP,
+ SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,
+ startInactiveSpan,
+ startSpanManual,
+} from '@sentry/core';
+
+/**
+ * Set up a mock OTEL tracer to allow inter-op with OpenTelemetry emitted spans.
+ * This is not perfect but handles easy/common use cases.
+ */
+export function setupOpenTelemetryTracer(): void {
+ trace.setGlobalTracerProvider(new SentryDenoTraceProvider());
+}
+
+class SentryDenoTraceProvider implements TracerProvider {
+ private readonly _tracers: Map = new Map();
+
+ public getTracer(name: string, version?: string, options?: { schemaUrl?: string }): Tracer {
+ const key = `${name}@${version || ''}:${options?.schemaUrl || ''}`;
+ if (!this._tracers.has(key)) {
+ this._tracers.set(key, new SentryDenoTracer());
+ }
+
+ // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+ return this._tracers.get(key)!;
+ }
+}
+
+class SentryDenoTracer implements Tracer {
+ public startSpan(name: string, options?: SpanOptions): Span {
+ // Map OpenTelemetry SpanKind to Sentry operation
+ const op = this._mapSpanKindToOp(options?.kind);
+
+ return startInactiveSpan({
+ name,
+ ...options,
+ attributes: {
+ ...options?.attributes,
+ [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'manual',
+ [SEMANTIC_ATTRIBUTE_SENTRY_OP]: op,
+ 'sentry.deno_tracer': true,
+ },
+ });
+ }
+
+ /**
+ * NOTE: This does not handle `context` being passed in. It will always put spans on the current scope.
+ */
+ public startActiveSpan unknown>(name: string, fn: F): ReturnType;
+ public startActiveSpan unknown>(name: string, options: SpanOptions, fn: F): ReturnType;
+ public startActiveSpan unknown>(
+ name: string,
+ options: SpanOptions,
+ context: Context,
+ fn: F,
+ ): ReturnType;
+ public startActiveSpan unknown>(
+ name: string,
+ options: unknown,
+ context?: unknown,
+ fn?: F,
+ ): ReturnType {
+ const opts = (typeof options === 'object' && options !== null ? options : {}) as SpanOptions;
+
+ // Map OpenTelemetry SpanKind to Sentry operation
+ const op = this._mapSpanKindToOp(opts.kind);
+
+ const spanOpts = {
+ name,
+ ...opts,
+ attributes: {
+ ...opts.attributes,
+ [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'manual',
+ [SEMANTIC_ATTRIBUTE_SENTRY_OP]: op,
+ 'sentry.deno_tracer': true,
+ },
+ };
+
+ const callback = (
+ typeof options === 'function'
+ ? options
+ : typeof context === 'function'
+ ? context
+ : typeof fn === 'function'
+ ? fn
+ : () => {}
+ ) as F;
+
+ // In OTEL the semantic matches `startSpanManual` because spans are not auto-ended
+ return startSpanManual(spanOpts, callback) as ReturnType;
+ }
+
+ private _mapSpanKindToOp(kind?: SpanKind): string {
+ switch (kind) {
+ case SpanKind.CLIENT:
+ return 'http.client';
+ case SpanKind.SERVER:
+ return 'http.server';
+ case SpanKind.PRODUCER:
+ return 'message.produce';
+ case SpanKind.CONSUMER:
+ return 'message.consume';
+ default:
+ return 'otel.span';
+ }
+ }
+}
diff --git a/packages/deno/src/sdk.ts b/packages/deno/src/sdk.ts
index 955417842f94..e670a86f50d6 100644
--- a/packages/deno/src/sdk.ts
+++ b/packages/deno/src/sdk.ts
@@ -16,6 +16,7 @@ import { denoContextIntegration } from './integrations/context';
import { contextLinesIntegration } from './integrations/contextlines';
import { globalHandlersIntegration } from './integrations/globalhandlers';
import { normalizePathsIntegration } from './integrations/normalizepaths';
+import { setupOpenTelemetryTracer } from './opentelemetry/tracer';
import { makeFetchTransport } from './transports';
import type { DenoOptions } from './types';
@@ -97,5 +98,13 @@ export function init(options: DenoOptions = {}): Client {
transport: options.transport || makeFetchTransport,
};
- return initAndBind(DenoClient, clientOptions);
+ const client = initAndBind(DenoClient, clientOptions);
+
+ // Set up OpenTelemetry compatibility to capture spans from libraries using @opentelemetry/api
+ // Note: This is separate from Deno's native OTEL support and doesn't capture auto-instrumented spans
+ if (!options.skipOpenTelemetrySetup) {
+ setupOpenTelemetryTracer();
+ }
+
+ return client;
}
diff --git a/packages/deno/src/types.ts b/packages/deno/src/types.ts
index 422e561bb644..1659e7a635e1 100644
--- a/packages/deno/src/types.ts
+++ b/packages/deno/src/types.ts
@@ -23,6 +23,19 @@ export interface BaseDenoOptions {
/** Sets an optional server name (device name) */
serverName?: string;
+ /**
+ * The Deno SDK is not OpenTelemetry native, however, we set up some OpenTelemetry compatibility
+ * via a custom trace provider.
+ * This ensures that any spans emitted via `@opentelemetry/api` will be captured by Sentry.
+ * HOWEVER, big caveat: This does not handle custom context handling, it will always work off the current scope.
+ * This should be good enough for many, but not all integrations.
+ *
+ * If you want to opt-out of setting up the OpenTelemetry compatibility tracer, set this to `true`.
+ *
+ * @default false
+ */
+ skipOpenTelemetrySetup?: boolean;
+
/** Callback that is executed when a fatal global error occurs. */
onFatalError?(this: void, error: Error): void;
}
diff --git a/packages/deno/test/opentelemetry.test.ts b/packages/deno/test/opentelemetry.test.ts
new file mode 100644
index 000000000000..2c37ddc48843
--- /dev/null
+++ b/packages/deno/test/opentelemetry.test.ts
@@ -0,0 +1,225 @@
+import { assertEquals, assertNotEquals } from 'https://deno.land/std@0.212.0/assert/mod.ts';
+import { context, propagation, trace } from 'npm:@opentelemetry/api@1';
+import type { DenoClient } from '../build/esm/index.js';
+import { getCurrentScope, getGlobalScope, getIsolationScope, init, startSpan } from '../build/esm/index.js';
+
+function resetGlobals(): void {
+ getCurrentScope().clear();
+ getCurrentScope().setClient(undefined);
+ getIsolationScope().clear();
+ getGlobalScope().clear();
+}
+
+function cleanupOtel(): void {
+ // Disable all globally registered APIs
+ trace.disable();
+ context.disable();
+ propagation.disable();
+}
+
+function resetSdk(): void {
+ resetGlobals();
+ cleanupOtel();
+}
+
+Deno.test('should not capture spans emitted via @opentelemetry/api when skipOpenTelemetrySetup is true', async () => {
+ resetSdk();
+ const transactionEvents: any[] = [];
+
+ const client = init({
+ dsn: 'https://username@domain/123',
+ tracesSampleRate: 1,
+ skipOpenTelemetrySetup: true,
+ beforeSendTransaction: event => {
+ transactionEvents.push(event);
+ return null;
+ },
+ }) as DenoClient;
+
+ const tracer = trace.getTracer('test');
+ const span = tracer.startSpan('test');
+ span.end();
+
+ await client.flush();
+
+ tracer.startActiveSpan('test 2', { attributes: { 'test.attribute': 'test' } }, span2 => {
+ const span = tracer.startSpan('test 3', { attributes: { 'test.attribute': 'test2' } });
+ span.end();
+ span2.end();
+ });
+
+ await client.flush();
+
+ assertEquals(transactionEvents.length, 0);
+});
+
+Deno.test('should capture spans emitted via @opentelemetry/api', async () => {
+ resetSdk();
+ const transactionEvents: any[] = [];
+
+ const client = init({
+ dsn: 'https://username@domain/123',
+ tracesSampleRate: 1,
+ beforeSendTransaction: event => {
+ transactionEvents.push(event);
+ return null;
+ },
+ }) as DenoClient;
+
+ const tracer = trace.getTracer('test');
+ const span = tracer.startSpan('test');
+ span.end();
+
+ await client.flush();
+
+ tracer.startActiveSpan('test 2', { attributes: { 'test.attribute': 'test' } }, span2 => {
+ const span = tracer.startSpan('test 3', { attributes: { 'test.attribute': 'test2' } });
+ span.end();
+ span2.end();
+ });
+
+ await client.flush();
+
+ assertEquals(transactionEvents.length, 2);
+ const [transactionEvent, transactionEvent2] = transactionEvents;
+
+ assertEquals(transactionEvent?.spans?.length, 0);
+ assertEquals(transactionEvent?.transaction, 'test');
+ assertEquals(transactionEvent?.contexts?.trace?.data?.['sentry.deno_tracer'], true);
+ assertEquals(transactionEvent?.contexts?.trace?.data?.['sentry.origin'], 'manual');
+ assertEquals(transactionEvent?.contexts?.trace?.data?.['sentry.sample_rate'], 1);
+ assertEquals(transactionEvent?.contexts?.trace?.data?.['sentry.source'], 'custom');
+
+ assertEquals(transactionEvent2?.spans?.length, 1);
+ assertEquals(transactionEvent2?.transaction, 'test 2');
+ assertEquals(transactionEvent2?.contexts?.trace?.data?.['sentry.deno_tracer'], true);
+ assertEquals(transactionEvent2?.contexts?.trace?.data?.['sentry.origin'], 'manual');
+ assertEquals(transactionEvent2?.contexts?.trace?.data?.['sentry.sample_rate'], 1);
+ assertEquals(transactionEvent2?.contexts?.trace?.data?.['sentry.source'], 'custom');
+ assertEquals(transactionEvent2?.contexts?.trace?.data?.['test.attribute'], 'test');
+
+ const childSpan = transactionEvent2?.spans?.[0];
+ assertEquals(childSpan?.description, 'test 3');
+ assertEquals(childSpan?.data?.['sentry.deno_tracer'], true);
+ assertEquals(childSpan?.data?.['sentry.origin'], 'manual');
+ assertEquals(childSpan?.data?.['test.attribute'], 'test2');
+});
+
+Deno.test('opentelemetry spans should interop with Sentry spans', async () => {
+ resetSdk();
+ const transactionEvents: any[] = [];
+
+ const client = init({
+ dsn: 'https://username@domain/123',
+ tracesSampleRate: 1,
+ beforeSendTransaction: event => {
+ transactionEvents.push(event);
+ return null;
+ },
+ }) as DenoClient;
+
+ const tracer = trace.getTracer('test');
+
+ startSpan({ name: 'sentry span' }, () => {
+ const span = tracer.startSpan('otel span');
+ span.end();
+ });
+
+ await client.flush();
+
+ assertEquals(transactionEvents.length, 1);
+ const [transactionEvent] = transactionEvents;
+
+ assertEquals(transactionEvent?.spans?.length, 1);
+ assertEquals(transactionEvent?.transaction, 'sentry span');
+ assertEquals(transactionEvent?.contexts?.trace?.data?.['sentry.origin'], 'manual');
+ assertEquals(transactionEvent?.contexts?.trace?.data?.['sentry.sample_rate'], 1);
+ assertEquals(transactionEvent?.contexts?.trace?.data?.['sentry.source'], 'custom');
+ // Note: Sentry-created spans don't have the deno_tracer marker
+ assertEquals(transactionEvent?.contexts?.trace?.data?.['sentry.deno_tracer'], undefined);
+
+ const otelSpan = transactionEvent?.spans?.[0];
+ assertEquals(otelSpan?.description, 'otel span');
+ assertEquals(otelSpan?.data?.['sentry.deno_tracer'], true);
+ assertEquals(otelSpan?.data?.['sentry.origin'], 'manual');
+});
+
+Deno.test('should be compatible with native Deno OpenTelemetry', async () => {
+ resetSdk();
+
+ const providerBefore = trace.getTracerProvider();
+
+ const client = init({
+ dsn: 'https://username@domain/123',
+ tracesSampleRate: 1,
+ beforeSendTransaction: () => null,
+ }) as DenoClient;
+
+ const providerAfter = trace.getTracerProvider();
+ assertEquals(providerBefore, providerAfter);
+
+ const tracer = trace.getTracer('compat-test');
+ const span = tracer.startSpan('test-span');
+ span.setAttributes({ 'test.compatibility': true });
+ span.end();
+
+ tracer.startActiveSpan('active-span', activeSpan => {
+ activeSpan.end();
+ });
+
+ const otelSpan = tracer.startSpan('post-init-span');
+ otelSpan.end();
+
+ startSpan({ name: 'sentry-span' }, () => {
+ const nestedOtelSpan = tracer.startSpan('nested-otel-span');
+ nestedOtelSpan.end();
+ });
+
+ await client.flush();
+});
+
+Deno.test('should verify native Deno OpenTelemetry works when enabled', async () => {
+ resetSdk();
+
+ // Set environment variable to enable native OTel
+ const originalValue = Deno.env.get('OTEL_DENO');
+ Deno.env.set('OTEL_DENO', 'true');
+
+ try {
+ const client = init({
+ dsn: 'https://username@domain/123',
+ tracesSampleRate: 1,
+ beforeSendTransaction: () => null,
+ }) as DenoClient;
+
+ const provider = trace.getTracerProvider();
+ const tracer = trace.getTracer('native-verification');
+ const span = tracer.startSpan('verification-span');
+
+ if (provider.constructor.name === 'Function') {
+ // Native OTel is active
+ assertNotEquals(span.constructor.name, 'NonRecordingSpan');
+
+ let contextWorks = false;
+ tracer.startActiveSpan('parent-span', parentSpan => {
+ if (trace.getActiveSpan() === parentSpan) {
+ contextWorks = true;
+ }
+ parentSpan.end();
+ });
+ assertEquals(contextWorks, true);
+ }
+
+ span.setAttributes({ 'test.native_otel': true });
+ span.end();
+
+ await client.flush();
+ } finally {
+ // Restore original environment
+ if (originalValue === undefined) {
+ Deno.env.delete('OTEL_DENO');
+ } else {
+ Deno.env.set('OTEL_DENO', originalValue);
+ }
+ }
+});
diff --git a/packages/google-cloud-serverless/src/index.ts b/packages/google-cloud-serverless/src/index.ts
index 83292ab11e46..e8042e4260a8 100644
--- a/packages/google-cloud-serverless/src/index.ts
+++ b/packages/google-cloud-serverless/src/index.ts
@@ -128,6 +128,7 @@ export {
vercelAIIntegration,
logger,
consoleLoggingIntegration,
+ createConsolaReporter,
wrapMcpServerWithSentry,
NODE_VERSION,
featureFlagsIntegration,
diff --git a/packages/nestjs/package.json b/packages/nestjs/package.json
index 132ca2b802b4..f231b220149d 100644
--- a/packages/nestjs/package.json
+++ b/packages/nestjs/package.json
@@ -45,10 +45,10 @@
},
"dependencies": {
"@opentelemetry/api": "^1.9.0",
- "@opentelemetry/core": "^2.0.0",
- "@opentelemetry/instrumentation": "^0.203.0",
- "@opentelemetry/instrumentation-nestjs-core": "0.49.0",
- "@opentelemetry/semantic-conventions": "^1.34.0",
+ "@opentelemetry/core": "^2.1.0",
+ "@opentelemetry/instrumentation": "^0.204.0",
+ "@opentelemetry/instrumentation-nestjs-core": "0.50.0",
+ "@opentelemetry/semantic-conventions": "^1.37.0",
"@sentry/core": "10.11.0",
"@sentry/node": "10.11.0"
},
diff --git a/packages/nextjs/.eslintrc.js b/packages/nextjs/.eslintrc.js
index d255f74ce829..1f0ae547d4e0 100644
--- a/packages/nextjs/.eslintrc.js
+++ b/packages/nextjs/.eslintrc.js
@@ -21,5 +21,11 @@ module.exports = {
'import/no-extraneous-dependencies': 'off',
},
},
+ {
+ files: ['src/config/polyfills/perf_hooks.js'],
+ globals: {
+ globalThis: 'readonly',
+ },
+ },
],
};
diff --git a/packages/nextjs/package.json b/packages/nextjs/package.json
index 0fe39c265264..d4817c742010 100644
--- a/packages/nextjs/package.json
+++ b/packages/nextjs/package.json
@@ -77,7 +77,7 @@
},
"dependencies": {
"@opentelemetry/api": "^1.9.0",
- "@opentelemetry/semantic-conventions": "^1.34.0",
+ "@opentelemetry/semantic-conventions": "^1.37.0",
"@rollup/plugin-commonjs": "28.0.1",
"@sentry-internal/browser-utils": "10.11.0",
"@sentry/bundler-plugin-core": "^4.3.0",
diff --git a/packages/nextjs/rollup.npm.config.mjs b/packages/nextjs/rollup.npm.config.mjs
index 3582cf4574ef..89271a21e9d3 100644
--- a/packages/nextjs/rollup.npm.config.mjs
+++ b/packages/nextjs/rollup.npm.config.mjs
@@ -88,5 +88,20 @@ export default [
},
}),
),
+ ...makeNPMConfigVariants(
+ makeBaseNPMConfig({
+ entrypoints: ['src/config/polyfills/perf_hooks.js'],
+
+ packageSpecificConfig: {
+ output: {
+ // Preserve the original file structure (i.e., so that everything is still relative to `src`)
+ entryFileNames: 'config/polyfills/[name].js',
+
+ // make it so Rollup calms down about the fact that we're combining default and named exports
+ exports: 'named',
+ },
+ },
+ }),
+ ),
...makeOtelLoaders('./build', 'sentry-node'),
];
diff --git a/packages/nextjs/src/common/captureRequestError.ts b/packages/nextjs/src/common/captureRequestError.ts
index fec9d46d0e65..6fd2e83d3188 100644
--- a/packages/nextjs/src/common/captureRequestError.ts
+++ b/packages/nextjs/src/common/captureRequestError.ts
@@ -38,6 +38,7 @@ export function captureRequestError(error: unknown, request: RequestInfo, errorC
captureException(error, {
mechanism: {
handled: false,
+ type: 'auto.function.nextjs.on_request_error',
},
});
diff --git a/packages/nextjs/src/common/pages-router-instrumentation/_error.ts b/packages/nextjs/src/common/pages-router-instrumentation/_error.ts
index b33c648839fa..354fbe0438e2 100644
--- a/packages/nextjs/src/common/pages-router-instrumentation/_error.ts
+++ b/packages/nextjs/src/common/pages-router-instrumentation/_error.ts
@@ -45,7 +45,7 @@ export async function captureUnderscoreErrorException(contextOrProps: ContextOrP
// is what passing a string to `captureException` will wind up doing)
captureException(err || `_error.js called with falsy error (${err})`, {
mechanism: {
- type: 'instrument',
+ type: 'auto.function.nextjs.underscore_error',
handled: false,
data: {
function: '_error.getInitialProps',
diff --git a/packages/nextjs/src/common/pages-router-instrumentation/wrapApiHandlerWithSentry.ts b/packages/nextjs/src/common/pages-router-instrumentation/wrapApiHandlerWithSentry.ts
index a0e4112404cd..4cf8fde751fb 100644
--- a/packages/nextjs/src/common/pages-router-instrumentation/wrapApiHandlerWithSentry.ts
+++ b/packages/nextjs/src/common/pages-router-instrumentation/wrapApiHandlerWithSentry.ts
@@ -112,7 +112,7 @@ export function wrapApiHandlerWithSentry(apiHandler: NextApiHandler, parameteriz
captureException(objectifiedErr, {
mechanism: {
- type: 'instrument',
+ type: 'auto.http.nextjs.api_handler',
handled: false,
data: {
wrapped_handler: wrappingTarget.name,
diff --git a/packages/nextjs/src/common/pages-router-instrumentation/wrapPageComponentWithSentry.ts b/packages/nextjs/src/common/pages-router-instrumentation/wrapPageComponentWithSentry.ts
index b08bdad5e9ab..693341024726 100644
--- a/packages/nextjs/src/common/pages-router-instrumentation/wrapPageComponentWithSentry.ts
+++ b/packages/nextjs/src/common/pages-router-instrumentation/wrapPageComponentWithSentry.ts
@@ -48,6 +48,7 @@ export function wrapPageComponentWithSentry(pageComponent: FunctionComponent | C
captureException(e, {
mechanism: {
handled: false,
+ type: 'auto.function.nextjs.page_class',
},
});
throw e;
@@ -77,6 +78,7 @@ export function wrapPageComponentWithSentry(pageComponent: FunctionComponent | C
captureException(e, {
mechanism: {
handled: false,
+ type: 'auto.function.nextjs.page_function',
},
});
throw e;
diff --git a/packages/nextjs/src/common/utils/wrapperUtils.ts b/packages/nextjs/src/common/utils/wrapperUtils.ts
index 23b960c857cf..5bde1f76f0d4 100644
--- a/packages/nextjs/src/common/utils/wrapperUtils.ts
+++ b/packages/nextjs/src/common/utils/wrapperUtils.ts
@@ -25,7 +25,11 @@ export function withErrorInstrumentation any>(
return await origFunction.apply(this, origFunctionArguments);
} catch (e) {
// TODO: Extract error logic from `withSentry` in here or create a new wrapper with said logic or something like that.
- captureException(e, { mechanism: { handled: false } });
+ captureException(e, {
+ // TODO: check if origFunction.name actually returns the correct name or minified garbage
+ // in this case, we can add another argument to this wrapper with the respective function name
+ mechanism: { handled: false, type: 'auto.function.nextjs.wrapped', data: { function: origFunction.name } },
+ });
throw e;
}
};
@@ -99,7 +103,7 @@ export async function callDataFetcherTraced Promis
try {
return await origFunction(...origFunctionArgs);
} catch (e) {
- captureException(e, { mechanism: { handled: false } });
+ captureException(e, { mechanism: { handled: false, type: 'auto.function.nextjs.data_fetcher' } });
throw e;
}
}
diff --git a/packages/nextjs/src/common/withServerActionInstrumentation.ts b/packages/nextjs/src/common/withServerActionInstrumentation.ts
index e3cc2831d5e4..f5a1170cc44b 100644
--- a/packages/nextjs/src/common/withServerActionInstrumentation.ts
+++ b/packages/nextjs/src/common/withServerActionInstrumentation.ts
@@ -7,6 +7,7 @@ import {
getClient,
getIsolationScope,
handleCallbackErrors,
+ SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,
SEMANTIC_ATTRIBUTE_SENTRY_SOURCE,
SPAN_STATUS_ERROR,
startSpan,
@@ -116,6 +117,7 @@ async function withServerActionInstrumentationImplementation {
@@ -130,6 +132,7 @@ async function withServerActionInstrumentationImplementation a
captureException(err, {
mechanism: {
handled: false,
+ type: 'auto.function.nextjs.generation_function',
+ data: {
+ function: generationFunctionIdentifier,
+ },
},
});
}
diff --git a/packages/nextjs/src/common/wrapMiddlewareWithSentry.ts b/packages/nextjs/src/common/wrapMiddlewareWithSentry.ts
index bd84fb4195b7..ab05fbd5e944 100644
--- a/packages/nextjs/src/common/wrapMiddlewareWithSentry.ts
+++ b/packages/nextjs/src/common/wrapMiddlewareWithSentry.ts
@@ -98,7 +98,7 @@ export function wrapMiddlewareWithSentry(
op: 'http.server.middleware',
attributes: {
[SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: spanSource,
- [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.function.nextjs.wrapMiddlewareWithSentry',
+ [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.function.nextjs.wrap_middleware',
...headerAttributes,
},
},
@@ -108,7 +108,7 @@ export function wrapMiddlewareWithSentry(
error => {
captureException(error, {
mechanism: {
- type: 'instrument',
+ type: 'auto.function.nextjs.wrap_middleware',
handled: false,
},
});
diff --git a/packages/nextjs/src/common/wrapRouteHandlerWithSentry.ts b/packages/nextjs/src/common/wrapRouteHandlerWithSentry.ts
index e10d51321a0e..54858a9bdae2 100644
--- a/packages/nextjs/src/common/wrapRouteHandlerWithSentry.ts
+++ b/packages/nextjs/src/common/wrapRouteHandlerWithSentry.ts
@@ -96,6 +96,7 @@ export function wrapRouteHandlerWithSentry any>(
captureException(error, {
mechanism: {
handled: false,
+ type: 'auto.function.nextjs.route_handler',
},
});
}
diff --git a/packages/nextjs/src/common/wrapServerComponentWithSentry.ts b/packages/nextjs/src/common/wrapServerComponentWithSentry.ts
index f0f8e9df8717..d25225a149f9 100644
--- a/packages/nextjs/src/common/wrapServerComponentWithSentry.ts
+++ b/packages/nextjs/src/common/wrapServerComponentWithSentry.ts
@@ -114,7 +114,7 @@ export function wrapServerComponentWithSentry any>
name: `${componentType} Server Component (${componentRoute})`,
attributes: {
[SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: 'component',
- [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.function.nextjs',
+ [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.function.nextjs.server_component',
'sentry.nextjs.ssr.function.type': componentType,
'sentry.nextjs.ssr.function.route': componentRoute,
},
@@ -136,6 +136,7 @@ export function wrapServerComponentWithSentry any>
captureException(error, {
mechanism: {
handled: false,
+ type: 'auto.function.nextjs.server_component',
},
});
}
diff --git a/packages/nextjs/src/config/polyfills/perf_hooks.js b/packages/nextjs/src/config/polyfills/perf_hooks.js
new file mode 100644
index 000000000000..1a0ce4a2af76
--- /dev/null
+++ b/packages/nextjs/src/config/polyfills/perf_hooks.js
@@ -0,0 +1,26 @@
+// Polyfill for Node.js perf_hooks module in edge runtime
+// This mirrors the polyfill from packages/vercel-edge/rollup.npm.config.mjs
+const __sentry__timeOrigin = Date.now();
+
+// Ensure performance global is available
+if (typeof globalThis !== 'undefined' && globalThis.performance === undefined) {
+ globalThis.performance = {
+ timeOrigin: __sentry__timeOrigin,
+ now: function () {
+ return Date.now() - __sentry__timeOrigin;
+ },
+ };
+}
+
+// Export the performance object for perf_hooks compatibility
+export const performance = globalThis.performance || {
+ timeOrigin: __sentry__timeOrigin,
+ now: function () {
+ return Date.now() - __sentry__timeOrigin;
+ },
+};
+
+// Default export for CommonJS compatibility
+export default {
+ performance,
+};
diff --git a/packages/nextjs/src/config/types.ts b/packages/nextjs/src/config/types.ts
index 1ca5eaa6bab0..55f080fb433e 100644
--- a/packages/nextjs/src/config/types.ts
+++ b/packages/nextjs/src/config/types.ts
@@ -581,6 +581,7 @@ export type BuildContext = {
webpack: {
version: string;
DefinePlugin: new (values: Record) => WebpackPluginInstance;
+ ProvidePlugin: new (values: Record) => WebpackPluginInstance;
};
// eslint-disable-next-line @typescript-eslint/no-explicit-any
defaultLoaders: any; // needed for type tests (test:types)
diff --git a/packages/nextjs/src/config/webpack.ts b/packages/nextjs/src/config/webpack.ts
index b336e1e2ee9b..8741efe81194 100644
--- a/packages/nextjs/src/config/webpack.ts
+++ b/packages/nextjs/src/config/webpack.ts
@@ -60,6 +60,8 @@ export function constructWebpackConfigFunction(
const pageExtensions = userNextConfig.pageExtensions || ['tsx', 'ts', 'jsx', 'js'];
const dotPrefixedPageExtensions = pageExtensions.map(ext => `.${ext}`);
const pageExtensionRegex = pageExtensions.map(escapeStringForRegex).join('|');
+ const nextVersion = nextJsVersion || getNextjsVersion();
+ const { major } = parseSemver(nextVersion || '');
// We add `.ts` and `.js` back in because `pageExtensions` might not be relevant to the instrumentation file
// e.g. user's setting `.mdx`. In that case we still want to default look up
@@ -70,8 +72,6 @@ export function constructWebpackConfigFunction(
warnAboutDeprecatedConfigFiles(projectDir, instrumentationFile, runtime);
}
if (runtime === 'server') {
- const nextJsVersion = getNextjsVersion();
- const { major } = parseSemver(nextJsVersion || '');
// was added in v15 (https://github.com/vercel/next.js/pull/67539)
if (major && major >= 15) {
warnAboutMissingOnRequestErrorHandler(instrumentationFile);
@@ -103,6 +103,11 @@ export function constructWebpackConfigFunction(
addOtelWarningIgnoreRule(newConfig);
+ // Add edge runtime polyfills when building for edge in dev mode
+ if (major && major === 13 && runtime === 'edge' && isDev) {
+ addEdgeRuntimePolyfills(newConfig, buildContext);
+ }
+
let pagesDirPath: string | undefined;
const maybePagesDirPath = path.join(projectDir, 'pages');
const maybeSrcPagesDirPath = path.join(projectDir, 'src', 'pages');
@@ -865,6 +870,24 @@ function addOtelWarningIgnoreRule(newConfig: WebpackConfigObjectWithModuleRules)
}
}
+function addEdgeRuntimePolyfills(newConfig: WebpackConfigObjectWithModuleRules, buildContext: BuildContext): void {
+ // Use ProvidePlugin to inject performance global only when accessed
+ newConfig.plugins = newConfig.plugins || [];
+ newConfig.plugins.push(
+ new buildContext.webpack.ProvidePlugin({
+ performance: [path.resolve(__dirname, 'polyfills', 'perf_hooks.js'), 'performance'],
+ }),
+ );
+
+ // Add module resolution aliases for problematic Node.js modules in edge runtime
+ newConfig.resolve = newConfig.resolve || {};
+ newConfig.resolve.alias = {
+ ...newConfig.resolve.alias,
+ // Redirect perf_hooks imports to a polyfilled version
+ perf_hooks: path.resolve(__dirname, 'polyfills', 'perf_hooks.js'),
+ };
+}
+
function _getModules(projectDir: string): Record {
try {
const packageJson = path.join(projectDir, 'package.json');
diff --git a/packages/nextjs/src/edge/wrapApiHandlerWithSentry.ts b/packages/nextjs/src/edge/wrapApiHandlerWithSentry.ts
index 6002981cfcf4..735caf8d7788 100644
--- a/packages/nextjs/src/edge/wrapApiHandlerWithSentry.ts
+++ b/packages/nextjs/src/edge/wrapApiHandlerWithSentry.ts
@@ -79,7 +79,7 @@ export function wrapApiHandlerWithSentry(
op: op,
attributes: {
[SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: 'route',
- [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.function.nextjs.wrapApiHandlerWithSentry',
+ [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.function.nextjs.wrap_api_handler',
...headerAttributes,
},
},
@@ -89,7 +89,7 @@ export function wrapApiHandlerWithSentry(
error => {
captureException(error, {
mechanism: {
- type: 'instrument',
+ type: 'auto.function.nextjs.wrap_api_handler',
handled: false,
},
});
diff --git a/packages/nextjs/test/config/fixtures.ts b/packages/nextjs/test/config/fixtures.ts
index a3c4feb0123b..5f5d4a2d3504 100644
--- a/packages/nextjs/test/config/fixtures.ts
+++ b/packages/nextjs/test/config/fixtures.ts
@@ -99,7 +99,13 @@ export function getBuildContext(
distDir: '.next',
...materializedNextConfig,
} as NextConfigObject,
- webpack: { version: webpackVersion, DefinePlugin: class {} as any },
+ webpack: {
+ version: webpackVersion,
+ DefinePlugin: class {} as any,
+ ProvidePlugin: class {
+ constructor(public definitions: Record) {}
+ } as any,
+ },
defaultLoaders: true,
totalPages: 2,
isServer: buildTarget === 'server' || buildTarget === 'edge',
diff --git a/packages/nextjs/test/config/webpack/constructWebpackConfig.test.ts b/packages/nextjs/test/config/webpack/constructWebpackConfig.test.ts
index 3a8e86b94e29..7371d35c859a 100644
--- a/packages/nextjs/test/config/webpack/constructWebpackConfig.test.ts
+++ b/packages/nextjs/test/config/webpack/constructWebpackConfig.test.ts
@@ -2,11 +2,13 @@
import '../mocks';
import * as core from '@sentry/core';
import { describe, expect, it, vi } from 'vitest';
+import * as util from '../../../src/config/util';
import * as getWebpackPluginOptionsModule from '../../../src/config/webpackPluginOptions';
import {
CLIENT_SDK_CONFIG_FILE,
clientBuildContext,
clientWebpackConfig,
+ edgeBuildContext,
exportedNextConfig,
serverBuildContext,
serverWebpackConfig,
@@ -185,4 +187,123 @@ describe('constructWebpackConfigFunction()', () => {
});
});
});
+
+ describe('edge runtime polyfills', () => {
+ it('adds polyfills only for edge runtime in dev mode on Next.js 13', async () => {
+ // Mock Next.js version 13 - polyfills should be added
+ vi.spyOn(util, 'getNextjsVersion').mockReturnValue('13.0.0');
+
+ // Test edge runtime in dev mode with Next.js 13 - should add polyfills
+ const edgeDevBuildContext = { ...edgeBuildContext, dev: true };
+ const edgeDevConfig = await materializeFinalWebpackConfig({
+ exportedNextConfig,
+ incomingWebpackConfig: serverWebpackConfig,
+ incomingWebpackBuildContext: edgeDevBuildContext,
+ });
+
+ const edgeProvidePlugin = edgeDevConfig.plugins?.find(plugin => plugin.constructor.name === 'ProvidePlugin');
+ expect(edgeProvidePlugin).toBeDefined();
+ expect(edgeDevConfig.resolve?.alias?.perf_hooks).toMatch(/perf_hooks\.js$/);
+
+ vi.restoreAllMocks();
+ });
+
+ it('does NOT add polyfills for edge runtime in prod mode even on Next.js 13', async () => {
+ // Mock Next.js version 13 - but prod mode should still not add polyfills
+ vi.spyOn(util, 'getNextjsVersion').mockReturnValue('13.0.0');
+
+ // Test edge runtime in prod mode - should NOT add polyfills
+ const edgeProdBuildContext = { ...edgeBuildContext, dev: false };
+ const edgeProdConfig = await materializeFinalWebpackConfig({
+ exportedNextConfig,
+ incomingWebpackConfig: serverWebpackConfig,
+ incomingWebpackBuildContext: edgeProdBuildContext,
+ });
+
+ const edgeProdProvidePlugin = edgeProdConfig.plugins?.find(plugin => plugin.constructor.name === 'ProvidePlugin');
+ expect(edgeProdProvidePlugin).toBeUndefined();
+
+ vi.restoreAllMocks();
+ });
+
+ it('does NOT add polyfills for server runtime even on Next.js 13', async () => {
+ // Mock Next.js version 13
+ vi.spyOn(util, 'getNextjsVersion').mockReturnValue('13.0.0');
+
+ // Test server runtime in dev mode - should NOT add polyfills
+ const serverDevBuildContext = { ...serverBuildContext, dev: true };
+ const serverDevConfig = await materializeFinalWebpackConfig({
+ exportedNextConfig,
+ incomingWebpackConfig: serverWebpackConfig,
+ incomingWebpackBuildContext: serverDevBuildContext,
+ });
+
+ const serverProvidePlugin = serverDevConfig.plugins?.find(plugin => plugin.constructor.name === 'ProvidePlugin');
+ expect(serverProvidePlugin).toBeUndefined();
+
+ vi.restoreAllMocks();
+ });
+
+ it('does NOT add polyfills for client runtime even on Next.js 13', async () => {
+ // Mock Next.js version 13
+ vi.spyOn(util, 'getNextjsVersion').mockReturnValue('13.0.0');
+
+ // Test client runtime in dev mode - should NOT add polyfills
+ const clientDevBuildContext = { ...clientBuildContext, dev: true };
+ const clientDevConfig = await materializeFinalWebpackConfig({
+ exportedNextConfig,
+ incomingWebpackConfig: clientWebpackConfig,
+ incomingWebpackBuildContext: clientDevBuildContext,
+ });
+
+ const clientProvidePlugin = clientDevConfig.plugins?.find(plugin => plugin.constructor.name === 'ProvidePlugin');
+ expect(clientProvidePlugin).toBeUndefined();
+
+ vi.restoreAllMocks();
+ });
+
+ it('does NOT add polyfills for edge runtime in dev mode on Next.js versions other than 13', async () => {
+ const edgeDevBuildContext = { ...edgeBuildContext, dev: true };
+
+ // Test with Next.js 12 - should NOT add polyfills
+ vi.spyOn(util, 'getNextjsVersion').mockReturnValue('12.3.0');
+ const edgeConfigV12 = await materializeFinalWebpackConfig({
+ exportedNextConfig,
+ incomingWebpackConfig: serverWebpackConfig,
+ incomingWebpackBuildContext: edgeDevBuildContext,
+ });
+ expect(edgeConfigV12.plugins?.find(plugin => plugin.constructor.name === 'ProvidePlugin')).toBeUndefined();
+ vi.restoreAllMocks();
+
+ // Test with Next.js 14 - should NOT add polyfills
+ vi.spyOn(util, 'getNextjsVersion').mockReturnValue('14.0.0');
+ const edgeConfigV14 = await materializeFinalWebpackConfig({
+ exportedNextConfig,
+ incomingWebpackConfig: serverWebpackConfig,
+ incomingWebpackBuildContext: edgeDevBuildContext,
+ });
+ expect(edgeConfigV14.plugins?.find(plugin => plugin.constructor.name === 'ProvidePlugin')).toBeUndefined();
+ vi.restoreAllMocks();
+
+ // Test with Next.js 15 - should NOT add polyfills
+ vi.spyOn(util, 'getNextjsVersion').mockReturnValue('15.0.0');
+ const edgeConfigV15 = await materializeFinalWebpackConfig({
+ exportedNextConfig,
+ incomingWebpackConfig: serverWebpackConfig,
+ incomingWebpackBuildContext: edgeDevBuildContext,
+ });
+ expect(edgeConfigV15.plugins?.find(plugin => plugin.constructor.name === 'ProvidePlugin')).toBeUndefined();
+ vi.restoreAllMocks();
+
+ // Test with undefined Next.js version - should NOT add polyfills
+ vi.spyOn(util, 'getNextjsVersion').mockReturnValue(undefined);
+ const edgeConfigUndefined = await materializeFinalWebpackConfig({
+ exportedNextConfig,
+ incomingWebpackConfig: serverWebpackConfig,
+ incomingWebpackBuildContext: edgeDevBuildContext,
+ });
+ expect(edgeConfigUndefined.plugins?.find(plugin => plugin.constructor.name === 'ProvidePlugin')).toBeUndefined();
+ vi.restoreAllMocks();
+ });
+ });
});
diff --git a/packages/node-core/package.json b/packages/node-core/package.json
index 695eea2c6626..8ca46387868a 100644
--- a/packages/node-core/package.json
+++ b/packages/node-core/package.json
@@ -58,12 +58,12 @@
},
"peerDependencies": {
"@opentelemetry/api": "^1.9.0",
- "@opentelemetry/context-async-hooks": "^1.30.1 || ^2.0.0",
- "@opentelemetry/core": "^1.30.1 || ^2.0.0",
+ "@opentelemetry/context-async-hooks": "^1.30.1 || ^2.1.0",
+ "@opentelemetry/core": "^1.30.1 || ^2.1.0",
"@opentelemetry/instrumentation": ">=0.57.1 <1",
- "@opentelemetry/resources": "^1.30.1 || ^2.0.0",
- "@opentelemetry/sdk-trace-base": "^1.30.1 || ^2.0.0",
- "@opentelemetry/semantic-conventions": "^1.34.0"
+ "@opentelemetry/resources": "^1.30.1 || ^2.1.0",
+ "@opentelemetry/sdk-trace-base": "^1.30.1 || ^2.1.0",
+ "@opentelemetry/semantic-conventions": "^1.37.0"
},
"dependencies": {
"@sentry/core": "10.11.0",
@@ -72,12 +72,12 @@
},
"devDependencies": {
"@opentelemetry/api": "^1.9.0",
- "@opentelemetry/context-async-hooks": "^2.0.0",
- "@opentelemetry/core": "^2.0.0",
- "@opentelemetry/instrumentation": "^0.203.0",
- "@opentelemetry/resources": "^2.0.0",
- "@opentelemetry/sdk-trace-base": "^2.0.0",
- "@opentelemetry/semantic-conventions": "^1.34.0",
+ "@opentelemetry/context-async-hooks": "^2.1.0",
+ "@opentelemetry/core": "^2.1.0",
+ "@opentelemetry/instrumentation": "^0.204.0",
+ "@opentelemetry/resources": "^2.1.0",
+ "@opentelemetry/sdk-trace-base": "^2.1.0",
+ "@opentelemetry/semantic-conventions": "^1.37.0",
"@types/node": "^18.19.1"
},
"scripts": {
diff --git a/packages/node-core/src/cron/cron.ts b/packages/node-core/src/cron/cron.ts
index ce6225ced2fa..2c764c877c46 100644
--- a/packages/node-core/src/cron/cron.ts
+++ b/packages/node-core/src/cron/cron.ts
@@ -99,7 +99,12 @@ export function instrumentCron(lib: T & CronJobConstructor, monitorSlug: stri
try {
await onTick(context, onComplete);
} catch (e) {
- captureException(e);
+ captureException(e, {
+ mechanism: {
+ handled: false,
+ type: 'auto.function.cron.instrumentCron',
+ },
+ });
throw e;
}
},
@@ -136,7 +141,12 @@ export function instrumentCron(lib: T & CronJobConstructor, monitorSlug: stri
try {
await onTick(context, onComplete);
} catch (e) {
- captureException(e);
+ captureException(e, {
+ mechanism: {
+ handled: false,
+ type: 'auto.function.cron.instrumentCron',
+ },
+ });
throw e;
}
},
diff --git a/packages/node-core/src/cron/node-cron.ts b/packages/node-core/src/cron/node-cron.ts
index 5b9e48900287..a2374b06d4b5 100644
--- a/packages/node-core/src/cron/node-cron.ts
+++ b/packages/node-core/src/cron/node-cron.ts
@@ -53,7 +53,12 @@ export function instrumentNodeCron(lib: Partial & T): T {
try {
return await callback();
} catch (e) {
- captureException(e);
+ captureException(e, {
+ mechanism: {
+ handled: false,
+ type: 'auto.function.node-cron.instrumentNodeCron',
+ },
+ });
throw e;
}
},
diff --git a/packages/node-core/src/index.ts b/packages/node-core/src/index.ts
index cf581bd63b66..87f96f09ab8e 100644
--- a/packages/node-core/src/index.ts
+++ b/packages/node-core/src/index.ts
@@ -35,7 +35,8 @@ export { getSentryRelease, defaultStackParser } from './sdk/api';
export { createGetModuleFromFilename } from './utils/module';
export { addOriginToSpan } from './utils/addOriginToSpan';
export { getRequestUrl } from './utils/getRequestUrl';
-export { isCjs } from './utils/commonjs';
+export { initializeEsmLoader } from './sdk/esmLoader';
+export { isCjs } from './utils/detection';
export { ensureIsWrapped } from './utils/ensureIsWrapped';
export { createMissingInstrumentationContext } from './utils/createMissingInstrumentationContext';
export { envToBool } from './utils/envToBool';
@@ -126,6 +127,7 @@ export {
zodErrorsIntegration,
profiler,
consoleLoggingIntegration,
+ createConsolaReporter,
consoleIntegration,
wrapMcpServerWithSentry,
featureFlagsIntegration,
diff --git a/packages/node-core/src/integrations/childProcess.ts b/packages/node-core/src/integrations/childProcess.ts
index 6fc6046c7e2f..0e3fcfe4633a 100644
--- a/packages/node-core/src/integrations/childProcess.ts
+++ b/packages/node-core/src/integrations/childProcess.ts
@@ -99,7 +99,7 @@ function captureWorkerThreadEvents(worker: Worker, options: Options): void {
.on('error', error => {
if (options.captureWorkerErrors !== false) {
captureException(error, {
- mechanism: { type: 'instrument', handled: false, data: { threadId: String(threadId) } },
+ mechanism: { type: 'auto.child_process.worker_thread', handled: false, data: { threadId: String(threadId) } },
});
} else {
addBreadcrumb({
diff --git a/packages/node-core/src/integrations/modules.ts b/packages/node-core/src/integrations/modules.ts
index 6724a473b5bb..7079f4a2fab8 100644
--- a/packages/node-core/src/integrations/modules.ts
+++ b/packages/node-core/src/integrations/modules.ts
@@ -1,7 +1,7 @@
import { existsSync, readFileSync } from 'node:fs';
import { dirname, join } from 'node:path';
import type { IntegrationFn } from '@sentry/core';
-import { isCjs } from '../utils/commonjs';
+import { isCjs } from '../utils/detection';
type ModuleInfo = Record;
diff --git a/packages/node-core/src/integrations/onuncaughtexception.ts b/packages/node-core/src/integrations/onuncaughtexception.ts
index 045e2e9f7736..41c4bf96917d 100644
--- a/packages/node-core/src/integrations/onuncaughtexception.ts
+++ b/packages/node-core/src/integrations/onuncaughtexception.ts
@@ -108,7 +108,7 @@ export function makeErrorHandler(client: NodeClient, options: OnUncaughtExceptio
},
mechanism: {
handled: false,
- type: 'onuncaughtexception',
+ type: 'auto.node.onuncaughtexception',
},
});
}
diff --git a/packages/node-core/src/integrations/onunhandledrejection.ts b/packages/node-core/src/integrations/onunhandledrejection.ts
index a11d5c3cf7b0..dbddb2a4c396 100644
--- a/packages/node-core/src/integrations/onunhandledrejection.ts
+++ b/packages/node-core/src/integrations/onunhandledrejection.ts
@@ -69,7 +69,7 @@ export function makeUnhandledPromiseHandler(
},
mechanism: {
handled: false,
- type: 'onunhandledrejection',
+ type: 'auto.node.onunhandledrejection',
},
});
});
diff --git a/packages/node-core/src/integrations/winston.ts b/packages/node-core/src/integrations/winston.ts
index a58a3ea31ad0..63e208920914 100644
--- a/packages/node-core/src/integrations/winston.ts
+++ b/packages/node-core/src/integrations/winston.ts
@@ -35,9 +35,6 @@ interface WinstonTransportOptions {
* @param TransportClass - The Winston transport class to extend.
* @returns The extended transport class.
*
- * @experimental This method will experience breaking changes. This is not yet part of
- * the stable Sentry SDK API and can be changed or removed without warning.
- *
* @example
* ```ts
* const winston = require('winston');
diff --git a/packages/node-core/src/sdk/esmLoader.ts b/packages/node-core/src/sdk/esmLoader.ts
index 2f0d8b405333..14f24f0df311 100644
--- a/packages/node-core/src/sdk/esmLoader.ts
+++ b/packages/node-core/src/sdk/esmLoader.ts
@@ -1,31 +1,31 @@
-import { consoleSandbox, debug, GLOBAL_OBJ } from '@sentry/core';
+import { debug, GLOBAL_OBJ } from '@sentry/core';
import { createAddHookMessageChannel } from 'import-in-the-middle';
-import moduleModule from 'module';
+import * as moduleModule from 'module';
+import { supportsEsmLoaderHooks } from '../utils/detection';
-/** Initialize the ESM loader. */
-export function maybeInitializeEsmLoader(): void {
- const [nodeMajor = 0, nodeMinor = 0] = process.versions.node.split('.').map(Number);
+/**
+ * Initialize the ESM loader - This method is private and not part of the public
+ * API.
+ *
+ * @ignore
+ */
+export function initializeEsmLoader(): void {
+ if (!supportsEsmLoaderHooks()) {
+ return;
+ }
+
+ if (!GLOBAL_OBJ._sentryEsmLoaderHookRegistered) {
+ GLOBAL_OBJ._sentryEsmLoaderHookRegistered = true;
- // Register hook was added in v20.6.0 and v18.19.0
- if (nodeMajor >= 21 || (nodeMajor === 20 && nodeMinor >= 6) || (nodeMajor === 18 && nodeMinor >= 19)) {
- if (!GLOBAL_OBJ._sentryEsmLoaderHookRegistered) {
- try {
- const { addHookMessagePort } = createAddHookMessageChannel();
- // @ts-expect-error register is available in these versions
- moduleModule.register('import-in-the-middle/hook.mjs', import.meta.url, {
- data: { addHookMessagePort, include: [] },
- transferList: [addHookMessagePort],
- });
- } catch (error) {
- debug.warn('Failed to register ESM hook', error);
- }
+ try {
+ const { addHookMessagePort } = createAddHookMessageChannel();
+ // @ts-expect-error register is available in these versions
+ moduleModule.register('import-in-the-middle/hook.mjs', import.meta.url, {
+ data: { addHookMessagePort, include: [] },
+ transferList: [addHookMessagePort],
+ });
+ } catch (error) {
+ debug.warn("Failed to register 'import-in-the-middle' hook", error);
}
- } else {
- consoleSandbox(() => {
- // eslint-disable-next-line no-console
- console.warn(
- `[Sentry] You are using Node.js v${process.versions.node} in ESM mode ("import syntax"). The Sentry Node.js SDK is not compatible with ESM in Node.js versions before 18.19.0 or before 20.6.0. Please either build your application with CommonJS ("require() syntax"), or upgrade your Node.js version.`,
- );
- });
}
}
diff --git a/packages/node-core/src/sdk/index.ts b/packages/node-core/src/sdk/index.ts
index e5b12166d962..c4a16d76a1d0 100644
--- a/packages/node-core/src/sdk/index.ts
+++ b/packages/node-core/src/sdk/index.ts
@@ -35,11 +35,11 @@ import { INTEGRATION_NAME as SPOTLIGHT_INTEGRATION_NAME, spotlightIntegration }
import { systemErrorIntegration } from '../integrations/systemError';
import { makeNodeTransport } from '../transports';
import type { NodeClientOptions, NodeOptions } from '../types';
-import { isCjs } from '../utils/commonjs';
+import { isCjs } from '../utils/detection';
import { envToBool } from '../utils/envToBool';
import { defaultStackParser, getSentryRelease } from './api';
import { NodeClient } from './client';
-import { maybeInitializeEsmLoader } from './esmLoader';
+import { initializeEsmLoader } from './esmLoader';
/**
* Get default integrations for the Node-Core SDK.
@@ -106,8 +106,8 @@ function _init(
}
}
- if (!isCjs() && options.registerEsmLoaderHooks !== false) {
- maybeInitializeEsmLoader();
+ if (options.registerEsmLoaderHooks !== false) {
+ initializeEsmLoader();
}
setOpenTelemetryContextAsyncContextStrategy();
@@ -131,7 +131,7 @@ function _init(
client.init();
- debug.log(`Running in ${isCjs() ? 'CommonJS' : 'ESM'} mode.`);
+ debug.log(`SDK initialized from ${isCjs() ? 'CommonJS' : 'ESM'}`);
client.startClientReportTracking();
diff --git a/packages/node-core/src/utils/commonjs.ts b/packages/node-core/src/utils/commonjs.ts
deleted file mode 100644
index 23a9b97f9fc1..000000000000
--- a/packages/node-core/src/utils/commonjs.ts
+++ /dev/null
@@ -1,8 +0,0 @@
-/** Detect CommonJS. */
-export function isCjs(): boolean {
- try {
- return typeof module !== 'undefined' && typeof module.exports !== 'undefined';
- } catch {
- return false;
- }
-}
diff --git a/packages/node-core/src/utils/createMissingInstrumentationContext.ts b/packages/node-core/src/utils/createMissingInstrumentationContext.ts
index 1930bcf782eb..3af8dc9e176a 100644
--- a/packages/node-core/src/utils/createMissingInstrumentationContext.ts
+++ b/packages/node-core/src/utils/createMissingInstrumentationContext.ts
@@ -1,5 +1,5 @@
import type { MissingInstrumentationContext } from '@sentry/core';
-import { isCjs } from './commonjs';
+import { isCjs } from './detection';
export const createMissingInstrumentationContext = (pkg: string): MissingInstrumentationContext => ({
package: pkg,
diff --git a/packages/node-core/src/utils/detection.ts b/packages/node-core/src/utils/detection.ts
new file mode 100644
index 000000000000..f7ae9a792c27
--- /dev/null
+++ b/packages/node-core/src/utils/detection.ts
@@ -0,0 +1,39 @@
+import { consoleSandbox } from '@sentry/core';
+import { NODE_MAJOR, NODE_MINOR } from '../nodeVersion';
+
+/** Detect CommonJS. */
+export function isCjs(): boolean {
+ try {
+ return typeof module !== 'undefined' && typeof module.exports !== 'undefined';
+ } catch {
+ return false;
+ }
+}
+
+let hasWarnedAboutNodeVersion: boolean | undefined;
+
+/**
+ * Check if the current Node.js version supports module.register
+ */
+export function supportsEsmLoaderHooks(): boolean {
+ if (isCjs()) {
+ return false;
+ }
+
+ if (NODE_MAJOR >= 21 || (NODE_MAJOR === 20 && NODE_MINOR >= 6) || (NODE_MAJOR === 18 && NODE_MINOR >= 19)) {
+ return true;
+ }
+
+ if (!hasWarnedAboutNodeVersion) {
+ hasWarnedAboutNodeVersion = true;
+
+ consoleSandbox(() => {
+ // eslint-disable-next-line no-console
+ console.warn(
+ `[Sentry] You are using Node.js v${process.versions.node} in ESM mode ("import syntax"). The Sentry Node.js SDK is not compatible with ESM in Node.js versions before 18.19.0 or before 20.6.0. Please either build your application with CommonJS ("require() syntax"), or upgrade your Node.js version.`,
+ );
+ });
+ }
+
+ return false;
+}
diff --git a/packages/node-core/src/utils/ensureIsWrapped.ts b/packages/node-core/src/utils/ensureIsWrapped.ts
index 70253d9debb7..a73c087ebaf2 100644
--- a/packages/node-core/src/utils/ensureIsWrapped.ts
+++ b/packages/node-core/src/utils/ensureIsWrapped.ts
@@ -1,8 +1,8 @@
import { isWrapped } from '@opentelemetry/instrumentation';
import { consoleSandbox, getClient, getGlobalScope, hasSpansEnabled, isEnabled } from '@sentry/core';
import type { NodeClient } from '../sdk/client';
-import { isCjs } from './commonjs';
import { createMissingInstrumentationContext } from './createMissingInstrumentationContext';
+import { isCjs } from './detection';
/**
* Checks and warns if a framework isn't wrapped by opentelemetry.
diff --git a/packages/node/package.json b/packages/node/package.json
index 77856d85df3a..ba44a688d33b 100644
--- a/packages/node/package.json
+++ b/packages/node/package.json
@@ -66,35 +66,35 @@
},
"dependencies": {
"@opentelemetry/api": "^1.9.0",
- "@opentelemetry/context-async-hooks": "^2.0.0",
- "@opentelemetry/core": "^2.0.0",
- "@opentelemetry/instrumentation": "^0.203.0",
- "@opentelemetry/instrumentation-amqplib": "0.50.0",
- "@opentelemetry/instrumentation-connect": "0.47.0",
- "@opentelemetry/instrumentation-dataloader": "0.21.1",
- "@opentelemetry/instrumentation-express": "0.52.0",
- "@opentelemetry/instrumentation-fs": "0.23.0",
- "@opentelemetry/instrumentation-generic-pool": "0.47.0",
- "@opentelemetry/instrumentation-graphql": "0.51.0",
- "@opentelemetry/instrumentation-hapi": "0.50.0",
- "@opentelemetry/instrumentation-http": "0.203.0",
+ "@opentelemetry/context-async-hooks": "^2.1.0",
+ "@opentelemetry/core": "^2.1.0",
+ "@opentelemetry/instrumentation": "^0.204.0",
+ "@opentelemetry/instrumentation-amqplib": "0.51.0",
+ "@opentelemetry/instrumentation-connect": "0.48.0",
+ "@opentelemetry/instrumentation-dataloader": "0.22.0",
+ "@opentelemetry/instrumentation-express": "0.53.0",
+ "@opentelemetry/instrumentation-fs": "0.24.0",
+ "@opentelemetry/instrumentation-generic-pool": "0.48.0",
+ "@opentelemetry/instrumentation-graphql": "0.52.0",
+ "@opentelemetry/instrumentation-hapi": "0.51.0",
+ "@opentelemetry/instrumentation-http": "0.204.0",
"@opentelemetry/instrumentation-ioredis": "0.52.0",
- "@opentelemetry/instrumentation-kafkajs": "0.13.0",
- "@opentelemetry/instrumentation-knex": "0.48.0",
- "@opentelemetry/instrumentation-koa": "0.51.0",
- "@opentelemetry/instrumentation-lru-memoizer": "0.48.0",
- "@opentelemetry/instrumentation-mongodb": "0.56.0",
- "@opentelemetry/instrumentation-mongoose": "0.50.0",
- "@opentelemetry/instrumentation-mysql": "0.49.0",
- "@opentelemetry/instrumentation-mysql2": "0.50.0",
- "@opentelemetry/instrumentation-pg": "0.55.0",
- "@opentelemetry/instrumentation-redis": "0.51.0",
- "@opentelemetry/instrumentation-tedious": "0.22.0",
- "@opentelemetry/instrumentation-undici": "0.14.0",
- "@opentelemetry/resources": "^2.0.0",
- "@opentelemetry/sdk-trace-base": "^2.0.0",
- "@opentelemetry/semantic-conventions": "^1.34.0",
- "@prisma/instrumentation": "6.14.0",
+ "@opentelemetry/instrumentation-kafkajs": "0.14.0",
+ "@opentelemetry/instrumentation-knex": "0.49.0",
+ "@opentelemetry/instrumentation-koa": "0.52.0",
+ "@opentelemetry/instrumentation-lru-memoizer": "0.49.0",
+ "@opentelemetry/instrumentation-mongodb": "0.57.0",
+ "@opentelemetry/instrumentation-mongoose": "0.51.0",
+ "@opentelemetry/instrumentation-mysql": "0.50.0",
+ "@opentelemetry/instrumentation-mysql2": "0.51.0",
+ "@opentelemetry/instrumentation-pg": "0.57.0",
+ "@opentelemetry/instrumentation-redis": "0.53.0",
+ "@opentelemetry/instrumentation-tedious": "0.23.0",
+ "@opentelemetry/instrumentation-undici": "0.15.0",
+ "@opentelemetry/resources": "^2.1.0",
+ "@opentelemetry/sdk-trace-base": "^2.1.0",
+ "@opentelemetry/semantic-conventions": "^1.37.0",
+ "@prisma/instrumentation": "6.15.0",
"@sentry/core": "10.11.0",
"@sentry/node-core": "10.11.0",
"@sentry/opentelemetry": "10.11.0",
diff --git a/packages/node/src/index.ts b/packages/node/src/index.ts
index f510ca733d19..84603db7e575 100644
--- a/packages/node/src/index.ts
+++ b/packages/node/src/index.ts
@@ -127,6 +127,7 @@ export {
zodErrorsIntegration,
profiler,
consoleLoggingIntegration,
+ createConsolaReporter,
consoleIntegration,
wrapMcpServerWithSentry,
featureFlagsIntegration,
diff --git a/packages/node/src/integrations/tracing/connect.ts b/packages/node/src/integrations/tracing/connect.ts
index c2ab3716bd33..3fd7d10b28fb 100644
--- a/packages/node/src/integrations/tracing/connect.ts
+++ b/packages/node/src/integrations/tracing/connect.ts
@@ -48,7 +48,12 @@ export const connectIntegration = defineIntegration(_connectIntegration);
// eslint-disable-next-line @typescript-eslint/no-explicit-any
function connectErrorMiddleware(err: any, req: any, res: any, next: any): void {
- captureException(err);
+ captureException(err, {
+ mechanism: {
+ handled: false,
+ type: 'auto.middleware.connect',
+ },
+ });
next(err);
}
diff --git a/packages/node/src/integrations/tracing/express.ts b/packages/node/src/integrations/tracing/express.ts
index fed0a65cfd0b..e645cc24d31e 100644
--- a/packages/node/src/integrations/tracing/express.ts
+++ b/packages/node/src/integrations/tracing/express.ts
@@ -130,7 +130,7 @@ export function expressErrorHandler(options?: ExpressHandlerOptions): ExpressErr
const shouldHandleError = options?.shouldHandleError || defaultShouldHandleError;
if (shouldHandleError(error)) {
- const eventId = captureException(error, { mechanism: { type: 'middleware', handled: false } });
+ const eventId = captureException(error, { mechanism: { type: 'auto.middleware.express', handled: false } });
(res as { sentry?: string }).sentry = eventId;
}
diff --git a/packages/node/src/integrations/tracing/fastify/index.ts b/packages/node/src/integrations/tracing/fastify/index.ts
index 65d783eb8be7..084c50a6957e 100644
--- a/packages/node/src/integrations/tracing/fastify/index.ts
+++ b/packages/node/src/integrations/tracing/fastify/index.ts
@@ -132,7 +132,7 @@ function handleFastifyError(
}
if (shouldHandleError(error, request, reply)) {
- captureException(error, { mechanism: { handled: false, type: 'fastify' } });
+ captureException(error, { mechanism: { handled: false, type: 'auto.function.fastify' } });
}
}
diff --git a/packages/node/src/integrations/tracing/firebase/otel/patches/firestore.ts b/packages/node/src/integrations/tracing/firebase/otel/patches/firestore.ts
index b450be959b69..cc28aded8e8c 100644
--- a/packages/node/src/integrations/tracing/firebase/otel/patches/firestore.ts
+++ b/packages/node/src/integrations/tracing/firebase/otel/patches/firestore.ts
@@ -16,7 +16,6 @@ import {
ATTR_SERVER_PORT,
} from '@opentelemetry/semantic-conventions';
import type { SpanAttributes } from '@sentry/core';
-import type { unwrap as shimmerUnwrap, wrap as shimmerWrap } from 'shimmer';
import type { FirebaseInstrumentation } from '../firebaseInstrumentation';
import type {
AddDocType,
@@ -37,6 +36,11 @@ import type {
WithFieldValue,
} from '../types';
+// Inline minimal types used from `shimmer` to avoid importing shimmer's types directly.
+// We only need the shape for `wrap` and `unwrap` used in this file.
+type ShimmerWrap = (target: any, name: string, wrapper: (...args: any[]) => any) => void;
+type ShimmerUnwrap = (target: any, name: string) => void;
+
/**
*
* @param tracer - Opentelemetry Tracer
@@ -47,8 +51,8 @@ import type {
export function patchFirestore(
tracer: Tracer,
firestoreSupportedVersions: string[],
- wrap: typeof shimmerWrap,
- unwrap: typeof shimmerUnwrap,
+ wrap: ShimmerWrap,
+ unwrap: ShimmerUnwrap,
config: FirebaseInstrumentationConfig,
): InstrumentationNodeModuleDefinition {
// eslint-disable-next-line @typescript-eslint/no-empty-function
@@ -102,8 +106,8 @@ export function patchFirestore(
function wrapMethods(
// eslint-disable-next-line @typescript-eslint/no-explicit-any
moduleExports: any,
- wrap: typeof shimmerWrap,
- unwrap: typeof shimmerUnwrap,
+ wrap: ShimmerWrap,
+ unwrap: ShimmerUnwrap,
tracer: Tracer,
firestoreSpanCreationHook: FirestoreSpanCreationHook,
// eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -121,7 +125,7 @@ function wrapMethods(
function unwrapMethods(
// eslint-disable-next-line @typescript-eslint/no-explicit-any
moduleExports: any,
- unwrap: typeof shimmerUnwrap,
+ unwrap: ShimmerUnwrap,
// eslint-disable-next-line @typescript-eslint/no-explicit-any
): any {
for (const method of ['addDoc', 'getDocs', 'setDoc', 'deleteDoc']) {
diff --git a/packages/node/src/integrations/tracing/hapi/index.ts b/packages/node/src/integrations/tracing/hapi/index.ts
index eaa8d9c56ad9..a8a64c0b0714 100644
--- a/packages/node/src/integrations/tracing/hapi/index.ts
+++ b/packages/node/src/integrations/tracing/hapi/index.ts
@@ -54,11 +54,8 @@ function isErrorEvent(event: unknown): event is RequestEvent {
function sendErrorToSentry(errorData: object): void {
captureException(errorData, {
mechanism: {
- type: 'hapi',
+ type: 'auto.function.hapi',
handled: false,
- data: {
- function: 'hapiErrorPlugin',
- },
},
});
}
diff --git a/packages/node/src/integrations/tracing/koa.ts b/packages/node/src/integrations/tracing/koa.ts
index 487f471a9a12..7125479e91e0 100644
--- a/packages/node/src/integrations/tracing/koa.ts
+++ b/packages/node/src/integrations/tracing/koa.ts
@@ -134,7 +134,12 @@ export const setupKoaErrorHandler = (app: { use: (arg0: (ctx: any, next: any) =>
try {
await next();
} catch (error) {
- captureException(error);
+ captureException(error, {
+ mechanism: {
+ handled: false,
+ type: 'auto.middleware.koa',
+ },
+ });
throw error;
}
});
diff --git a/packages/node/src/integrations/tracing/prisma.ts b/packages/node/src/integrations/tracing/prisma.ts
index bc845362b6bb..503e8c1908a4 100644
--- a/packages/node/src/integrations/tracing/prisma.ts
+++ b/packages/node/src/integrations/tracing/prisma.ts
@@ -1,4 +1,7 @@
+import type { Link, Tracer } from '@opentelemetry/api';
+import { context, SpanKind, trace, TraceFlags } from '@opentelemetry/api';
import type { Instrumentation } from '@opentelemetry/instrumentation';
+import type { IdGenerator } from '@opentelemetry/sdk-trace-base';
import { PrismaInstrumentation } from '@prisma/instrumentation';
import { consoleSandbox, defineIntegration, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, spanToJSON } from '@sentry/core';
import { generateInstrumentOnce } from '@sentry/node-core';
@@ -9,6 +12,27 @@ const INTEGRATION_NAME = 'Prisma';
type CompatibilityLayerTraceHelper = PrismaV5TracingHelper & PrismaV6TracingHelper;
+// Vendored in from @prisma/instrumentation v5:
+type V5EngineSpanEvent = {
+ span: boolean;
+ spans: V5EngineSpan[];
+};
+
+type V5EngineSpanKind = 'client' | 'internal';
+
+type V5EngineSpan = {
+ span: boolean;
+ name: string;
+ trace_id: string;
+ span_id: string;
+ parent_span_id: string;
+ start_time: [number, number];
+ end_time: [number, number];
+ attributes?: Record;
+ links?: { trace_id: string; span_id: string }[];
+ kind: V5EngineSpanKind;
+};
+
function isPrismaV6TracingHelper(helper: unknown): helper is PrismaV6TracingHelper {
return !!helper && typeof helper === 'object' && 'dispatchEngineSpans' in helper;
}
@@ -25,6 +49,17 @@ function getPrismaTracingHelper(): unknown | undefined {
return prismaTracingHelper;
}
+type TracerWithIdGenerator = Tracer & {
+ _idGenerator?: IdGenerator;
+};
+
+interface PrismaOptions {
+ /**
+ * @deprecated This is no longer used, v5 works out of the box.
+ */
+ prismaInstrumentation?: Instrumentation;
+}
+
class SentryPrismaInteropInstrumentation extends PrismaInstrumentation {
public constructor() {
super();
@@ -35,38 +70,104 @@ class SentryPrismaInteropInstrumentation extends PrismaInstrumentation {
// The PrismaIntegration (super class) defines a global variable `global["PRISMA_INSTRUMENTATION"]` when `enable()` is called. This global variable holds a "TracingHelper" which Prisma uses internally to create tracing data. It's their way of not depending on OTEL with their main package. The sucky thing is, prisma broke the interface of the tracing helper with the v6 major update. This means that if you use Prisma 5 with the v6 instrumentation (or vice versa) Prisma just blows up, because tries to call methods on the helper that no longer exist.
// Because we actually want to use the v6 instrumentation and not blow up in Prisma 5 user's faces, what we're doing here is backfilling the v5 method (`createEngineSpan`) with a noop so that no longer crashes when it attempts to call that function.
- // We still won't fully emit all the spans, but this could potentially be implemented in the future.
const prismaTracingHelper = getPrismaTracingHelper();
- let emittedWarning = false;
-
if (isPrismaV6TracingHelper(prismaTracingHelper)) {
- (prismaTracingHelper as CompatibilityLayerTraceHelper).createEngineSpan = () => {
- consoleSandbox(() => {
- if (!emittedWarning) {
- emittedWarning = true;
+ // Inspired & adjusted from https://github.com/prisma/prisma/tree/5.22.0/packages/instrumentation
+ (prismaTracingHelper as CompatibilityLayerTraceHelper).createEngineSpan = (
+ engineSpanEvent: V5EngineSpanEvent,
+ ) => {
+ const tracer = trace.getTracer('prismaV5Compatibility') as TracerWithIdGenerator;
+
+ // Prisma v5 relies on being able to create spans with a specific span & trace ID
+ // this is no longer possible in OTEL v2, there is no public API to do this anymore
+ // So in order to kind of hack this possibility, we rely on the internal `_idGenerator` property
+ // This is used to generate the random IDs, and we overwrite this temporarily to generate static IDs
+ // This is flawed and may not work, e.g. if the code is bundled and the private property is renamed
+ // in such cases, these spans will not be captured and some Prisma spans will be missing
+ const initialIdGenerator = tracer._idGenerator;
+
+ if (!initialIdGenerator) {
+ consoleSandbox(() => {
// eslint-disable-next-line no-console
console.warn(
- '[Sentry] The Sentry SDK supports tracing with Prisma version 5 only with limited capabilities. For full tracing capabilities pass `prismaInstrumentation` for version 5 to the Sentry `prismaIntegration`. Read more: https://docs.sentry.io/platforms/javascript/guides/node/configuration/integrations/prisma/',
+ '[Sentry] Could not find _idGenerator on tracer, skipping Prisma v5 compatibility - some Prisma spans may be missing!',
);
- }
- });
+ });
+
+ return;
+ }
+
+ try {
+ engineSpanEvent.spans.forEach(engineSpan => {
+ const kind = engineSpanKindToOTELSpanKind(engineSpan.kind);
+
+ const parentSpanId = engineSpan.parent_span_id;
+ const spanId = engineSpan.span_id;
+ const traceId = engineSpan.trace_id;
+
+ const links: Link[] | undefined = engineSpan.links?.map(link => {
+ return {
+ context: {
+ traceId: link.trace_id,
+ spanId: link.span_id,
+ traceFlags: TraceFlags.SAMPLED,
+ },
+ };
+ });
+
+ const ctx = trace.setSpanContext(context.active(), {
+ traceId,
+ spanId: parentSpanId,
+ traceFlags: TraceFlags.SAMPLED,
+ });
+
+ context.with(ctx, () => {
+ const temporaryIdGenerator: IdGenerator = {
+ generateTraceId: () => {
+ return traceId;
+ },
+ generateSpanId: () => {
+ return spanId;
+ },
+ };
+
+ tracer._idGenerator = temporaryIdGenerator;
+
+ const span = tracer.startSpan(engineSpan.name, {
+ kind,
+ links,
+ startTime: engineSpan.start_time,
+ attributes: engineSpan.attributes,
+ });
+
+ span.end(engineSpan.end_time);
+
+ tracer._idGenerator = initialIdGenerator;
+ });
+ });
+ } finally {
+ // Ensure we always restore this at the end, even if something errors
+ tracer._idGenerator = initialIdGenerator;
+ }
};
}
}
}
-export const instrumentPrisma = generateInstrumentOnce<{ prismaInstrumentation?: Instrumentation }>(
- INTEGRATION_NAME,
- options => {
- // Use a passed instrumentation instance to support older Prisma versions
- if (options?.prismaInstrumentation) {
- return options.prismaInstrumentation;
- }
+function engineSpanKindToOTELSpanKind(engineSpanKind: V5EngineSpanKind): SpanKind {
+ switch (engineSpanKind) {
+ case 'client':
+ return SpanKind.CLIENT;
+ case 'internal':
+ default: // Other span kinds aren't currently supported
+ return SpanKind.INTERNAL;
+ }
+}
- return new SentryPrismaInteropInstrumentation();
- },
-);
+export const instrumentPrisma = generateInstrumentOnce(INTEGRATION_NAME, _options => {
+ return new SentryPrismaInteropInstrumentation();
+});
/**
* Adds Sentry tracing instrumentation for the [prisma](https://www.npmjs.com/package/prisma) library.
@@ -100,49 +201,36 @@ export const instrumentPrisma = generateInstrumentOnce<{ prismaInstrumentation?:
* }
* ```
*/
-export const prismaIntegration = defineIntegration(
- ({
- prismaInstrumentation,
- }: {
- /**
- * Overrides the instrumentation used by the Sentry SDK with the passed in instrumentation instance.
- *
- * NOTE: By default, the Sentry SDK uses the Prisma v6 instrumentation. Use this option if you need performance instrumentation different Prisma versions.
- *
- * For more information refer to the documentation of `prismaIntegration()` or see https://docs.sentry.io/platforms/javascript/guides/node/configuration/integrations/prisma/
- */
- prismaInstrumentation?: Instrumentation;
- } = {}) => {
- return {
- name: INTEGRATION_NAME,
- setupOnce() {
- instrumentPrisma({ prismaInstrumentation });
- },
- setup(client) {
- // If no tracing helper exists, we skip any work here
- // this means that prisma is not being used
- if (!getPrismaTracingHelper()) {
- return;
+export const prismaIntegration = defineIntegration((_options?: PrismaOptions) => {
+ return {
+ name: INTEGRATION_NAME,
+ setupOnce() {
+ instrumentPrisma();
+ },
+ setup(client) {
+ // If no tracing helper exists, we skip any work here
+ // this means that prisma is not being used
+ if (!getPrismaTracingHelper()) {
+ return;
+ }
+
+ client.on('spanStart', span => {
+ const spanJSON = spanToJSON(span);
+ if (spanJSON.description?.startsWith('prisma:')) {
+ span.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, 'auto.db.otel.prisma');
+ }
+
+ // Make sure we use the query text as the span name, for ex. SELECT * FROM "User" WHERE "id" = $1
+ if (spanJSON.description === 'prisma:engine:db_query' && spanJSON.data['db.query.text']) {
+ span.updateName(spanJSON.data['db.query.text'] as string);
}
- client.on('spanStart', span => {
- const spanJSON = spanToJSON(span);
- if (spanJSON.description?.startsWith('prisma:')) {
- span.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, 'auto.db.otel.prisma');
- }
-
- // Make sure we use the query text as the span name, for ex. SELECT * FROM "User" WHERE "id" = $1
- if (spanJSON.description === 'prisma:engine:db_query' && spanJSON.data['db.query.text']) {
- span.updateName(spanJSON.data['db.query.text'] as string);
- }
-
- // In Prisma v5.22+, the `db.system` attribute is automatically set
- // On older versions, this is missing, so we add it here
- if (spanJSON.description === 'prisma:engine:db_query' && !spanJSON.data['db.system']) {
- span.setAttribute('db.system', 'prisma');
- }
- });
- },
- };
- },
-);
+ // In Prisma v5.22+, the `db.system` attribute is automatically set
+ // On older versions, this is missing, so we add it here
+ if (spanJSON.description === 'prisma:engine:db_query' && !spanJSON.data['db.system']) {
+ span.setAttribute('db.system', 'prisma');
+ }
+ });
+ },
+ };
+});
diff --git a/packages/node/src/integrations/tracing/vercelai/instrumentation.ts b/packages/node/src/integrations/tracing/vercelai/instrumentation.ts
index 0b66f7e80919..bf32d417c42e 100644
--- a/packages/node/src/integrations/tracing/vercelai/instrumentation.ts
+++ b/packages/node/src/integrations/tracing/vercelai/instrumentation.ts
@@ -9,6 +9,7 @@ import {
getActiveSpan,
getCurrentScope,
handleCallbackErrors,
+ isThenable,
SDK_VERSION,
withScope,
} from '@sentry/core';
@@ -71,7 +72,7 @@ function isToolError(obj: unknown): obj is ToolError {
* Check for tool errors in the result and capture them
* Tool errors are not rejected in Vercel V5, it is added as metadata to the result content
*/
-function checkResultForToolErrors(result: unknown | Promise): void {
+function checkResultForToolErrors(result: unknown): void {
if (typeof result !== 'object' || result === null || !('content' in result)) {
return;
}
@@ -236,13 +237,18 @@ export class SentryVercelAiInstrumentation extends InstrumentationBase {
};
return handleCallbackErrors(
- async () => {
+ () => {
// @ts-expect-error we know that the method exists
- const result = await originalMethod.apply(this, args);
+ const result = originalMethod.apply(this, args);
- // Tool errors are not rejected in Vercel V5, it is added as metadata to the result content
- checkResultForToolErrors(result);
+ if (isThenable(result)) {
+ // check for tool errors when the promise resolves, keep the original promise identity
+ result.then(checkResultForToolErrors, () => {});
+ return result;
+ }
+ // check for tool errors when the result is synchronous
+ checkResultForToolErrors(result);
return result;
},
error => {
diff --git a/packages/node/src/sdk/initOtel.ts b/packages/node/src/sdk/initOtel.ts
index ef27be0514c3..67de29821537 100644
--- a/packages/node/src/sdk/initOtel.ts
+++ b/packages/node/src/sdk/initOtel.ts
@@ -7,11 +7,14 @@ import {
ATTR_SERVICE_VERSION,
SEMRESATTRS_SERVICE_NAMESPACE,
} from '@opentelemetry/semantic-conventions';
-import { consoleSandbox, debug as coreDebug, GLOBAL_OBJ, SDK_VERSION } from '@sentry/core';
-import { type NodeClient, isCjs, SentryContextManager, setupOpenTelemetryLogger } from '@sentry/node-core';
+import { debug as coreDebug, SDK_VERSION } from '@sentry/core';
+import {
+ type NodeClient,
+ initializeEsmLoader,
+ SentryContextManager,
+ setupOpenTelemetryLogger,
+} from '@sentry/node-core';
import { SentryPropagator, SentrySampler, SentrySpanProcessor } from '@sentry/opentelemetry';
-import { createAddHookMessageChannel } from 'import-in-the-middle';
-import moduleModule from 'module';
import { DEBUG_BUILD } from '../debug-build';
import { getOpenTelemetryInstrumentationToPreload } from '../integrations/tracing';
@@ -35,34 +38,6 @@ export function initOpenTelemetry(client: NodeClient, options: AdditionalOpenTel
client.traceProvider = provider;
}
-/** Initialize the ESM loader. */
-export function maybeInitializeEsmLoader(): void {
- const [nodeMajor = 0, nodeMinor = 0] = process.versions.node.split('.').map(Number);
-
- // Register hook was added in v20.6.0 and v18.19.0
- if (nodeMajor >= 21 || (nodeMajor === 20 && nodeMinor >= 6) || (nodeMajor === 18 && nodeMinor >= 19)) {
- if (!GLOBAL_OBJ._sentryEsmLoaderHookRegistered) {
- try {
- const { addHookMessagePort } = createAddHookMessageChannel();
- // @ts-expect-error register is available in these versions
- moduleModule.register('import-in-the-middle/hook.mjs', import.meta.url, {
- data: { addHookMessagePort, include: [] },
- transferList: [addHookMessagePort],
- });
- } catch (error) {
- coreDebug.warn('Failed to register ESM hook', error);
- }
- }
- } else {
- consoleSandbox(() => {
- // eslint-disable-next-line no-console
- console.warn(
- `[Sentry] You are using Node.js v${process.versions.node} in ESM mode ("import syntax"). The Sentry Node.js SDK is not compatible with ESM in Node.js versions before 18.19.0 or before 20.6.0. Please either build your application with CommonJS ("require() syntax"), or upgrade your Node.js version.`,
- );
- });
- }
-}
-
interface NodePreloadOptions {
debug?: boolean;
integrations?: string[];
@@ -80,9 +55,7 @@ export function preloadOpenTelemetry(options: NodePreloadOptions = {}): void {
coreDebug.enable();
}
- if (!isCjs()) {
- maybeInitializeEsmLoader();
- }
+ initializeEsmLoader();
// These are all integrations that we need to pre-load to ensure they are set up before any other code runs
getPreloadMethods(options.integrations).forEach(fn => {
diff --git a/packages/nuxt/src/runtime/hooks/captureErrorHook.ts b/packages/nuxt/src/runtime/hooks/captureErrorHook.ts
index 7a27b7e6e4c6..9c2bc1011277 100644
--- a/packages/nuxt/src/runtime/hooks/captureErrorHook.ts
+++ b/packages/nuxt/src/runtime/hooks/captureErrorHook.ts
@@ -40,7 +40,7 @@ export async function sentryCaptureErrorHook(error: Error, errorContext: Capture
captureException(error, {
captureContext: { contexts: { nuxt: structuredContext } },
- mechanism: { handled: false },
+ mechanism: { handled: false, type: 'auto.function.nuxt.nitro' },
});
await flushIfServerless();
diff --git a/packages/nuxt/src/runtime/plugins/index.ts b/packages/nuxt/src/runtime/plugins/index.ts
index dbe41b848a0c..b7a5c217edf2 100644
--- a/packages/nuxt/src/runtime/plugins/index.ts
+++ b/packages/nuxt/src/runtime/plugins/index.ts
@@ -1,2 +1 @@
-// fixme: Can this be exported like this?
export { sentryCloudflareNitroPlugin } from './sentry-cloudflare.server';
diff --git a/packages/nuxt/src/runtime/plugins/sentry-cloudflare.server.ts b/packages/nuxt/src/runtime/plugins/sentry-cloudflare.server.ts
index 4ddbe8749586..5438ac829d8a 100644
--- a/packages/nuxt/src/runtime/plugins/sentry-cloudflare.server.ts
+++ b/packages/nuxt/src/runtime/plugins/sentry-cloudflare.server.ts
@@ -1,4 +1,4 @@
-import type { ExecutionContext, IncomingRequestCfProperties } from '@cloudflare/workers-types';
+import type { IncomingRequestCfProperties } from '@cloudflare/workers-types';
import type { CloudflareOptions } from '@sentry/cloudflare';
import { setAsyncLocalStorageAsyncContextStrategy, wrapRequestHandler } from '@sentry/cloudflare';
import { debug, getDefaultIsolationScope, getIsolationScope, getTraceData } from '@sentry/core';
@@ -8,50 +8,7 @@ import type { NuxtRenderHTMLContext } from 'nuxt/app';
import { sentryCaptureErrorHook } from '../hooks/captureErrorHook';
import { updateRouteBeforeResponse } from '../hooks/updateRouteBeforeResponse';
import { addSentryTracingMetaTags } from '../utils';
-
-interface CfEventType {
- protocol: string;
- host: string;
- method: string;
- headers: Record;
- context: {
- cf: {
- httpProtocol?: string;
- country?: string;
- // ...other CF properties
- };
- cloudflare: {
- context: ExecutionContext;
- request?: Record;
- env?: Record;
- };
- };
-}
-
-function isEventType(event: unknown): event is CfEventType {
- if (event === null || typeof event !== 'object') return false;
-
- return (
- // basic properties
- 'protocol' in event &&
- 'host' in event &&
- typeof event.protocol === 'string' &&
- typeof event.host === 'string' &&
- // context property
- 'context' in event &&
- typeof event.context === 'object' &&
- event.context !== null &&
- // context.cf properties
- 'cf' in event.context &&
- typeof event.context.cf === 'object' &&
- event.context.cf !== null &&
- // context.cloudflare properties
- 'cloudflare' in event.context &&
- typeof event.context.cloudflare === 'object' &&
- event.context.cloudflare !== null &&
- 'context' in event.context.cloudflare
- );
-}
+import { getCfProperties, getCloudflareProperties, hasCfProperty, isEventType } from '../utils/event-type-check';
/**
* Sentry Cloudflare Nitro plugin for when using the "cloudflare-pages" preset in Nuxt.
@@ -107,13 +64,13 @@ export const sentryCloudflareNitroPlugin =
const request = new Request(url, {
method: event.method,
headers: event.headers,
- cf: event.context.cf,
+ cf: getCfProperties(event),
}) as Request>;
const requestHandlerOptions = {
options: cloudflareOptions,
request,
- context: event.context.cloudflare.context,
+ context: getCloudflareProperties(event).context,
};
return wrapRequestHandler(requestHandlerOptions, () => {
@@ -124,7 +81,7 @@ export const sentryCloudflareNitroPlugin =
const traceData = getTraceData();
if (traceData && Object.keys(traceData).length > 0) {
// Storing trace data in the WeakMap using event.context.cf as key for later use in HTML meta-tags
- traceDataMap.set(event.context.cf, traceData);
+ traceDataMap.set(getCfProperties(event), traceData);
debug.log('Stored trace data for later use in HTML meta-tags: ', traceData);
}
@@ -144,7 +101,19 @@ export const sentryCloudflareNitroPlugin =
// @ts-expect-error - 'render:html' is a valid hook name in the Nuxt context
nitroApp.hooks.hook('render:html', (html: NuxtRenderHTMLContext, { event }: { event: H3Event }) => {
- const storedTraceData = event?.context?.cf ? traceDataMap.get(event.context.cf) : undefined;
+ let storedTraceData: ReturnType | undefined = undefined;
+
+ if (
+ event?.context &&
+ '_platform' in event.context &&
+ event.context._platform &&
+ hasCfProperty(event.context._platform)
+ ) {
+ storedTraceData = traceDataMap.get(event.context._platform.cf);
+ } else if (event?.context && hasCfProperty(event.context)) {
+ // legacy support (before Nitro v2.11.7 (PR: https://github.com/nitrojs/nitro/pull/3224))
+ storedTraceData = traceDataMap.get(event.context.cf);
+ }
if (storedTraceData && Object.keys(storedTraceData).length > 0) {
debug.log('Using stored trace data for HTML meta-tags: ', storedTraceData);
diff --git a/packages/nuxt/src/runtime/utils.ts b/packages/nuxt/src/runtime/utils.ts
index 29abbe23ec62..ce8069c58cdb 100644
--- a/packages/nuxt/src/runtime/utils.ts
+++ b/packages/nuxt/src/runtime/utils.ts
@@ -81,7 +81,7 @@ export function reportNuxtError(options: {
setTimeout(() => {
captureException(error, {
captureContext: { contexts: { nuxt: metadata } },
- mechanism: { handled: false },
+ mechanism: { handled: false, type: `auto.function.nuxt.${instance ? 'vue' : 'app'}-error` },
});
});
}
diff --git a/packages/nuxt/src/runtime/utils/event-type-check.ts b/packages/nuxt/src/runtime/utils/event-type-check.ts
new file mode 100644
index 000000000000..1da0d8b2677a
--- /dev/null
+++ b/packages/nuxt/src/runtime/utils/event-type-check.ts
@@ -0,0 +1,105 @@
+import type { CfProperties, ExecutionContext } from '@cloudflare/workers-types';
+
+interface EventBase {
+ protocol: string;
+ host: string;
+ method: string;
+ headers: Record;
+}
+
+interface MinimalCloudflareProps {
+ context: ExecutionContext;
+ request?: Record;
+ env?: Record;
+}
+
+interface CloudflareContext {
+ cf: CfProperties;
+ cloudflare: MinimalCloudflareProps;
+}
+
+// Direct shape: cf and cloudflare are directly on context
+interface CfEventDirect extends EventBase {
+ context: CloudflareContext;
+}
+
+// Nested shape: cf and cloudflare are under _platform
+// Since Nitro v2.11.7 (PR: https://github.com/nitrojs/nitro/pull/3224)
+interface CfEventPlatform extends EventBase {
+ context: {
+ _platform: CloudflareContext;
+ };
+}
+
+export type CfEventType = CfEventDirect | CfEventPlatform;
+
+function hasCloudflareProperty(context: unknown): boolean {
+ return (
+ context !== null &&
+ typeof context === 'object' &&
+ // context.cloudflare properties
+ 'cloudflare' in context &&
+ typeof context.cloudflare === 'object' &&
+ context.cloudflare !== null &&
+ 'context' in context.cloudflare
+ );
+}
+
+/**
+ * Type guard to check if an event context object has cf properties
+ */
+export function hasCfProperty(context: unknown): context is { cf: CfProperties } {
+ return (
+ context !== null &&
+ typeof context === 'object' &&
+ // context.cf properties
+ 'cf' in context &&
+ typeof context.cf === 'object' &&
+ context.cf !== null
+ );
+}
+
+function hasCfAndCloudflare(context: unknown): context is CloudflareContext {
+ return hasCfProperty(context) && hasCloudflareProperty(context);
+}
+
+/**
+ * Type guard to check if an event is a Cloudflare event (nested in _platform or direct)
+ */
+export function isEventType(event: unknown): event is CfEventType {
+ if (event === null || typeof event !== 'object') return false;
+
+ return (
+ // basic properties
+ 'protocol' in event &&
+ 'host' in event &&
+ typeof event.protocol === 'string' &&
+ typeof event.host === 'string' &&
+ // context property
+ 'context' in event &&
+ typeof event.context === 'object' &&
+ event.context !== null &&
+ // context.cf properties
+ (hasCfAndCloudflare(event.context) || ('_platform' in event.context && hasCfAndCloudflare(event.context._platform)))
+ );
+}
+
+/**
+ * Extracts cf properties from a Cloudflare event
+ */
+export function getCfProperties(event: CfEventType): CfProperties {
+ if ('cf' in event.context) {
+ return event.context.cf;
+ }
+ return event.context._platform.cf;
+}
+
+/**
+ * Extracts cloudflare properties from a Cloudflare event
+ */
+export function getCloudflareProperties(event: CfEventType): MinimalCloudflareProps {
+ if ('cloudflare' in event.context) {
+ return event.context.cloudflare;
+ }
+ return event.context._platform.cloudflare;
+}
diff --git a/packages/nuxt/test/runtime/utils.test.ts b/packages/nuxt/test/runtime/utils.test.ts
index 9c3dd568d67a..70226ee12c86 100644
--- a/packages/nuxt/test/runtime/utils.test.ts
+++ b/packages/nuxt/test/runtime/utils.test.ts
@@ -119,7 +119,7 @@ describe('reportNuxtError', () => {
expect(captureException).toHaveBeenCalledWith(mockError, {
captureContext: { contexts: { nuxt: { info: undefined } } },
- mechanism: { handled: false },
+ mechanism: { handled: false, type: 'auto.function.nuxt.app-error' },
});
});
@@ -129,7 +129,7 @@ describe('reportNuxtError', () => {
expect(captureException).toHaveBeenCalledWith(mockError, {
captureContext: { contexts: { nuxt: { info: undefined, propsData: { foo: 'bar' } } } },
- mechanism: { handled: false },
+ mechanism: { handled: false, type: 'auto.function.nuxt.vue-error' },
});
});
@@ -141,7 +141,7 @@ describe('reportNuxtError', () => {
expect(captureException).toHaveBeenCalledWith(mockError, {
captureContext: { contexts: { nuxt: { info: undefined } } },
- mechanism: { handled: false },
+ mechanism: { handled: false, type: 'auto.function.nuxt.vue-error' },
});
});
@@ -151,7 +151,7 @@ describe('reportNuxtError', () => {
expect(captureException).toHaveBeenCalledWith(mockError, {
captureContext: { contexts: { nuxt: { info: 'Some info' } } },
- mechanism: { handled: false },
+ mechanism: { handled: false, type: 'auto.function.nuxt.app-error' },
});
});
});
diff --git a/packages/nuxt/test/runtime/utils/event-type-check.test.ts b/packages/nuxt/test/runtime/utils/event-type-check.test.ts
new file mode 100644
index 000000000000..a63de96b193d
--- /dev/null
+++ b/packages/nuxt/test/runtime/utils/event-type-check.test.ts
@@ -0,0 +1,216 @@
+import type { CfProperties } from '@cloudflare/workers-types';
+import { describe, expect, it, vi } from 'vitest';
+import {
+ type CfEventType,
+ getCfProperties,
+ getCloudflareProperties,
+ isEventType,
+} from '../../../src/runtime/utils/event-type-check';
+
+describe('event-type-check', () => {
+ const mockCfProperties: CfProperties = {
+ colo: 'IMLND',
+ country: 'IL',
+ region: 'CoreRegion',
+ timezone: 'ImagineLand/Core',
+ city: 'Core',
+ } as CfProperties;
+
+ const mockCloudflareProperties = {
+ context: {
+ waitUntil: vi.fn(),
+ passThroughOnException: vi.fn(),
+ props: { key: 'value' },
+ },
+ request: { url: 'https://example.com' },
+ env: { API_KEY: 'test' },
+ };
+
+ const createUnnestedCfEvent = (): CfEventType => ({
+ protocol: 'https',
+ host: 'example.com',
+ method: 'GET',
+ headers: { 'user-agent': 'test' },
+ context: {
+ cf: mockCfProperties,
+ cloudflare: mockCloudflareProperties,
+ },
+ });
+
+ const createPlatformCfEvent = (): CfEventType => ({
+ protocol: 'https',
+ host: 'example.com',
+ method: 'POST',
+ headers: { 'content-type': 'application/json' },
+ context: {
+ _platform: {
+ cf: mockCfProperties,
+ cloudflare: mockCloudflareProperties,
+ },
+ },
+ });
+
+ describe('isEventType', () => {
+ describe('should return true for valid Cloudflare events', () => {
+ it.each([
+ ['direct cf event', createUnnestedCfEvent()],
+ ['platform cf event', createPlatformCfEvent()],
+ ])('%s', (_, event) => {
+ expect(isEventType(event)).toBe(true);
+ });
+ });
+
+ describe('should return false for invalid inputs', () => {
+ it.each([
+ ['null', null],
+ ['undefined', undefined],
+ ['string', 'invalid'],
+ ['number', 123],
+ ['boolean', true],
+ ['array', []],
+ ['empty object', {}],
+ ])('%s', (_, input) => {
+ expect(isEventType(input)).toBe(false);
+ });
+ });
+
+ describe('should return false for objects missing required properties', () => {
+ const baseEvent = createUnnestedCfEvent();
+
+ it.each([
+ ['missing protocol', { ...baseEvent, protocol: undefined }],
+ ['missing host', { ...baseEvent, host: undefined }],
+ ['missing context', { ...baseEvent, context: undefined }],
+ ['null context', { ...baseEvent, context: null }],
+ ['context without cf', { ...baseEvent, context: { cloudflare: mockCloudflareProperties } }],
+ ['context without cloudflare', { ...baseEvent, context: { cf: mockCfProperties } }],
+ ['context with null cf', { ...baseEvent, context: { cf: null, cloudflare: mockCloudflareProperties } }],
+ ['context with null cloudflare', { ...baseEvent, context: { cf: mockCfProperties, cloudflare: null } }],
+ [
+ 'cloudflare without context property',
+ {
+ ...baseEvent,
+ context: {
+ cf: mockCfProperties,
+ cloudflare: { request: {}, env: {} },
+ },
+ },
+ ],
+ ])('%s', (_, invalidEvent) => {
+ expect(isEventType(invalidEvent)).toBe(false);
+ });
+ });
+
+ describe('should return false for platform events missing required properties', () => {
+ const basePlatformEvent = createPlatformCfEvent();
+
+ it.each([
+ [
+ 'platform without cf',
+ {
+ ...basePlatformEvent,
+ context: {
+ _platform: {
+ cloudflare: mockCloudflareProperties,
+ },
+ },
+ },
+ ],
+ [
+ 'platform without cloudflare',
+ {
+ ...basePlatformEvent,
+ context: {
+ _platform: {
+ cf: mockCfProperties,
+ },
+ },
+ },
+ ],
+ [
+ 'platform with null cf',
+ {
+ ...basePlatformEvent,
+ context: {
+ _platform: {
+ cf: null,
+ cloudflare: mockCloudflareProperties,
+ },
+ },
+ },
+ ],
+ ])('%s', (_, invalidEvent) => {
+ expect(isEventType(invalidEvent)).toBe(false);
+ });
+ });
+ });
+
+ describe('getCfProperties', () => {
+ it.each([
+ ['direct cf event', createUnnestedCfEvent()],
+ ['platform cf event', createPlatformCfEvent()],
+ ])('should extract cf properties from %s', (_, event) => {
+ const result = getCfProperties(event);
+ expect(result).toEqual(mockCfProperties);
+ expect(result.colo).toBe('IMLND');
+ expect(result.country).toBe('IL');
+ });
+
+ it('should return the same cf properties for both event types', () => {
+ const directEvent = createUnnestedCfEvent();
+ const platformEvent = createPlatformCfEvent();
+
+ const directCf = getCfProperties(directEvent);
+ const platformCf = getCfProperties(platformEvent);
+
+ expect(directCf).toEqual(platformCf);
+ });
+ });
+
+ describe('getCloudflareProperties', () => {
+ it.each([
+ ['direct cf event', createUnnestedCfEvent()],
+ ['platform cf event', createPlatformCfEvent()],
+ ])('should extract cloudflare properties from %s', (_, event) => {
+ const result = getCloudflareProperties(event);
+ expect(result).toEqual(mockCloudflareProperties);
+ expect(result.context).toBeDefined();
+ expect(result.request).toEqual({ url: 'https://example.com' });
+ expect(result.env).toEqual({ API_KEY: 'test' });
+ });
+
+ it('should return the same cloudflare properties for both event types', () => {
+ const directEvent = createUnnestedCfEvent();
+ const platformEvent = createPlatformCfEvent();
+
+ const directCloudflare = getCloudflareProperties(directEvent);
+ const platformCloudflare = getCloudflareProperties(platformEvent);
+
+ expect(directCloudflare).toEqual(platformCloudflare);
+ });
+ });
+
+ describe('integration tests', () => {
+ it('should work together for a complete workflow', () => {
+ const event = createUnnestedCfEvent();
+
+ expect(isEventType(event)).toBe(true);
+
+ const cf = getCfProperties(event);
+ const cloudflare = getCloudflareProperties(event);
+
+ expect(cf.country).toBe('IL');
+ expect(cloudflare.request?.url).toBe('https://example.com');
+ });
+
+ it('should handle both event structures consistently', () => {
+ const events = [createUnnestedCfEvent(), createPlatformCfEvent()];
+
+ events.forEach(event => {
+ expect(isEventType(event)).toBe(true);
+ expect(getCfProperties(event)).toEqual(mockCfProperties);
+ expect(getCloudflareProperties(event)).toEqual(mockCloudflareProperties);
+ });
+ });
+ });
+});
diff --git a/packages/opentelemetry/package.json b/packages/opentelemetry/package.json
index c21b7cfd782a..13f2c2d990e7 100644
--- a/packages/opentelemetry/package.json
+++ b/packages/opentelemetry/package.json
@@ -43,17 +43,17 @@
},
"peerDependencies": {
"@opentelemetry/api": "^1.9.0",
- "@opentelemetry/context-async-hooks": "^1.30.1 || ^2.0.0",
- "@opentelemetry/core": "^1.30.1 || ^2.0.0",
- "@opentelemetry/sdk-trace-base": "^1.30.1 || ^2.0.0",
- "@opentelemetry/semantic-conventions": "^1.34.0"
+ "@opentelemetry/context-async-hooks": "^1.30.1 || ^2.1.0",
+ "@opentelemetry/core": "^1.30.1 || ^2.1.0",
+ "@opentelemetry/sdk-trace-base": "^1.30.1 || ^2.1.0",
+ "@opentelemetry/semantic-conventions": "^1.37.0"
},
"devDependencies": {
"@opentelemetry/api": "^1.9.0",
- "@opentelemetry/context-async-hooks": "^2.0.0",
- "@opentelemetry/core": "^2.0.0",
- "@opentelemetry/sdk-trace-base": "^2.0.0",
- "@opentelemetry/semantic-conventions": "^1.34.0"
+ "@opentelemetry/context-async-hooks": "^2.1.0",
+ "@opentelemetry/core": "^2.1.0",
+ "@opentelemetry/sdk-trace-base": "^2.1.0",
+ "@opentelemetry/semantic-conventions": "^1.37.0"
},
"scripts": {
"build": "run-p build:transpile build:types",
diff --git a/packages/react-router/package.json b/packages/react-router/package.json
index 659c39996819..4709b74853ef 100644
--- a/packages/react-router/package.json
+++ b/packages/react-router/package.json
@@ -46,9 +46,9 @@
},
"dependencies": {
"@opentelemetry/api": "^1.9.0",
- "@opentelemetry/core": "^2.0.0",
- "@opentelemetry/instrumentation": "^0.203.0",
- "@opentelemetry/semantic-conventions": "^1.34.0",
+ "@opentelemetry/core": "^2.1.0",
+ "@opentelemetry/instrumentation": "^0.204.0",
+ "@opentelemetry/semantic-conventions": "^1.37.0",
"@sentry/browser": "10.11.0",
"@sentry/cli": "^2.52.0",
"@sentry/core": "10.11.0",
diff --git a/packages/react-router/test/server/createSentryHandleError.test.ts b/packages/react-router/test/server/createSentryHandleError.test.ts
index 0cad5d2a04ba..dddcf2eba86c 100644
--- a/packages/react-router/test/server/createSentryHandleError.test.ts
+++ b/packages/react-router/test/server/createSentryHandleError.test.ts
@@ -156,7 +156,8 @@ describe('createSentryHandleError', () => {
});
describe('flushIfServerless behavior', () => {
- it('should wait for flushIfServerless to complete', async () => {
+ it('waits for flushIfServerless to complete', async () => {
+ vi.useFakeTimers();
const handleError = createSentryHandleError({});
let resolveFlush: () => void;
@@ -172,7 +173,8 @@ describe('createSentryHandleError', () => {
const handleErrorPromise = handleError(mockError, mockArgs);
- setTimeout(() => resolveFlush(), 10);
+ vi.advanceTimersByTime(10);
+ resolveFlush!();
await handleErrorPromise;
const endTime = Date.now();
diff --git a/packages/react/src/error.ts b/packages/react/src/error.ts
index ca5ccd8b2698..c10cebe4ecf4 100644
--- a/packages/react/src/error.ts
+++ b/packages/react/src/error.ts
@@ -95,8 +95,11 @@ export function reactErrorHandler(
): (error: any, errorInfo: ErrorInfo) => void {
// eslint-disable-next-line @typescript-eslint/no-explicit-any
return (error: any, errorInfo: ErrorInfo) => {
- const eventId = captureReactException(error, errorInfo);
- if (callback) {
+ const hasCallback = !!callback;
+ const eventId = captureReactException(error, errorInfo, {
+ mechanism: { handled: hasCallback, type: 'auto.function.react.error_handler' },
+ });
+ if (hasCallback) {
callback(error, errorInfo, eventId);
}
};
diff --git a/packages/react/src/errorboundary.tsx b/packages/react/src/errorboundary.tsx
index f37afe961042..6377ae9c8399 100644
--- a/packages/react/src/errorboundary.tsx
+++ b/packages/react/src/errorboundary.tsx
@@ -123,7 +123,9 @@ class ErrorBoundary extends React.Component {
test.each([
@@ -13,3 +14,45 @@ describe('isAtLeastReact17', () => {
expect(isAtLeastReact17(input)).toBe(output);
});
});
+
+describe('reactErrorHandler', () => {
+ const captureException = vi.spyOn(SentryBrowser, 'captureException');
+
+ beforeEach(() => {
+ captureException.mockClear();
+ });
+
+ it('captures errors as unhandled when no callback is provided', () => {
+ const error = new Error('test error');
+ const errorInfo = { componentStack: 'component stack' };
+
+ const handler = reactErrorHandler();
+
+ handler(error, errorInfo);
+
+ expect(captureException).toHaveBeenCalledTimes(1);
+ expect(captureException).toHaveBeenCalledWith(error, {
+ mechanism: { handled: false, type: 'auto.function.react.error_handler' },
+ });
+ });
+
+ it('captures errors as handled when a callback is provided', () => {
+ captureException.mockReturnValueOnce('custom-event-id');
+
+ const error = new Error('test error');
+ const errorInfo = { componentStack: 'component stack' };
+
+ const callback = vi.fn();
+ const handler = reactErrorHandler(callback);
+
+ handler(error, errorInfo);
+
+ expect(captureException).toHaveBeenCalledTimes(1);
+ expect(captureException).toHaveBeenCalledWith(error, {
+ mechanism: { handled: true, type: 'auto.function.react.error_handler' },
+ });
+
+ expect(callback).toHaveBeenCalledTimes(1);
+ expect(callback).toHaveBeenCalledWith(error, errorInfo, 'custom-event-id');
+ });
+});
diff --git a/packages/react/test/errorboundary.test.tsx b/packages/react/test/errorboundary.test.tsx
index 5e731cc86b49..3d2198e81dc9 100644
--- a/packages/react/test/errorboundary.test.tsx
+++ b/packages/react/test/errorboundary.test.tsx
@@ -385,7 +385,7 @@ describe('ErrorBoundary', () => {
expect(mockCaptureException).toHaveBeenCalledTimes(1);
expect(mockCaptureException).toHaveBeenLastCalledWith(expect.any(Error), {
- mechanism: { handled: true },
+ mechanism: { handled: true, type: 'auto.function.react.error_boundary' },
});
expect(scopeSetContextSpy).toHaveBeenCalledTimes(1);
@@ -444,7 +444,7 @@ describe('ErrorBoundary', () => {
expect(mockCaptureException).toHaveBeenCalledTimes(1);
expect(mockCaptureException).toHaveBeenLastCalledWith('bam', {
- mechanism: { handled: true },
+ mechanism: { handled: true, type: 'auto.function.react.error_boundary' },
});
expect(scopeSetContextSpy).toHaveBeenCalledTimes(1);
@@ -483,7 +483,7 @@ describe('ErrorBoundary', () => {
expect(mockCaptureException).toHaveBeenCalledTimes(1);
expect(mockCaptureException).toHaveBeenLastCalledWith(expect.any(Error), {
- mechanism: { handled: true },
+ mechanism: { handled: true, type: 'auto.function.react.error_boundary' },
});
expect(scopeSetContextSpy).toHaveBeenCalledTimes(1);
@@ -527,7 +527,7 @@ describe('ErrorBoundary', () => {
expect(mockCaptureException).toHaveBeenCalledTimes(1);
expect(mockCaptureException).toHaveBeenLastCalledWith(expect.any(Error), {
- mechanism: { handled: true },
+ mechanism: { handled: true, type: 'auto.function.react.error_boundary' },
});
expect(scopeSetContextSpy).toHaveBeenCalledTimes(1);
@@ -695,7 +695,7 @@ describe('ErrorBoundary', () => {
expect(mockCaptureException).toHaveBeenCalledTimes(1);
expect(mockCaptureException).toHaveBeenLastCalledWith(expect.any(Object), {
- mechanism: { handled: expected },
+ mechanism: { handled: expected, type: 'auto.function.react.error_boundary' },
});
expect(scopeSetContextSpy).toHaveBeenCalledTimes(1);
diff --git a/packages/remix/package.json b/packages/remix/package.json
index 903019b09cdc..0bf7416ef2fe 100644
--- a/packages/remix/package.json
+++ b/packages/remix/package.json
@@ -65,8 +65,8 @@
},
"dependencies": {
"@opentelemetry/api": "^1.9.0",
- "@opentelemetry/instrumentation": "^0.203.0",
- "@opentelemetry/semantic-conventions": "^1.34.0",
+ "@opentelemetry/instrumentation": "^0.204.0",
+ "@opentelemetry/semantic-conventions": "^1.37.0",
"@remix-run/router": "1.x",
"@sentry/cli": "^2.52.0",
"@sentry/core": "10.11.0",
diff --git a/packages/remix/src/server/errors.ts b/packages/remix/src/server/errors.ts
index def6092717c8..e622e743b74c 100644
--- a/packages/remix/src/server/errors.ts
+++ b/packages/remix/src/server/errors.ts
@@ -65,7 +65,7 @@ export async function captureRemixServerException(err: unknown, name: string, re
scope.addEventProcessor(event => {
addExceptionMechanism(event, {
- type: 'instrument',
+ type: 'auto.function.remix.server',
handled: false,
data: {
function: name,
diff --git a/packages/remix/src/server/index.ts b/packages/remix/src/server/index.ts
index 9a785f1d144c..ef25e4b703e6 100644
--- a/packages/remix/src/server/index.ts
+++ b/packages/remix/src/server/index.ts
@@ -118,6 +118,7 @@ export {
zodErrorsIntegration,
logger,
consoleLoggingIntegration,
+ createConsolaReporter,
createSentryWinstonTransport,
} from '@sentry/node';
diff --git a/packages/remix/test/integration/test/server/instrumentation/action.test.ts b/packages/remix/test/integration/test/server/instrumentation/action.test.ts
index bca38429ee29..d511368ba707 100644
--- a/packages/remix/test/integration/test/server/instrumentation/action.test.ts
+++ b/packages/remix/test/integration/test/server/instrumentation/action.test.ts
@@ -90,7 +90,7 @@ describe('Remix API Actions', () => {
function: 'remix.server.handleError',
},
handled: false,
- type: 'instrument',
+ type: 'auto.function.remix.server',
},
},
],
@@ -185,7 +185,7 @@ describe('Remix API Actions', () => {
function: 'remix.server.handleError',
},
handled: false,
- type: 'instrument',
+ type: 'auto.function.remix.server',
},
},
],
@@ -232,7 +232,7 @@ describe('Remix API Actions', () => {
function: 'action',
},
handled: false,
- type: 'instrument',
+ type: 'auto.function.remix.server',
},
},
],
@@ -279,7 +279,7 @@ describe('Remix API Actions', () => {
function: 'action',
},
handled: false,
- type: 'instrument',
+ type: 'auto.function.remix.server',
},
},
],
@@ -326,7 +326,7 @@ describe('Remix API Actions', () => {
function: 'action',
},
handled: false,
- type: 'instrument',
+ type: 'auto.function.remix.server',
},
},
],
@@ -373,7 +373,7 @@ describe('Remix API Actions', () => {
function: 'action',
},
handled: false,
- type: 'instrument',
+ type: 'auto.function.remix.server',
},
},
],
@@ -420,7 +420,7 @@ describe('Remix API Actions', () => {
function: 'remix.server.handleError',
},
handled: false,
- type: 'instrument',
+ type: 'auto.function.remix.server',
},
},
],
@@ -467,7 +467,7 @@ describe('Remix API Actions', () => {
function: 'remix.server.handleError',
},
handled: false,
- type: 'instrument',
+ type: 'auto.function.remix.server',
},
},
],
diff --git a/packages/remix/test/integration/test/server/instrumentation/loader.test.ts b/packages/remix/test/integration/test/server/instrumentation/loader.test.ts
index c90c23d135c8..75bcadf29b0c 100644
--- a/packages/remix/test/integration/test/server/instrumentation/loader.test.ts
+++ b/packages/remix/test/integration/test/server/instrumentation/loader.test.ts
@@ -35,7 +35,7 @@ describe('Remix API Loaders', () => {
function: 'remix.server.handleError',
},
handled: false,
- type: 'instrument',
+ type: 'auto.function.remix.server',
},
},
],
@@ -77,7 +77,7 @@ describe('Remix API Loaders', () => {
function: 'loader',
},
handled: false,
- type: 'instrument',
+ type: 'auto.function.remix.server',
},
},
],
@@ -155,7 +155,7 @@ describe('Remix API Loaders', () => {
function: 'remix.server.handleError',
},
handled: false,
- type: 'instrument',
+ type: 'auto.function.remix.server',
},
},
],
diff --git a/packages/remix/test/integration/test/server/instrumentation/ssr.test.ts b/packages/remix/test/integration/test/server/instrumentation/ssr.test.ts
index 1b2a97a99b55..4f5965fac31f 100644
--- a/packages/remix/test/integration/test/server/instrumentation/ssr.test.ts
+++ b/packages/remix/test/integration/test/server/instrumentation/ssr.test.ts
@@ -36,7 +36,7 @@ describe('Server Side Rendering', () => {
function: 'remix.server.handleError',
},
handled: false,
- type: 'instrument',
+ type: 'auto.function.remix.server',
},
},
],
diff --git a/packages/replay-internal/src/coreHandlers/handleAfterSendEvent.ts b/packages/replay-internal/src/coreHandlers/handleAfterSendEvent.ts
index 827fc6f5b99b..4df1b62532ac 100644
--- a/packages/replay-internal/src/coreHandlers/handleAfterSendEvent.ts
+++ b/packages/replay-internal/src/coreHandlers/handleAfterSendEvent.ts
@@ -14,11 +14,10 @@ export function handleAfterSendEvent(replay: ReplayContainer): AfterSendEventCal
return;
}
- const statusCode = sendResponse?.statusCode;
+ const statusCode = sendResponse.statusCode;
// We only want to do stuff on successful error sending, otherwise you get error replays without errors attached
- // If not using the base transport, we allow `undefined` response (as a custom transport may not implement this correctly yet)
- // If we do use the base transport, we skip if we encountered an non-OK status code
+ // We skip if we encountered an non-OK status code
if (!statusCode || statusCode < 200 || statusCode >= 300) {
return;
}
diff --git a/packages/replay-internal/src/util/logger.ts b/packages/replay-internal/src/util/logger.ts
index 89ded3c69468..dfdd44b18472 100644
--- a/packages/replay-internal/src/util/logger.ts
+++ b/packages/replay-internal/src/util/logger.ts
@@ -74,7 +74,12 @@ function makeReplayDebugLogger(): ReplayDebugLogger {
coreDebug.error(PREFIX, error);
if (_capture) {
- captureException(error);
+ captureException(error, {
+ mechanism: {
+ handled: true,
+ type: 'auto.function.replay.debug',
+ },
+ });
} else if (_trace) {
// No need for a breadcrumb if `_capture` is enabled since it should be
// captured as an exception
diff --git a/packages/replay-internal/test/integration/sendReplayEvent.test.ts b/packages/replay-internal/test/integration/sendReplayEvent.test.ts
index 3b6c9b5764e1..1e870a8f577b 100644
--- a/packages/replay-internal/test/integration/sendReplayEvent.test.ts
+++ b/packages/replay-internal/test/integration/sendReplayEvent.test.ts
@@ -399,7 +399,12 @@ describe('Integration | sendReplayEvent', () => {
expect(spyHandleException).toHaveBeenCalledTimes(5);
const expectedError = new Error('Unable to send Replay - max retries exceeded');
(expectedError as any).cause = new Error('Something bad happened');
- expect(spyHandleException).toHaveBeenLastCalledWith(expectedError);
+ expect(spyHandleException).toHaveBeenLastCalledWith(expectedError, {
+ mechanism: {
+ handled: true,
+ type: 'auto.function.replay.debug',
+ },
+ });
const spyHandleExceptionCall = spyHandleException.mock.calls;
expect(spyHandleExceptionCall[spyHandleExceptionCall.length - 1][0]?.cause.message).toEqual(
diff --git a/packages/replay-internal/test/unit/util/logger.test.ts b/packages/replay-internal/test/unit/util/logger.test.ts
index a52512dabed8..a3fc85099525 100644
--- a/packages/replay-internal/test/unit/util/logger.test.ts
+++ b/packages/replay-internal/test/unit/util/logger.test.ts
@@ -52,7 +52,12 @@ describe('logger', () => {
const err = new Error('An error');
debug.exception(err, 'a message');
if (captureExceptions) {
- expect(mockCaptureException).toHaveBeenCalledWith(err);
+ expect(mockCaptureException).toHaveBeenCalledWith(err, {
+ mechanism: {
+ handled: true,
+ type: 'auto.function.replay.debug',
+ },
+ });
}
expect(mockLogError).toHaveBeenCalledWith('[Replay] ', 'a message');
expect(mockLogError).toHaveBeenLastCalledWith('[Replay] ', err);
@@ -75,7 +80,12 @@ describe('logger', () => {
const err = new Error('An error');
debug.exception(err);
if (captureExceptions) {
- expect(mockCaptureException).toHaveBeenCalledWith(err);
+ expect(mockCaptureException).toHaveBeenCalledWith(err, {
+ mechanism: {
+ handled: true,
+ type: 'auto.function.replay.debug',
+ },
+ });
expect(mockAddBreadcrumb).not.toHaveBeenCalled();
}
expect(mockLogError).toHaveBeenCalledTimes(1);
diff --git a/packages/solid/src/errorboundary.ts b/packages/solid/src/errorboundary.ts
index df75f9da80f9..aaf99c3f23b2 100644
--- a/packages/solid/src/errorboundary.ts
+++ b/packages/solid/src/errorboundary.ts
@@ -17,7 +17,12 @@ export function withSentryErrorBoundary(ErrorBoundary: Component void): JSX.Element => {
- captureException(error);
+ captureException(error, {
+ mechanism: {
+ handled: true, // handled because user has to provide a fallback
+ type: 'auto.function.solid.error_boundary',
+ },
+ });
const f = local.fallback;
return typeof f === 'function' ? f(error, reset) : f;
diff --git a/packages/solid/test/errorboundary.test.tsx b/packages/solid/test/errorboundary.test.tsx
index 0ba1a2602bfe..53539e9b0d8e 100644
--- a/packages/solid/test/errorboundary.test.tsx
+++ b/packages/solid/test/errorboundary.test.tsx
@@ -49,7 +49,12 @@ describe('withSentryErrorBoundary', () => {
));
expect(mockCaptureException).toHaveBeenCalledTimes(1);
- expect(mockCaptureException).toHaveBeenLastCalledWith(new ReferenceError('NonExistentComponent is not defined'));
+ expect(mockCaptureException).toHaveBeenLastCalledWith(new ReferenceError('NonExistentComponent is not defined'), {
+ mechanism: {
+ handled: true,
+ type: 'auto.function.solid.error_boundary',
+ },
+ });
});
it('renders the fallback component', async () => {
@@ -89,13 +94,23 @@ describe('withSentryErrorBoundary', () => {
));
expect(mockCaptureException).toHaveBeenCalledTimes(1);
- expect(mockCaptureException).toHaveBeenNthCalledWith(1, new ReferenceError('NonExistentComponent is not defined'));
+ expect(mockCaptureException).toHaveBeenNthCalledWith(1, new ReferenceError('NonExistentComponent is not defined'), {
+ mechanism: {
+ handled: true,
+ type: 'auto.function.solid.error_boundary',
+ },
+ });
const button = await findByRole('button');
await user.click(button);
expect(mockCaptureException).toHaveBeenCalledTimes(2);
- expect(mockCaptureException).toHaveBeenNthCalledWith(2, new ReferenceError('NonExistentComponent is not defined'));
+ expect(mockCaptureException).toHaveBeenNthCalledWith(2, new ReferenceError('NonExistentComponent is not defined'), {
+ mechanism: {
+ handled: true,
+ type: 'auto.function.solid.error_boundary',
+ },
+ });
});
it('renders children when there is no error', async () => {
diff --git a/packages/solidstart/src/server/index.ts b/packages/solidstart/src/server/index.ts
index 17e7eaa9ef50..d1ad987da56f 100644
--- a/packages/solidstart/src/server/index.ts
+++ b/packages/solidstart/src/server/index.ts
@@ -123,6 +123,7 @@ export {
zodErrorsIntegration,
logger,
consoleLoggingIntegration,
+ createConsolaReporter,
createSentryWinstonTransport,
} from '@sentry/node';
diff --git a/packages/solidstart/src/server/withServerActionInstrumentation.ts b/packages/solidstart/src/server/withServerActionInstrumentation.ts
index c5c726614279..753188f805c3 100644
--- a/packages/solidstart/src/server/withServerActionInstrumentation.ts
+++ b/packages/solidstart/src/server/withServerActionInstrumentation.ts
@@ -48,7 +48,7 @@ export async function withServerActionInstrumentation {
));
expect(mockCaptureException).toHaveBeenCalledTimes(1);
- expect(mockCaptureException).toHaveBeenLastCalledWith(new ReferenceError('NonExistentComponent is not defined'));
+ expect(mockCaptureException).toHaveBeenLastCalledWith(new ReferenceError('NonExistentComponent is not defined'), {
+ mechanism: {
+ handled: true,
+ type: 'auto.function.solid.error_boundary',
+ },
+ });
});
it('renders the fallback component', async () => {
@@ -89,13 +94,23 @@ describe('withSentryErrorBoundary', () => {
));
expect(mockCaptureException).toHaveBeenCalledTimes(1);
- expect(mockCaptureException).toHaveBeenNthCalledWith(1, new ReferenceError('NonExistentComponent is not defined'));
+ expect(mockCaptureException).toHaveBeenNthCalledWith(1, new ReferenceError('NonExistentComponent is not defined'), {
+ mechanism: {
+ handled: true,
+ type: 'auto.function.solid.error_boundary',
+ },
+ });
const button = await findByRole('button');
await user.click(button);
expect(mockCaptureException).toHaveBeenCalledTimes(2);
- expect(mockCaptureException).toHaveBeenNthCalledWith(2, new ReferenceError('NonExistentComponent is not defined'));
+ expect(mockCaptureException).toHaveBeenNthCalledWith(2, new ReferenceError('NonExistentComponent is not defined'), {
+ mechanism: {
+ handled: true,
+ type: 'auto.function.solid.error_boundary',
+ },
+ });
});
it('renders children when there is no error', async () => {
diff --git a/packages/solidstart/test/server/errorboundary.test.tsx b/packages/solidstart/test/server/errorboundary.test.tsx
index afa2d44e98d7..3ed39bbfea13 100644
--- a/packages/solidstart/test/server/errorboundary.test.tsx
+++ b/packages/solidstart/test/server/errorboundary.test.tsx
@@ -49,7 +49,12 @@ describe('withSentryErrorBoundary', () => {
));
expect(mockCaptureException).toHaveBeenCalledTimes(1);
- expect(mockCaptureException).toHaveBeenLastCalledWith(new ReferenceError('NonExistentComponent is not defined'));
+ expect(mockCaptureException).toHaveBeenLastCalledWith(new ReferenceError('NonExistentComponent is not defined'), {
+ mechanism: {
+ handled: true,
+ type: 'auto.function.solid.error_boundary',
+ },
+ });
});
it('renders the fallback component', async () => {
@@ -89,13 +94,23 @@ describe('withSentryErrorBoundary', () => {
));
expect(mockCaptureException).toHaveBeenCalledTimes(1);
- expect(mockCaptureException).toHaveBeenNthCalledWith(1, new ReferenceError('NonExistentComponent is not defined'));
+ expect(mockCaptureException).toHaveBeenNthCalledWith(1, new ReferenceError('NonExistentComponent is not defined'), {
+ mechanism: {
+ handled: true,
+ type: 'auto.function.solid.error_boundary',
+ },
+ });
const button = await findByRole('button');
await user.click(button);
expect(mockCaptureException).toHaveBeenCalledTimes(2);
- expect(mockCaptureException).toHaveBeenNthCalledWith(2, new ReferenceError('NonExistentComponent is not defined'));
+ expect(mockCaptureException).toHaveBeenNthCalledWith(2, new ReferenceError('NonExistentComponent is not defined'), {
+ mechanism: {
+ handled: true,
+ type: 'auto.function.solid.error_boundary',
+ },
+ });
});
it('renders children when there is no error', async () => {
diff --git a/packages/solidstart/test/server/withServerActionInstrumentation.test.ts b/packages/solidstart/test/server/withServerActionInstrumentation.test.ts
index d2bc90259942..cdfb8050e20d 100644
--- a/packages/solidstart/test/server/withServerActionInstrumentation.test.ts
+++ b/packages/solidstart/test/server/withServerActionInstrumentation.test.ts
@@ -74,7 +74,9 @@ describe('withServerActionInstrumentation', () => {
await expect(res).rejects.toThrow();
expect(mockCaptureException).toHaveBeenCalledTimes(1);
- expect(mockCaptureException).toHaveBeenCalledWith(error, { mechanism: { handled: false, type: 'solidstart' } });
+ expect(mockCaptureException).toHaveBeenCalledWith(error, {
+ mechanism: { handled: false, type: 'auto.function.solidstart' },
+ });
});
it("doesn't call captureException for thrown redirects", async () => {
diff --git a/packages/sveltekit/src/client/handleError.ts b/packages/sveltekit/src/client/handleError.ts
index 14a0a5b4b9cd..d6c50b3519a9 100644
--- a/packages/sveltekit/src/client/handleError.ts
+++ b/packages/sveltekit/src/client/handleError.ts
@@ -38,7 +38,7 @@ export function handleErrorWithSentry(handleError?: HandleClientError): HandleCl
captureException(input.error, {
mechanism: {
- type: 'sveltekit',
+ type: 'auto.function.sveltekit.handle_error',
handled: !!handleError,
},
});
diff --git a/packages/sveltekit/src/client/load.ts b/packages/sveltekit/src/client/load.ts
index bf8cf7cb058e..216d2c373547 100644
--- a/packages/sveltekit/src/client/load.ts
+++ b/packages/sveltekit/src/client/load.ts
@@ -29,11 +29,8 @@ function sendErrorToSentry(e: unknown): unknown {
captureException(objectifiedErr, {
mechanism: {
- type: 'sveltekit',
+ type: 'auto.function.sveltekit.load',
handled: false,
- data: {
- function: 'load',
- },
},
});
diff --git a/packages/sveltekit/src/server-common/handleError.ts b/packages/sveltekit/src/server-common/handleError.ts
index 0ca6597ea864..4a7bce331622 100644
--- a/packages/sveltekit/src/server-common/handleError.ts
+++ b/packages/sveltekit/src/server-common/handleError.ts
@@ -36,7 +36,7 @@ export function handleErrorWithSentry(handleError?: HandleServerError): HandleSe
captureException(input.error, {
mechanism: {
- type: 'sveltekit',
+ type: 'auto.function.sveltekit.handle_error',
handled: !!handleError,
},
});
diff --git a/packages/sveltekit/src/server-common/serverRoute.ts b/packages/sveltekit/src/server-common/serverRoute.ts
index d09233cb3633..3b98ce270f2d 100644
--- a/packages/sveltekit/src/server-common/serverRoute.ts
+++ b/packages/sveltekit/src/server-common/serverRoute.ts
@@ -62,7 +62,7 @@ export function wrapServerRouteWithSentry(
() => wrappingTarget.apply(thisArg, args),
);
} catch (e) {
- sendErrorToSentry(e, 'serverRoute');
+ sendErrorToSentry(e, 'server_route');
throw e;
} finally {
await flushIfServerless();
diff --git a/packages/sveltekit/src/server-common/utils.ts b/packages/sveltekit/src/server-common/utils.ts
index b861bf758697..6fc67dc60612 100644
--- a/packages/sveltekit/src/server-common/utils.ts
+++ b/packages/sveltekit/src/server-common/utils.ts
@@ -23,7 +23,7 @@ export function getTracePropagationData(event: RequestEvent): { sentryTrace: str
*
* @returns an objectified version of @param e
*/
-export function sendErrorToSentry(e: unknown, handlerFn: 'handle' | 'load' | 'serverRoute'): object {
+export function sendErrorToSentry(e: unknown, handlerFn: 'handle' | 'load' | 'server_route'): object {
// In case we have a primitive, wrap it in the equivalent wrapper class (string -> String, etc.) so that we can
// store a seen flag on it.
const objectifiedErr = objectify(e);
@@ -42,11 +42,8 @@ export function sendErrorToSentry(e: unknown, handlerFn: 'handle' | 'load' | 'se
captureException(objectifiedErr, {
mechanism: {
- type: 'sveltekit',
+ type: `auto.function.sveltekit.${handlerFn}`,
handled: false,
- data: {
- function: handlerFn,
- },
},
});
diff --git a/packages/sveltekit/src/server/index.ts b/packages/sveltekit/src/server/index.ts
index d287331df14d..0613d6397f96 100644
--- a/packages/sveltekit/src/server/index.ts
+++ b/packages/sveltekit/src/server/index.ts
@@ -125,6 +125,7 @@ export {
zodErrorsIntegration,
logger,
consoleLoggingIntegration,
+ createConsolaReporter,
createSentryWinstonTransport,
vercelAIIntegration,
} from '@sentry/node';
diff --git a/packages/sveltekit/src/vite/sentryVitePlugins.ts b/packages/sveltekit/src/vite/sentryVitePlugins.ts
index 61b388a94cf2..56493e071a55 100644
--- a/packages/sveltekit/src/vite/sentryVitePlugins.ts
+++ b/packages/sveltekit/src/vite/sentryVitePlugins.ts
@@ -91,31 +91,80 @@ export function generateVitePluginOptions(
};
}
+ // todo(v11): remove deprecated options (Also from options type)
+
// Source Maps
if (svelteKitPluginOptions.autoUploadSourceMaps && process.env.NODE_ENV !== 'development') {
- const { unstable_sentryVitePluginOptions, ...sourceMapsUploadOptions } =
- svelteKitPluginOptions.sourceMapsUploadOptions || {};
+ const {
+ // eslint-disable-next-line deprecation/deprecation
+ unstable_sentryVitePluginOptions: deprecated_unstableSourceMapUploadOptions,
+ ...deprecatedSourceMapUploadOptions
+ // eslint-disable-next-line deprecation/deprecation
+ } = svelteKitPluginOptions.sourceMapsUploadOptions || {};
+
+ const {
+ // eslint-disable-next-line @typescript-eslint/no-unused-vars,deprecation/deprecation
+ sourceMapsUploadOptions: _filtered1,
+ // eslint-disable-next-line @typescript-eslint/no-unused-vars
+ unstable_sentryVitePluginOptions: _filtered2,
+ // eslint-disable-next-line @typescript-eslint/no-unused-vars
+ autoUploadSourceMaps: _filtered3,
+ // eslint-disable-next-line @typescript-eslint/no-unused-vars
+ autoInstrument: _filtered4,
+ sentryUrl,
+ ...newSvelteKitPluginOptions
+ } = svelteKitPluginOptions;
+
+ const { unstable_sentryVitePluginOptions } = svelteKitPluginOptions;
sentryVitePluginsOptions = {
...(sentryVitePluginsOptions ? sentryVitePluginsOptions : {}),
- ...sourceMapsUploadOptions,
+ ...deprecatedSourceMapUploadOptions,
+ ...newSvelteKitPluginOptions,
+
+ url: sentryUrl,
+
+ ...deprecated_unstableSourceMapUploadOptions,
...unstable_sentryVitePluginOptions,
+
adapter: svelteKitPluginOptions.adapter,
// override the plugin's debug flag with the one from the top-level options
debug: svelteKitPluginOptions.debug,
};
- if (sentryVitePluginsOptions.sourcemaps) {
+ // Handle sourcemaps options - merge deprecated and new, with new taking precedence
+ if (
+ // eslint-disable-next-line deprecation/deprecation
+ deprecatedSourceMapUploadOptions.sourcemaps ||
+ svelteKitPluginOptions.sourcemaps ||
+ deprecated_unstableSourceMapUploadOptions?.sourcemaps ||
+ unstable_sentryVitePluginOptions?.sourcemaps
+ ) {
sentryVitePluginsOptions.sourcemaps = {
- ...sourceMapsUploadOptions?.sourcemaps,
+ // eslint-disable-next-line deprecation/deprecation
+ ...deprecatedSourceMapUploadOptions.sourcemaps,
+ ...svelteKitPluginOptions.sourcemaps,
+ // Also handle nested deprecated options from unstable plugin options
+ ...deprecated_unstableSourceMapUploadOptions?.sourcemaps,
...unstable_sentryVitePluginOptions?.sourcemaps,
};
}
- if (sentryVitePluginsOptions.release) {
+ // Handle release options - merge deprecated and new, with new taking precedence
+ if (
+ // eslint-disable-next-line deprecation/deprecation
+ deprecatedSourceMapUploadOptions.release ||
+ svelteKitPluginOptions.release ||
+ deprecated_unstableSourceMapUploadOptions?.release ||
+ unstable_sentryVitePluginOptions?.release
+ ) {
sentryVitePluginsOptions.release = {
- ...sourceMapsUploadOptions?.release,
+ // eslint-disable-next-line deprecation/deprecation
+ ...deprecatedSourceMapUploadOptions.release,
+ ...svelteKitPluginOptions.release,
+ // Also handle nested deprecated options from unstable plugin options
+ ...deprecated_unstableSourceMapUploadOptions?.release,
...unstable_sentryVitePluginOptions?.release,
};
}
diff --git a/packages/sveltekit/src/vite/types.ts b/packages/sveltekit/src/vite/types.ts
index 4267ce378bb1..5f623cc876ad 100644
--- a/packages/sveltekit/src/vite/types.ts
+++ b/packages/sveltekit/src/vite/types.ts
@@ -1,3 +1,4 @@
+import type { BuildTimeOptionsBase, UnstableVitePluginOptions } from '@sentry/core';
import type { SentryVitePluginOptions } from '@sentry/vite-plugin';
import type { AutoInstrumentSelection } from './autoInstrument';
import type { SupportedSvelteKitAdapters } from './detectAdapter';
@@ -19,18 +20,24 @@ type SourceMapsUploadOptions = {
*
* To create an auth token, follow this guide:
* @see https://docs.sentry.io/product/accounts/auth-tokens/#organization-auth-tokens
+ *
+ * @deprecated Use option `authToken` instead of `sourceMapsUploadOptions.authToken`
*/
authToken?: string;
/**
* The organization slug of your Sentry organization.
* Instead of specifying this option, you can also set the `SENTRY_ORG` environment variable.
+ *
+ * @deprecated Use option `org` instead of `sourceMapsUploadOptions.org`
*/
org?: string;
/**
* The project slug of your Sentry project.
* Instead of specifying this option, you can also set the `SENTRY_PROJECT` environment variable.
+ *
+ * @deprecated Use option `project` instead of `sourceMapsUploadOptions.project`
*/
project?: string;
@@ -39,11 +46,13 @@ type SourceMapsUploadOptions = {
* It will not collect any sensitive or user-specific data.
*
* @default true
+ * @deprecated Use option `telemetry` instead of `sourceMapsUploadOptions.telemetry`
*/
telemetry?: boolean;
/**
* Options related to sourcemaps
+ * @deprecated Use `sourcemaps` instead of `sourceMapsUploadOptions.sourcemaps`
*/
sourcemaps?: {
/**
@@ -55,6 +64,7 @@ type SourceMapsUploadOptions = {
*
* The globbing patterns must follow the implementation of the `glob` package.
* @see https://www.npmjs.com/package/glob#glob-primer
+ * @deprecated Use `sourcemaps.assets` instead of `sourceMapsUploadOptions.sourcemaps.assets`
*/
assets?: string | Array;
@@ -65,6 +75,8 @@ type SourceMapsUploadOptions = {
* or the default value for `assets` are uploaded.
*
* The globbing patterns follow the implementation of the glob package. (https://www.npmjs.com/package/glob)
+ *
+ * @deprecated Use `sourcemaps.ignore` instead of `sourceMapsUploadOptions.sourcemaps.ignore`
*/
ignore?: string | Array;
@@ -75,6 +87,8 @@ type SourceMapsUploadOptions = {
* @default [] - By default no files are deleted.
*
* The globbing patterns follow the implementation of the glob package. (https://www.npmjs.com/package/glob)
+ *
+ * @deprecated Use `sourcemaps.filesToDeleteAfterUpload` instead of `sourceMapsUploadOptions.sourcemaps.filesToDeleteAfterUpload`
*/
filesToDeleteAfterUpload?: string | Array;
};
@@ -83,6 +97,8 @@ type SourceMapsUploadOptions = {
* Options related to managing the Sentry releases for a build.
*
* Note: Managing releases is optional and not required for uploading source maps.
+ *
+ * @deprecated Use `release` instead of `sourceMapsUploadOptions.release`
*/
release?: {
/**
@@ -94,6 +110,8 @@ type SourceMapsUploadOptions = {
* access to git CLI and for the root directory to be a valid repository).
*
* If you didn't provide a value and the plugin can't automatically detect one, no release will be created.
+ *
+ * @deprecated Use `release.name` instead of `sourceMapsUploadOptions.release.name`
*/
name?: string;
@@ -102,12 +120,16 @@ type SourceMapsUploadOptions = {
* sending events.
*
* Defaults to `true`.
+ *
+ * @deprecated Use `release.inject` instead of `sourceMapsUploadOptions.release.inject`
*/
inject?: boolean;
};
/**
* The URL of the Sentry instance to upload the source maps to.
+ *
+ * @deprecated Use `sentryUrl` instead of `sourceMapsUploadOptions.url`
*/
url?: string;
@@ -123,105 +145,54 @@ type SourceMapsUploadOptions = {
* changes can occur at any time within a major SDK version.
*
* Furthermore, some options are untested with SvelteKit specifically. Use with caution.
- */
- unstable_sentryVitePluginOptions?: Partial;
-};
-
-type BundleSizeOptimizationOptions = {
- /**
- * If set to `true`, the plugin will attempt to tree-shake (remove) any debugging code within the Sentry SDK.
- * Note that the success of this depends on tree shaking being enabled in your build tooling.
*
- * Setting this option to `true` will disable features like the SDK's `debug` option.
- */
- excludeDebugStatements?: boolean;
-
- /**
- * If set to true, the plugin will try to tree-shake tracing statements out.
- * Note that the success of this depends on tree shaking generally being enabled in your build.
- * Attention: DO NOT enable this when you're using any performance monitoring-related SDK features (e.g. Sentry.startSpan()).
+ * @deprecated Use `unstable_sentryVitePluginOptions` instead of `sourceMapsUploadOptions.unstable_sentryVitePluginOptions`
*/
- excludeTracing?: boolean;
-
- /**
- * If set to `true`, the plugin will attempt to tree-shake (remove) code related to the Sentry SDK's Session Replay Shadow DOM recording functionality.
- * Note that the success of this depends on tree shaking being enabled in your build tooling.
- *
- * This option is safe to be used when you do not want to capture any Shadow DOM activity via Sentry Session Replay.
- */
- excludeReplayShadowDom?: boolean;
-
- /**
- * If set to `true`, the plugin will attempt to tree-shake (remove) code related to the Sentry SDK's Session Replay `iframe` recording functionality.
- * Note that the success of this depends on tree shaking being enabled in your build tooling.
- *
- * You can safely do this when you do not want to capture any `iframe` activity via Sentry Session Replay.
- */
- excludeReplayIframe?: boolean;
-
- /**
- * If set to `true`, the plugin will attempt to tree-shake (remove) code related to the Sentry SDK's Session Replay's Compression Web Worker.
- * Note that the success of this depends on tree shaking being enabled in your build tooling.
- *
- * **Notice:** You should only do use this option if you manually host a compression worker and configure it in your Sentry Session Replay integration config via the `workerUrl` option.
- */
- excludeReplayWorker?: boolean;
+ unstable_sentryVitePluginOptions?: Partial;
};
/** Options for the Sentry SvelteKit plugin */
-export type SentrySvelteKitPluginOptions = {
- /**
- * If this flag is `true`, the Sentry plugins will log some useful debug information.
- * @default false.
- */
- debug?: boolean;
-
- /**
- * The Sentry plugin will automatically instrument certain parts of your SvelteKit application at build time.
- * Set this option to `false` to disable this behavior or what is intrumented by passing an object.
- *
- * Auto instrumentation includes:
- * - Universal `load` functions in `+page.(js|ts)` files
- * - Server-only `load` functions in `+page.server.(js|ts)` files
- *
- * @default true (meaning, the plugin will instrument all of the above)
- */
- autoInstrument?: boolean | AutoInstrumentSelection;
-
- /**
- * Specify which SvelteKit adapter you're using.
- * By default, the SDK will attempt auto-detect the used adapter at build time and apply the
- * correct config for source maps upload or auto-instrumentation.
- *
- * Currently, the SDK supports the following adapters:
- * - node (@sveltejs/adapter-node)
- * - auto (@sveltejs/adapter-auto) only Vercel
- * - vercel (@sveltejs/adapter-auto) only Serverless functions, no edge runtime
- *
- * Set this option, if the SDK detects the wrong adapter or you want to use an adapter
- * that is not in this list. If you specify 'other', you'll most likely need to configure
- * source maps upload yourself.
- *
- * @default {} the SDK attempts to auto-detect the used adapter at build time
- */
- adapter?: SupportedSvelteKitAdapters;
+export type SentrySvelteKitPluginOptions = BuildTimeOptionsBase &
+ UnstableVitePluginOptions> & {
+ /**
+ * The Sentry plugin will automatically instrument certain parts of your SvelteKit application at build time.
+ * Set this option to `false` to disable this behavior or what is intrumented by passing an object.
+ *
+ * Auto instrumentation includes:
+ * - Universal `load` functions in `+page.(js|ts)` files
+ * - Server-only `load` functions in `+page.server.(js|ts)` files
+ *
+ * @default true (meaning, the plugin will instrument all of the above)
+ */
+ autoInstrument?: boolean | AutoInstrumentSelection;
- /**
- * Options for the Sentry Vite plugin to customize bundle size optimizations.
- *
- * These options are always read from the `sentryAstro` integration.
- * Do not define them in the `sentry.client.config.(js|ts)` or `sentry.server.config.(js|ts)` files.
- */
- bundleSizeOptimizations?: BundleSizeOptimizationOptions;
+ /**
+ * Specify which SvelteKit adapter you're using.
+ * By default, the SDK will attempt auto-detect the used adapter at build time and apply the
+ * correct config for source maps upload or auto-instrumentation.
+ *
+ * Currently, the SDK supports the following adapters:
+ * - node (@sveltejs/adapter-node)
+ * - auto (@sveltejs/adapter-auto) only Vercel
+ * - vercel (@sveltejs/adapter-auto) only Serverless functions, no edge runtime
+ *
+ * Set this option, if the SDK detects the wrong adapter or you want to use an adapter
+ * that is not in this list. If you specify 'other', you'll most likely need to configure
+ * source maps upload yourself.
+ *
+ * @default {} the SDK attempts to auto-detect the used adapter at build time
+ */
+ adapter?: SupportedSvelteKitAdapters;
- /**
- * If this flag is `true`, the Sentry plugins will automatically upload source maps to Sentry.
- * @default true`.
- */
- autoUploadSourceMaps?: boolean;
+ /**
+ * If this flag is `true`, the Sentry plugins will automatically upload source maps to Sentry.
+ * @default true`.
+ */
+ autoUploadSourceMaps?: boolean;
- /**
- * Options related to source maps upload to Sentry
- */
- sourceMapsUploadOptions?: SourceMapsUploadOptions;
-};
+ /** * Options related to source maps upload to Sentry
+ *
+ * @deprecated This option was deprecated as it adds unnecessary nesting. Put the options one level higher to the root-level of the Sentry Svelte plugin options.
+ */
+ sourceMapsUploadOptions?: SourceMapsUploadOptions;
+ };
diff --git a/packages/sveltekit/test/client/handleError.test.ts b/packages/sveltekit/test/client/handleError.test.ts
index 810acd865aa2..3511ff62f83b 100644
--- a/packages/sveltekit/test/client/handleError.test.ts
+++ b/packages/sveltekit/test/client/handleError.test.ts
@@ -21,10 +21,6 @@ const navigationEvent: NavigationEvent = {
url: new URL('http://example.org/users/123'),
};
-const captureExceptionEventHint = {
- mechanism: { handled: false, type: 'sveltekit' },
-};
-
const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(_ => {});
describe('handleError (client)', () => {
@@ -42,7 +38,9 @@ describe('handleError (client)', () => {
expect(returnVal).not.toBeDefined();
expect(mockCaptureException).toHaveBeenCalledTimes(1);
- expect(mockCaptureException).toHaveBeenCalledWith(mockError, captureExceptionEventHint);
+ expect(mockCaptureException).toHaveBeenCalledWith(mockError, {
+ mechanism: { handled: false, type: 'auto.function.sveltekit.handle_error' },
+ });
// The default handler logs the error to the console
expect(consoleErrorSpy).toHaveBeenCalledTimes(1);
});
@@ -56,7 +54,7 @@ describe('handleError (client)', () => {
expect(returnVal.message).toEqual('Whoops!');
expect(mockCaptureException).toHaveBeenCalledTimes(1);
expect(mockCaptureException).toHaveBeenCalledWith(mockError, {
- mechanism: { handled: true, type: 'sveltekit' },
+ mechanism: { handled: true, type: 'auto.function.sveltekit.handle_error' },
});
// Check that the default handler wasn't invoked
diff --git a/packages/sveltekit/test/client/load.test.ts b/packages/sveltekit/test/client/load.test.ts
index 465167265d49..b7d0b58ffe93 100644
--- a/packages/sveltekit/test/client/load.test.ts
+++ b/packages/sveltekit/test/client/load.test.ts
@@ -154,7 +154,7 @@ describe('wrapLoadWithSentry', () => {
expect(mockCaptureException).toHaveBeenCalledTimes(1);
expect(mockCaptureException).toHaveBeenCalledWith(expect.any(Error), {
- mechanism: { handled: false, type: 'sveltekit', data: { function: 'load' } },
+ mechanism: { handled: false, type: 'auto.function.sveltekit.load' },
});
});
diff --git a/packages/sveltekit/test/server-common/handle.test.ts b/packages/sveltekit/test/server-common/handle.test.ts
index db1e1fe4811f..fdb4a1103d90 100644
--- a/packages/sveltekit/test/server-common/handle.test.ts
+++ b/packages/sveltekit/test/server-common/handle.test.ts
@@ -317,7 +317,7 @@ describe('sentryHandle', () => {
} catch (e) {
expect(mockCaptureException).toBeCalledTimes(1);
expect(mockCaptureException).toBeCalledWith(expect.any(Error), {
- mechanism: { handled: false, type: 'sveltekit', data: { function: 'handle' } },
+ mechanism: { handled: false, type: 'auto.function.sveltekit.handle' },
});
}
});
diff --git a/packages/sveltekit/test/server-common/handleError.test.ts b/packages/sveltekit/test/server-common/handleError.test.ts
index 6b4b3af992d1..30fa7e78c137 100644
--- a/packages/sveltekit/test/server-common/handleError.test.ts
+++ b/packages/sveltekit/test/server-common/handleError.test.ts
@@ -5,10 +5,6 @@ import { handleErrorWithSentry } from '../../src/server-common/handleError';
const mockCaptureException = vi.spyOn(SentryCore, 'captureException').mockImplementation(() => 'xx');
-const captureExceptionEventHint = {
- mechanism: { handled: false, type: 'sveltekit' },
-};
-
function handleError(_input: { error: unknown; event: RequestEvent }): ReturnType {
return {
message: 'Whoops!',
@@ -73,7 +69,9 @@ describe('handleError (server)', () => {
expect(returnVal).not.toBeDefined();
expect(mockCaptureException).toHaveBeenCalledTimes(1);
- expect(mockCaptureException).toHaveBeenCalledWith(mockError, captureExceptionEventHint);
+ expect(mockCaptureException).toHaveBeenCalledWith(mockError, {
+ mechanism: { handled: false, type: 'auto.function.sveltekit.handle_error' },
+ });
// The default handler logs the error to the console
expect(consoleErrorSpy).toHaveBeenCalledTimes(1);
});
@@ -91,7 +89,7 @@ describe('handleError (server)', () => {
expect(returnVal.message).toEqual('Whoops!');
expect(mockCaptureException).toHaveBeenCalledTimes(1);
expect(mockCaptureException).toHaveBeenCalledWith(mockError, {
- mechanism: { handled: true, type: 'sveltekit' },
+ mechanism: { handled: true, type: 'auto.function.sveltekit.handle_error' },
});
// Check that the default handler wasn't invoked
expect(consoleErrorSpy).toHaveBeenCalledTimes(0);
diff --git a/packages/sveltekit/test/server-common/load.test.ts b/packages/sveltekit/test/server-common/load.test.ts
index c3200d9a7927..4ec2cf6967c2 100644
--- a/packages/sveltekit/test/server-common/load.test.ts
+++ b/packages/sveltekit/test/server-common/load.test.ts
@@ -150,7 +150,7 @@ describe.each([
expect(mockCaptureException).toHaveBeenCalledTimes(1);
expect(mockCaptureException).toHaveBeenCalledWith(expect.any(Error), {
- mechanism: { handled: false, type: 'sveltekit', data: { function: 'load' } },
+ mechanism: { handled: false, type: 'auto.function.sveltekit.load' },
});
});
});
diff --git a/packages/sveltekit/test/server-common/serverRoute.test.ts b/packages/sveltekit/test/server-common/serverRoute.test.ts
index 046c3673a8c7..2ec3ef2cf2d2 100644
--- a/packages/sveltekit/test/server-common/serverRoute.test.ts
+++ b/packages/sveltekit/test/server-common/serverRoute.test.ts
@@ -85,7 +85,7 @@ describe('wrapServerRouteWithSentry', () => {
}).rejects.toThrowError('Server Route Error');
expect(captureExceptionSpy).toHaveBeenCalledWith(error, {
- mechanism: { type: 'sveltekit', handled: false, data: { function: 'serverRoute' } },
+ mechanism: { type: 'auto.function.sveltekit.server_route', handled: false },
});
});
@@ -101,7 +101,10 @@ describe('wrapServerRouteWithSentry', () => {
expect(captureExceptionSpy).toHaveBeenCalledWith(
{ body: { message: `error(${status}) error` }, status },
{
- mechanism: { type: 'sveltekit', handled: false, data: { function: 'serverRoute' } },
+ mechanism: {
+ type: 'auto.function.sveltekit.server_route',
+ handled: false,
+ },
},
);
});
diff --git a/packages/sveltekit/test/vite/sentrySvelteKitPlugins.test.ts b/packages/sveltekit/test/vite/sentrySvelteKitPlugins.test.ts
index fa8df96f03a6..eef008fca73d 100644
--- a/packages/sveltekit/test/vite/sentrySvelteKitPlugins.test.ts
+++ b/packages/sveltekit/test/vite/sentrySvelteKitPlugins.test.ts
@@ -30,6 +30,7 @@ function getSentrySvelteKitPlugins(options?: Parameters[
authToken: 'token',
org: 'org',
project: 'project',
+ // eslint-disable-next-line deprecation/deprecation
...options?.sourceMapsUploadOptions,
},
...options,
@@ -389,4 +390,263 @@ describe('generateVitePluginOptions', () => {
process.env.NODE_ENV = originalEnv;
});
+
+ it.each([
+ {
+ testName: 'org setting precedence',
+ options: {
+ autoUploadSourceMaps: true,
+ org: 'root-org',
+ sourceMapsUploadOptions: {
+ org: 'deprecated-org',
+ unstable_sentryVitePluginOptions: {
+ org: 'unstable-org',
+ },
+ },
+ unstable_sentryVitePluginOptions: {
+ org: 'new-unstable-org',
+ },
+ },
+ expectedOrg: 'new-unstable-org',
+ },
+ {
+ testName: 'project setting precedence',
+ options: {
+ autoUploadSourceMaps: true,
+ project: 'root-project',
+ sourceMapsUploadOptions: {
+ project: 'deprecated-project',
+ unstable_sentryVitePluginOptions: {
+ project: 'unstable-project',
+ },
+ },
+ unstable_sentryVitePluginOptions: {
+ project: 'new-unstable-project',
+ },
+ },
+ expectedProject: 'new-unstable-project',
+ },
+ {
+ testName: 'authToken setting precedence',
+ options: {
+ autoUploadSourceMaps: true,
+ authToken: 'root-token',
+ sourceMapsUploadOptions: {
+ authToken: 'deprecated-token',
+ unstable_sentryVitePluginOptions: {
+ authToken: 'unstable-token',
+ },
+ },
+ unstable_sentryVitePluginOptions: {
+ authToken: 'new-unstable-token',
+ },
+ },
+ expectedAuthToken: 'new-unstable-token',
+ },
+ {
+ testName: 'telemetry setting precedence',
+ options: {
+ autoUploadSourceMaps: true,
+ telemetry: true,
+ sourceMapsUploadOptions: {
+ telemetry: false,
+ unstable_sentryVitePluginOptions: {
+ telemetry: true,
+ },
+ },
+ unstable_sentryVitePluginOptions: {
+ telemetry: false,
+ },
+ },
+ expectedTelemetry: false,
+ },
+ {
+ testName: 'url setting precedence',
+ options: {
+ autoUploadSourceMaps: true,
+ sentryUrl: 'https://root.sentry.io',
+ sourceMapsUploadOptions: {
+ url: 'https://deprecated.sentry.io',
+ unstable_sentryVitePluginOptions: {
+ url: 'https://unstable.sentry.io',
+ },
+ },
+ unstable_sentryVitePluginOptions: {
+ url: 'https://new-unstable.sentry.io',
+ },
+ },
+ expectedUrl: 'https://new-unstable.sentry.io',
+ },
+ ])(
+ 'should use correct $testName',
+ ({ options, expectedOrg, expectedProject, expectedAuthToken, expectedTelemetry, expectedUrl }) => {
+ const result = generateVitePluginOptions(options as SentrySvelteKitPluginOptions);
+
+ if (expectedOrg !== undefined) {
+ expect(result?.org).toBe(expectedOrg);
+ }
+ if (expectedProject !== undefined) {
+ expect(result?.project).toBe(expectedProject);
+ }
+ if (expectedAuthToken !== undefined) {
+ expect(result?.authToken).toBe(expectedAuthToken);
+ }
+ if (expectedTelemetry !== undefined) {
+ expect(result?.telemetry).toBe(expectedTelemetry);
+ }
+ if (expectedUrl !== undefined) {
+ expect(result?.url).toBe(expectedUrl);
+ }
+ },
+ );
+
+ it('should handle sourcemap settings with correct order of overrides', () => {
+ const options: SentrySvelteKitPluginOptions = {
+ autoUploadSourceMaps: true,
+ sourcemaps: {
+ assets: ['root/*.js'],
+ ignore: ['root/ignore/*.js'],
+ filesToDeleteAfterUpload: ['root/delete/*.js'],
+ },
+ sourceMapsUploadOptions: {
+ sourcemaps: {
+ assets: ['deprecated/*.js'],
+ ignore: ['deprecated/ignore/*.js'],
+ filesToDeleteAfterUpload: ['deprecated/delete/*.js'],
+ },
+ unstable_sentryVitePluginOptions: {
+ sourcemaps: {
+ assets: ['unstable/*.js'],
+ ignore: ['unstable/ignore/*.js'],
+ },
+ },
+ },
+ unstable_sentryVitePluginOptions: {
+ sourcemaps: {
+ assets: ['new-unstable/*.js'],
+ filesToDeleteAfterUpload: ['new-unstable/delete/*.js'],
+ },
+ },
+ };
+
+ const result = generateVitePluginOptions(options);
+
+ expect(result?.sourcemaps).toEqual({
+ assets: ['new-unstable/*.js'], // new unstable takes precedence
+ ignore: ['unstable/ignore/*.js'], // from deprecated unstable (not overridden by new unstable)
+ filesToDeleteAfterUpload: ['new-unstable/delete/*.js'], // new unstable takes precedence
+ });
+ });
+
+ it('should handle release settings with correct order of overrides', () => {
+ const newReleaseOptions = {
+ name: 'root-release',
+ inject: true,
+ };
+ const newUnstableReleaseOptions = {
+ name: 'new-unstable-release',
+ deploy: {
+ env: 'production',
+ },
+ };
+
+ const options: SentrySvelteKitPluginOptions = {
+ autoUploadSourceMaps: true,
+ release: newReleaseOptions,
+ sourceMapsUploadOptions: {
+ release: {
+ name: 'deprecated-release',
+ inject: false,
+ },
+ unstable_sentryVitePluginOptions: {
+ release: { name: 'deprecated-unstable-release', setCommits: { auto: true } },
+ },
+ },
+ unstable_sentryVitePluginOptions: { release: newUnstableReleaseOptions },
+ };
+
+ const result = generateVitePluginOptions(options);
+
+ expect(result?.release).toEqual({
+ name: newUnstableReleaseOptions.name,
+ inject: newReleaseOptions.inject,
+ setCommits: {
+ auto: true, // from deprecated unstable (not overridden)
+ },
+ deploy: {
+ env: 'production', // from new unstable
+ },
+ });
+ });
+
+ it('should handle complex override scenario with all settings', () => {
+ const options: SentrySvelteKitPluginOptions = {
+ autoUploadSourceMaps: true,
+ org: 'root-org',
+ project: 'root-project',
+ authToken: 'root-token',
+ telemetry: true,
+ sentryUrl: 'https://root.sentry.io',
+ debug: false,
+ sourcemaps: {
+ assets: ['root/*.js'],
+ },
+ release: {
+ name: 'root-1.0.0',
+ },
+ sourceMapsUploadOptions: {
+ org: 'deprecated-org',
+ project: 'deprecated-project',
+ authToken: 'deprecated-token',
+ telemetry: false,
+ url: 'https://deprecated.sentry.io',
+ sourcemaps: {
+ assets: ['deprecated/*.js'],
+ ignore: ['deprecated/ignore/*.js'],
+ },
+ release: {
+ name: 'deprecated-1.0.0',
+ inject: false,
+ },
+ unstable_sentryVitePluginOptions: {
+ org: 'old-unstable-org',
+ sourcemaps: {
+ assets: ['old-unstable/*.js'],
+ },
+ },
+ },
+ unstable_sentryVitePluginOptions: {
+ org: 'new-unstable-org',
+ authToken: 'new-unstable-token',
+ sourcemaps: {
+ assets: ['new-unstable/*.js'],
+ filesToDeleteAfterUpload: ['new-unstable/delete/*.js'],
+ },
+ release: {
+ name: 'new-unstable-1.0.0',
+ },
+ },
+ };
+
+ const result = generateVitePluginOptions(options);
+
+ expect(result).toEqual({
+ org: 'new-unstable-org',
+ project: 'root-project',
+ authToken: 'new-unstable-token',
+ telemetry: true,
+ url: 'https://root.sentry.io',
+ sourcemaps: {
+ assets: ['new-unstable/*.js'],
+ ignore: ['deprecated/ignore/*.js'],
+ filesToDeleteAfterUpload: ['new-unstable/delete/*.js'],
+ },
+ release: {
+ name: 'new-unstable-1.0.0',
+ inject: false,
+ },
+ adapter: undefined,
+ debug: false,
+ });
+ });
});
diff --git a/packages/tanstackstart-react/package.json b/packages/tanstackstart-react/package.json
index 4eb3507ad0be..42d94c1188c8 100644
--- a/packages/tanstackstart-react/package.json
+++ b/packages/tanstackstart-react/package.json
@@ -51,7 +51,7 @@
},
"dependencies": {
"@opentelemetry/api": "^1.9.0",
- "@opentelemetry/semantic-conventions": "^1.34.0",
+ "@opentelemetry/semantic-conventions": "^1.37.0",
"@sentry-internal/browser-utils": "10.11.0",
"@sentry/core": "10.11.0",
"@sentry/node": "10.11.0",
diff --git a/packages/vercel-edge/package.json b/packages/vercel-edge/package.json
index 7cb476c38f40..3afcf65244aa 100644
--- a/packages/vercel-edge/package.json
+++ b/packages/vercel-edge/package.json
@@ -40,14 +40,14 @@
},
"dependencies": {
"@opentelemetry/api": "^1.9.0",
- "@opentelemetry/resources": "^2.0.0",
+ "@opentelemetry/resources": "^2.1.0",
"@sentry/core": "10.11.0"
},
"devDependencies": {
"@edge-runtime/types": "3.0.1",
- "@opentelemetry/core": "^2.0.0",
- "@opentelemetry/sdk-trace-base": "^2.0.0",
- "@opentelemetry/semantic-conventions": "^1.34.0",
+ "@opentelemetry/core": "^2.1.0",
+ "@opentelemetry/sdk-trace-base": "^2.1.0",
+ "@opentelemetry/semantic-conventions": "^1.37.0",
"@sentry/opentelemetry": "10.11.0"
},
"scripts": {
diff --git a/packages/vercel-edge/src/index.ts b/packages/vercel-edge/src/index.ts
index e2fd90eda5b7..3e432c06c1fd 100644
--- a/packages/vercel-edge/src/index.ts
+++ b/packages/vercel-edge/src/index.ts
@@ -70,6 +70,7 @@ export {
// eslint-disable-next-line deprecation/deprecation
inboundFiltersIntegration,
instrumentOpenAiClient,
+ instrumentAnthropicAiClient,
eventFiltersIntegration,
linkedErrorsIntegration,
requestDataIntegration,
@@ -92,6 +93,7 @@ export {
spanToBaggageHeader,
wrapMcpServerWithSentry,
consoleLoggingIntegration,
+ createConsolaReporter,
featureFlagsIntegration,
} from '@sentry/core';
diff --git a/packages/vue/src/errorhandler.ts b/packages/vue/src/errorhandler.ts
index f8ca3b9a2c9f..c18a51492c4a 100644
--- a/packages/vue/src/errorhandler.ts
+++ b/packages/vue/src/errorhandler.ts
@@ -30,7 +30,7 @@ export const attachErrorHandler = (app: Vue, options: VueOptions): void => {
setTimeout(() => {
captureException(error, {
captureContext: { contexts: { vue: metadata } },
- mechanism: { handled: !!originalErrorHandler, type: 'vue' },
+ mechanism: { handled: !!originalErrorHandler, type: 'auto.function.vue.error_handler' },
});
});
diff --git a/packages/vue/test/errorHandler.test.ts b/packages/vue/test/errorHandler.test.ts
index 9e8e7572ba54..54fd80133017 100644
--- a/packages/vue/test/errorHandler.test.ts
+++ b/packages/vue/test/errorHandler.test.ts
@@ -26,7 +26,9 @@ describe('attachErrorHandler', () => {
// assert
t.expect.errorToHaveBeenCaptured().withoutProps();
- t.expect.errorToHaveBeenCaptured().withMechanismMetadata({ handled: false, type: 'vue' });
+ t.expect
+ .errorToHaveBeenCaptured()
+ .withMechanismMetadata({ handled: false, type: 'auto.function.vue.error_handler' });
});
});
@@ -47,7 +49,9 @@ describe('attachErrorHandler', () => {
// assert
t.expect.errorToHaveBeenCaptured().withoutProps();
- t.expect.errorToHaveBeenCaptured().withMechanismMetadata({ handled: false, type: 'vue' });
+ t.expect
+ .errorToHaveBeenCaptured()
+ .withMechanismMetadata({ handled: false, type: 'auto.function.vue.error_handler' });
});
});
@@ -146,7 +150,9 @@ describe('attachErrorHandler', () => {
vi.runAllTimers();
// assert
- t.expect.errorToHaveBeenCaptured().withMechanismMetadata({ handled: false, type: 'vue' });
+ t.expect
+ .errorToHaveBeenCaptured()
+ .withMechanismMetadata({ handled: false, type: 'auto.function.vue.error_handler' });
});
it('should mark error as handled and properly delegate to error handler', () => {
@@ -167,7 +173,9 @@ describe('attachErrorHandler', () => {
// assert
t.expect.errorHandlerSpy.toHaveBeenCalledWith(expect.any(Error), vm, 'stub-lifecycle-hook');
- t.expect.errorToHaveBeenCaptured().withMechanismMetadata({ handled: true, type: 'vue' });
+ t.expect
+ .errorToHaveBeenCaptured()
+ .withMechanismMetadata({ handled: true, type: 'auto.function.vue.error_handler' });
});
});
});
@@ -305,7 +313,7 @@ const testHarness = ({
withoutProps: () => {
expect(contexts).not.toHaveProperty('vue.propsData');
},
- withMechanismMetadata: (mechanism: { handled: boolean; type: 'vue' }) => {
+ withMechanismMetadata: (mechanism: { handled: boolean; type: 'auto.function.vue.error_handler' }) => {
expect(mechanismMetadata).toEqual(mechanism);
},
};
diff --git a/yarn.lock b/yarn.lock
index db7641e5a892..f1bedd816167 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -5858,13 +5858,6 @@
dependencies:
"@octokit/openapi-types" "^18.0.0"
-"@opentelemetry/api-logs@0.203.0":
- version "0.203.0"
- resolved "https://registry.yarnpkg.com/@opentelemetry/api-logs/-/api-logs-0.203.0.tgz#3309a76c51a848ea820cd7f00ee62daf36b06380"
- integrity sha512-9B9RU0H7Ya1Dx/Rkyc4stuBZSGVQF27WigitInx2QQoj6KUpEFYPKoWjdFTunJYxmXmh17HeBvbMa1EhGyPmqQ==
- dependencies:
- "@opentelemetry/api" "^1.3.0"
-
"@opentelemetry/api-logs@0.204.0":
version "0.204.0"
resolved "https://registry.yarnpkg.com/@opentelemetry/api-logs/-/api-logs-0.204.0.tgz#c0285aa5c79625a1c424854393902d21732fd76b"
@@ -5884,108 +5877,100 @@
resolved "https://registry.yarnpkg.com/@opentelemetry/api/-/api-1.9.0.tgz#d03eba68273dc0f7509e2a3d5cba21eae10379fe"
integrity sha512-3giAOQvZiH5F9bMlMiv8+GSPMeqg0dbaeo58/0SlA9sxSqZhnUtxzX9/2FzyhS9sWQf5S0GJE0AKBrFqjpeYcg==
-"@opentelemetry/context-async-hooks@^2.0.0":
- version "2.0.0"
- resolved "https://registry.yarnpkg.com/@opentelemetry/context-async-hooks/-/context-async-hooks-2.0.0.tgz#c98a727238ca199cda943780acf6124af8d8cd80"
- integrity sha512-IEkJGzK1A9v3/EHjXh3s2IiFc6L4jfK+lNgKVgUjeUJQRRhnVFMIO3TAvKwonm9O1HebCuoOt98v8bZW7oVQHA==
-
-"@opentelemetry/core@2.0.0":
- version "2.0.0"
- resolved "https://registry.yarnpkg.com/@opentelemetry/core/-/core-2.0.0.tgz#37e9f0e9ddec4479b267aca6f32d88757c941b3a"
- integrity sha512-SLX36allrcnVaPYG3R78F/UZZsBsvbc7lMCLx37LyH5MJ1KAAZ2E3mW9OAD3zGz0G8q/BtoS5VUrjzDydhD6LQ==
- dependencies:
- "@opentelemetry/semantic-conventions" "^1.29.0"
+"@opentelemetry/context-async-hooks@^2.1.0":
+ version "2.1.0"
+ resolved "https://registry.yarnpkg.com/@opentelemetry/context-async-hooks/-/context-async-hooks-2.1.0.tgz#de1de21d9536abfe73769f822b52a59a8c97b083"
+ integrity sha512-zOyetmZppnwTyPrt4S7jMfXiSX9yyfF0hxlA8B5oo2TtKl+/RGCy7fi4DrBfIf3lCPrkKsRBWZZD7RFojK7FDg==
-"@opentelemetry/core@2.0.1", "@opentelemetry/core@^2.0.0":
- version "2.0.1"
- resolved "https://registry.yarnpkg.com/@opentelemetry/core/-/core-2.0.1.tgz#44e1149d5666a4743cde943ef89841db3ce0f8bc"
- integrity sha512-MaZk9SJIDgo1peKevlbhP6+IwIiNPNmswNL4AF0WaQJLbHXjr9SrZMgS12+iqr9ToV4ZVosCcc0f8Rg67LXjxw==
+"@opentelemetry/core@2.1.0", "@opentelemetry/core@^2.0.0", "@opentelemetry/core@^2.1.0":
+ version "2.1.0"
+ resolved "https://registry.yarnpkg.com/@opentelemetry/core/-/core-2.1.0.tgz#5539f04eb9e5245e000b0c3f77bdfaa07557e3a7"
+ integrity sha512-RMEtHsxJs/GiHHxYT58IY57UXAQTuUnZVco6ymDEqTNlJKTimM4qPUPVe8InNFyBjhHBEAx4k3Q8LtNayBsbUQ==
dependencies:
"@opentelemetry/semantic-conventions" "^1.29.0"
-"@opentelemetry/instrumentation-amqplib@0.50.0":
- version "0.50.0"
- resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-amqplib/-/instrumentation-amqplib-0.50.0.tgz#91899a7e2821db956daeaa803d3bd8f5af8b8050"
- integrity sha512-kwNs/itehHG/qaQBcVrLNcvXVPW0I4FCOVtw3LHMLdYIqD7GJ6Yv2nX+a4YHjzbzIeRYj8iyMp0Bl7tlkidq5w==
+"@opentelemetry/instrumentation-amqplib@0.51.0":
+ version "0.51.0"
+ resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-amqplib/-/instrumentation-amqplib-0.51.0.tgz#1779326433f1ab8a743bbf8e1957e1b1252cf036"
+ integrity sha512-XGmjYwjVRktD4agFnWBWQXo9SiYHKBxR6Ag3MLXwtLE4R99N3a08kGKM5SC1qOFKIELcQDGFEFT9ydXMH00Luw==
dependencies:
"@opentelemetry/core" "^2.0.0"
- "@opentelemetry/instrumentation" "^0.203.0"
+ "@opentelemetry/instrumentation" "^0.204.0"
"@opentelemetry/semantic-conventions" "^1.27.0"
-"@opentelemetry/instrumentation-aws-sdk@0.57.0":
- version "0.57.0"
- resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-aws-sdk/-/instrumentation-aws-sdk-0.57.0.tgz#22d0a2ac113718c85c39d3561ee338dfad2234f6"
- integrity sha512-RfbyjaeZzX3mPhuaRHlSAQyfX3skfeWOl30jrqSXtE9k0DPdnIqpHhdYS0C/DEDuZbwTmruVJ4cUwMBw5Z6FAg==
+"@opentelemetry/instrumentation-aws-sdk@0.59.0":
+ version "0.59.0"
+ resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-aws-sdk/-/instrumentation-aws-sdk-0.59.0.tgz#bd612836a6158f1773369a5646984b95f805273d"
+ integrity sha512-GN/9YGBMb//s0vnchM2jMCkCaIKDB/Piau72fcuqcDXNBffMgu+AA9vCHZD2umriciXLtXJ2GXTh2/yaaHwLIw==
dependencies:
"@opentelemetry/core" "^2.0.0"
- "@opentelemetry/instrumentation" "^0.203.0"
- "@opentelemetry/propagation-utils" "^0.31.3"
+ "@opentelemetry/instrumentation" "^0.204.0"
"@opentelemetry/semantic-conventions" "^1.34.0"
-"@opentelemetry/instrumentation-connect@0.47.0":
- version "0.47.0"
- resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-connect/-/instrumentation-connect-0.47.0.tgz#47271b8454fa88d97aa78e175c3d0cb7e10bd9e2"
- integrity sha512-pjenvjR6+PMRb6/4X85L4OtkQCootgb/Jzh/l/Utu3SJHBid1F+gk9sTGU2FWuhhEfV6P7MZ7BmCdHXQjgJ42g==
+"@opentelemetry/instrumentation-connect@0.48.0":
+ version "0.48.0"
+ resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-connect/-/instrumentation-connect-0.48.0.tgz#4481c84315b33b54a67c6e787be0eb72a84b23b3"
+ integrity sha512-OMjc3SFL4pC16PeK+tDhwP7MRvDPalYCGSvGqUhX5rASkI2H0RuxZHOWElYeXkV0WP+70Gw6JHWac/2Zqwmhdw==
dependencies:
"@opentelemetry/core" "^2.0.0"
- "@opentelemetry/instrumentation" "^0.203.0"
+ "@opentelemetry/instrumentation" "^0.204.0"
"@opentelemetry/semantic-conventions" "^1.27.0"
"@types/connect" "3.4.38"
-"@opentelemetry/instrumentation-dataloader@0.21.1":
- version "0.21.1"
- resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-dataloader/-/instrumentation-dataloader-0.21.1.tgz#46fbbe59d9d6796980707768cf733225d43adea5"
- integrity sha512-hNAm/bwGawLM8VDjKR0ZUDJ/D/qKR3s6lA5NV+btNaPVm2acqhPcT47l2uCVi+70lng2mywfQncor9v8/ykuyw==
+"@opentelemetry/instrumentation-dataloader@0.22.0":
+ version "0.22.0"
+ resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-dataloader/-/instrumentation-dataloader-0.22.0.tgz#a34f8ac6ec18e8f1585dcd89f9f611570868d1a2"
+ integrity sha512-bXnTcwtngQsI1CvodFkTemrrRSQjAjZxqHVc+CJZTDnidT0T6wt3jkKhnsjU/Kkkc0lacr6VdRpCu2CUWa0OKw==
dependencies:
- "@opentelemetry/instrumentation" "^0.203.0"
+ "@opentelemetry/instrumentation" "^0.204.0"
-"@opentelemetry/instrumentation-express@0.52.0":
- version "0.52.0"
- resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-express/-/instrumentation-express-0.52.0.tgz#d87d2130fe779dd757db28edb78262af83510d5b"
- integrity sha512-W7pizN0Wh1/cbNhhTf7C62NpyYw7VfCFTYg0DYieSTrtPBT1vmoSZei19wfKLnrMsz3sHayCg0HxCVL2c+cz5w==
+"@opentelemetry/instrumentation-express@0.53.0":
+ version "0.53.0"
+ resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-express/-/instrumentation-express-0.53.0.tgz#902634e3de640bd4fa5370924397e716608ecb90"
+ integrity sha512-r/PBafQmFYRjuxLYEHJ3ze1iBnP2GDA1nXOSS6E02KnYNZAVjj6WcDA1MSthtdAUUK0XnotHvvWM8/qz7DMO5A==
dependencies:
"@opentelemetry/core" "^2.0.0"
- "@opentelemetry/instrumentation" "^0.203.0"
+ "@opentelemetry/instrumentation" "^0.204.0"
"@opentelemetry/semantic-conventions" "^1.27.0"
-"@opentelemetry/instrumentation-fs@0.23.0":
- version "0.23.0"
- resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-fs/-/instrumentation-fs-0.23.0.tgz#e3cd3a53fa975c69de33e207b35561f3f90106f0"
- integrity sha512-Puan+QopWHA/KNYvDfOZN6M/JtF6buXEyD934vrb8WhsX1/FuM7OtoMlQyIqAadnE8FqqDL4KDPiEfCQH6pQcQ==
+"@opentelemetry/instrumentation-fs@0.24.0":
+ version "0.24.0"
+ resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-fs/-/instrumentation-fs-0.24.0.tgz#edf0f7418f6a1cdcbe135857ab75629e7d94b910"
+ integrity sha512-HjIxJ6CBRD770KNVaTdMXIv29Sjz4C1kPCCK5x1Ujpc6SNnLGPqUVyJYZ3LUhhnHAqdbrl83ogVWjCgeT4Q0yw==
dependencies:
"@opentelemetry/core" "^2.0.0"
- "@opentelemetry/instrumentation" "^0.203.0"
+ "@opentelemetry/instrumentation" "^0.204.0"
-"@opentelemetry/instrumentation-generic-pool@0.47.0":
- version "0.47.0"
- resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-generic-pool/-/instrumentation-generic-pool-0.47.0.tgz#f5fa9d42236eb7d57fa544954f316faee937b0b4"
- integrity sha512-UfHqf3zYK+CwDwEtTjaD12uUqGGTswZ7ofLBEdQ4sEJp9GHSSJMQ2hT3pgBxyKADzUdoxQAv/7NqvL42ZI+Qbw==
+"@opentelemetry/instrumentation-generic-pool@0.48.0":
+ version "0.48.0"
+ resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-generic-pool/-/instrumentation-generic-pool-0.48.0.tgz#76fc08d76515db04f3833d730c5cb18cb0b237d4"
+ integrity sha512-TLv/On8pufynNR+pUbpkyvuESVASZZKMlqCm4bBImTpXKTpqXaJJ3o/MUDeMlM91rpen+PEv2SeyOKcHCSlgag==
dependencies:
- "@opentelemetry/instrumentation" "^0.203.0"
+ "@opentelemetry/instrumentation" "^0.204.0"
-"@opentelemetry/instrumentation-graphql@0.51.0":
- version "0.51.0"
- resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-graphql/-/instrumentation-graphql-0.51.0.tgz#1b29aa6330d196d523460e593167dca7dbcd42bb"
- integrity sha512-LchkOu9X5DrXAnPI1+Z06h/EH/zC7D6sA86hhPrk3evLlsJTz0grPrkL/yUJM9Ty0CL/y2HSvmWQCjbJEz/ADg==
+"@opentelemetry/instrumentation-graphql@0.52.0":
+ version "0.52.0"
+ resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-graphql/-/instrumentation-graphql-0.52.0.tgz#a2d23a669bdd0a1b031f785fe447d5a34ac56343"
+ integrity sha512-3fEJ8jOOMwopvldY16KuzHbRhPk8wSsOTSF0v2psmOCGewh6ad+ZbkTx/xyUK9rUdUMWAxRVU0tFpj4Wx1vkPA==
dependencies:
- "@opentelemetry/instrumentation" "^0.203.0"
+ "@opentelemetry/instrumentation" "^0.204.0"
-"@opentelemetry/instrumentation-hapi@0.50.0":
- version "0.50.0"
- resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-hapi/-/instrumentation-hapi-0.50.0.tgz#c755e9c21bfeb82046221bfd51303f816ae649e8"
- integrity sha512-5xGusXOFQXKacrZmDbpHQzqYD1gIkrMWuwvlrEPkYOsjUqGUjl1HbxCsn5Y9bUXOCgP1Lj6A4PcKt1UiJ2MujA==
+"@opentelemetry/instrumentation-hapi@0.51.0":
+ version "0.51.0"
+ resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-hapi/-/instrumentation-hapi-0.51.0.tgz#879926dfbb2e1609cc8658392167b1456c75d9e0"
+ integrity sha512-qyf27DaFNL1Qhbo/da+04MSCw982B02FhuOS5/UF+PMhM61CcOiu7fPuXj8TvbqyReQuJFljXE6UirlvoT/62g==
dependencies:
"@opentelemetry/core" "^2.0.0"
- "@opentelemetry/instrumentation" "^0.203.0"
+ "@opentelemetry/instrumentation" "^0.204.0"
"@opentelemetry/semantic-conventions" "^1.27.0"
-"@opentelemetry/instrumentation-http@0.203.0":
- version "0.203.0"
- resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-http/-/instrumentation-http-0.203.0.tgz#21f198547b5c72fc64e83ed25cdc991aef7b8fee"
- integrity sha512-y3uQAcCOAwnO6vEuNVocmpVzG3PER6/YZqbPbbffDdJ9te5NkHEkfSMNzlC3+v7KlE+WinPGc3N7MR30G1HY2g==
+"@opentelemetry/instrumentation-http@0.204.0":
+ version "0.204.0"
+ resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-http/-/instrumentation-http-0.204.0.tgz#faaf009b75e6a68729923b0a2a5270dc7d336f1d"
+ integrity sha512-1afJYyGRA4OmHTv0FfNTrTAzoEjPQUYgd+8ih/lX0LlZBnGio/O80vxA0lN3knsJPS7FiDrsDrWq25K7oAzbkw==
dependencies:
- "@opentelemetry/core" "2.0.1"
- "@opentelemetry/instrumentation" "0.203.0"
+ "@opentelemetry/core" "2.1.0"
+ "@opentelemetry/instrumentation" "0.204.0"
"@opentelemetry/semantic-conventions" "^1.29.0"
forwarded-parse "2.1.2"
@@ -5998,129 +5983,120 @@
"@opentelemetry/redis-common" "^0.38.0"
"@opentelemetry/semantic-conventions" "^1.27.0"
-"@opentelemetry/instrumentation-kafkajs@0.13.0":
- version "0.13.0"
- resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-kafkajs/-/instrumentation-kafkajs-0.13.0.tgz#f959fecd0a9d53bed2fd662e41a5c155295ffbc8"
- integrity sha512-FPQyJsREOaGH64hcxlzTsIEQC4DYANgTwHjiB7z9lldmvua1LRMVn3/FfBlzXoqF179B0VGYviz6rn75E9wsDw==
+"@opentelemetry/instrumentation-kafkajs@0.14.0":
+ version "0.14.0"
+ resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-kafkajs/-/instrumentation-kafkajs-0.14.0.tgz#ffc30728b5845907d2c5b9f3883676c754ef4927"
+ integrity sha512-kbB5yXS47dTIdO/lfbbXlzhvHFturbux4EpP0+6H78Lk0Bn4QXiZQW7rmZY1xBCY16mNcCb8Yt0mhz85hTnSVA==
dependencies:
- "@opentelemetry/instrumentation" "^0.203.0"
+ "@opentelemetry/instrumentation" "^0.204.0"
"@opentelemetry/semantic-conventions" "^1.30.0"
-"@opentelemetry/instrumentation-knex@0.48.0":
- version "0.48.0"
- resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-knex/-/instrumentation-knex-0.48.0.tgz#ed24a81dfe6099cfe56136a3fed90565e1259f58"
- integrity sha512-V5wuaBPv/lwGxuHjC6Na2JFRjtPgstw19jTFl1B1b6zvaX8zVDYUDaR5hL7glnQtUSCMktPttQsgK4dhXpddcA==
+"@opentelemetry/instrumentation-knex@0.49.0":
+ version "0.49.0"
+ resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-knex/-/instrumentation-knex-0.49.0.tgz#8c04c80c00ead5fbdf600cd2460dcd21b4069157"
+ integrity sha512-NKsRRT27fbIYL4Ix+BjjP8h4YveyKc+2gD6DMZbr5R5rUeDqfC8+DTfIt3c3ex3BIc5Vvek4rqHnN7q34ZetLQ==
dependencies:
- "@opentelemetry/instrumentation" "^0.203.0"
+ "@opentelemetry/instrumentation" "^0.204.0"
"@opentelemetry/semantic-conventions" "^1.33.1"
-"@opentelemetry/instrumentation-koa@0.51.0":
- version "0.51.0"
- resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-koa/-/instrumentation-koa-0.51.0.tgz#1ff57866b7882033639477d3d2d9bada19a2129f"
- integrity sha512-XNLWeMTMG1/EkQBbgPYzCeBD0cwOrfnn8ao4hWgLv0fNCFQu1kCsJYygz2cvKuCs340RlnG4i321hX7R8gj3Rg==
+"@opentelemetry/instrumentation-koa@0.52.0":
+ version "0.52.0"
+ resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-koa/-/instrumentation-koa-0.52.0.tgz#7266785ea85334366c3e50dc2b45468df438eb3f"
+ integrity sha512-JJSBYLDx/mNSy8Ibi/uQixu2rH0bZODJa8/cz04hEhRaiZQoeJ5UrOhO/mS87IdgVsHrnBOsZ6vDu09znupyuA==
dependencies:
"@opentelemetry/core" "^2.0.0"
- "@opentelemetry/instrumentation" "^0.203.0"
+ "@opentelemetry/instrumentation" "^0.204.0"
"@opentelemetry/semantic-conventions" "^1.27.0"
-"@opentelemetry/instrumentation-lru-memoizer@0.48.0":
- version "0.48.0"
- resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-lru-memoizer/-/instrumentation-lru-memoizer-0.48.0.tgz#b9fbbd45b7a742a6795bf7166f65684251f184b1"
- integrity sha512-KUW29wfMlTPX1wFz+NNrmE7IzN7NWZDrmFWHM/VJcmFEuQGnnBuTIdsP55CnBDxKgQ/qqYFp4udQFNtjeFosPw==
+"@opentelemetry/instrumentation-lru-memoizer@0.49.0":
+ version "0.49.0"
+ resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-lru-memoizer/-/instrumentation-lru-memoizer-0.49.0.tgz#6353b877628339e3f07189f4fb15919a73fe1503"
+ integrity sha512-ctXu+O/1HSadAxtjoEg2w307Z5iPyLOMM8IRNwjaKrIpNAthYGSOanChbk1kqY6zU5CrpkPHGdAT6jk8dXiMqw==
dependencies:
- "@opentelemetry/instrumentation" "^0.203.0"
+ "@opentelemetry/instrumentation" "^0.204.0"
-"@opentelemetry/instrumentation-mongodb@0.56.0":
- version "0.56.0"
- resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-mongodb/-/instrumentation-mongodb-0.56.0.tgz#81281d2d151c3bfb26864c50b938a82ba2831b2d"
- integrity sha512-YG5IXUUmxX3Md2buVMvxm9NWlKADrnavI36hbJsihqqvBGsWnIfguf0rUP5Srr0pfPqhQjUP+agLMsvu0GmUpA==
+"@opentelemetry/instrumentation-mongodb@0.57.0":
+ version "0.57.0"
+ resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-mongodb/-/instrumentation-mongodb-0.57.0.tgz#e697261b2eac05280134e1851b72c89d5b4b3da8"
+ integrity sha512-KD6Rg0KSHWDkik+qjIOWoksi1xqSpix8TSPfquIK1DTmd9OTFb5PHmMkzJe16TAPVEuElUW8gvgP59cacFcrMQ==
dependencies:
- "@opentelemetry/instrumentation" "^0.203.0"
+ "@opentelemetry/instrumentation" "^0.204.0"
"@opentelemetry/semantic-conventions" "^1.27.0"
-"@opentelemetry/instrumentation-mongoose@0.50.0":
- version "0.50.0"
- resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-mongoose/-/instrumentation-mongoose-0.50.0.tgz#1fae5d2769ca7e67d15291fb91b61403839ad91d"
- integrity sha512-Am8pk1Ct951r4qCiqkBcGmPIgGhoDiFcRtqPSLbJrUZqEPUsigjtMjoWDRLG1Ki1NHgOF7D0H7d+suWz1AAizw==
+"@opentelemetry/instrumentation-mongoose@0.51.0":
+ version "0.51.0"
+ resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-mongoose/-/instrumentation-mongoose-0.51.0.tgz#688e9f3448e3d0979c4aaab5b566e14f30a1aa72"
+ integrity sha512-gwWaAlhhV2By7XcbyU3DOLMvzsgeaymwP/jktDC+/uPkCmgB61zurwqOQdeiRq9KAf22Y2dtE5ZLXxytJRbEVA==
dependencies:
"@opentelemetry/core" "^2.0.0"
- "@opentelemetry/instrumentation" "^0.203.0"
+ "@opentelemetry/instrumentation" "^0.204.0"
"@opentelemetry/semantic-conventions" "^1.27.0"
-"@opentelemetry/instrumentation-mysql2@0.50.0":
- version "0.50.0"
- resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-mysql2/-/instrumentation-mysql2-0.50.0.tgz#259344ba8771fd59c70a1a91360215b4b047a323"
- integrity sha512-PoOMpmq73rOIE3nlTNLf3B1SyNYGsp7QXHYKmeTZZnJ2Ou7/fdURuOhWOI0e6QZ5gSem18IR1sJi6GOULBQJ9g==
+"@opentelemetry/instrumentation-mysql2@0.51.0":
+ version "0.51.0"
+ resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-mysql2/-/instrumentation-mysql2-0.51.0.tgz#7eec3a0b9e4b27759df5df1c82eaedcf34b27528"
+ integrity sha512-zT2Wg22Xn43RyfU3NOUmnFtb5zlDI0fKcijCj9AcK9zuLZ4ModgtLXOyBJSSfO+hsOCZSC1v/Fxwj+nZJFdzLQ==
dependencies:
- "@opentelemetry/instrumentation" "^0.203.0"
+ "@opentelemetry/instrumentation" "^0.204.0"
"@opentelemetry/semantic-conventions" "^1.27.0"
"@opentelemetry/sql-common" "^0.41.0"
-"@opentelemetry/instrumentation-mysql@0.49.0":
- version "0.49.0"
- resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-mysql/-/instrumentation-mysql-0.49.0.tgz#24fa7473134867236ed4068ee645e51922bcb654"
- integrity sha512-QU9IUNqNsrlfE3dJkZnFHqLjlndiU39ll/YAAEvWE40sGOCi9AtOF6rmEGzJ1IswoZ3oyePV7q2MP8SrhJfVAA==
+"@opentelemetry/instrumentation-mysql@0.50.0":
+ version "0.50.0"
+ resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-mysql/-/instrumentation-mysql-0.50.0.tgz#25de9de05191cecf8b01df379544eba50fa6f548"
+ integrity sha512-duKAvMRI3vq6u9JwzIipY9zHfikN20bX05sL7GjDeLKr2qV0LQ4ADtKST7KStdGcQ+MTN5wghWbbVdLgNcB3rA==
dependencies:
- "@opentelemetry/instrumentation" "^0.203.0"
+ "@opentelemetry/instrumentation" "^0.204.0"
"@opentelemetry/semantic-conventions" "^1.27.0"
"@types/mysql" "2.15.27"
-"@opentelemetry/instrumentation-nestjs-core@0.49.0":
- version "0.49.0"
- resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-nestjs-core/-/instrumentation-nestjs-core-0.49.0.tgz#a79428e72c14250c44913a3a57f39c7297aab013"
- integrity sha512-1R/JFwdmZIk3T/cPOCkVvFQeKYzbbUvDxVH3ShXamUwBlGkdEu5QJitlRMyVNZaHkKZKWgYrBarGQsqcboYgaw==
+"@opentelemetry/instrumentation-nestjs-core@0.50.0":
+ version "0.50.0"
+ resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-nestjs-core/-/instrumentation-nestjs-core-0.50.0.tgz#f803bbeb6c972ac8f0685885cca7f6e5a4e09056"
+ integrity sha512-10u2Gjw260W8vdUem6pM7ENrb8i+UAyrgouhjN7HRdQYh9rcit51tRhgrI52fxTsRjrrBNIItHkX0YM8WnEU2w==
dependencies:
- "@opentelemetry/instrumentation" "^0.203.0"
+ "@opentelemetry/instrumentation" "^0.204.0"
"@opentelemetry/semantic-conventions" "^1.30.0"
-"@opentelemetry/instrumentation-pg@0.55.0":
- version "0.55.0"
- resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-pg/-/instrumentation-pg-0.55.0.tgz#f411d1e48c50b1c1f0f185d9fe94cfbb8812d8f6"
- integrity sha512-yfJ5bYE7CnkW/uNsnrwouG/FR7nmg09zdk2MSs7k0ZOMkDDAE3WBGpVFFApGgNu2U+gtzLgEzOQG4I/X+60hXw==
+"@opentelemetry/instrumentation-pg@0.57.0":
+ version "0.57.0"
+ resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-pg/-/instrumentation-pg-0.57.0.tgz#346cb613ccd1100221cef9692271468a3fe92eb0"
+ integrity sha512-dWLGE+r5lBgm2A8SaaSYDE3OKJ/kwwy5WLyGyzor8PLhUL9VnJRiY6qhp4njwhnljiLtzeffRtG2Mf/YyWLeTw==
dependencies:
"@opentelemetry/core" "^2.0.0"
- "@opentelemetry/instrumentation" "^0.203.0"
- "@opentelemetry/semantic-conventions" "^1.27.0"
+ "@opentelemetry/instrumentation" "^0.204.0"
+ "@opentelemetry/semantic-conventions" "^1.34.0"
"@opentelemetry/sql-common" "^0.41.0"
- "@types/pg" "8.15.4"
+ "@types/pg" "8.15.5"
"@types/pg-pool" "2.0.6"
-"@opentelemetry/instrumentation-redis@0.51.0":
- version "0.51.0"
- resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-redis/-/instrumentation-redis-0.51.0.tgz#70504ba6c3856fcb25e436b4915e85efaa7d38a6"
- integrity sha512-uL/GtBA0u72YPPehwOvthAe+Wf8k3T+XQPBssJmTYl6fzuZjNq8zTfxVFhl9nRFjFVEe+CtiYNT0Q3AyqW1Z0A==
+"@opentelemetry/instrumentation-redis@0.53.0":
+ version "0.53.0"
+ resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-redis/-/instrumentation-redis-0.53.0.tgz#826cfeacebaf7ce571bb932ad410f23caf170b9c"
+ integrity sha512-WUHV8fr+8yo5RmzyU7D5BIE1zwiaNQcTyZPwtxlfr7px6NYYx7IIpSihJK7WA60npWynfxxK1T67RAVF0Gdfjg==
dependencies:
- "@opentelemetry/instrumentation" "^0.203.0"
+ "@opentelemetry/instrumentation" "^0.204.0"
"@opentelemetry/redis-common" "^0.38.0"
"@opentelemetry/semantic-conventions" "^1.27.0"
-"@opentelemetry/instrumentation-tedious@0.22.0":
- version "0.22.0"
- resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-tedious/-/instrumentation-tedious-0.22.0.tgz#f71374c52cb9c57a6b879bea3256a1465c02efbb"
- integrity sha512-XrrNSUCyEjH1ax9t+Uo6lv0S2FCCykcF7hSxBMxKf7Xn0bPRxD3KyFUZy25aQXzbbbUHhtdxj3r2h88SfEM3aA==
+"@opentelemetry/instrumentation-tedious@0.23.0":
+ version "0.23.0"
+ resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-tedious/-/instrumentation-tedious-0.23.0.tgz#a781de2cb33ff71ef65bbefba11c9fe2d79c4b32"
+ integrity sha512-3TMTk/9VtlRonVTaU4tCzbg4YqW+Iq/l5VnN2e5whP6JgEg/PKfrGbqQ+CxQWNLfLaQYIUgEZqAn5gk/inh1uQ==
dependencies:
- "@opentelemetry/instrumentation" "^0.203.0"
+ "@opentelemetry/instrumentation" "^0.204.0"
"@opentelemetry/semantic-conventions" "^1.27.0"
"@types/tedious" "^4.0.14"
-"@opentelemetry/instrumentation-undici@0.14.0":
- version "0.14.0"
- resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-undici/-/instrumentation-undici-0.14.0.tgz#7a9cd276f7664773b5daf5ae53365b3593e6e7a9"
- integrity sha512-2HN+7ztxAReXuxzrtA3WboAKlfP5OsPA57KQn2AdYZbJ3zeRPcLXyW4uO/jpLE6PLm0QRtmeGCmfYpqRlwgSwg==
+"@opentelemetry/instrumentation-undici@0.15.0":
+ version "0.15.0"
+ resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation-undici/-/instrumentation-undici-0.15.0.tgz#c8193a162d4abe61c2fd247912e0cb8c0c3bc10c"
+ integrity sha512-sNFGA/iCDlVkNjzTzPRcudmI11vT/WAfAguRdZY9IspCw02N4WSC72zTuQhSMheh2a1gdeM9my1imnKRvEEvEg==
dependencies:
"@opentelemetry/core" "^2.0.0"
- "@opentelemetry/instrumentation" "^0.203.0"
-
-"@opentelemetry/instrumentation@0.203.0", "@opentelemetry/instrumentation@^0.203.0":
- version "0.203.0"
- resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation/-/instrumentation-0.203.0.tgz#5c74a41cd6868f7ba47b346ff5a58ea7b18cf381"
- integrity sha512-ke1qyM+3AK2zPuBPb6Hk/GCsc5ewbLvPNkEuELx/JmANeEp6ZjnZ+wypPAJSucTw0wvCGrUaibDSdcrGFoWxKQ==
- dependencies:
- "@opentelemetry/api-logs" "0.203.0"
- import-in-the-middle "^1.8.1"
- require-in-the-middle "^7.1.1"
+ "@opentelemetry/instrumentation" "^0.204.0"
-"@opentelemetry/instrumentation@^0.204.0":
+"@opentelemetry/instrumentation@0.204.0", "@opentelemetry/instrumentation@^0.204.0":
version "0.204.0"
resolved "https://registry.yarnpkg.com/@opentelemetry/instrumentation/-/instrumentation-0.204.0.tgz#587c104c02c9ccb38932ce508d9c81514ec7a7c4"
integrity sha512-vV5+WSxktzoMP8JoYWKeopChy6G3HKk4UQ2hESCRDUUTZqQ3+nM3u8noVG0LmNfRWwcFBnbZ71GKC7vaYYdJ1g==
@@ -6141,45 +6117,32 @@
semver "^7.5.2"
shimmer "^1.2.1"
-"@opentelemetry/propagation-utils@^0.31.3":
- version "0.31.3"
- resolved "https://registry.yarnpkg.com/@opentelemetry/propagation-utils/-/propagation-utils-0.31.3.tgz#42aab61a1a3cec64ce221cbcec5f3f6fc84e9701"
- integrity sha512-ZI6LKjyo+QYYZY5SO8vfoCQ9A69r1/g+pyjvtu5RSK38npINN1evEmwqbqhbg2CdcIK3a4PN6pDAJz/yC5/gAA==
-
"@opentelemetry/redis-common@^0.38.0":
version "0.38.0"
resolved "https://registry.yarnpkg.com/@opentelemetry/redis-common/-/redis-common-0.38.0.tgz#87d2a792dcbcf466a41bb7dfb8a7cd094d643d0b"
integrity sha512-4Wc0AWURII2cfXVVoZ6vDqK+s5n4K5IssdrlVrvGsx6OEOKdghKtJZqXAHWFiZv4nTDLH2/2fldjIHY8clMOjQ==
-"@opentelemetry/resources@2.0.0":
- version "2.0.0"
- resolved "https://registry.yarnpkg.com/@opentelemetry/resources/-/resources-2.0.0.tgz#15c04794c32b7d0b3c7589225ece6ae9bba25989"
- integrity sha512-rnZr6dML2z4IARI4zPGQV4arDikF/9OXZQzrC01dLmn0CZxU5U5OLd/m1T7YkGRj5UitjeoCtg/zorlgMQcdTg==
- dependencies:
- "@opentelemetry/core" "2.0.0"
- "@opentelemetry/semantic-conventions" "^1.29.0"
-
-"@opentelemetry/resources@^2.0.0":
- version "2.0.1"
- resolved "https://registry.yarnpkg.com/@opentelemetry/resources/-/resources-2.0.1.tgz#0365d134291c0ed18d96444a1e21d0e6a481c840"
- integrity sha512-dZOB3R6zvBwDKnHDTB4X1xtMArB/d324VsbiPkX/Yu0Q8T2xceRthoIVFhJdvgVM2QhGVUyX9tzwiNxGtoBJUw==
+"@opentelemetry/resources@2.1.0", "@opentelemetry/resources@^2.1.0":
+ version "2.1.0"
+ resolved "https://registry.yarnpkg.com/@opentelemetry/resources/-/resources-2.1.0.tgz#11772e732af4f27953cf55567a6630d8b4d8282d"
+ integrity sha512-1CJjf3LCvoefUOgegxi8h6r4B/wLSzInyhGP2UmIBYNlo4Qk5CZ73e1eEyWmfXvFtm1ybkmfb2DqWvspsYLrWw==
dependencies:
- "@opentelemetry/core" "2.0.1"
+ "@opentelemetry/core" "2.1.0"
"@opentelemetry/semantic-conventions" "^1.29.0"
-"@opentelemetry/sdk-trace-base@^2.0.0":
- version "2.0.0"
- resolved "https://registry.yarnpkg.com/@opentelemetry/sdk-trace-base/-/sdk-trace-base-2.0.0.tgz#ebc06ea7537dea62f3882f8236c1234f4faf6b23"
- integrity sha512-qQnYdX+ZCkonM7tA5iU4fSRsVxbFGml8jbxOgipRGMFHKaXKHQ30js03rTobYjKjIfnOsZSbHKWF0/0v0OQGfw==
+"@opentelemetry/sdk-trace-base@^2.1.0":
+ version "2.1.0"
+ resolved "https://registry.yarnpkg.com/@opentelemetry/sdk-trace-base/-/sdk-trace-base-2.1.0.tgz#9d31474824e9ed215f94bf71260d5321f64d402a"
+ integrity sha512-uTX9FBlVQm4S2gVQO1sb5qyBLq/FPjbp+tmGoxu4tIgtYGmBYB44+KX/725RFDe30yBSaA9Ml9fqphe1hbUyLQ==
dependencies:
- "@opentelemetry/core" "2.0.0"
- "@opentelemetry/resources" "2.0.0"
+ "@opentelemetry/core" "2.1.0"
+ "@opentelemetry/resources" "2.1.0"
"@opentelemetry/semantic-conventions" "^1.29.0"
-"@opentelemetry/semantic-conventions@^1.27.0", "@opentelemetry/semantic-conventions@^1.29.0", "@opentelemetry/semantic-conventions@^1.30.0", "@opentelemetry/semantic-conventions@^1.33.1", "@opentelemetry/semantic-conventions@^1.34.0", "@opentelemetry/semantic-conventions@^1.36.0":
- version "1.36.0"
- resolved "https://registry.yarnpkg.com/@opentelemetry/semantic-conventions/-/semantic-conventions-1.36.0.tgz#149449bd4df4d0464220915ad4164121e0d75d4d"
- integrity sha512-TtxJSRD8Ohxp6bKkhrm27JRHAxPczQA7idtcTOMYI+wQRRrfgqxHv1cFbCApcSnNjtXkmzFozn6jQtFrOmbjPQ==
+"@opentelemetry/semantic-conventions@^1.27.0", "@opentelemetry/semantic-conventions@^1.29.0", "@opentelemetry/semantic-conventions@^1.30.0", "@opentelemetry/semantic-conventions@^1.33.1", "@opentelemetry/semantic-conventions@^1.34.0", "@opentelemetry/semantic-conventions@^1.37.0":
+ version "1.37.0"
+ resolved "https://registry.yarnpkg.com/@opentelemetry/semantic-conventions/-/semantic-conventions-1.37.0.tgz#aa2b4fa0b910b66a050c5ddfcac1d262e91a321a"
+ integrity sha512-JD6DerIKdJGmRp4jQyX5FlrQjA4tjOw1cvfsPAZXfOOEErMUHjPcPSICS+6WnM0nB0efSFARh0KAZss+bvExOA==
"@opentelemetry/sql-common@^0.41.0":
version "0.41.0"
@@ -6341,10 +6304,61 @@
resolved "https://registry.yarnpkg.com/@poppinss/exception/-/exception-1.2.2.tgz#8d30d42e126c54fe84e997433e4dcac610090743"
integrity sha512-m7bpKCD4QMlFCjA/nKTs23fuvoVFoA83brRKmObCUNmi/9tVu8Ve3w4YQAnJu4q3Tjf5fr685HYIC/IA2zHRSg==
-"@prisma/instrumentation@6.14.0":
- version "6.14.0"
- resolved "https://registry.yarnpkg.com/@prisma/instrumentation/-/instrumentation-6.14.0.tgz#8f6e43b73ee2b88b98cec901457f4da7da13aea3"
- integrity sha512-Po/Hry5bAeunRDq0yAQueKookW3glpP+qjjvvyOfm6dI2KG5/Y6Bgg3ahyWd7B0u2E+Wf9xRk2rtdda7ySgK1A==
+"@prisma/client@6.15.0":
+ version "6.15.0"
+ resolved "https://registry.yarnpkg.com/@prisma/client/-/client-6.15.0.tgz#c4166aa8492878c842e63c515853d7a4125e6168"
+ integrity sha512-wR2LXUbOH4cL/WToatI/Y2c7uzni76oNFND7+23ypLllBmIS8e3ZHhO+nud9iXSXKFt1SoM3fTZvHawg63emZw==
+
+"@prisma/config@6.15.0":
+ version "6.15.0"
+ resolved "https://registry.yarnpkg.com/@prisma/config/-/config-6.15.0.tgz#b9a4fd87620baae3ce71015ee4ad632995838d89"
+ integrity sha512-KMEoec9b2u6zX0EbSEx/dRpx1oNLjqJEBZYyK0S3TTIbZ7GEGoVyGyFRk4C72+A38cuPLbfQGQvgOD+gBErKlA==
+ dependencies:
+ c12 "3.1.0"
+ deepmerge-ts "7.1.5"
+ effect "3.16.12"
+ empathic "2.0.0"
+
+"@prisma/debug@6.15.0":
+ version "6.15.0"
+ resolved "https://registry.yarnpkg.com/@prisma/debug/-/debug-6.15.0.tgz#8595f8ae91eadd20d926398449b8602c74e36bbf"
+ integrity sha512-y7cSeLuQmyt+A3hstAs6tsuAiVXSnw9T55ra77z0nbNkA8Lcq9rNcQg6PI00by/+WnE/aMRJ/W7sZWn2cgIy1g==
+
+"@prisma/engines-version@6.15.0-5.85179d7826409ee107a6ba334b5e305ae3fba9fb":
+ version "6.15.0-5.85179d7826409ee107a6ba334b5e305ae3fba9fb"
+ resolved "https://registry.yarnpkg.com/@prisma/engines-version/-/engines-version-6.15.0-5.85179d7826409ee107a6ba334b5e305ae3fba9fb.tgz#718b17890287447360107bef3675487d8cb0ae15"
+ integrity sha512-a/46aK5j6L3ePwilZYEgYDPrhBQ/n4gYjLxT5YncUTJJNRnTCVjPF86QdzUOLRdYjCLfhtZp9aum90W0J+trrg==
+
+"@prisma/engines@6.15.0":
+ version "6.15.0"
+ resolved "https://registry.yarnpkg.com/@prisma/engines/-/engines-6.15.0.tgz#77a220e40f4ed3345ef27407f8f0323e80debea8"
+ integrity sha512-opITiR5ddFJ1N2iqa7mkRlohCZqVSsHhRcc29QXeldMljOf4FSellLT0J5goVb64EzRTKcIDeIsJBgmilNcKxA==
+ dependencies:
+ "@prisma/debug" "6.15.0"
+ "@prisma/engines-version" "6.15.0-5.85179d7826409ee107a6ba334b5e305ae3fba9fb"
+ "@prisma/fetch-engine" "6.15.0"
+ "@prisma/get-platform" "6.15.0"
+
+"@prisma/fetch-engine@6.15.0":
+ version "6.15.0"
+ resolved "https://registry.yarnpkg.com/@prisma/fetch-engine/-/fetch-engine-6.15.0.tgz#ec7e57030789ed42a87bf5b66be4db6e612412e9"
+ integrity sha512-xcT5f6b+OWBq6vTUnRCc7qL+Im570CtwvgSj+0MTSGA1o9UDSKZ/WANvwtiRXdbYWECpyC3CukoG3A04VTAPHw==
+ dependencies:
+ "@prisma/debug" "6.15.0"
+ "@prisma/engines-version" "6.15.0-5.85179d7826409ee107a6ba334b5e305ae3fba9fb"
+ "@prisma/get-platform" "6.15.0"
+
+"@prisma/get-platform@6.15.0":
+ version "6.15.0"
+ resolved "https://registry.yarnpkg.com/@prisma/get-platform/-/get-platform-6.15.0.tgz#86a114534a534090b931801b83356b0bbe676f29"
+ integrity sha512-Jbb+Xbxyp05NSR1x2epabetHiXvpO8tdN2YNoWoA/ZsbYyxxu/CO/ROBauIFuMXs3Ti+W7N7SJtWsHGaWte9Rg==
+ dependencies:
+ "@prisma/debug" "6.15.0"
+
+"@prisma/instrumentation@6.15.0":
+ version "6.15.0"
+ resolved "https://registry.yarnpkg.com/@prisma/instrumentation/-/instrumentation-6.15.0.tgz#40b066dc6b1ea621aa5ae0fd6d54319550b7d8c9"
+ integrity sha512-6TXaH6OmDkMOQvOxwLZ8XS51hU2v4A3vmE2pSijCIiGRJYyNeMcL6nMHQMyYdZRD8wl7LF3Wzc+AMPMV/9Oo7A==
dependencies:
"@opentelemetry/instrumentation" "^0.52.0 || ^0.53.0 || ^0.54.0 || ^0.55.0 || ^0.56.0 || ^0.57.0"
@@ -7688,6 +7702,11 @@
resolved "https://registry.yarnpkg.com/@speed-highlight/core/-/core-1.2.7.tgz#eeaa7c1e7198559abbb98e4acbc93d108d35f2d3"
integrity sha512-0dxmVj4gxg3Jg879kvFS/msl4s9F3T9UXC1InxgOf7t5NvcPD97u/WTA5vL/IxWHMn7qSxBozqrnnE2wvl1m8g==
+"@standard-schema/spec@^1.0.0":
+ version "1.0.0"
+ resolved "https://registry.yarnpkg.com/@standard-schema/spec/-/spec-1.0.0.tgz#f193b73dc316c4170f2e82a881da0f550d551b9c"
+ integrity sha512-m2bOd0f2RT9k8QJx1JN85cZYyH1RqFBdlwtkSlf4tBDYLCiiZnv1fIIwacK6cqwXavOydf0NPToMQgpKq+dVlA==
+
"@supabase/auth-js@2.69.1":
version "2.69.1"
resolved "https://registry.yarnpkg.com/@supabase/auth-js/-/auth-js-2.69.1.tgz#fcf310d24dfab823ffbf22191e6ceaef933360d8"
@@ -8649,10 +8668,10 @@
dependencies:
"@types/pg" "*"
-"@types/pg@*", "@types/pg@8.15.4", "@types/pg@^8.6.5":
- version "8.15.4"
- resolved "https://registry.yarnpkg.com/@types/pg/-/pg-8.15.4.tgz#419f791c6fac8e0bed66dd8f514b60f8ba8db46d"
- integrity sha512-I6UNVBAoYbvuWkkU3oosC8yxqH21f4/Jc4DK71JLG3dT2mdlGe1z+ep/LQGXaKaOgcvUrsQoPRqfgtMcvZiJhg==
+"@types/pg@*", "@types/pg@8.15.5", "@types/pg@^8.6.5":
+ version "8.15.5"
+ resolved "https://registry.yarnpkg.com/@types/pg/-/pg-8.15.5.tgz#ef43e0f33b62dac95cae2f042888ec7980b30c09"
+ integrity sha512-LF7lF6zWEKxuT3/OR8wAZGzkg4ENGXFNyiV/JeOt9z5B+0ZVwbql9McqX5c/WStFq1GaGso7H1AzP/qSzmlCKQ==
dependencies:
"@types/node" "*"
pg-protocol "*"
@@ -12168,6 +12187,24 @@ bytes@3.1.2, bytes@^3.1.2:
resolved "https://registry.yarnpkg.com/bytes/-/bytes-3.1.2.tgz#8b0beeb98605adf1b128fa4386403c009e0221a5"
integrity sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==
+c12@3.1.0, c12@^3.0.4:
+ version "3.1.0"
+ resolved "https://registry.yarnpkg.com/c12/-/c12-3.1.0.tgz#9e237970e1d3b74ebae51d25945cb59664c12c89"
+ integrity sha512-uWoS8OU1MEIsOv8p/5a82c3H31LsWVR5qiyXVfBNOzfffjUWtPnhAb4BYI2uG2HfGmZmFjCtui5XNWaps+iFuw==
+ dependencies:
+ chokidar "^4.0.3"
+ confbox "^0.2.2"
+ defu "^6.1.4"
+ dotenv "^16.6.1"
+ exsolve "^1.0.7"
+ giget "^2.0.0"
+ jiti "^2.4.2"
+ ohash "^2.0.11"
+ pathe "^2.0.3"
+ perfect-debounce "^1.0.0"
+ pkg-types "^2.2.0"
+ rc9 "^2.1.2"
+
c12@^1.11.2:
version "1.11.2"
resolved "https://registry.yarnpkg.com/c12/-/c12-1.11.2.tgz#f8a1e30c10f4b273894a1bcb6944f76c15b56717"
@@ -12186,24 +12223,6 @@ c12@^1.11.2:
pkg-types "^1.2.0"
rc9 "^2.1.2"
-c12@^3.0.4:
- version "3.0.4"
- resolved "https://registry.yarnpkg.com/c12/-/c12-3.0.4.tgz#2d65d9ba8f6958bd88f65013f54e15140332099b"
- integrity sha512-t5FaZTYbbCtvxuZq9xxIruYydrAGsJ+8UdP0pZzMiK2xl/gNiSOy0OxhLzHUEEb0m1QXYqfzfvyIFEmz/g9lqg==
- dependencies:
- chokidar "^4.0.3"
- confbox "^0.2.2"
- defu "^6.1.4"
- dotenv "^16.5.0"
- exsolve "^1.0.5"
- giget "^2.0.0"
- jiti "^2.4.2"
- ohash "^2.0.11"
- pathe "^2.0.3"
- perfect-debounce "^1.0.0"
- pkg-types "^2.1.0"
- rc9 "^2.1.2"
-
cac@^6.7.14:
version "6.7.14"
resolved "https://registry.yarnpkg.com/cac/-/cac-6.7.14.tgz#804e1e6f506ee363cb0e3ccbb09cad5dd9870959"
@@ -13937,6 +13956,11 @@ deep-is@^0.1.3:
resolved "https://registry.yarnpkg.com/deep-is/-/deep-is-0.1.3.tgz#b369d6fb5dbc13eecf524f91b070feedc357cf34"
integrity sha1-s2nW+128E+7PUk+RsHD+7cNXzzQ=
+deepmerge-ts@7.1.5:
+ version "7.1.5"
+ resolved "https://registry.yarnpkg.com/deepmerge-ts/-/deepmerge-ts-7.1.5.tgz#ff818564007f5c150808d2b7b732cac83aa415ab"
+ integrity sha512-HOJkrhaYsweh+W+e74Yn7YStZOilkoPb6fycpwNLKzSPtruFs48nYis0zy5yJz1+ktUhHxoRDJ27RQAWLIJVJw==
+
deepmerge@^4.2.2, deepmerge@^4.3.1:
version "4.3.1"
resolved "https://registry.yarnpkg.com/deepmerge/-/deepmerge-4.3.1.tgz#44b5f2147cd3b00d4b56137685966f26fd25dd4a"
@@ -14507,10 +14531,10 @@ dotenv@16.0.3:
resolved "https://registry.yarnpkg.com/dotenv/-/dotenv-16.0.3.tgz#115aec42bac5053db3c456db30cc243a5a836a07"
integrity sha512-7GO6HghkA5fYG9TYnNxi14/7K9f5occMlp3zXAuSxn7CKCxt9xbNWG7yF8hTCSUchlfWSe3uLmlPfigevRItzQ==
-dotenv@^16.3.1, dotenv@^16.4.5, dotenv@^16.5.0:
- version "16.6.0"
- resolved "https://registry.yarnpkg.com/dotenv/-/dotenv-16.6.0.tgz#b96bd4e7c2043ba5f51cbe1b8f9347850c864850"
- integrity sha512-Omf1L8paOy2VJhILjyhrhqwLIdstqm1BvcDPKg4NGAlkwEu9ODyrFbvk8UymUOMCT+HXo31jg1lArIrVAAhuGA==
+dotenv@^16.3.1, dotenv@^16.4.5, dotenv@^16.6.1:
+ version "16.6.1"
+ resolved "https://registry.yarnpkg.com/dotenv/-/dotenv-16.6.1.tgz#773f0e69527a8315c7285d5ee73c4459d20a8020"
+ integrity sha512-uBq4egWHTcTt33a72vpSG0z3HnPuIl6NqYcTrKEg2azoEyl2hpW0zqlxysq2pK9HlDIHyHyakeYaYnSAwd8bow==
dotenv@~10.0.0:
version "10.0.0"
@@ -14590,6 +14614,14 @@ ee-first@1.1.1:
resolved "https://registry.yarnpkg.com/ee-first/-/ee-first-1.1.1.tgz#590c61156b0ae2f4f0255732a158b266bc56b21d"
integrity sha1-WQxhFWsK4vTwJVcyoViyZrxWsh0=
+effect@3.16.12:
+ version "3.16.12"
+ resolved "https://registry.yarnpkg.com/effect/-/effect-3.16.12.tgz#3762f745846cfa4905512e397e17f683438addbe"
+ integrity sha512-N39iBk0K71F9nb442TLbTkjl24FLUzuvx2i1I2RsEAQsdAdUTuUoW0vlfUXgkMTUOnYqKnWcFfqw4hK4Pw27hg==
+ dependencies:
+ "@standard-schema/spec" "^1.0.0"
+ fast-check "^3.23.1"
+
ejs@^3.1.7:
version "3.1.8"
resolved "https://registry.yarnpkg.com/ejs/-/ejs-3.1.8.tgz#758d32910c78047585c7ef1f92f9ee041c1c190b"
@@ -15164,6 +15196,11 @@ emojis-list@^3.0.0:
resolved "https://registry.yarnpkg.com/emojis-list/-/emojis-list-3.0.0.tgz#5570662046ad29e2e916e71aae260abdff4f6a78"
integrity sha512-/kyM18EfinwXZbno9FyUGeFh87KC8HRQBQGildHZbEuRyWFOmv1U10o9BBp8XVZDVNNuQKyIGIu5ZYAAXJ0V2Q==
+empathic@2.0.0:
+ version "2.0.0"
+ resolved "https://registry.yarnpkg.com/empathic/-/empathic-2.0.0.tgz#71d3c2b94fad49532ef98a6c34be0386659f6131"
+ integrity sha512-i6UzDscO/XfAcNYD75CfICkmfLedpyPDdozrLMmQc5ORaQcdMoc21OnlEylMIqI7U8eniKrPMxxtj8k0vhmJhA==
+
enabled@2.0.x:
version "2.0.0"
resolved "https://registry.yarnpkg.com/enabled/-/enabled-2.0.0.tgz#f9dd92ec2d6f4bbc0d5d1e64e21d61cd4665e7c2"
@@ -16568,7 +16605,7 @@ express@5.1.0:
type-is "^2.0.1"
vary "^1.1.2"
-exsolve@^1.0.4, exsolve@^1.0.5, exsolve@^1.0.7:
+exsolve@^1.0.4, exsolve@^1.0.7:
version "1.0.7"
resolved "https://registry.yarnpkg.com/exsolve/-/exsolve-1.0.7.tgz#3b74e4c7ca5c5f9a19c3626ca857309fa99f9e9e"
integrity sha512-VO5fQUzZtI6C+vx4w/4BWJpg3s/5l+6pRQEHzFRM8WFi4XffSP1Z+4qi7GbjWbvRQEbdIco5mIMq+zX4rPuLrw==
@@ -16649,6 +16686,13 @@ fake-indexeddb@^4.0.1:
dependencies:
realistic-structured-clone "^3.0.0"
+fast-check@^3.23.1:
+ version "3.23.2"
+ resolved "https://registry.yarnpkg.com/fast-check/-/fast-check-3.23.2.tgz#0129f1eb7e4f500f58e8290edc83c670e4a574a2"
+ integrity sha512-h5+1OzzfCC3Ef7VbtKdcv7zsstUQwUDlYpUTvjeUsJAssPgLn7QzbboPtL5ro04Mq0rPOsMzl7q5hIbRs2wD1A==
+ dependencies:
+ pure-rand "^6.1.0"
+
fast-deep-equal@^3.1.1, fast-deep-equal@^3.1.3:
version "3.1.3"
resolved "https://registry.yarnpkg.com/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz#3a7d56b559d6cbc3eb512325244e619a65c6c525"
@@ -24783,10 +24827,10 @@ pkg-types@^1.0.3, pkg-types@^1.1.3, pkg-types@^1.2.0, pkg-types@^1.3.0:
mlly "^1.7.4"
pathe "^2.0.1"
-pkg-types@^2.0.0, pkg-types@^2.0.1, pkg-types@^2.1.0:
- version "2.1.1"
- resolved "https://registry.yarnpkg.com/pkg-types/-/pkg-types-2.1.1.tgz#b8b209b2e269af62f55ba51f0648b540039dc6ca"
- integrity sha512-eY0QFb6eSwc9+0d/5D2lFFUq+A3n3QNGSy/X2Nvp+6MfzGw2u6EbA7S80actgjY1lkvvI0pqB+a4hioMh443Ew==
+pkg-types@^2.0.0, pkg-types@^2.0.1, pkg-types@^2.1.0, pkg-types@^2.2.0:
+ version "2.3.0"
+ resolved "https://registry.yarnpkg.com/pkg-types/-/pkg-types-2.3.0.tgz#037f2c19bd5402966ff6810e32706558cb5b5726"
+ integrity sha512-SIqCzDRg0s9npO5XQ3tNZioRY1uK06lA41ynBC1YmFTmnY6FjUjVt6s4LoADmwoig1qqD0oK8h1p/8mlMx8Oig==
dependencies:
confbox "^0.2.2"
exsolve "^1.0.7"
@@ -25630,6 +25674,14 @@ printf@^0.6.1:
resolved "https://registry.yarnpkg.com/printf/-/printf-0.6.1.tgz#b9afa3d3b55b7f2e8b1715272479fc756ed88650"
integrity sha512-is0ctgGdPJ5951KulgfzvHGwJtZ5ck8l042vRkV6jrkpBzTmb/lueTqguWHy2JfVA+RY6gFVlaZgUS0j7S/dsw==
+prisma@6.15.0:
+ version "6.15.0"
+ resolved "https://registry.yarnpkg.com/prisma/-/prisma-6.15.0.tgz#198f95a4468aba8f3c95b58bf3400f65daeb8942"
+ integrity sha512-E6RCgOt+kUVtjtZgLQDBJ6md2tDItLJNExwI0XJeBc1FKL+Vwb+ovxXxuok9r8oBgsOXBA33fGDuE/0qDdCWqQ==
+ dependencies:
+ "@prisma/config" "6.15.0"
+ "@prisma/engines" "6.15.0"
+
prismjs@^1.29.0:
version "1.29.0"
resolved "https://registry.yarnpkg.com/prismjs/-/prismjs-1.29.0.tgz#f113555a8fa9b57c35e637bba27509dcf802dd12"
@@ -25828,6 +25880,11 @@ pupa@^2.1.1:
dependencies:
escape-goat "^2.0.0"
+pure-rand@^6.1.0:
+ version "6.1.0"
+ resolved "https://registry.yarnpkg.com/pure-rand/-/pure-rand-6.1.0.tgz#d173cf23258231976ccbdb05247c9787957604f2"
+ integrity sha512-bVWawvoZoBYpp6yIoQtQXHZjmz35RSVHnUOTefl8Vcjr8snTPY1wnpSPMWekcFwbxI6gtmT7rSYPFvz71ldiOA==
+
qs@6.13.0:
version "6.13.0"
resolved "https://registry.yarnpkg.com/qs/-/qs-6.13.0.tgz#6ca3bd58439f7e245655798997787b0d88a51906"
@@ -28751,7 +28808,6 @@ stylus@0.59.0, stylus@^0.59.0:
sucrase@^3.27.0, sucrase@^3.35.0, sucrase@getsentry/sucrase#es2020-polyfills:
version "3.36.0"
- uid fd682f6129e507c00bb4e6319cc5d6b767e36061
resolved "https://codeload.github.com/getsentry/sucrase/tar.gz/fd682f6129e507c00bb4e6319cc5d6b767e36061"
dependencies:
"@jridgewell/gen-mapping" "^0.3.2"