Merge branch 'refs/heads/develop' into sig/nuxt-4

# Conflicts:
#	yarn.lock

Author: s1gr1d

dev-packages/node-integration-tests/package.json

@@ -51,6 +51,7 @@
     "http-terminator": "^3.2.0",
     "ioredis": "^5.4.1",
     "kafkajs": "2.2.4",
+    "lru-memoizer": "2.3.0",
     "mongodb": "^3.7.3",
     "mongodb-memory-server-global": "^7.6.3",
     "mongoose": "^5.13.22",

dev-packages/node-integration-tests/suites/tracing/lru-memoizer/scenario.js

@@ -0,0 +1,47 @@
+const { loggingTransport } = require('@sentry-internal/node-integration-tests');
+const Sentry = require('@sentry/node');
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  release: '1.0',
+  tracesSampleRate: 1.0,
+  transport: loggingTransport,
+});
+
+// Stop the process from exiting before the transaction is sent
+setInterval(() => {}, 1000);
+
+const run = async () => {
+  // Test ported from the OTEL implementation:
+  // https://github.com/open-telemetry/opentelemetry-js-contrib/blob/0d6ebded313bb75b5a0e7a6422206c922daf3943/plugins/node/instrumentation-lru-memoizer/test/index.test.ts#L28
+  const memoizer = require('lru-memoizer');
+
+  let memoizerLoadCallback;
+  const memoizedFoo = memoizer({
+    load: (_param, callback) => {
+      memoizerLoadCallback = callback;
+    },
+    hash: () => 'bar',
+  });
+
+  Sentry.startSpan({ op: 'run' }, async span => {
+    const outerSpanContext = span.spanContext();
+
+    memoizedFoo({ foo: 'bar' }, () => {
+      const innerContext = Sentry.getActiveSpan().spanContext();
+
+      // The span context should be the same as the outer span
+      // Throwing an error here will cause the test to fail
+      if (outerSpanContext !== innerContext) {
+        throw new Error('Outer and inner span context should match');
+      }
+    });
+
+    span.end();
+  });
+
+  // Invoking the load callback outside the span
+  memoizerLoadCallback();
+};
+
+run();

dev-packages/node-integration-tests/suites/tracing/lru-memoizer/test.ts

@@ -0,0 +1,29 @@
+import { cleanupChildProcesses, createRunner } from '../../../utils/runner';
+
+describe('lru-memoizer', () => {
+  afterAll(() => {
+    cleanupChildProcesses();
+  });
+
+  test('keeps outer context inside the memoized inner functions', done => {
+    createRunner(__dirname, 'scenario.js')
+      // We expect only one transaction and nothing else.
+      // A failed test will result in an error event being sent to Sentry.
+      // Which will fail this suite.
+      .expect({
+        transaction: {
+          transaction: '<unknown>',
+          contexts: {
+            trace: expect.objectContaining({
+              op: 'run',
+              data: expect.objectContaining({
+                'sentry.op': 'run',
+                'sentry.origin': 'manual',
+              }),
+            }),
+          },
+        },
+      })
+      .start(done);
+  });
+});

packages/astro/src/index.server.ts

