feat(server-utils)!: Emit low cardinality redis and mongodb span names

packages/server-utils/src/integrations/mongodb/mongodb-span.ts

@@ -9,7 +9,13 @@ import {
   SERVER_PORT,
 } from '@sentry/conventions/attributes';
 import type { Span, SpanAttributes } from '@sentry/core';
-import { isObjectLike, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, startInactiveSpan } from '@sentry/core';
+import {
+  getClient,
+  hasSpanStreamingEnabled,
+  isObjectLike,
+  SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,
+  startInactiveSpan,
+} from '@sentry/core';
 
 // `db.connection_string` is not part of `@sentry/conventions`, so it stays inlined to match
 // what `@opentelemetry/instrumentation-mongodb` emitted.
@@ -220,8 +226,22 @@ export function getV3SpanAttributes(
  * to support platforms that lack it (ie, Deno).
  */
 export function startMongoSpan(attributes: SpanAttributes): Span {
+  const client = getClient();
+  const operation = attributes[DB_OPERATION_NAME] as string | undefined;
+  const target = (attributes[DB_COLLECTION_NAME] || attributes[DB_NAMESPACE]) as string | undefined;
+  // With span streaming, span names have to be low cardinality, so `{db.operation.name}` paired with
+  // `{db.collection.name}` (or `{db.namespace}`) is used instead of the query document, falling back
+  // to that target alone and then to `{db.system.name}`.
+  const streamedName =
+    client && hasSpanStreamingEnabled(client)
+      ? operation && target
+        ? `${operation} ${target}`
+        : target || DB_SYSTEM_VALUE_MONGODB
+      : undefined;
+
   return startInactiveSpan({
-    name: (attributes[DB_QUERY_TEXT] as string) || `mongodb.${attributes[DB_OPERATION_NAME] || 'command'}`,
+    name:
+      streamedName || (attributes[DB_QUERY_TEXT] as string) || `mongodb.${attributes[DB_OPERATION_NAME] || 'command'}`,
     op: 'db',
     attributes: {
       [SENTRY_KIND]: 'client',

packages/server-utils/src/integrations/redis/index.ts

@@ -15,6 +15,8 @@ import {
   isObjectLike,
   defineIntegration,
   getActiveSpan,
+  getClient,
+  hasSpanStreamingEnabled,
   SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,
   SPAN_STATUS_ERROR,
   startInactiveSpan,
@@ -101,8 +103,21 @@ function nodeRedisAttributes(options: NodeRedisClientOptions | undefined): SpanA
 
 function startCommandSpan(commandName: string, commandArgs: Array<string | Buffer>, attributes: SpanAttributes): Span {
   const dbStatement = defaultDbStatementSerializer(commandName, commandArgs);
+  const client = getClient();
+  const host = attributes[SERVER_ADDRESS];
+  const port = attributes[SERVER_PORT];
+  // The serialized statement carries command arguments, so with span streaming — where span names have
+  // to be low cardinality — `{db.operation.name} {server.address}:{server.port}` is used instead.
+  // Redis has no collection or namespace to pair with, so `{db.system.name}` is next.
+  const streamedName =
+    client && hasSpanStreamingEnabled(client)
+      ? host && port != null
+        ? `${commandName} ${host}:${port}`
+        : DB_SYSTEM_VALUE_REDIS
+      : undefined;
+
   return startInactiveSpan({
-    name: dbStatement || `redis-${commandName}`,
+    name: streamedName || dbStatement || `redis-${commandName}`,
     attributes: {
       [SENTRY_KIND]: 'client',
       ...attributes,

packages/server-utils/src/integrations/redis/ioredis-channel-subscriber.ts

@@ -10,7 +10,7 @@ import {
 } from '@sentry/conventions/attributes';
 import { DB_QUERY, DB } from '@sentry/conventions/op';
 import type { Span } from '@sentry/core';
-import { SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, startInactiveSpan } from '@sentry/core';
+import { getClient, hasSpanStreamingEnabled, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, startInactiveSpan } from '@sentry/core';
 import { CHANNELS } from '../../orchestrion/channels';
 import { bindTracingChannelToSpan } from '../../tracing-channel';
 import type { RedisCacheOptions } from './redis-cache';
@@ -76,8 +76,19 @@ export function startIORedisCommandSpan(data: IORedisCommandContext): Span | und
   tracedCommands.add(command);
   const { host, port } = getConnectionOptions(data.self);
   const statement = defaultDbStatementSerializer(command.name, command.args ?? []);
+  const client = getClient();
+  // The serialized statement carries command arguments, so with span streaming — where span names have
+  // to be low cardinality — `{db.operation.name} {server.address}:{server.port}` is used instead.
+  // Redis has no collection or namespace to pair with, so `{db.system.name}` is next.
+  const streamedName =
+    client && hasSpanStreamingEnabled(client)
+      ? host && port != null
+        ? `${command.name} ${host}:${port}`
+        : 'redis'
+      : undefined;
+
   return startInactiveSpan({
-    name: statement,
+    name: streamedName || statement,
     attributes: {
       [SENTRY_KIND]: 'client',
       ...connectionAttributes(host, port),

packages/server-utils/test/integrations/redis/ioredis-channel-subscriber.test.ts

@@ -39,6 +39,23 @@ describe('startIORedisCommandSpan', () => {
     );
   });
 
+  it('names the span from the conventions with span streaming enabled', () => {
+    vi.spyOn(SentryCore, 'getClient').mockReturnValue({
+      getOptions: () => ({ traceLifecycle: 'stream' }),
+    } as unknown as ReturnType<typeof SentryCore.getClient>);
+
+    startIORedisCommandSpan(ctx({ name: 'set', args: ['test-key', 'test-value'] }));
+
+    expect(startInactiveSpanSpy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        // `{db.operation.name} {server.address}:{server.port}` — redis has no collection or namespace
+        name: 'set localhost:6379',
+        // the serialized statement, which carries the key, is still reported as an attribute
+        attributes: expect.objectContaining({ 'db.query.text': 'set test-key [1 other arguments]' }),
+      }),
+    );
+  });
+
   it('emits a single span when the same command is re-sent from the offline queue', () => {
     const command = { name: 'set', args: ['test-key', 'test-value'] };