test(node): Replace lru-memoizer fake unit test with integration coverage (#21437)

Move the fake-based lru-memoizer unit test to integration tests using
the real package.

Context propagation is asserted via a span attribute. The test resolves
the memoized load from outside the span and records whether the callback
still ran in its originating span's context, instead of relying on a
thrown error that the runner might miss once the expected transactions
arrive.

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: nicohrubec

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

@@ -0,0 +1,54 @@
+import * as Sentry from '@sentry/node';
+import memoizer from 'lru-memoizer';
+
+const run = async () => {
+  // lru-memoizer's only job is to bind the active context onto each memoized callback, so the
+  // callback runs in its originating span's context whenever the (possibly async) load resolves.
+  // To test that: `load` captures its callback without resolving, so memoized calls stay queued.
+  // We register one call per span, then resolve the load from outside both spans (see below) -
+  // if binding works, each queued callback still sees its own span active.
+  let memoizerLoadCallback;
+  const memoizedFoo = memoizer({
+    load: (_param, callback) => {
+      memoizerLoadCallback = callback;
+    },
+    hash: () => 'bar',
+  });
+
+  // Concurrent calls with the same key share one in-flight load, so each span's callback is queued
+  // against it. We record on each transaction whether its callback kept its own span's context.
+  const first = Sentry.startSpan(
+    { op: 'first' },
+    firstSpan =>
+      new Promise(resolve => {
+        memoizedFoo({ foo: 'bar' }, () => {
+          firstSpan.setAttribute(
+            'memoized.context_preserved',
+            Sentry.getActiveSpan()?.spanContext().spanId === firstSpan.spanContext().spanId,
+          );
+          resolve();
+        });
+      }),
+  );
+
+  const second = Sentry.startSpan(
+    { op: 'second' },
+    secondSpan =>
+      new Promise(resolve => {
+        memoizedFoo({ foo: 'bar' }, () => {
+          secondSpan.setAttribute(
+            'memoized.context_preserved',
+            Sentry.getActiveSpan()?.spanContext().spanId === secondSpan.spanContext().spanId,
+          );
+          resolve();
+        });
+      }),
+  );
+
+  // Fire the single load outside both spans, resolving both queued waiters.
+  memoizerLoadCallback();
+
+  await Promise.all([first, second]);
+};
+
+run();

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

@@ -2,6 +2,20 @@ import * as Sentry from '@sentry/node';
 import memoizer from 'lru-memoizer';
 
 const run = async () => {
+  // The sync memoizer is passed through untouched by the instrumentation.
+  const memoizedSync = memoizer.sync({ load: () => 'foo', hash: () => 'bar' });
+  if (memoizedSync({ foo: 'bar' }) !== 'foo') {
+    throw new Error('Sync memoizer should return the loaded value');
+  }
+
+  // A non-function last argument must be passed through without throwing.
+  const memoizedNoCallback = memoizer({ load: () => {}, hash: () => 'bar' });
+  memoizedNoCallback({ foo: 'bar' }, null);
+
+  // lru-memoizer's only job is to bind the active context onto the memoized callback, so it runs in
+  // its originating span's context whenever the (possibly async) load resolves. To test that, `load`
+  // captures its callback without resolving (the call stays queued), and we resolve it later from
+  // outside the span.
   // 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
   let memoizerLoadCallback;
@@ -12,24 +26,26 @@ const run = async () => {
     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');
-      }
-    });
+  // Keep the span open until the memoized callback fires, recording on the transaction whether the
+  // callback ran in the originating span's context.
+  const spanFinished = Sentry.startSpan(
+    { op: 'run' },
+    span =>
+      new Promise(resolve => {
+        memoizedFoo({ foo: 'bar' }, () => {
+          span.setAttribute(
+            'memoized.context_preserved',
+            Sentry.getActiveSpan()?.spanContext().spanId === span.spanContext().spanId,
+          );
+          resolve();
+        });
+      }),
+  );
 
-    span.end();
-  });
-
-  // Invoking the load callback outside the span
+  // Fire the load outside the span, so the assertion above proves the context was restored.
   memoizerLoadCallback();
+
+  await spanFinished;
 };
 
 run();

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

@@ -13,9 +13,6 @@ describe('lru-memoizer', () => {
     (createTestRunner, test) => {
       test('keeps outer context inside the memoized inner functions', async () => {
         await createTestRunner()
-          // 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>',
@@ -25,6 +22,7 @@ describe('lru-memoizer', () => {
                   data: expect.objectContaining({
                     'sentry.op': 'run',
                     'sentry.origin': 'manual',
+                    'memoized.context_preserved': true,
                   }),
                 }),
               },
@@ -36,4 +34,29 @@ describe('lru-memoizer', () => {
     },
     { failsOnEsm: true },
   );
+
+  createEsmAndCjsTests(
+    __dirname,
+    'scenario-parallel.mjs',
+    'instrument.mjs',
+    (createTestRunner, test) => {
+      test('keeps each span context across parallel memoized requests', async () => {
+        // Each parallel request emits a transaction whose callback must have run in its own context.
+        // Two identical expectations keep this order-independent.
+        const expectation = {
+          transaction: {
+            contexts: {
+              trace: expect.objectContaining({
+                op: expect.stringMatching(/^(first|second)$/),
+                data: expect.objectContaining({ 'memoized.context_preserved': true }),
+              }),
+            },
+          },
+        };
+
+        await createTestRunner().expect(expectation).expect(expectation).start().completed();
+      });
+    },
+    { failsOnEsm: true },
+  );
 });