@@ -72,6 +72,7 @@ export {
   lastEventId,
   linkedErrorsIntegration,
   localVariablesIntegration,
+  lruMemoizerIntegration,
   makeNodeTransport,
   metrics,
   modulesIntegration,

packages/aws-serverless/src/index.ts

@@ -91,6 +91,7 @@ export {
   genericPoolIntegration,
   graphqlIntegration,
   kafkaIntegration,
+  lruMemoizerIntegration,
   mongoIntegration,
   mongooseIntegration,
   mysqlIntegration,

packages/bun/src/index.ts

@@ -112,6 +112,7 @@ export {
   genericPoolIntegration,
   graphqlIntegration,
   kafkaIntegration,
+  lruMemoizerIntegration,
   mongoIntegration,
   mongooseIntegration,
   mysqlIntegration,

packages/google-cloud-serverless/src/index.ts

@@ -91,6 +91,7 @@ export {
   genericPoolIntegration,
   graphqlIntegration,
   kafkaIntegration,
+  lruMemoizerIntegration,
   mongoIntegration,
   mongooseIntegration,
   mysqlIntegration,

packages/node/package.json

@@ -82,6 +82,7 @@
     "@opentelemetry/instrumentation-ioredis": "0.43.0",
     "@opentelemetry/instrumentation-kafkajs": "0.3.0",
     "@opentelemetry/instrumentation-koa": "0.43.0",
+    "@opentelemetry/instrumentation-lru-memoizer": "0.40.0",
     "@opentelemetry/instrumentation-mongodb": "0.47.0",
     "@opentelemetry/instrumentation-mongoose": "0.42.0",
     "@opentelemetry/instrumentation-mysql": "0.41.0",

packages/node/src/index.ts

@@ -15,6 +15,7 @@ export { expressIntegration, expressErrorHandler, setupExpressErrorHandler } fro
 export { fastifyIntegration, setupFastifyErrorHandler } from './integrations/tracing/fastify';
 export { graphqlIntegration } from './integrations/tracing/graphql';
 export { kafkaIntegration } from './integrations/tracing/kafka';
+export { lruMemoizerIntegration } from './integrations/tracing/lrumemoizer';
 export { mongoIntegration } from './integrations/tracing/mongo';
 export { mongooseIntegration } from './integrations/tracing/mongoose';
 export { mysqlIntegration } from './integrations/tracing/mysql';

packages/node/src/integrations/tracing/index.ts

@@ -11,6 +11,7 @@ import { graphqlIntegration, instrumentGraphql } from './graphql';
 import { hapiIntegration, instrumentHapi } from './hapi';
 import { instrumentKafka, kafkaIntegration } from './kafka';
 import { instrumentKoa, koaIntegration } from './koa';
+import { instrumentLruMemoizer, lruMemoizerIntegration } from './lrumemoizer';
 import { instrumentMongo, mongoIntegration } from './mongo';
 import { instrumentMongoose, mongooseIntegration } from './mongoose';
 import { instrumentMysql, mysqlIntegration } from './mysql';
@@ -45,6 +46,7 @@ export function getAutoPerformanceIntegrations(): Integration[] {
     kafkaIntegration(),
     dataloaderIntegration(),
     amqplibIntegration(),
+    lruMemoizerIntegration(),
   ];
 }
 
@@ -61,6 +63,7 @@ export function getOpenTelemetryInstrumentationToPreload(): (((options?: any) =>
     instrumentHapi,
     instrumentKafka,
     instrumentKoa,
+    instrumentLruMemoizer,
     instrumentNest,
     instrumentMongo,
     instrumentMongoose,

packages/node/src/integrations/tracing/lrumemoizer.ts

@@ -0,0 +1,25 @@
+import { LruMemoizerInstrumentation } from '@opentelemetry/instrumentation-lru-memoizer';
+
+import { defineIntegration } from '@sentry/core';
+import type { IntegrationFn } from '@sentry/types';
+import { generateInstrumentOnce } from '../../otel/instrument';
+
+const INTEGRATION_NAME = 'LruMemoizer';
+
+export const instrumentLruMemoizer = generateInstrumentOnce(INTEGRATION_NAME, () => new LruMemoizerInstrumentation());
+
+const _lruMemoizerIntegration = (() => {
+  return {
+    name: INTEGRATION_NAME,
+    setupOnce() {
+      instrumentLruMemoizer();
+    },
+  };
+}) satisfies IntegrationFn;
+
+/**
+ * LruMemoizer integration
+ *
+ * Propagate traces through LruMemoizer.
+ */
+export const lruMemoizerIntegration = defineIntegration(_lruMemoizerIntegration);

packages/replay-internal/src/coreHandlers/handleGlobalEvent.ts

@@ -14,8 +14,8 @@ import { shouldSampleForBufferEvent } from './util/shouldSampleForBufferEvent';
 export function handleGlobalEventListener(replay: ReplayContainer): (event: Event, hint: EventHint) => Event | null {
   return Object.assign(
     (event: Event, hint: EventHint) => {
-      // Do nothing if replay has been disabled
-      if (!replay.isEnabled()) {
+      // Do nothing if replay has been disabled or paused
+      if (!replay.isEnabled() || replay.isPaused()) {
         return event;
       }
 

packages/replay-internal/test/integration/coreHandlers/handleGlobalEvent.test.ts

@@ -397,4 +397,23 @@ describe('Integration | coreHandlers | handleGlobalEvent', () => {
 
     expect(handleGlobalEventListener(replay)(errorEvent, {})).toEqual(errorEvent);
   });
+
+  it('does not add replayId if replay is paused', async () => {
+    const transaction = Transaction();
+    const error = Error();
+
+    replay['_isPaused'] = true;
+
+    expect(handleGlobalEventListener(replay)(transaction, {})).toEqual(
+      expect.not.objectContaining({
+        // no tags at all here by default
+        tags: expect.anything(),
+      }),
+    );
+    expect(handleGlobalEventListener(replay)(error, {})).toEqual(
+      expect.objectContaining({
+        tags: expect.not.objectContaining({ replayId: expect.anything() }),
+      }),
+    );
+  });
 });

packages/types/src/checkin.ts

@@ -2,7 +2,7 @@ import type { TraceContext } from './context';
 
 interface CrontabSchedule {
   type: 'crontab';
-  // The crontab schedule string, e.g. 0 * * * *.
+  /** The crontab schedule string, e.g. 0 * * * *. */
   value: string;
 }
 
@@ -14,32 +14,37 @@ interface IntervalSchedule {
 
 type MonitorSchedule = CrontabSchedule | IntervalSchedule;
 
-// https://develop.sentry.dev/sdk/check-ins/
 export interface SerializedCheckIn {
-  // Check-In ID (unique and client generated).
+  /** Check-In ID (unique and client generated). */
   check_in_id: string;
-  // The distinct slug of the monitor.
+  /** The distinct slug of the monitor. */
   monitor_slug: string;
-  // The status of the check-in.
+  /** The status of the check-in. */
   status: 'in_progress' | 'ok' | 'error';
-  // The duration of the check-in in seconds. Will only take effect if the status is ok or error.
+  /** The duration of the check-in in seconds. Will only take effect if the status is ok or error. */
   duration?: number;
   release?: string;
   environment?: string;
   monitor_config?: {
     schedule: MonitorSchedule;
-    // The allowed allowed margin of minutes after the expected check-in time that
-    // the monitor will not be considered missed for.
+    /**
+     * The allowed allowed margin of minutes after the expected check-in time that
+     * the monitor will not be considered missed for.
+     */
     checkin_margin?: number;
-    // The allowed allowed duration in minutes that the monitor may be `in_progress`
-    // for before being considered failed due to timeout.
+    /**
+     * The allowed allowed duration in minutes that the monitor may be `in_progress`
+     * for before being considered failed due to timeout.
+     */
     max_runtime?: number;
-    // A tz database string representing the timezone which the monitor's execution schedule is in.
-    // See: https://en.wikipedia.org/wiki/List_of_tz_database_time_zones
+    /**
+     * A tz database string representing the timezone which the monitor's execution schedule is in.
+     * See: https://en.wikipedia.org/wiki/List_of_tz_database_time_zones
+     */
     timezone?: string;
-    // How many consecutive failed check-ins it takes to create an issue.
+    /** How many consecutive failed check-ins it takes to create an issue. */
     failure_issue_threshold?: number;
-    // How many consecutive OK check-ins it takes to resolve an issue.
+    /** How many consecutive OK check-ins it takes to resolve an issue. */
     recovery_threshold?: number;
   };
   contexts?: {
@@ -48,27 +53,27 @@ export interface SerializedCheckIn {
 }
 
 export interface HeartbeatCheckIn {
-  // The distinct slug of the monitor.
+  /** The distinct slug of the monitor. */
   monitorSlug: SerializedCheckIn['monitor_slug'];
-  // The status of the check-in.
+  /** The status of the check-in. */
   status: 'ok' | 'error';
 }
 
 export interface InProgressCheckIn {
-  // The distinct slug of the monitor.
+  /** The distinct slug of the monitor. */
   monitorSlug: SerializedCheckIn['monitor_slug'];
-  // The status of the check-in.
+  /** The status of the check-in. */
   status: 'in_progress';
 }
 
 export interface FinishedCheckIn {
-  // The distinct slug of the monitor.
+  /** The distinct slug of the monitor. */
   monitorSlug: SerializedCheckIn['monitor_slug'];
-  // The status of the check-in.
+  /** The status of the check-in. */
   status: 'ok' | 'error';
-  // Check-In ID (unique and client generated).
+  /** Check-In ID (unique and client generated). */
   checkInId: SerializedCheckIn['check_in_id'];
-  // The duration of the check-in in seconds. Will only take effect if the status is ok or error.
+  /** The duration of the check-in in seconds. Will only take effect if the status is ok or error. */
   duration?: SerializedCheckIn['duration'];
 }
 
@@ -77,18 +82,27 @@ export type CheckIn = HeartbeatCheckIn | InProgressCheckIn | FinishedCheckIn;
 type SerializedMonitorConfig = NonNullable<SerializedCheckIn['monitor_config']>;
 
 export interface MonitorConfig {
+  /**
+   * The schedule on which the monitor should run. Either a crontab schedule string or an interval.
+   */
   schedule: MonitorSchedule;
-  // The allowed allowed margin of minutes after the expected check-in time that
-  // the monitor will not be considered missed for.
+  /**
+   * The allowed allowed margin of minutes after the expected check-in time that
+   * the monitor will not be considered missed for.
+   */
   checkinMargin?: SerializedMonitorConfig['checkin_margin'];
-  // The allowed allowed duration in minutes that the monitor may be `in_progress`
-  // for before being considered failed due to timeout.
+  /**
+   * The allowed allowed duration in minutes that the monitor may be `in_progress`
+   * for before being considered failed due to timeout.
+   */
   maxRuntime?: SerializedMonitorConfig['max_runtime'];
-  // A tz database string representing the timezone which the monitor's execution schedule is in.
-  // See: https://en.wikipedia.org/wiki/List_of_tz_database_time_zones
+  /**
+   * A tz database string representing the timezone which the monitor's execution schedule is in.
+   * See: https://en.wikipedia.org/wiki/List_of_tz_database_time_zones
+   */
   timezone?: SerializedMonitorConfig['timezone'];
-  // How many consecutive failed check-ins it takes to create an issue.
+  /** How many consecutive failed check-ins it takes to create an issue. */
   failureIssueThreshold?: SerializedMonitorConfig['failure_issue_threshold'];
-  // How many consecutive OK check-ins it takes to resolve an issue.
+  /** How many consecutive OK check-ins it takes to resolve an issue. */
   recoveryThreshold?: SerializedMonitorConfig['recovery_threshold'];
 }