Merge remote-tracking branch 'origin/develop' into lforst-deprecate-aoti

Author: Luca Forstner

docs/migration/draft-v9-migration-guide.md

@@ -35,7 +35,9 @@
 - Deprecated `getNumberOfUrlSegments`. No replacements.
 - Deprecated `BAGGAGE_HEADER_NAME`. No replacements.
 - Deprecated `makeFifoCache`. No replacements.
+- Deprecated `dynamicRequire`. No replacements.
 - Deprecated `flatten`. No replacements.
+- Deprecated `_browserPerformanceTimeOriginMode`. No replacements.
 
 ## `@sentry/core`
 
@@ -87,6 +89,18 @@
   });
   ```
 
+## `@sentry/astro`
+
+- Deprecated passing `dsn`, `release`, `environment`, `sampleRate`, `tracesSampleRate`, `replaysSessionSampleRate` to the integration. Use the runtime-specific `Sentry.init()` calls for passing these options instead.
+
+## `@sentry/remix`
+
+- Deprecated `autoInstrumentRemix: false`. The next major version will default to behaving as if this option were `true` and the option itself will be removed.
+
+## `@sentry/opentelemetry`
+
+- Deprecated `generateSpanContextForPropagationContext` in favor of doing this manually - we do not need this export anymore.
+
 ## Server-side SDKs (`@sentry/node` and all dependents)
 
 - Deprecated `processThreadBreadcrumbIntegration` in favor of `childProcessIntegration`. Functionally they are the same.

packages/astro/src/integration/snippets.ts

@@ -14,6 +14,7 @@ export function buildSdkInitFileImportSnippet(filePath: string): string {
  * default options.
  */
 export function buildClientSnippet(options: SentryOptions): string {
+  /* eslint-disable deprecation/deprecation */
   return `import * as Sentry from "@sentry/astro";
 
 Sentry.init({
@@ -22,6 +23,7 @@ Sentry.init({
   replaysSessionSampleRate: ${options.replaysSessionSampleRate ?? 0.1},
   replaysOnErrorSampleRate: ${options.replaysOnErrorSampleRate ?? 1.0},
 });`;
+  /* eslint-enable deprecation/deprecation */
 }
 
 /**
@@ -36,6 +38,7 @@ Sentry.init({
 });`;
 }
 
+/* eslint-disable deprecation/deprecation */
 const buildCommonInitOptions = (options: SentryOptions): string => `dsn: ${
   options.dsn ? JSON.stringify(options.dsn) : 'import.meta.env.PUBLIC_SENTRY_DSN'
 },
@@ -45,6 +48,7 @@ const buildCommonInitOptions = (options: SentryOptions): string => `dsn: ${
   tracesSampleRate: ${options.tracesSampleRate ?? 1.0},${
     options.sampleRate ? `\n  sampleRate: ${options.sampleRate},` : ''
   }`;
+/* eslint-enable deprecation/deprecation */
 
 /**
  * We don't include the `BrowserTracing` integration if `bundleSizeOptimizations.excludeTracing` is falsy.
@@ -61,9 +65,13 @@ const buildClientIntegrations = (options: SentryOptions): string => {
   }
 
   if (
+    // eslint-disable-next-line deprecation/deprecation
     options.replaysSessionSampleRate == null ||
+    // eslint-disable-next-line deprecation/deprecation
     options.replaysSessionSampleRate ||
+    // eslint-disable-next-line deprecation/deprecation
     options.replaysOnErrorSampleRate == null ||
+    // eslint-disable-next-line deprecation/deprecation
     options.replaysOnErrorSampleRate
   ) {
     integrations.push('Sentry.replayIntegration()');

packages/astro/src/integration/types.ts

@@ -150,6 +150,7 @@ type SdkEnabledOptions = {
    * Sentry code will be added to your bundle.
    *
    * @default true - the SDK is enabled by default for both, client and server.
+   *
    */
   enabled?:
     | boolean
@@ -159,6 +160,41 @@ type SdkEnabledOptions = {
       };
 };
 
+type DeprecatedRuntimeOptions = Pick<
+  Options,
+  'environment' | 'release' | 'dsn' | 'debug' | 'sampleRate' | 'tracesSampleRate'
+> &
+  Pick<BrowserOptions, 'replaysSessionSampleRate' | 'replaysOnErrorSampleRate'> & {
+    /**
+     * @deprecated Use the `environment` option in your runtime-specific Sentry.init() call in sentry.client.config.(js|ts) or sentry.server.config.(js|ts) instead.
+     */
+    environment?: string;
+    /**
+     * @deprecated Use the `release` option in your runtime-specific Sentry.init() call in sentry.client.config.(js|ts) or sentry.server.config.(js|ts) instead.
+     */
+    release?: string;
+    /**
+     * @deprecated Use the `dsn` option in your runtime-specific Sentry.init() call in sentry.client.config.(js|ts) or sentry.server.config.(js|ts) instead.
+     */
+    dsn?: string;
+    /**
+     * @deprecated Use the `sampleRate` option in your runtime-specific Sentry.init() call in sentry.client.config.(js|ts) or sentry.server.config.(js|ts) instead.
+     */
+    sampleRate?: number;
+    /**
+     * @deprecated Use the `tracesSampleRate` option in your runtime-specific Sentry.init() call in sentry.client.config.(js|ts) or sentry.server.config.(js|ts) instead.
+     */
+    tracesSampleRate?: number;
+    /**
+     * @deprecated Use the `replaysSessionSampleRate` option in your Sentry.init() call in sentry.client.config.(js|ts) instead.
+     */
+    replaysSessionSampleRate?: number;
+    /**
+     * @deprecated Use the `replaysOnErrorSampleRate` option in your Sentry.init() call in sentry.client.config.(js|ts) instead.
+     */
+    replaysOnErrorSampleRate?: number;
+  };
+
 /**
  * A subset of Sentry SDK options that can be set via the `sentryAstro` integration.
  * Some options (e.g. integrations) are set by default and cannot be changed here.
@@ -169,8 +205,7 @@ type SdkEnabledOptions = {
  * If you specify a dedicated init file, the SDK options passed to `sentryAstro` will be ignored.
  */
 export type SentryOptions = SdkInitPaths &
-  Pick<Options, 'dsn' | 'release' | 'environment' | 'sampleRate' | 'tracesSampleRate' | 'debug'> &
-  Pick<BrowserOptions, 'replaysSessionSampleRate' | 'replaysOnErrorSampleRate'> &
+  DeprecatedRuntimeOptions &
   InstrumentationOptions &
   SdkEnabledOptions & {
     /**
@@ -187,4 +222,8 @@ export type SentryOptions = SdkInitPaths &
      * Do not define them in the `sentry.client.config.(js|ts)` or `sentry.server.config.(js|ts)` files.
      */
     bundleSizeOptimizations?: BundleSizeOptimizationOptions;
+    /**
+     * If enabled, prints debug logs during the build process.
+     */
+    debug?: boolean;
   };

packages/core/src/utils-hoist/index.ts

@@ -49,6 +49,7 @@ export {
   parseSemver,
   uuid4,
 } from './misc';
+// eslint-disable-next-line deprecation/deprecation
 export { dynamicRequire, isNodeEnv, loadModule } from './node';
 export { normalize, normalizeToSize, normalizeUrlToBase } from './normalize';
 export {
@@ -113,6 +114,7 @@ export {
 } from './supports';
 export { SyncPromise, rejectedSyncPromise, resolvedSyncPromise } from './syncpromise';
 export {
+  // eslint-disable-next-line deprecation/deprecation
   _browserPerformanceTimeOriginMode,
   browserPerformanceTimeOrigin,
   dateTimestampInSeconds,

packages/core/src/utils-hoist/node.ts

@@ -23,6 +23,7 @@ export function isNodeEnv(): boolean {
  * Requires a module which is protected against bundler minification.
  *
  * @param request The module path to resolve
+ * @deprecated This function will be removed in the next major version.
  */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function dynamicRequire(mod: any, request: string): any {
@@ -47,14 +48,17 @@ export function loadModule<T>(moduleName: string): T | undefined {
   let mod: T | undefined;
 
   try {
+    // eslint-disable-next-line deprecation/deprecation
     mod = dynamicRequire(module, moduleName);
   } catch (e) {
     // no-empty
   }
 
   if (!mod) {
     try {
+      // eslint-disable-next-line deprecation/deprecation
       const { cwd } = dynamicRequire(module, 'process');
+      // eslint-disable-next-line deprecation/deprecation
       mod = dynamicRequire(module, `${cwd()}/node_modules/${moduleName}`) as T;
     } catch (e) {
       // no-empty

packages/core/src/utils-hoist/time.ts

@@ -70,6 +70,8 @@ export const timestampInSeconds = createUnixTimestampInSecondsFunc();
 
 /**
  * Internal helper to store what is the source of browserPerformanceTimeOrigin below. For debugging only.
+ *
+ * @deprecated This variable will be removed in the next major version.
  */
 export let _browserPerformanceTimeOriginMode: string;
 
@@ -84,6 +86,7 @@ export const browserPerformanceTimeOrigin = ((): number | undefined => {
 
   const { performance } = GLOBAL_OBJ as typeof GLOBAL_OBJ & Window;
   if (!performance || !performance.now) {
+    // eslint-disable-next-line deprecation/deprecation
     _browserPerformanceTimeOriginMode = 'none';
     return undefined;
   }
@@ -113,15 +116,18 @@ export const browserPerformanceTimeOrigin = ((): number | undefined => {
   if (timeOriginIsReliable || navigationStartIsReliable) {
     // Use the more reliable time origin
     if (timeOriginDelta <= navigationStartDelta) {
+      // eslint-disable-next-line deprecation/deprecation
       _browserPerformanceTimeOriginMode = 'timeOrigin';
       return performance.timeOrigin;
     } else {
+      // eslint-disable-next-line deprecation/deprecation
       _browserPerformanceTimeOriginMode = 'navigationStart';
       return navigationStart;
     }
   }
 
   // Either both timeOrigin and navigationStart are skewed or neither is available, fallback to Date.
+  // eslint-disable-next-line deprecation/deprecation
   _browserPerformanceTimeOriginMode = 'dateNow';
   return dateNow;
 })();

packages/node/src/integrations/node-fetch.ts

@@ -1,16 +1,10 @@
-import { context, propagation, trace } from '@opentelemetry/api';
 import { registerInstrumentations } from '@opentelemetry/instrumentation';
 import type { UndiciRequest, UndiciResponse } from '@opentelemetry/instrumentation-undici';
 import { UndiciInstrumentation } from '@opentelemetry/instrumentation-undici';
-import {
-  SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,
-  addBreadcrumb,
-  defineIntegration,
-  getCurrentScope,
-  hasTracingEnabled,
-} from '@sentry/core';
+import { LRUMap, getClient, getTraceData } from '@sentry/core';
+import { SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, addBreadcrumb, defineIntegration, hasTracingEnabled } from '@sentry/core';
 import { getBreadcrumbLogLevelFromHttpStatusCode, getSanitizedUrlString, parseUrl } from '@sentry/core';
-import { generateSpanContextForPropagationContext, getPropagationContextFromSpan } from '@sentry/opentelemetry';
+import { shouldPropagateTraceForUrl } from '@sentry/opentelemetry';
 import type { IntegrationFn, SanitizedRequestData } from '@sentry/types';
 
 interface NodeFetchOptions {
@@ -34,6 +28,8 @@ const _nativeNodeFetchIntegration = ((options: NodeFetchOptions = {}) => {
   return {
     name: 'NodeFetch',
     setupOnce() {
+      const propagationDecisionMap = new LRUMap<string, boolean>(100);
+
       const instrumentation = new UndiciInstrumentation({
         requireParentforSpans: false,
         ignoreRequestHook: request => {
@@ -47,22 +43,10 @@ const _nativeNodeFetchIntegration = ((options: NodeFetchOptions = {}) => {
           // If tracing is disabled, we still want to propagate traces
           // So we do that manually here, matching what the instrumentation does otherwise
           if (!hasTracingEnabled()) {
-            const ctx = context.active();
-            const addedHeaders: Record<string, string> = {};
-
-            // We generate a virtual span context from the active one,
-            // Where we attach the URL to the trace state, so the propagator can pick it up
-            const activeSpan = trace.getSpan(ctx);
-            const propagationContext = activeSpan
-              ? getPropagationContextFromSpan(activeSpan)
-              : getCurrentScope().getPropagationContext();
-
-            const spanContext = generateSpanContextForPropagationContext(propagationContext);
-            // We know that in practice we'll _always_ haven a traceState here
-            spanContext.traceState = spanContext.traceState?.set('sentry.url', url);
-            const ctxWithUrlTraceState = trace.setSpanContext(ctx, spanContext);
-
-            propagation.inject(ctxWithUrlTraceState, addedHeaders);
+            const tracePropagationTargets = getClient()?.getOptions().tracePropagationTargets;
+            const addedHeaders = shouldPropagateTraceForUrl(url, tracePropagationTargets, propagationDecisionMap)
+              ? getTraceData()
+              : {};
 
             const requestHeaders = request.headers;
             if (Array.isArray(requestHeaders)) {

packages/nuxt/src/server/sdk.ts

@@ -1,3 +1,4 @@
+import * as path from 'node:path';
 import { applySdkMetadata, flush, getGlobalScope } from '@sentry/core';
 import { logger, vercelWaitUntil } from '@sentry/core';
 import {
@@ -33,23 +34,26 @@ export function init(options: SentryNuxtServerOptions): Client | undefined {
 }
 
 /**
- * Filter out transactions for Nuxt build assets
- * This regex matches the default path to the nuxt-generated build assets (`_nuxt`).
+ * Filter out transactions for resource requests which we don't want to send to Sentry
+ * for quota reasons.
  *
  * Only exported for testing
  */
 export function lowQualityTransactionsFilter(options: SentryNuxtServerOptions): EventProcessor {
   return Object.assign(
     (event => {
-      if (event.type === 'transaction' && event.transaction?.match(/^GET \/_nuxt\//)) {
-        // todo: the buildAssetDir could be changed in the nuxt config - change this to a more generic solution
+      if (event.type !== 'transaction' || !event.transaction) {
+        return event;
+      }
+      // We don't want to send transaction for file requests, so everything ending with a *.someExtension should be filtered out
+      // path.extname will return an empty string for normal page requests
+      if (path.extname(event.transaction)) {
         options.debug &&
           DEBUG_BUILD &&
           logger.log('NuxtLowQualityTransactionsFilter filtered transaction: ', event.transaction);
         return null;
-      } else {
-        return event;
       }
+      return event;
     }) satisfies EventProcessor,
     { id: 'NuxtLowQualityTransactionsFilter' },
   );

packages/nuxt/test/server/sdk.test.ts

@@ -45,45 +45,39 @@ describe('Nuxt Server SDK', () => {
       expect(init({})).not.toBeUndefined();
     });
 
-    it('filters out low quality transactions', async () => {
+    describe('low quality transactions filter (%s)', () => {
       const beforeSendEvent = vi.fn(event => event);
       const client = init({
         dsn: 'https://[email protected]/1337',
       }) as NodeClient;
       client.on('beforeSendEvent', beforeSendEvent);
 
-      client.captureEvent({ type: 'transaction', transaction: 'GET /' });
-      client.captureEvent({ type: 'transaction', transaction: 'GET /_nuxt/some_asset.js' });
-      // Although this has the name of the build asset directory (_nuxt), it should not be filtered out as it would not match the regex
-      client.captureEvent({ type: 'transaction', transaction: 'GET _nuxt/some_asset.js' });
-      client.captureEvent({ type: 'transaction', transaction: 'POST /_server' });
-
-      await client!.flush();
+      it.each([
+        [
+          'GET /_nuxt/some_asset.js',
+          'GET _nuxt/some_asset.js',
+          'GET /icons/favicon.ico',
+          'GET /assets/logo.png',
+          'GET /icons/zones/forest.svg',
+        ],
+      ])('filters out low quality transactions', async transaction => {
+        client.captureEvent({ type: 'transaction', transaction });
+        await client!.flush();
+        expect(beforeSendEvent).not.toHaveBeenCalled();
+      });
 
-      expect(beforeSendEvent).toHaveBeenCalledTimes(3);
-      expect(beforeSendEvent).toHaveBeenCalledWith(
-        expect.objectContaining({
-          transaction: 'GET /',
-        }),
-        expect.any(Object),
-      );
-      expect(beforeSendEvent).toHaveBeenCalledWith(
-        expect.objectContaining({
-          transaction: 'GET _nuxt/some_asset.js',
-        }),
-        expect.any(Object),
-      );
-      expect(beforeSendEvent).not.toHaveBeenCalledWith(
-        expect.objectContaining({
-          transaction: 'GET /_nuxt/some_asset.js',
-        }),
-        expect.any(Object),
-      );
-      expect(beforeSendEvent).toHaveBeenCalledWith(
-        expect.objectContaining({
-          transaction: 'POST /_server',
-        }),
-        expect.any(Object),
+      it.each(['GET /', 'POST /_server'])(
+        'does not filter out high quality or route transactions (%s)',
+        async transaction => {
+          client.captureEvent({ type: 'transaction', transaction });
+          await client!.flush();
+          expect(beforeSendEvent).toHaveBeenCalledWith(
+            expect.objectContaining({
+              transaction,
+            }),
+            expect.any(Object),
+          );
+        },
       );
     });