feat(node): use diagnostics_channel for redis >= 5.12.0

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

@@ -80,6 +80,7 @@
     "prisma": "6.15.0",
     "proxy": "^2.1.1",
     "redis-4": "npm:redis@^4.6.14",
+    "redis-5": "npm:redis@^5.12.0",
     "reflect-metadata": "0.2.1",
     "rxjs": "^7.8.2",
     "tedious": "^19.2.1",

dev-packages/node-integration-tests/suites/tracing/redis-dc/docker-compose.yml

@@ -0,0 +1,15 @@
+version: '3.9'
+
+services:
+  db:
+    image: redis:latest
+    restart: always
+    container_name: integration-tests-redis-dc
+    ports:
+      - '6379:6379'
+    healthcheck:
+      test: ['CMD-SHELL', 'redis-cli ping | grep -q PONG']
+      interval: 2s
+      timeout: 3s
+      retries: 30
+      start_period: 5s

dev-packages/node-integration-tests/suites/tracing/redis-dc/scenario-redis-5.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,
+  integrations: [Sentry.redisIntegration({ cachePrefixes: ['dc-cache:'] })],
+});
+
+// Stop the process from exiting before the transaction is sent
+setInterval(() => {}, 1000);
+
+async function run() {
+  // Yield a microtick so the DC subscriber (deferred via Promise.resolve().then)
+  // is registered before node-redis eagerly creates its native TracingChannels on require().
+  await Promise.resolve();
+
+  const { createClient } = require('redis-5');
+  const redisClient = await createClient({ socket: { host: '127.0.0.1', port: 6379 } }).connect();
+
+  await Sentry.startSpan(
+    {
+      name: 'Test Span Redis 5 DC',
+      op: 'test-span-redis-5-dc',
+    },
+    async () => {
+      try {
+        await redisClient.set('dc-test-key', 'test-value');
+        await redisClient.set('dc-cache:test-key', 'test-value');
+
+        await redisClient.set('dc-cache:test-key-ex', 'test-value', { EX: 10 });
+
+        await redisClient.get('dc-test-key');
+        await redisClient.get('dc-cache:test-key');
+        await redisClient.get('dc-cache:unavailable-data');
+
+        await redisClient.mGet(['dc-test-key', 'dc-cache:test-key', 'dc-cache:unavailable-data']);
+      } finally {
+        await redisClient.disconnect();
+      }
+    },
+  );
+}
+
+run();

dev-packages/node-integration-tests/suites/tracing/redis-dc/test.ts

