maybe this

Author: chargome

dev-packages/node-integration-tests/suites/tracing/http-client-spans/fetch-basic-streamed/scenario.ts

@@ -0,0 +1,20 @@
+import * as Sentry from '@sentry/node';
+import { loggingTransport } from '@sentry-internal/node-integration-tests';
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  release: '1.0',
+  tracesSampleRate: 1.0,
+  traceLifecycle: 'stream',
+  transport: loggingTransport,
+});
+
+async function run(): Promise<void> {
+  await Sentry.startSpan({ name: 'test_transaction' }, async () => {
+    await fetch(`${process.env.SERVER_URL}/api/v0`);
+  });
+
+  await Sentry.flush();
+}
+
+void run();

dev-packages/node-integration-tests/suites/tracing/http-client-spans/fetch-basic-streamed/test.ts

@@ -0,0 +1,30 @@
+import { createTestServer } from '@sentry-internal/test-utils';
+import { expect, test } from 'vitest';
+import { createRunner } from '../../../../utils/runner';
+
+test('captures streamed spans with sentry.op for outgoing fetch requests', async () => {
+  expect.assertions(2);
+
+  const [SERVER_URL, closeTestServer] = await createTestServer()
+    .get('/api/v0', () => {
+      // Just ensure we're called
+      expect(true).toBe(true);
+    })
+    .start();
+
+  await createRunner(__dirname, 'scenario.ts')
+    .withEnv({ SERVER_URL })
+    .expect({
+      span: container => {
+        const httpClientSpan = container.items.find(
+          item =>
+            item.attributes?.['sentry.op']?.type === 'string' && item.attributes['sentry.op'].value === 'http.client',
+        );
+
+        expect(httpClientSpan).toBeDefined();
+      },
+    })
+    .start()
+    .completed();
+  closeTestServer();
+});

packages/core/src/tracing/spans/captureSpan.ts

@@ -3,6 +3,7 @@ import type { Client } from '../../client';
 import type { ScopeData } from '../../scope';
 import {
   SEMANTIC_ATTRIBUTE_SENTRY_ENVIRONMENT,
+  SEMANTIC_ATTRIBUTE_SENTRY_OP,
   SEMANTIC_ATTRIBUTE_SENTRY_RELEASE,
   SEMANTIC_ATTRIBUTE_SENTRY_SDK_NAME,
   SEMANTIC_ATTRIBUTE_SENTRY_SDK_VERSION,
@@ -79,6 +80,17 @@ export function captureSpan(span: Span, client: Client): SerializedStreamedSpanW
     });
   }
 
+  // Backfill sentry.op from span attributes when not explicitly set.
+  // OTel-originated spans don't have sentry.op set — we infer it from semantic conventions.
+  if (!processedSpan.attributes?.[SEMANTIC_ATTRIBUTE_SENTRY_OP]) {
+    const inferredOp = inferOpFromAttributes(processedSpan.attributes);
+    if (inferredOp) {
+      safeSetSpanJSONAttributes(processedSpan, {
+        [SEMANTIC_ATTRIBUTE_SENTRY_OP]: inferredOp,
+      });
+    }
+  }
+
   return {
     ...streamedSpanJsonToSerializedSpan(processedSpan),
     _segmentSpan: segmentSpan,
@@ -150,3 +162,29 @@ export function safeSetSpanJSONAttributes(
     }
   });
 }
+
+/**
+ * Infer `sentry.op` from span attributes based on OTel semantic conventions.
+ * This is needed because OTel-originated spans don't set `sentry.op` — the non-streamed
+ * path infers it in the `SentrySpanExporter`, but streamed spans skip the exporter entirely.
+ */
+function inferOpFromAttributes(attributes?: RawAttributes<Record<string, unknown>>): string | undefined {
+  if (!attributes) {
+    return undefined;
+  }
+
+  const httpMethod = attributes['http.request.method'] || attributes['http.method'];
+  if (httpMethod) {
+    // Determine client vs server from the span's parent:
+    // - Spans with a server address are outgoing (client) requests
+    // - The `sentry.origin` attribute can also indicate the direction
+    return attributes['server.address'] || attributes['net.peer.name'] ? 'http.client' : 'http.server';
+  }
+
+  const dbSystem = attributes['db.system.name'] || attributes['db.system'];
+  if (dbSystem) {
+    return 'db';
+  }
+
+  return undefined;
+}