feat(core): Deprecate StartSpanOptions.origin in favour of passing attribute (#10274)

To remove ambiguity and normalization logic in v8, we should only set the origin as an attribute, not as a top level option in the new startSpan APIs.

Author: Lms24

packages/astro/src/server/middleware.ts

@@ -1,4 +1,4 @@
-import { SEMANTIC_ATTRIBUTE_SENTRY_SOURCE } from '@sentry/core';
+import { SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, SEMANTIC_ATTRIBUTE_SENTRY_SOURCE } from '@sentry/core';
 import {
   captureException,
   continueTrace,
@@ -119,9 +119,11 @@ async function instrumentRequest(
     const res = await startSpan(
       {
         ...traceCtx,
+        attributes: {
+          [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.http.astro',
+        },
         name: `${method} ${interpolatedRoute || ctx.url.pathname}`,
         op: 'http.server',
-        origin: 'auto.http.astro',
         status: 'ok',
         metadata: {
           // eslint-disable-next-line deprecation/deprecation

packages/astro/test/server/middleware.test.ts

@@ -58,6 +58,9 @@ describe('sentryMiddleware', () => {
 
     expect(startSpanSpy).toHaveBeenCalledWith(
       {
+        attributes: {
+          'sentry.origin': 'auto.http.astro',
+        },
         data: {
           method: 'GET',
           url: 'https://mydomain.io/users/123/details',
@@ -66,7 +69,6 @@ describe('sentryMiddleware', () => {
         metadata: {},
         name: 'GET /users/[id]/details',
         op: 'http.server',
-        origin: 'auto.http.astro',
         status: 'ok',
       },
       expect.any(Function), // the `next` function
@@ -94,6 +96,9 @@ describe('sentryMiddleware', () => {
 
     expect(startSpanSpy).toHaveBeenCalledWith(
       {
+        attributes: {
+          'sentry.origin': 'auto.http.astro',
+        },
         data: {
           method: 'GET',
           url: 'http://localhost:1234/a%xx',
@@ -102,7 +107,6 @@ describe('sentryMiddleware', () => {
         metadata: {},
         name: 'GET a%xx',
         op: 'http.server',
-        origin: 'auto.http.astro',
         status: 'ok',
       },
       expect.any(Function), // the `next` function

packages/bun/src/integrations/bunserver.ts

@@ -1,4 +1,5 @@
 import {
+  SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,
   SEMANTIC_ATTRIBUTE_SENTRY_SOURCE,
   Transaction,
   captureException,
@@ -69,9 +70,11 @@ function instrumentBunServeOptions(serveOptions: Parameters<typeof Bun.serve>[0]
           ctx => {
             return startSpan(
               {
+                attributes: {
+                  [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.http.bun.serve',
+                },
                 op: 'http.server',
                 name: `${request.method} ${parsedUrl.path || '/'}`,
-                origin: 'auto.http.bun.serve',
                 ...ctx,
                 data,
                 metadata: {

packages/core/src/tracing/span.ts

@@ -130,11 +130,15 @@ export class Span implements SpanInterface {
     this.tags = spanContext.tags ? { ...spanContext.tags } : {};
     // eslint-disable-next-line deprecation/deprecation
     this.data = spanContext.data ? { ...spanContext.data } : {};
-    this._attributes = spanContext.attributes ? { ...spanContext.attributes } : {};
     // eslint-disable-next-line deprecation/deprecation
     this.instrumenter = spanContext.instrumenter || 'sentry';
 
-    this.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, spanContext.origin || 'manual');
+    this._attributes = {};
+    this.setAttributes({
+      [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: spanContext.origin || 'manual',
+      [SEMANTIC_ATTRIBUTE_SENTRY_OP]: spanContext.op,
+      ...spanContext.attributes,
+    });
 
     // eslint-disable-next-line deprecation/deprecation
     this._name = spanContext.name || spanContext.description;
@@ -146,9 +150,6 @@ export class Span implements SpanInterface {
     if ('sampled' in spanContext) {
       this._sampled = spanContext.sampled;
     }
-    if (spanContext.op) {
-      this.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_OP, spanContext.op);
-    }
     if (spanContext.status) {
       this._status = spanContext.status;
     }

packages/core/src/tracing/trace.ts

@@ -20,7 +20,7 @@ import { handleCallbackErrors } from '../utils/handleCallbackErrors';
 import { hasTracingEnabled } from '../utils/hasTracingEnabled';
 import { spanTimeInputToSeconds, spanToJSON } from '../utils/spanUtils';
 
-interface StartSpanOptions extends TransactionContext {
+interface StartSpanOptions extends Omit<TransactionContext, 'origin'> {
   /** A manually specified start time for the created `Span` object. */
   startTime?: SpanTimeInput;
 
@@ -33,7 +33,11 @@ interface StartSpanOptions extends TransactionContext {
   /** An op for the span. This is a categorization for spans. */
   op?: string;
 
-  /** The origin of the span - if it comes from auto instrumenation or manual instrumentation. */
+  /**
+   * The origin of the span - if it comes from auto instrumentation or manual instrumentation.
+   *
+   * @deprecated Set `attributes[SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]` instead.
+   */
   origin?: SpanOrigin;
 
   /** Attributes for the span. */

packages/core/test/lib/tracing/trace.test.ts

@@ -229,6 +229,40 @@ describe('startSpan', () => {
       expect(ref.spanRecorder.spans).toHaveLength(2);
       expect(spanToJSON(ref.spanRecorder.spans[1]).op).toEqual('db.query');
     });
+
+    it.each([
+      { origin: 'auto.http.browser' },
+      { attributes: { 'sentry.origin': 'auto.http.browser' } },
+      // attribute should take precedence over top level origin
+      { origin: 'manual', attributes: { 'sentry.origin': 'auto.http.browser' } },
+    ])('correctly sets the span origin', async () => {
+      let ref: any = undefined;
+      client.on('finishTransaction', transaction => {
+        ref = transaction;
+      });
+      try {
+        await startSpan({ name: 'GET users/[id]', origin: 'auto.http.browser' }, () => {
+          return callback();
+        });
+      } catch (e) {
+        //
+      }
+
+      const jsonSpan = spanToJSON(ref);
+      expect(jsonSpan).toEqual({
+        data: {
+          'sentry.origin': 'auto.http.browser',
+          'sentry.sample_rate': 0,
+        },
+        origin: 'auto.http.browser',
+        description: 'GET users/[id]',
+        span_id: expect.any(String),
+        start_timestamp: expect.any(Number),
+        status: isError ? 'internal_error' : undefined,
+        timestamp: expect.any(Number),
+        trace_id: expect.any(String),
+      });
+    });
   });
 
   it('creates & finishes span', async () => {

packages/ember/addon/index.ts

@@ -5,7 +5,7 @@ import { getOwnConfig, isDevelopingApp, macroCondition } from '@embroider/macros
 import { startSpan } from '@sentry/browser';
 import type { BrowserOptions } from '@sentry/browser';
 import * as Sentry from '@sentry/browser';
-import { applySdkMetadata } from '@sentry/core';
+import { SEMANTIC_ATTRIBUTE_SENTRY_SOURCE, applySdkMetadata } from '@sentry/core';
 import { GLOBAL_OBJ } from '@sentry/utils';
 import Ember from 'ember';
 
@@ -82,9 +82,11 @@ export const instrumentRoutePerformance = <T extends RouteConstructor>(BaseRoute
   ): Promise<ReturnType<X>> => {
     return startSpan(
       {
+        attributes: {
+          [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: 'ember',
+        },
         op,
         name: description,
-        origin: 'auto.ui.ember',
       },
       () => {
         return fn(...args);

packages/ember/addon/instance-initializers/sentry-performance.ts

@@ -11,6 +11,7 @@ import type { ExtendedBackburner } from '@sentry/ember/runloop';
 import type { Span, Transaction } from '@sentry/types';
 import { GLOBAL_OBJ, browserPerformanceTimeOrigin, timestampInSeconds } from '@sentry/utils';
 
+import { SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN } from '@sentry/core';
 import type { BrowserClient } from '..';
 import { getActiveSpan, startInactiveSpan } from '..';
 import type { EmberRouterMain, EmberSentryConfig, GlobalConfig, OwnConfig, StartTransactionFunction } from '../types';
@@ -150,9 +151,11 @@ export function _instrumentEmberRouter(
       },
     });
     transitionSpan = startInactiveSpan({
+      attributes: {
+        [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.ui.ember',
+      },
       op: 'ui.ember.transition',
       name: `route:${fromRoute} -> route:${toRoute}`,
-      origin: 'auto.ui.ember',
     });
   });
 
@@ -212,9 +215,11 @@ function _instrumentEmberRunloop(config: EmberSentryConfig): void {
 
         if ((now - currentQueueStart) * 1000 >= minQueueDuration) {
           startInactiveSpan({
+            attributes: {
+              [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.ui.ember',
+            },
             name: 'runloop',
             op: `ui.ember.runloop.${queue}`,
-            origin: 'auto.ui.ember',
             startTimestamp: currentQueueStart,
           })?.end(now);
         }
@@ -370,7 +375,9 @@ function _instrumentInitialLoad(config: EmberSentryConfig): void {
   startInactiveSpan({
     op: 'ui.ember.init',
     name: 'init',
-    origin: 'auto.ui.ember',
+    attributes: {
+      [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.ui.ember',
+    },
     startTimestamp,
   })?.end(endTimestamp);
   performance.clearMarks(startName);

packages/nextjs/src/common/utils/edgeWrapperUtils.ts

@@ -1,4 +1,5 @@
 import {
+  SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,
   SEMANTIC_ATTRIBUTE_SENTRY_SOURCE,
   addTracingExtensions,
   captureException,
@@ -40,8 +41,10 @@ export function withEdgeWrapping<H extends EdgeRouteHandler>(
         ...transactionContext,
         name: options.spanDescription,
         op: options.spanOp,
-        origin: 'auto.function.nextjs.withEdgeWrapping',
-        attributes: { [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: 'route' },
+        attributes: {
+          [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: 'route',
+          [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.function.nextjs.withEdgeWrapping',
+        },
         metadata: {
           // eslint-disable-next-line deprecation/deprecation
           ...transactionContext.metadata,

packages/nextjs/src/common/wrapApiHandlerWithSentry.ts

@@ -9,6 +9,7 @@ import {
 } from '@sentry/core';
 import { consoleSandbox, isString, logger, objectify, stripUrlQueryAndFragment } from '@sentry/utils';
 
+import { SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN } from '@sentry/core';
 import type { AugmentedNextApiRequest, AugmentedNextApiResponse, NextApiHandler } from './types';
 import { platformSupportsStreaming } from './utils/platformSupportsStreaming';
 import { flushQueue } from './utils/responseEnd';
@@ -108,9 +109,9 @@ export function withSentry(apiHandler: NextApiHandler, parameterizedRoute?: stri
             ...transactionContext,
             name: `${reqMethod}${reqPath}`,
             op: 'http.server',
-            origin: 'auto.http.nextjs',
             attributes: {
               [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: 'route',
+              [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.http.nextjs',
             },
             metadata: {
               // eslint-disable-next-line deprecation/deprecation