@sentry/ember 7.98.0 → 7.100.0

package/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);

package/addon/instance-initializers/sentry-performance.ts

@@ -8,17 +8,13 @@ import type { EmberRunQueues } from '@ember/runloop/-private/types';
 import { getOwnConfig, isTesting, macroCondition } from '@embroider/macros';
 import * as Sentry from '@sentry/browser';
 import type { ExtendedBackburner } from '@sentry/ember/runloop';
-import type { Span, Transaction } from '@sentry/types';
+import type { Span } 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';
-
-type SentryTestRouterService = RouterService & {
-  _startTransaction?: StartTransactionFunction;
-  _sentryInstrumented?: boolean;
-};
+import type { EmberRouterMain, EmberSentryConfig, GlobalConfig, OwnConfig } from '../types';
 
 function getSentryConfig(): EmberSentryConfig {
   const _global = GLOBAL_OBJ as typeof GLOBAL_OBJ & GlobalConfig;
@@ -97,26 +93,29 @@ export function _instrumentEmberRouter(
   routerService: RouterService,
   routerMain: EmberRouterMain,
   config: EmberSentryConfig,
-  startTransaction: StartTransactionFunction,
-  startTransactionOnPageLoad?: boolean,
-): {
-  startTransaction: StartTransactionFunction;
-} {
+): void {
   const { disableRunloopPerformance } = config;
   const location = routerMain.location;
-  let activeTransaction: Transaction | undefined;
+  let activeRootSpan: Span | undefined;
   let transitionSpan: Span | undefined;
 
+  // Maintaining backwards compatibility with config.browserTracingOptions, but passing it with Sentry options is preferred.
+  const browserTracingOptions = config.browserTracingOptions || config.sentry.browserTracingOptions || {};
   const url = getLocationURL(location);
 
-  if (macroCondition(isTesting())) {
-    (routerService as SentryTestRouterService)._sentryInstrumented = true;
-    (routerService as SentryTestRouterService)._startTransaction = startTransaction;
+  const client = Sentry.getClient<BrowserClient>();
+
+  if (!client) {
+    return;
   }
 
-  if (startTransactionOnPageLoad && url) {
+  if (
+    url &&
+    browserTracingOptions.startTransactionOnPageLoad !== false &&
+    browserTracingOptions.instrumentPageLoad !== false
+  ) {
     const routeInfo = routerService.recognize(url);
-    activeTransaction = startTransaction({
+    Sentry.startBrowserTracingPageLoadSpan(client, {
       name: `route:${routeInfo.name}`,
       op: 'pageload',
       origin: 'auto.pageload.ember',
@@ -126,20 +125,29 @@ export function _instrumentEmberRouter(
         'routing.instrumentation': '@sentry/ember',
       },
     });
+    activeRootSpan = getActiveSpan();
   }
 
   const finishActiveTransaction = (_: unknown, nextInstance: unknown): void => {
     if (nextInstance) {
       return;
     }
-    activeTransaction?.end();
+    activeRootSpan?.end();
     getBackburner().off('end', finishActiveTransaction);
   };
 
+  if (
+    browserTracingOptions.startTransactionOnLocationChange === false &&
+    browserTracingOptions.instrumentNavigation === false
+  ) {
+    return;
+  }
+
   routerService.on('routeWillChange', (transition: Transition) => {
     const { fromRoute, toRoute } = getTransitionInformation(transition, routerService);
-    activeTransaction?.end();
-    activeTransaction = startTransaction({
+    activeRootSpan?.end();
+
+    Sentry.startBrowserTracingNavigationSpan(client, {
       name: `route:${toRoute}`,
       op: 'navigation',
       origin: 'auto.navigation.ember',
@@ -149,30 +157,31 @@ export function _instrumentEmberRouter(
         'routing.instrumentation': '@sentry/ember',
       },
     });
+
+    activeRootSpan = getActiveSpan();
+
     transitionSpan = startInactiveSpan({
+      attributes: {
+        [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.ui.ember',
+      },
       op: 'ui.ember.transition',
       name: `route:${fromRoute} -> route:${toRoute}`,
-      origin: 'auto.ui.ember',
     });
   });
 
   routerService.on('routeDidChange', () => {
-    if (!transitionSpan || !activeTransaction) {
+    if (!transitionSpan || !activeRootSpan) {
       return;
     }
     transitionSpan.end();
 
     if (disableRunloopPerformance) {
-      activeTransaction.end();
+      activeRootSpan.end();
       return;
     }
 
     getBackburner().on('end', finishActiveTransaction);
   });
-
-  return {
-    startTransaction,
-  };
 }
 
 function _instrumentEmberRunloop(config: EmberSentryConfig): void {
@@ -212,9 +221,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 +381,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);
@@ -404,61 +417,63 @@ export async function instrumentForPerformance(appInstance: ApplicationInstance)
   // Maintaining backwards compatibility with config.browserTracingOptions, but passing it with Sentry options is preferred.
   const browserTracingOptions = config.browserTracingOptions || config.sentry.browserTracingOptions || {};
 
-  const { BrowserTracing } = await import('@sentry/browser');
+  const { browserTracingIntegration } = await import('@sentry/browser');
 
   const idleTimeout = config.transitionTimeout || 5000;
 
-  const browserTracing = new BrowserTracing({
-    routingInstrumentation: (customStartTransaction, startTransactionOnPageLoad) => {
-      // eslint-disable-next-line ember/no-private-routing-service
-      const routerMain = appInstance.lookup('router:main') as EmberRouterMain;
-      let routerService = appInstance.lookup('service:router') as RouterService & {
-        externalRouter?: RouterService;
-        _hasMountedSentryPerformanceRouting?: boolean;
-      };
-
-      if (routerService.externalRouter) {
-        // Using ember-engines-router-service in an engine.
-        routerService = routerService.externalRouter;
-      }
-      if (routerService._hasMountedSentryPerformanceRouting) {
-        // Routing listens to route changes on the main router, and should not be initialized multiple times per page.
-        return;
-      }
-      if (!routerService.recognize) {
-        // Router is missing critical functionality to limit cardinality of the transaction names.
-        return;
-      }
-      routerService._hasMountedSentryPerformanceRouting = true;
-      _instrumentEmberRouter(routerService, routerMain, config, customStartTransaction, startTransactionOnPageLoad);
-    },
+  const browserTracing = browserTracingIntegration({
     idleTimeout,
     ...browserTracingOptions,
+    instrumentNavigation: false,
+    instrumentPageLoad: false,
   });
 
-  if (macroCondition(isTesting())) {
-    const client = Sentry.getClient();
-
-    if (
-      client &&
-      (client as BrowserClient).getIntegrationByName &&
-      (client as BrowserClient).getIntegrationByName('BrowserTracing')
-    ) {
-      // Initializers are called more than once in tests, causing the integrations to not be setup correctly.
-      return;
-    }
-  }
+  const client = Sentry.getClient<BrowserClient>();
+
+  const isAlreadyInitialized = macroCondition(isTesting()) ? !!client?.getIntegrationByName('BrowserTracing') : false;
 
-  const client = Sentry.getClient();
   if (client && client.addIntegration) {
     client.addIntegration(browserTracing);
   }
 
+  // We _always_ call this, as it triggers the page load & navigation spans
+  _instrumentNavigation(appInstance, config);
+
+  // Skip instrumenting the stuff below again in tests, as these are not reset between tests
+  if (isAlreadyInitialized) {
+    return;
+  }
+
   _instrumentEmberRunloop(config);
   _instrumentComponents(config);
   _instrumentInitialLoad(config);
 }
 
+function _instrumentNavigation(appInstance: ApplicationInstance, config: EmberSentryConfig): void {
+  // eslint-disable-next-line ember/no-private-routing-service
+  const routerMain = appInstance.lookup('router:main') as EmberRouterMain;
+  let routerService = appInstance.lookup('service:router') as RouterService & {
+    externalRouter?: RouterService;
+    _hasMountedSentryPerformanceRouting?: boolean;
+  };
+
+  if (routerService.externalRouter) {
+    // Using ember-engines-router-service in an engine.
+    routerService = routerService.externalRouter;
+  }
+  if (routerService._hasMountedSentryPerformanceRouting) {
+    // Routing listens to route changes on the main router, and should not be initialized multiple times per page.
+    return;
+  }
+  if (!routerService.recognize) {
+    // Router is missing critical functionality to limit cardinality of the transaction names.
+    return;
+  }
+
+  routerService._hasMountedSentryPerformanceRouting = true;
+  _instrumentEmberRouter(routerService, routerMain, config);
+}
+
 export default {
   initialize,
 };

package/addon/types.ts

@@ -1,7 +1,9 @@
-import type { BrowserOptions, BrowserTracing } from '@sentry/browser';
+import type { BrowserOptions, BrowserTracing, browserTracingIntegration } from '@sentry/browser';
 import type { Transaction, TransactionContext } from '@sentry/types';
 
-type BrowserTracingOptions = ConstructorParameters<typeof BrowserTracing>[0];
+type BrowserTracingOptions = Parameters<typeof browserTracingIntegration>[0] &
+  // eslint-disable-next-line deprecation/deprecation
+  ConstructorParameters<typeof BrowserTracing>[0];
 
 export type EmberSentryConfig = {
   sentry: BrowserOptions & { browserTracingOptions?: BrowserTracingOptions };
@@ -31,7 +33,7 @@ export interface EmberRouterMain {
     rootURL: string;
   };
 }
-
+/** @deprecated This will be removed in v8. */
 export type StartTransactionFunction = (context: TransactionContext) => Transaction | undefined;
 
 export type GlobalConfig = {

package/instance-initializers/sentry-performance.d.ts

@@ -1,10 +1,8 @@
 import type ApplicationInstance from '@ember/application/instance';
 import type RouterService from '@ember/routing/router-service';
-import type { EmberRouterMain, EmberSentryConfig, StartTransactionFunction } from '../types';
+import type { EmberRouterMain, EmberSentryConfig } from '../types';
 export declare function initialize(appInstance: ApplicationInstance): void;
-export declare function _instrumentEmberRouter(routerService: RouterService, routerMain: EmberRouterMain, config: EmberSentryConfig, startTransaction: StartTransactionFunction, startTransactionOnPageLoad?: boolean): {
-    startTransaction: StartTransactionFunction;
-};
+export declare function _instrumentEmberRouter(routerService: RouterService, routerMain: EmberRouterMain, config: EmberSentryConfig): void;
 export declare function instrumentForPerformance(appInstance: ApplicationInstance): Promise<void>;
 declare const _default: {
     initialize: typeof initialize;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentry/ember",
-  "version": "7.98.0",
+  "version": "7.100.0",
   "description": "Official Sentry SDK for Ember.js",
   "repository": "git://github.com/getsentry/sentry-javascript.git",
   "homepage": "https://github.com/getsentry/sentry-javascript/tree/master/packages/ember",
@@ -32,10 +32,10 @@
   },
   "dependencies": {
     "@embroider/macros": "^1.9.0",
-    "@sentry/browser": "7.98.0",
-    "@sentry/core": "7.98.0",
-    "@sentry/types": "7.98.0",
-    "@sentry/utils": "7.98.0",
+    "@sentry/browser": "7.100.0",
+    "@sentry/core": "7.100.0",
+    "@sentry/types": "7.100.0",
+    "@sentry/utils": "7.100.0",
     "ember-auto-import": "^1.12.1 || ^2.4.3",
     "ember-cli-babel": "^7.26.11",
     "ember-cli-htmlbars": "^6.1.1",

package/types.d.ts

@@ -1,6 +1,6 @@
-import type { BrowserOptions, BrowserTracing } from '@sentry/browser';
+import type { BrowserOptions, BrowserTracing, browserTracingIntegration } from '@sentry/browser';
 import type { Transaction, TransactionContext } from '@sentry/types';
-type BrowserTracingOptions = ConstructorParameters<typeof BrowserTracing>[0];
+type BrowserTracingOptions = Parameters<typeof browserTracingIntegration>[0] & ConstructorParameters<typeof BrowserTracing>[0];
 export type EmberSentryConfig = {
     sentry: BrowserOptions & {
         browserTracingOptions?: BrowserTracingOptions;
@@ -28,6 +28,7 @@ export interface EmberRouterMain {
         rootURL: string;
     };
 }
+/** @deprecated This will be removed in v8. */
 export type StartTransactionFunction = (context: TransactionContext) => Transaction | undefined;
 export type GlobalConfig = {
     __sentryEmberConfig: EmberSentryConfig['sentry'];