feat(node): Add diagnostics-channel instrumentation for lru-memoizer

Adds an experimental orchestrion (diagnostics-channel) integration for lru-memoizer, active only when `experimentalUseDiagnosticsChannelInjection()` is opted into. It rebinds the memoized callback to the caller's active span (the channel equivalent of the OTel `context.bind`) and creates no spans. Purely additive — the vendored OTel integration stays the default and is filtered out via `replacedOtelIntegrationNames` only when opted in.

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

Author: nicohrubec

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

@@ -90,7 +90,12 @@ describe('lru-memoizer', () => {
             },
           };
 
-          await createTestRunner().withFlags(...flags).expect(expectation).expect(expectation).start().completed();
+          await createTestRunner()
+            .withFlags(...flags)
+            .expect(expectation)
+            .expect(expectation)
+            .start()
+            .completed();
         });
       });
     });

packages/node/src/sdk/experimentalUseDiagnosticsChannelInjection.ts

@@ -1,4 +1,8 @@
-import { mysqlChannelIntegration, detectOrchestrionSetup } from '@sentry/server-utils/orchestrion';
+import {
+  mysqlChannelIntegration,
+  lruMemoizerChannelIntegration,
+  detectOrchestrionSetup,
+} from '@sentry/server-utils/orchestrion';
 import { registerDiagnosticsChannelInjection } from '@sentry/server-utils/orchestrion/register';
 import type { DiagnosticsChannelInjection } from './diagnosticsChannelInjection';
 import { setDiagnosticsChannelInjectionLoader } from './diagnosticsChannelInjection';
@@ -38,8 +42,8 @@ import { setDiagnosticsChannelInjectionLoader } from './diagnosticsChannelInject
 export function experimentalUseDiagnosticsChannelInjection(): void {
   setDiagnosticsChannelInjectionLoader(
     (): DiagnosticsChannelInjection => ({
-      integrations: [mysqlChannelIntegration()],
-      replacedOtelIntegrationNames: ['Mysql'],
+      integrations: [mysqlChannelIntegration(), lruMemoizerChannelIntegration()],
+      replacedOtelIntegrationNames: ['Mysql', 'LruMemoizer'],
       register: registerDiagnosticsChannelInjection,
       detect: detectOrchestrionSetup,
     }),

packages/server-utils/src/integrations/tracing-channel/lru-memoizer.ts

@@ -0,0 +1,65 @@
+import * as diagnosticsChannel from 'node:diagnostics_channel';
+import type { IntegrationFn } from '@sentry/core';
+import { debug, defineIntegration, getActiveSpan, withActiveSpan } from '@sentry/core';
+import { DEBUG_BUILD } from '../../debug-build';
+import { CHANNELS } from '../../orchestrion/channels';
+
+// Same name as the OTel integration by design — when enabled, the OTel
+// 'LruMemoizer' integration is omitted from the default set.
+const INTEGRATION_NAME = 'LruMemoizer';
+
+interface LruMemoizerChannelContext {
+  arguments: unknown[];
+}
+
+const _lruMemoizerChannelIntegration = (() => {
+  return {
+    name: INTEGRATION_NAME,
+    setupOnce() {
+      // `tracingChannel` is unavailable before Node 18.19 — no-op instead of throwing (#21783).
+      if (!diagnosticsChannel.tracingChannel) {
+        return;
+      }
+
+      DEBUG_BUILD && debug.log(`[orchestrion:lru-memoizer] subscribing to channel "${CHANNELS.LRU_MEMOIZER_LOAD}"`);
+      const lruMemoizerCh = diagnosticsChannel.tracingChannel(CHANNELS.LRU_MEMOIZER_LOAD);
+
+      lruMemoizerCh.subscribe({
+        // lru-memoizer queues the callback and fires it later via setImmediate, from a
+        // different async context. Rebind it to the caller's active span (still correct
+        // here, synchronously inside the memoized call) so nested spans parent correctly.
+        // This is the channel equivalent of the OTel version's `context.bind(context.active(), cb)`.
+        // orchestrion (kind: 'Callback') has already spliced its own wrapper into the last
+        // arg by the time `start` fires, and only publishes `start` when that arg is a function.
+        start(rawCtx) {
+          const ctx = rawCtx as LruMemoizerChannelContext;
+          const parentSpan = getActiveSpan();
+          if (!parentSpan || ctx.arguments.length === 0) {
+            return;
+          }
+          const cbIdx = ctx.arguments.length - 1;
+          const orchestrionWrappedCb = ctx.arguments[cbIdx];
+          if (typeof orchestrionWrappedCb !== 'function') {
+            return;
+          }
+          const wrapped = orchestrionWrappedCb as (...a: unknown[]) => unknown;
+          ctx.arguments[cbIdx] = function (this: unknown, ...args: unknown[]): unknown {
+            return withActiveSpan(parentSpan, () => wrapped.apply(this, args));
+          };
+        },
+        end() {},
+        asyncStart() {},
+        asyncEnd() {},
+        error() {},
+      });
+    },
+  };
+}) satisfies IntegrationFn;
+
+/**
+ * EXPERIMENTAL — orchestrion-driven lru-memoizer integration. Subscribes to
+ * `orchestrion:lru-memoizer:load` (injected into `lru-memoizer/lib/async.js`'s
+ * `memoizedFunction`). Creates no spans; only rebinds the memoized callback to the
+ * caller's active span. Requires the orchestrion runtime hook or bundler plugin.
+ */
+export const lruMemoizerChannelIntegration = defineIntegration(_lruMemoizerChannelIntegration);

packages/server-utils/src/orchestrion/channels.ts

@@ -13,6 +13,7 @@
  */
 export const CHANNELS = {
   MYSQL_QUERY: 'orchestrion:mysql:query',
+  LRU_MEMOIZER_LOAD: 'orchestrion:lru-memoizer:load',
 } as const;
 
 export type ChannelName = (typeof CHANNELS)[keyof typeof CHANNELS];

packages/server-utils/src/orchestrion/config.ts

@@ -32,6 +32,12 @@ export const SENTRY_INSTRUMENTATIONS: InstrumentationConfig[] = [
     // attach `'end'`/`'error'` listeners that finish the span.
     functionQuery: { expressionName: 'query', kind: 'Auto' },
   },
+  {
+    channelName: 'load',
+    // `>=2.1.0` only: the named `function memoizedFunction()` the selector targets exists from 2.1.0
+    module: { name: 'lru-memoizer', versionRange: '>=2.1.0 <4', filePath: 'lib/async.js' },
+    functionQuery: { functionName: 'memoizedFunction', kind: 'Callback' },
+  },
 ];
 
 /**

packages/server-utils/src/orchestrion/index.ts

@@ -1,2 +1,3 @@
 export { detectOrchestrionSetup } from './detect';
 export { mysqlChannelIntegration } from '../integrations/tracing-channel/mysql';
+export { lruMemoizerChannelIntegration } from '../integrations/tracing-channel/lru-memoizer';