@@ -0,0 +1,110 @@
+import { afterAll, describe, expect, test } from 'vitest';
+import { cleanupChildProcesses, createRunner } from '../../../utils/runner';
+
+describe('redis v5 diagnostics_channel auto instrumentation', () => {
+  afterAll(() => {
+    cleanupChildProcesses();
+  });
+
+  test('should create spans for redis v5 commands via diagnostics_channel', { timeout: 60_000 }, async () => {
+    const EXPECTED_TRANSACTION = {
+      transaction: 'Test Span Redis 5 DC',
+      spans: expect.arrayContaining([
+        expect.objectContaining({
+          op: 'db.redis',
+          origin: 'auto.db.redis.diagnostic_channel',
+          data: expect.objectContaining({
+            'sentry.op': 'db.redis',
+            'sentry.origin': 'auto.db.redis.diagnostic_channel',
+            'db.system': 'redis',
+            'db.statement': 'SET dc-test-key [1 other arguments]',
+          }),
+        }),
+        // cache SET: span name updated to key by cacheResponseHook
+        expect.objectContaining({
+          description: 'dc-cache:test-key',
+          op: 'cache.put',
+          origin: 'auto.db.redis.diagnostic_channel',
+          data: expect.objectContaining({
+            'sentry.origin': 'auto.db.redis.diagnostic_channel',
+            'db.statement': 'SET dc-cache:test-key [1 other arguments]',
+            'cache.key': ['dc-cache:test-key'],
+            'cache.item_size': 2,
+          }),
+        }),
+        // cache SET with EX option: redis v5 sends SET key value EX 10 as the command
+        expect.objectContaining({
+          description: 'dc-cache:test-key-ex',
+          op: 'cache.put',
+          origin: 'auto.db.redis.diagnostic_channel',
+          data: expect.objectContaining({
+            'sentry.origin': 'auto.db.redis.diagnostic_channel',
+            'db.statement': 'SET dc-cache:test-key-ex [3 other arguments]',
+            'cache.key': ['dc-cache:test-key-ex'],
+            'cache.item_size': 2,
+          }),
+        }),
+        expect.objectContaining({
+          op: 'db.redis',
+          origin: 'auto.db.redis.diagnostic_channel',
+          data: expect.objectContaining({
+            'sentry.op': 'db.redis',
+            'sentry.origin': 'auto.db.redis.diagnostic_channel',
+            'db.system': 'redis',
+            'db.statement': 'GET dc-test-key',
+          }),
+        }),
+        // cache GET (hit)
+        expect.objectContaining({
+          description: 'dc-cache:test-key',
+          op: 'cache.get',
+          origin: 'auto.db.redis.diagnostic_channel',
+          data: expect.objectContaining({
+            'sentry.origin': 'auto.db.redis.diagnostic_channel',
+            'db.statement': 'GET dc-cache:test-key',
+            'cache.hit': true,
+            'cache.key': ['dc-cache:test-key'],
+            'cache.item_size': 10,
+          }),
+        }),
+        // cache GET (miss)
+        expect.objectContaining({
+          description: 'dc-cache:unavailable-data',
+          op: 'cache.get',
+          origin: 'auto.db.redis.diagnostic_channel',
+          data: expect.objectContaining({
+            'sentry.origin': 'auto.db.redis.diagnostic_channel',
+            'db.statement': 'GET dc-cache:unavailable-data',
+            'cache.hit': false,
+            'cache.key': ['dc-cache:unavailable-data'],
+          }),
+        }),
+        // MGET: node-redis sanitizes args for diagnostics_channel (keys become '?'),
+        // so cache detection cannot match prefixes — remains a plain db.redis span.
+        expect.objectContaining({
+          op: 'db.redis',
+          origin: 'auto.db.redis.diagnostic_channel',
+          data: expect.objectContaining({
+            'sentry.op': 'db.redis',
+            'sentry.origin': 'auto.db.redis.diagnostic_channel',
+            'db.system': 'redis',
+            'db.statement': 'MGET [3 other arguments]',
+          }),
+        }),
+      ]),
+    };
+
+    // node-redis emits a node-redis:connect DC event for the initial connection.
+    // That fires before startSpan so it arrives as the first envelope.
+    const EXPECTED_CONNECT = {
+      transaction: 'redis-connect',
+    };
+
+    await createRunner(__dirname, 'scenario-redis-5.js')
+      .withDockerCompose({ workingDirectory: [__dirname] })
+      .expect({ transaction: EXPECTED_CONNECT })
+      .expect({ transaction: EXPECTED_TRANSACTION })
+      .start()
+      .completed();
+  });
+});

packages/node/rollup.npm.config.mjs

@@ -6,6 +6,7 @@ export default [
     makeBaseNPMConfig({
       entrypoints: ['src/index.ts', 'src/init.ts', 'src/preload.ts'],
       packageSpecificConfig: {
+        external: [/^@sentry\/opentelemetry/],
         output: {
           // set exports to 'named' or 'auto' so that rollup doesn't warn
           exports: 'named',

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

@@ -6,7 +6,6 @@ import {
   SEMANTIC_ATTRIBUTE_CACHE_ITEM_SIZE,
   SEMANTIC_ATTRIBUTE_CACHE_KEY,
   SEMANTIC_ATTRIBUTE_SENTRY_OP,
-  SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,
   spanToJSON,
   truncate,
 } from '@sentry/core';
@@ -23,6 +22,7 @@ import {
 import type { IORedisResponseCustomAttributeFunction } from './vendored/types';
 import { IORedisInstrumentation } from './vendored/ioredis-instrumentation';
 import { RedisInstrumentation } from './vendored/redis-instrumentation';
+import { subscribeRedisDiagnosticChannels } from './redis-dc-subscriber';
 
 interface RedisOptions {
   /**
@@ -53,8 +53,6 @@ export const cacheResponseHook: IORedisResponseCustomAttributeFunction = (
   cmdArgs: IORedisCommandArgs,
   response: unknown,
 ) => {
-  span.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, 'auto.db.otel.redis');
-
   const safeKey = getCacheKeySafely(redisCommand, cmdArgs);
   const cacheOperation = getCacheOperation(redisCommand);
 
@@ -120,6 +118,11 @@ export const instrumentRedis = Object.assign(
   (): void => {
     instrumentIORedis();
     instrumentRedisModule();
+    // node-redis >= 5.12.0 publishes via diagnostics_channel. The subscriber uses
+    // `@sentry/opentelemetry/tracing-channel`, which needs the Sentry OTel context manager
+    // to be registered before it can `bindStore`. `initOpenTelemetry()` runs after integration
+    // `setupOnce`, so defer to the next tick.
+    void Promise.resolve().then(() => subscribeRedisDiagnosticChannels(cacheResponseHook));
 
     // todo: implement them gradually
     // new LegacyRedisInstrumentation({}),