Merge branch 'develop' into sig/truncation-redis

Author: s1gr1d

.size-limit.js

@@ -190,7 +190,7 @@ module.exports = [
     path: createCDNPath('bundle.tracing.min.js'),
     gzip: false,
     brotli: false,
-    limit: '124.1 KB',
+    limit: '125 KB',
   },
   {
     name: 'CDN Bundle (incl. Tracing, Replay) - uncompressed',

README.md

@@ -28,7 +28,7 @@ convenient interface and improved consistency between various JavaScript environ
 - [![Forum](https://img.shields.io/badge/forum-sentry-green.svg)](https://forum.sentry.io/c/sdks)
 - [![Discord](https://img.shields.io/discord/621778831602221064)](https://discord.gg/Ww9hbqr)
 - [![Stack Overflow](https://img.shields.io/badge/stack%20overflow-sentry-green.svg)](http://stackoverflow.com/questions/tagged/sentry)
-- [![Twitter Follow](https://img.shields.io/twitter/follow/getsentry?label=getsentry&style=social)](https://twitter.com/intent/follow?screen_name=getsentry)
+- [![X Follow](https://img.shields.io/twitter/follow/sentry?label=sentry&style=social)](https://x.com/intent/follow?screen_name=sentry)
 
 ## Contents
 

dev-packages/browser-integration-tests/suites/public-api/metrics/init.js

@@ -4,9 +4,6 @@ window.Sentry = Sentry;
 
 Sentry.init({
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
-  _experiments: {
-    enableMetrics: true,
-  },
   release: '1.0.0',
   environment: 'test',
   integrations: integrations => {

dev-packages/e2e-tests/test-applications/nextjs-16/tests/middleware.test.ts

@@ -62,9 +62,15 @@ test('Faulty middlewares', async ({ request }) => {
 test('Should trace outgoing fetch requests inside middleware and create breadcrumbs for it', async ({ request }) => {
   test.skip(isDevMode, 'The fetch requests ends up in a separate tx in dev atm');
   const middlewareTransactionPromise = waitForTransaction('nextjs-16', async transactionEvent => {
+    return transactionEvent?.transaction === 'middleware GET';
+  });
+
+  // In some builds (especially webpack), fetch spans may end up in a separate transaction instead of as child spans
+  // This test validates that the fetch is traced either way
+  const fetchTransactionPromise = waitForTransaction('nextjs-16', async transactionEvent => {
     return (
-      transactionEvent?.transaction === 'middleware GET' &&
-      !!transactionEvent.spans?.find(span => span.op === 'http.client')
+      transactionEvent?.transaction === 'GET http://localhost:3030/' ||
+      transactionEvent?.contexts?.trace?.description === 'GET http://localhost:3030/'
     );
   });
 
@@ -74,40 +80,7 @@ test('Should trace outgoing fetch requests inside middleware and create breadcru
 
   const middlewareTransaction = await middlewareTransactionPromise;
 
-  expect(middlewareTransaction.spans).toEqual(
-    expect.arrayContaining([
-      {
-        data: {
-          'http.request.method': 'GET',
-          'http.request.method_original': 'GET',
-          'http.response.status_code': 200,
-          'network.peer.address': '::1',
-          'network.peer.port': 3030,
-          'otel.kind': 'CLIENT',
-          'sentry.op': 'http.client',
-          'sentry.origin': 'auto.http.otel.node_fetch',
-          'server.address': 'localhost',
-          'server.port': 3030,
-          url: 'http://localhost:3030/',
-          'url.full': 'http://localhost:3030/',
-          'url.path': '/',
-          'url.query': '',
-          'url.scheme': 'http',
-          'user_agent.original': 'node',
-        },
-        description: 'GET http://localhost:3030/',
-        op: 'http.client',
-        origin: 'auto.http.otel.node_fetch',
-        parent_span_id: expect.stringMatching(/[a-f0-9]{16}/),
-        span_id: expect.stringMatching(/[a-f0-9]{16}/),
-        start_timestamp: expect.any(Number),
-        status: 'ok',
-        timestamp: expect.any(Number),
-        trace_id: expect.stringMatching(/[a-f0-9]{32}/),
-      },
-    ]),
-  );
-
+  // Breadcrumbs should always be created for the fetch request
   expect(middlewareTransaction.breadcrumbs).toEqual(
     expect.arrayContaining([
       {
@@ -118,4 +91,52 @@ test('Should trace outgoing fetch requests inside middleware and create breadcru
       },
     ]),
   );
+
+  // Check if http.client span exists as a child of the middleware transaction
+  const hasHttpClientSpan = !!middlewareTransaction.spans?.find(span => span.op === 'http.client');
+
+  if (hasHttpClientSpan) {
+    // Check if fetch is traced as a child span of the middleware transaction
+    expect(middlewareTransaction.spans).toEqual(
+      expect.arrayContaining([
+        {
+          data: {
+            'http.request.method': 'GET',
+            'http.request.method_original': 'GET',
+            'http.response.status_code': 200,
+            'network.peer.address': '::1',
+            'network.peer.port': 3030,
+            'otel.kind': 'CLIENT',
+            'sentry.op': 'http.client',
+            'sentry.origin': 'auto.http.otel.node_fetch',
+            'server.address': 'localhost',
+            'server.port': 3030,
+            url: 'http://localhost:3030/',
+            'url.full': 'http://localhost:3030/',
+            'url.path': '/',
+            'url.query': '',
+            'url.scheme': 'http',
+            'user_agent.original': 'node',
+          },
+          description: 'GET http://localhost:3030/',
+          op: 'http.client',
+          origin: 'auto.http.otel.node_fetch',
+          parent_span_id: expect.stringMatching(/[a-f0-9]{16}/),
+          span_id: expect.stringMatching(/[a-f0-9]{16}/),
+          start_timestamp: expect.any(Number),
+          status: 'ok',
+          timestamp: expect.any(Number),
+          trace_id: expect.stringMatching(/[a-f0-9]{32}/),
+        },
+      ]),
+    );
+  } else {
+    // Alternatively, fetch is traced as a separate transaction, similar to Dev builds
+    const fetchTransaction = await fetchTransactionPromise;
+
+    expect(fetchTransaction.contexts?.trace?.op).toBe('http.client');
+    expect(fetchTransaction.contexts?.trace?.status).toBe('ok');
+    expect(fetchTransaction.contexts?.trace?.data?.['http.request.method']).toBe('GET');
+    expect(fetchTransaction.contexts?.trace?.data?.['url.full']).toBe('http://localhost:3030/');
+  }
 });

dev-packages/e2e-tests/test-applications/nextjs-app-dir/tests/server-components.test.ts

@@ -39,7 +39,6 @@ test('Sends a transaction for a request to app router', async ({ page }) => {
     headers: expect.objectContaining({
       'user-agent': expect.any(String),
     }),
-    url: expect.stringContaining('/server-component/parameter/1337/42'),
   });
 
   // The transaction should not contain any spans with the same name as the transaction

dev-packages/node-core-integration-tests/suites/public-api/metrics/scenario.ts

@@ -6,9 +6,6 @@ const client = Sentry.init({
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0.0',
   environment: 'test',
-  _experiments: {
-    enableMetrics: true,
-  },
   transport: loggingTransport,
 });
 

dev-packages/node-integration-tests/suites/public-api/metrics/scenario.ts

@@ -5,9 +5,6 @@ Sentry.init({
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0.0',
   environment: 'test',
-  _experiments: {
-    enableMetrics: true,
-  },
   transport: loggingTransport,
 });
 

packages/aws-serverless/package.json

@@ -71,6 +71,7 @@
     "@opentelemetry/semantic-conventions": "^1.37.0",
     "@sentry/core": "10.23.0",
     "@sentry/node": "10.23.0",
+    "@sentry/node-core": "10.23.0",
     "@types/aws-lambda": "^8.10.62"
   },
   "devDependencies": {

packages/aws-serverless/src/init.ts

@@ -2,6 +2,7 @@ import type { Integration, Options } from '@sentry/core';
 import { applySdkMetadata, debug, getSDKSource } from '@sentry/core';
 import type { NodeClient, NodeOptions } from '@sentry/node';
 import { getDefaultIntegrationsWithoutPerformance, initWithoutDefaultIntegrations } from '@sentry/node';
+import { envToBool } from '@sentry/node-core';
 import { DEBUG_BUILD } from './debug-build';
 import { awsIntegration } from './integration/aws';
 import { awsLambdaIntegration } from './integration/awslambda';
@@ -54,7 +55,10 @@ export function getDefaultIntegrations(_options: Options): Integration[] {
 
 export interface AwsServerlessOptions extends NodeOptions {
   /**
-   * If Sentry events should be proxied through the Lambda extension when using the Lambda layer. Defaults to `true` when using the Lambda layer.
+   * If Sentry events should be proxied through the Lambda extension when using the Lambda layer.
+   * Defaults to `true` when using the Lambda layer.
+   *
+   * Can also be configured via the `SENTRY_LAYER_EXTENSION` environment variable.
    */
   useLayerExtension?: boolean;
 }
@@ -68,31 +72,41 @@ export function init(options: AwsServerlessOptions = {}): NodeClient | undefined
   const sdkSource = getSDKSource();
   const proxyWouldInterfere = shouldDisableLayerExtensionForProxy();
 
+  // Determine useLayerExtension value with the following priority:
+  // 1. Explicit option value (if provided)
+  // 2. Environment variable SENTRY_LAYER_EXTENSION (if set)
+  // 3. Default logic based on sdkSource, tunnel, and proxy settings
+  const useLayerExtensionFromEnv = envToBool(process.env.SENTRY_LAYER_EXTENSION, { strict: true });
+  const defaultUseLayerExtension = sdkSource === 'aws-lambda-layer' && !options.tunnel && !proxyWouldInterfere;
+  const useLayerExtension = options.useLayerExtension ?? useLayerExtensionFromEnv ?? defaultUseLayerExtension;
+
   const opts = {
     defaultIntegrations: getDefaultIntegrations(options),
-    useLayerExtension: sdkSource === 'aws-lambda-layer' && !options.tunnel && !proxyWouldInterfere,
+    useLayerExtension,
     ...options,
   };
 
   if (opts.useLayerExtension) {
-    if (sdkSource === 'aws-lambda-layer') {
-      if (!opts.tunnel) {
-        DEBUG_BUILD && debug.log('Proxying Sentry events through the Sentry Lambda extension');
-        opts.tunnel = 'http://localhost:9000/envelope';
-      } else {
+    if (sdkSource !== 'aws-lambda-layer') {
+      DEBUG_BUILD && debug.warn('The Sentry Lambda extension is only supported when using the AWS Lambda layer.');
+    } else if (opts.tunnel || proxyWouldInterfere) {
+      if (opts.tunnel) {
         DEBUG_BUILD &&
           debug.warn(
             `Using a custom tunnel with the Sentry Lambda extension is not supported. Events will be tunnelled to ${opts.tunnel} and not through the extension.`,
           );
       }
+
+      if (proxyWouldInterfere) {
+        DEBUG_BUILD &&
+          debug.warn(
+            'Sentry Lambda extension is disabled due to proxy environment variables (http_proxy/https_proxy). Consider adding localhost to no_proxy to re-enable.',
+          );
+      }
     } else {
-      DEBUG_BUILD && debug.warn('The Sentry Lambda extension is only supported when using the AWS Lambda layer.');
+      DEBUG_BUILD && debug.log('Proxying Sentry events through the Sentry Lambda extension');
+      opts.tunnel = 'http://localhost:9000/envelope';
     }
-  } else if (sdkSource === 'aws-lambda-layer' && proxyWouldInterfere) {
-    DEBUG_BUILD &&
-      debug.warn(
-        'Sentry Lambda extension disabled due to proxy environment variables (http_proxy/https_proxy). Consider adding localhost to no_proxy to re-enable.',
-      );
   }
 
   applySdkMetadata(opts, 'aws-serverless', ['aws-serverless'], sdkSource);

packages/aws-serverless/test/init.test.ts

@@ -19,9 +19,13 @@ const mockInitWithoutDefaultIntegrations = vi.mocked(initWithoutDefaultIntegrati
 
 describe('init', () => {
   beforeEach(() => {
+    // Clear all mocks between tests
+    vi.clearAllMocks();
+
     // Clean up environment variables between tests
     delete process.env.http_proxy;
     delete process.env.no_proxy;
+    delete process.env.SENTRY_LAYER_EXTENSION;
   });
 
   describe('Lambda extension setup', () => {
@@ -386,4 +390,96 @@ describe('init', () => {
       );
     });
   });
+
+  describe('SENTRY_LAYER_EXTENSION environment variable', () => {
+    test('should enable useLayerExtension when SENTRY_LAYER_EXTENSION=true', () => {
+      process.env.SENTRY_LAYER_EXTENSION = 'true';
+      mockGetSDKSource.mockReturnValue('aws-lambda-layer');
+      const options: AwsServerlessOptions = {};
+
+      init(options);
+
+      expect(mockInitWithoutDefaultIntegrations).toHaveBeenCalledWith(
+        expect.objectContaining({
+          useLayerExtension: true,
+          tunnel: 'http://localhost:9000/envelope',
+        }),
+      );
+    });
+
+    test('should disable useLayerExtension when SENTRY_LAYER_EXTENSION=false', () => {
+      process.env.SENTRY_LAYER_EXTENSION = 'false';
+      mockGetSDKSource.mockReturnValue('aws-lambda-layer');
+      const options: AwsServerlessOptions = {};
+
+      init(options);
+
+      expect(mockInitWithoutDefaultIntegrations).toHaveBeenCalledWith(
+        expect.objectContaining({
+          useLayerExtension: false,
+        }),
+      );
+      expect(mockInitWithoutDefaultIntegrations).toHaveBeenCalledWith(
+        expect.not.objectContaining({
+          tunnel: expect.any(String),
+        }),
+      );
+    });
+
+    test('should fall back to default behavior when SENTRY_LAYER_EXTENSION is not set', () => {
+      mockGetSDKSource.mockReturnValue('aws-lambda-layer');
+      const options: AwsServerlessOptions = {};
+
+      init(options);
+
+      expect(mockInitWithoutDefaultIntegrations).toHaveBeenCalledWith(
+        expect.objectContaining({
+          useLayerExtension: true,
+          tunnel: 'http://localhost:9000/envelope',
+        }),
+      );
+    });
+
+    test('should prioritize explicit option over environment variable', () => {
+      process.env.SENTRY_LAYER_EXTENSION = 'true';
+      mockGetSDKSource.mockReturnValue('aws-lambda-layer');
+      const options: AwsServerlessOptions = {
+        useLayerExtension: false,
+      };
+
+      init(options);
+
+      expect(mockInitWithoutDefaultIntegrations).toHaveBeenCalledWith(
+        expect.objectContaining({
+          useLayerExtension: false,
+        }),
+      );
+      expect(mockInitWithoutDefaultIntegrations).toHaveBeenCalledWith(
+        expect.not.objectContaining({
+          tunnel: expect.any(String),
+        }),
+      );
+    });
+
+    test('should not set tunnel even tho useLayerExtension is set via env var when proxy is explicitly set', () => {
+      process.env.http_proxy = 'http://proxy.example.com:8080';
+      process.env.SENTRY_LAYER_EXTENSION = 'true';
+      mockGetSDKSource.mockReturnValue('aws-lambda-layer');
+      const options: AwsServerlessOptions = {};
+
+      init(options);
+
+      // useLayerExtension is respected but tunnel is not set due to proxy interference
+      expect(mockInitWithoutDefaultIntegrations).toHaveBeenCalledWith(
+        expect.objectContaining({
+          useLayerExtension: true,
+        }),
+      );
+      expect(mockInitWithoutDefaultIntegrations).toHaveBeenCalledWith(
+        expect.not.objectContaining({
+          tunnel: expect.any(String),
+        }),
+      );
+    });
+  });
 });