process kit spans

Author: Lms24

packages/sveltekit/src/server-common/handle.ts

@@ -7,10 +7,13 @@ import {
   getDefaultIsolationScope,
   getIsolationScope,
   getTraceMetaTags,
+  SEMANTIC_ATTRIBUTE_SENTRY_OP,
   SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,
   SEMANTIC_ATTRIBUTE_SENTRY_SOURCE,
   setHttpStatus,
+  spanToJSON,
   startSpan,
+  updateSpanName,
   winterCGRequestToRequestData,
   withIsolationScope,
 } from '@sentry/core';
@@ -97,7 +100,8 @@ interface BackwardsForwardsCompatibleEvent {
   tracing?: {
     /** Whether tracing is enabled. */
     enabled: boolean;
-    // omitting other properties for now, since we don't use them.
+    current: Span;
+    root: Span;
   };
 }
 
@@ -140,30 +144,56 @@ async function instrumentHandle(
   // We only start a span if SvelteKit's native tracing is not enabled. Two reasons:
   // - Used Kit version doesn't yet support tracing
   // - Users didn't enable tracing
-  const shouldStartSpan = !event.tracing?.enabled;
+  const kitTracingEnabled = event.tracing?.enabled;
 
   try {
-    const resolveWithSentry: (span?: Span) => Promise<Response> = async (span?: Span) => {
+    const resolveWithSentry: (sentrySpan?: Span) => Promise<Response> = async (sentrySpan?: Span) => {
       getCurrentScope().setSDKProcessingMetadata({
         // We specifically avoid cloning the request here to avoid double read errors.
         // We only read request headers so we're not consuming the body anyway.
         // Note to future readers: This sounds counter-intuitive but please read
         // https://github.com/getsentry/sentry-javascript/issues/14583
         normalizedRequest: winterCGRequestToRequestData(event.request),
       });
+
       const res = await resolve(event, {
         transformPageChunk: addSentryCodeToPage({
           injectFetchProxyScript: options.injectFetchProxyScript ?? true,
         }),
       });
-      if (span) {
-        setHttpStatus(span, res.status);
+
+      const kitRootSpan = event.tracing?.root;
+
+      if (sentrySpan) {
+        setHttpStatus(sentrySpan, res.status);
+      } else if (kitRootSpan) {
+        // Update the root span emitted from SvelteKit to resemble a `http.server` span
+        // We're doing this here instead of an event processor to ensure we update the
+        // span name as early as possible (for dynamic sampling, et al.)
+        // Other spans are enhanced in the `processKitSpans` function.
+        const spanJson = spanToJSON(kitRootSpan);
+        const kitRootSpanAttributes = spanJson.data;
+        const originalName = spanJson.description;
+
+        const routeName = kitRootSpanAttributes['http.route'];
+        if (routeName && typeof routeName === 'string') {
+          updateSpanName(kitRootSpan, routeName);
+        }
+
+        kitRootSpan.setAttributes({
+          [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'http.server',
+          [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.http.sveltejs.kit',
+          [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: routeId ? 'route' : 'url',
+          'sveltekit.tracing.original_name': originalName,
+        });
       }
+
       return res;
     };
 
-    const resolveResult = shouldStartSpan
-      ? await startSpan(
+    const resolveResult = kitTracingEnabled
+      ? await resolveWithSentry()
+      : await startSpan(
           {
             op: 'http.server',
             attributes: {
@@ -174,8 +204,8 @@ async function instrumentHandle(
             name: routeName,
           },
           resolveWithSentry,
-        )
-      : await resolveWithSentry();
+        );
+
     return resolveResult;
   } catch (e: unknown) {
     sendErrorToSentry(e, 'handle');
@@ -237,11 +267,14 @@ export function sentryHandle(handlerOptions?: SentryHandleOptions): Handle {
         // https://github.com/getsentry/sentry-javascript/issues/14583
         normalizedRequest: winterCGRequestToRequestData(input.event.request),
       });
-      return continueTrace(getTracePropagationData(input.event), () =>
-        instrumentHandle(input, {
-          ...options,
-        }),
-      );
+
+      if (backwardsForwardsCompatibleEvent.tracing?.enabled) {
+        // if sveltekit tracing is enabled (since 2.31.0), trace continuation is handled by
+        // kit before our hook is executed. No noeed to call `continueTrace` from our end
+        return instrumentHandle(input, options);
+      }
+
+      return continueTrace(getTracePropagationData(input.event), () => instrumentHandle(input, options));
     });
   };
 

packages/sveltekit/src/server-common/processKitSpans.ts

@@ -0,0 +1,72 @@
+import type { Integration, SpanOrigin } from '@sentry/core';
+import { type SpanJSON, SEMANTIC_ATTRIBUTE_SENTRY_OP, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN } from '@sentry/core';
+
+/**
+ * A small integration that preprocesses spans so that SvelteKit-generated spans
+ * (via Kit's tracing feature since 2.31.0) get the correct Sentry attributes
+ * and data.
+ */
+export function svelteKitSpansIntegration(): Integration {
+  return {
+    name: 'SvelteKitSpansEnhancment',
+    preprocessEvent(event) {
+      if (event.type === 'transaction') {
+        event.spans?.forEach(_enhanceKitSpan);
+      }
+    },
+  };
+}
+
+/**
+ * Adds sentry-specific attributes and data to a span emitted by SvelteKit's native tracing (since 2.31.0)
+ * @exported for testing
+ */
+export function _enhanceKitSpan(span: SpanJSON): void {
+  let op: string | undefined = undefined;
+  let origin: SpanOrigin | undefined = undefined;
+
+  const spanName = span.description;
+
+  switch (spanName) {
+    case 'sveltekit.resolve':
+      op = 'http.sveltekit.resolve';
+      origin = 'auto.http.sveltekit';
+      break;
+    case 'sveltekit.load':
+      op = 'function.sveltekit.load';
+      origin = 'auto.function.sveltekit.load';
+      break;
+    case 'sveltekit.form_action':
+      op = 'function.sveltekit.form_action';
+      origin = 'auto.function.sveltekit.action';
+      break;
+    case 'sveltekit.remote.call':
+      op = 'function.sveltekit.remote';
+      origin = 'auto.rpc.sveltekit.remote';
+      break;
+    case 'sveltekit.handle.root':
+      // We don't want to overwrite the root handle span at this point since
+      // we already enhance the root span in our `sentryHandle` hook.
+      break;
+    default: {
+      if (spanName?.startsWith('sveltekit.handle.sequenced.')) {
+        op = 'function.sveltekit.handle';
+        origin = 'auto.function.sveltekit.handle';
+      }
+      break;
+    }
+  }
+
+  const previousOp = span.op || span.data[SEMANTIC_ATTRIBUTE_SENTRY_OP];
+  const previousOrigin = span.origin || span.data[SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN];
+
+  if (!previousOp && op) {
+    span.op = op;
+    span.data[SEMANTIC_ATTRIBUTE_SENTRY_OP] = op;
+  }
+
+  if (!previousOrigin && origin) {
+    span.origin = origin;
+    span.data[SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN] = origin;
+  }
+}

packages/sveltekit/src/server/sdk.ts

@@ -1,6 +1,7 @@
 import { applySdkMetadata } from '@sentry/core';
 import type { NodeClient, NodeOptions } from '@sentry/node';
 import { getDefaultIntegrations as getDefaultNodeIntegrations, init as initNodeSdk } from '@sentry/node';
+import { svelteKitSpansIntegration } from '../server-common/processKitSpans';
 import { rewriteFramesIntegration } from '../server-common/rewriteFramesIntegration';
 
 /**
@@ -9,7 +10,11 @@ import { rewriteFramesIntegration } from '../server-common/rewriteFramesIntegrat
  */
 export function init(options: NodeOptions): NodeClient | undefined {
   const opts = {
-    defaultIntegrations: [...getDefaultNodeIntegrations(options), rewriteFramesIntegration()],
+    defaultIntegrations: [
+      ...getDefaultNodeIntegrations(options),
+      rewriteFramesIntegration(),
+      svelteKitSpansIntegration(),
+    ],
     ...options,
   };
 

packages/sveltekit/src/worker/cloudflare.ts

@@ -6,6 +6,7 @@ import {
 } from '@sentry/cloudflare';
 import { addNonEnumerableProperty } from '@sentry/core';
 import type { Handle } from '@sveltejs/kit';
+import { svelteKitSpansIntegration } from '../server-common/processKitSpans';
 import { rewriteFramesIntegration } from '../server-common/rewriteFramesIntegration';
 
 /**
@@ -16,7 +17,11 @@ import { rewriteFramesIntegration } from '../server-common/rewriteFramesIntegrat
  */
 export function initCloudflareSentryHandle(options: CloudflareOptions): Handle {
   const opts: CloudflareOptions = {
-    defaultIntegrations: [...getDefaultCloudflareIntegrations(options), rewriteFramesIntegration()],
+    defaultIntegrations: [
+      ...getDefaultCloudflareIntegrations(options),
+      rewriteFramesIntegration(),
+      svelteKitSpansIntegration(),
+    ],
     ...options,
   };
 

packages/sveltekit/test/server-common/processKitSpans.test.ts

@@ -0,0 +1,144 @@
+import type { EventType, SpanJSON, TransactionEvent } from '@sentry/core';
+import { SEMANTIC_ATTRIBUTE_SENTRY_OP, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN } from '@sentry/core';
+import { describe, expect, it } from 'vitest';
+import { _enhanceKitSpan, svelteKitSpansIntegration } from '../../src/server-common/processKitSpans';
+
+describe('svelteKitSpansIntegration', () => {
+  it('has a name and a preprocessEventHook', () => {
+    const integration = svelteKitSpansIntegration();
+
+    expect(integration.name).toBe('SvelteKitSpansEnhancment');
+    expect(typeof integration.preprocessEvent).toBe('function');
+  });
+
+  it('enhances spans from SvelteKit', () => {
+    const event: TransactionEvent = {
+      type: 'transaction',
+      spans: [
+        {
+          description: 'sveltekit.resolve',
+          data: {
+            someAttribute: 'someValue',
+          },
+          span_id: '123',
+          trace_id: 'abc',
+          start_timestamp: 0,
+        },
+      ],
+    };
+
+    // @ts-expect-error -- passing in an empty option for client but it is unused in the integration
+    svelteKitSpansIntegration().preprocessEvent?.(event, {}, {});
+
+    expect(event.spans).toHaveLength(1);
+    expect(event.spans?.[0]?.op).toBe('http.sveltekit.resolve');
+    expect(event.spans?.[0]?.origin).toBe('auto.http.sveltekit');
+    expect(event.spans?.[0]?.data[SEMANTIC_ATTRIBUTE_SENTRY_OP]).toBe('http.sveltekit.resolve');
+    expect(event.spans?.[0]?.data[SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]).toBe('auto.http.sveltekit');
+  });
+
+  describe('_enhanceKitSpan', () => {
+    it.each([
+      ['sveltekit.resolve', 'http.sveltekit.resolve', 'auto.http.sveltekit'],
+      ['sveltekit.load', 'function.sveltekit.load', 'auto.function.sveltekit.load'],
+      ['sveltekit.form_action', 'function.sveltekit.form_action', 'auto.function.sveltekit.action'],
+      ['sveltekit.remote.call', 'function.sveltekit.remote', 'auto.rpc.sveltekit.remote'],
+      ['sveltekit.handle.sequenced.0', 'function.sveltekit.handle', 'auto.function.sveltekit.handle'],
+      ['sveltekit.handle.sequenced.myHandler', 'function.sveltekit.handle', 'auto.function.sveltekit.handle'],
+    ])('enhances %s span with the correct op and origin', (spanName, op, origin) => {
+      const span = {
+        description: spanName,
+        data: {
+          someAttribute: 'someValue',
+        },
+        span_id: '123',
+        trace_id: 'abc',
+        start_timestamp: 0,
+      } as SpanJSON;
+
+      _enhanceKitSpan(span);
+
+      expect(span.op).toBe(op);
+      expect(span.origin).toBe(origin);
+      expect(span.data[SEMANTIC_ATTRIBUTE_SENTRY_OP]).toBe(op);
+      expect(span.data[SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]).toBe(origin);
+    });
+
+    it("doesn't change spans from other origins", () => {
+      const span = {
+        description: 'someOtherSpan',
+        data: {},
+      } as SpanJSON;
+
+      _enhanceKitSpan(span);
+
+      expect(span.op).toBeUndefined();
+      expect(span.origin).toBeUndefined();
+      expect(span.data[SEMANTIC_ATTRIBUTE_SENTRY_OP]).toBeUndefined();
+      expect(span.data[SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]).toBeUndefined();
+    });
+
+    it("doesn't overwrite the sveltekit.handle.root span", () => {
+      const rootHandleSpan = {
+        description: 'sveltekit.handle.root',
+        op: 'http.server',
+        origin: 'auto.http.sveltekit',
+        data: {
+          [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'http.server',
+          [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.http.sveltekit',
+        },
+        span_id: '123',
+        trace_id: 'abc',
+        start_timestamp: 0,
+      } as SpanJSON;
+
+      _enhanceKitSpan(rootHandleSpan);
+
+      expect(rootHandleSpan.data[SEMANTIC_ATTRIBUTE_SENTRY_OP]).toBe('http.server');
+      expect(rootHandleSpan.data[SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]).toBe('auto.http.sveltekit');
+      expect(rootHandleSpan.op).toBe('http.server');
+      expect(rootHandleSpan.origin).toBe('auto.http.sveltekit');
+    });
+
+    it("doesn't enhance unrelated spans", () => {
+      const span = {
+        description: 'someOtherSpan',
+        data: {
+          [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'db',
+          [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.db.pg',
+        },
+        op: 'db',
+        origin: 'auto.db.pg',
+        span_id: '123',
+        trace_id: 'abc',
+        start_timestamp: 0,
+      } as SpanJSON;
+
+      _enhanceKitSpan(span);
+
+      expect(span.op).toBe('db');
+      expect(span.origin).toBe('auto.db.pg');
+      expect(span.data[SEMANTIC_ATTRIBUTE_SENTRY_OP]).toBe('db');
+      expect(span.data[SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]).toBe('auto.db.pg');
+    });
+
+    it("doesn't overwrite already set ops or origins on sveltekit spans", () => {
+      // for example, if users manually set this (for whatever reason)
+      const span = {
+        description: 'sveltekit.resolve',
+        origin: 'auto.custom.origin',
+        data: {
+          [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'custom.op',
+        },
+        span_id: '123',
+        trace_id: 'abc',
+        start_timestamp: 0,
+      } as SpanJSON;
+
+      _enhanceKitSpan(span);
+
+      expect(span.origin).toBe('auto.custom.origin');
+      expect(span.data[SEMANTIC_ATTRIBUTE_SENTRY_OP]).toBe('custom.op');
+    });
+  });
+});