@sentry/ember 10.70.0 → 11.0.0-alpha.1

package/.oxlintrc.json

@@ -8,12 +8,6 @@
         "browser": true,
         "node": false
       }
-    },
-    {
-      "files": ["{addon,app,tests}/**/*.{js,ts,d.ts}"],
-      "rules": {
-        "import/no-unresolved": "off"
-      }
     }
   ]
 }

package/addon/index.ts

@@ -4,6 +4,8 @@
 import { assert } from '@ember/debug';
 import type Route from '@ember/routing/route';
 import { getOwnConfig } from '@embroider/macros';
+import { CODE_FUNCTION_NAME, SENTRY_OP } from '@sentry/conventions/attributes';
+import { GENERAL_FUNCTION_SPAN_OP } from '@sentry/conventions/op';
 import type { BrowserOptions } from '@sentry/browser';
 import { startSpan } from '@sentry/browser';
 import * as Sentry from '@sentry/browser';
@@ -54,7 +56,7 @@ type RouteConstructor = new (...args: ConstructorParameters<typeof Route>) => Ro
 export const instrumentRoutePerformance = <T extends RouteConstructor>(BaseRoute: T): T => {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   const instrumentFunction = async <X extends (...args: unknown[]) => any>(
-    op: string,
+    hookName: string,
     name: string,
     fn: X,
     args: Parameters<X>,
@@ -65,8 +67,9 @@ export const instrumentRoutePerformance = <T extends RouteConstructor>(BaseRoute
         attributes: {
           [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: source,
           [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.ui.ember',
+          [SENTRY_OP]: GENERAL_FUNCTION_SPAN_OP,
+          [CODE_FUNCTION_NAME]: hookName,
         },
-        op,
         name,
         onlyIfParent: true,
       },
@@ -82,32 +85,20 @@ export const instrumentRoutePerformance = <T extends RouteConstructor>(BaseRoute
     // @ts-expect-error TS2545 We do not need to redefine a constructor here
     [routeName]: class extends BaseRoute {
       public beforeModel(...args: unknown[]): void | Promise<unknown> {
-        return instrumentFunction(
-          'ui.ember.route.before_model',
-          this.fullRouteName,
-          super.beforeModel.bind(this),
-          args,
-          'custom',
-        );
+        return instrumentFunction('beforeModel', this.fullRouteName, super.beforeModel.bind(this), args, 'custom');
       }
 
       public async model(...args: unknown[]): Promise<unknown> {
-        return instrumentFunction('ui.ember.route.model', this.fullRouteName, super.model.bind(this), args, 'custom');
+        return instrumentFunction('model', this.fullRouteName, super.model.bind(this), args, 'custom');
       }
 
       public afterModel(...args: unknown[]): void | Promise<unknown> {
-        return instrumentFunction(
-          'ui.ember.route.after_model',
-          this.fullRouteName,
-          super.afterModel.bind(this),
-          args,
-          'custom',
-        );
+        return instrumentFunction('afterModel', this.fullRouteName, super.afterModel.bind(this), args, 'custom');
       }
 
       public setupController(...args: unknown[]): void | Promise<unknown> {
         return instrumentFunction(
-          'ui.ember.route.setup_controller',
+          'setupController',
           this.fullRouteName,
           super.setupController.bind(this),
           args,

package/addon/utils/instrumentEmberAppInstanceForPerformance.ts

@@ -14,7 +14,7 @@ import {
 import type { Client, Span } from '@sentry/core';
 import type { EmberRouterMain } from '../types';
 import { getBackburner } from './performance';
-import { URL_FULL, URL_PATH, URL_TEMPLATE } from '@sentry/conventions/attributes';
+import { SENTRY_OP, URL_FULL, URL_PATH, URL_TEMPLATE } from '@sentry/conventions/attributes';
 
 type TransitionWithIntent = Transition & { intent?: { url?: string } };
 
@@ -200,9 +200,10 @@ function _instrumentEmberRouter(
 
     transitionSpan = startInactiveSpan({
       attributes: {
+        // TODO(conventions): Replace `'router'` with the `router` span op constant once it is released in `@sentry/conventions`.
+        [SENTRY_OP]: 'router',
         [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.ui.ember',
       },
-      op: 'ui.ember.transition',
       name: `route:${fromRoute} -> route:${toRoute}`,
       onlyIfParent: true,
     });

package/addon/utils/instrumentEmberGlobals.ts

@@ -1,6 +1,8 @@
 import { subscribe } from '@ember/instrumentation';
 import { scheduleOnce } from '@ember/runloop';
 import type { EmberRunQueues } from '@ember/runloop/-private/types';
+import { SENTRY_OP, UI_COMPONENT_NAME } from '@sentry/conventions/attributes';
+import { BROWSER_UI_RENDER_SPAN_OP, BROWSER_UI_TASK_SPAN_OP, GENERAL_FUNCTION_SPAN_OP } from '@sentry/conventions/op';
 import { getActiveSpan, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, startInactiveSpan } from '@sentry/browser';
 import type { Span } from '@sentry/core';
 import { browserPerformanceTimeOrigin, timestampInSeconds } from '@sentry/core';
@@ -13,13 +15,10 @@ type Payload = {
 };
 
 type RenderEntry = {
-  payload: Payload;
   now: number;
 };
 
-interface RenderEntries {
-  [name: string]: RenderEntry;
-}
+export type RenderEntries = WeakMap<Payload, RenderEntry>;
 
 /** This is global, so should only be run once in tests! */
 export function instrumentGlobalsForPerformance(config: {
@@ -89,10 +88,11 @@ function _instrumentEmberRunloop(config: { minimumRunloopQueueDuration?: number
         if ((now - currentQueueStart) * 1000 >= minQueueDuration) {
           startInactiveSpan({
             attributes: {
+              [SENTRY_OP]: BROWSER_UI_TASK_SPAN_OP,
               [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.ui.ember',
+              'ember.runloop.queue': queue,
             },
             name: 'runloop',
-            op: `ui.ember.runloop.${queue}`,
             startTime: currentQueueStart,
             onlyIfParent: true,
           })?.end(now);
@@ -124,36 +124,39 @@ function _instrumentEmberRunloop(config: { minimumRunloopQueueDuration?: number
   });
 }
 
-function processComponentRenderBefore(payload: Payload, beforeEntries: RenderEntries): void {
-  const info = {
-    payload,
-    now: timestampInSeconds(),
-  };
-  beforeEntries[payload.object] = info;
+export function _processComponentRenderBefore(payload: Payload, beforeEntries: RenderEntries): void {
+  beforeEntries.set(payload, { now: timestampInSeconds() });
 }
 
-function processComponentRenderAfter(
+export function _processComponentRenderAfter(
   payload: Payload,
   beforeEntries: RenderEntries,
   op: string,
   minComponentDuration: number,
 ): void {
-  const begin = beforeEntries[payload.object];
+  const begin = beforeEntries.get(payload);
 
   if (!begin) {
     return;
   }
 
+  // A WeakMap entry cannot outlive its payload, but delete promptly anyway
+  // so a long-lived payload doesn't keep the entry around between renders.
+  beforeEntries.delete(payload);
+
   const now = timestampInSeconds();
   const componentRenderDuration = now - begin.now;
 
+  const name = payload.containerKey || payload.object;
+
   if (componentRenderDuration * 1000 >= minComponentDuration) {
     startInactiveSpan({
-      name: payload.containerKey || payload.object,
-      op,
+      name,
       startTime: begin.now,
       attributes: {
+        [SENTRY_OP]: op,
         [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.ui.ember',
+        [UI_COMPONENT_NAME]: name,
       },
       onlyIfParent: true,
     })?.end(now);
@@ -168,27 +171,27 @@ function _instrumentComponents(config: {
 
   const minComponentDuration = minimumComponentRenderDuration ?? 2;
 
-  const beforeEntries = {} as RenderEntries;
-  const beforeComponentDefinitionEntries = {} as RenderEntries;
+  const beforeEntries: RenderEntries = new WeakMap();
+  const beforeComponentDefinitionEntries: RenderEntries = new WeakMap();
 
   function _subscribeToRenderEvents(): void {
     subscribe('render.component', {
       before(_name: string, _timestamp: number, payload: Payload) {
-        processComponentRenderBefore(payload, beforeEntries);
+        _processComponentRenderBefore(payload, beforeEntries);
       },
 
       after(_name: string, _timestamp: number, payload: Payload, _beganIndex: number) {
-        processComponentRenderAfter(payload, beforeEntries, 'ui.ember.component.render', minComponentDuration);
+        _processComponentRenderAfter(payload, beforeEntries, BROWSER_UI_RENDER_SPAN_OP, minComponentDuration);
       },
     });
     if (enableComponentDefinitions) {
       subscribe('render.getComponentDefinition', {
         before(_name: string, _timestamp: number, payload: Payload) {
-          processComponentRenderBefore(payload, beforeComponentDefinitionEntries);
+          _processComponentRenderBefore(payload, beforeComponentDefinitionEntries);
         },
 
         after(_name: string, _timestamp: number, payload: Payload, _beganIndex: number) {
-          processComponentRenderAfter(payload, beforeComponentDefinitionEntries, 'ui.ember.component.definition', 0);
+          _processComponentRenderAfter(payload, beforeComponentDefinitionEntries, GENERAL_FUNCTION_SPAN_OP, 0);
         },
       });
     }
@@ -230,9 +233,10 @@ function _instrumentInitialLoad(): void {
   const endTime = startTime + measure.duration / 1000;
 
   startInactiveSpan({
-    op: 'ui.ember.init',
     name: 'init',
     attributes: {
+      // TODO(v11): Replace with the `ui.mount` constant from `@sentry/conventions/op` once it is registered there.
+      [SENTRY_OP]: 'ui.mount',
       [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.ui.ember',
     },
     startTime,

package/addon/utils/performance.ts

@@ -22,7 +22,7 @@ export function getSentryConfig(): EmberSentryConfig {
 
 export function getBackburner(): Pick<ExtendedBackburner, 'on' | 'off'> {
   if (_backburner) {
-    return _backburner as unknown as Pick<ExtendedBackburner, 'on' | 'off'>;
+    return _backburner;
   }
 
   if ((run as unknown as { backburner?: Pick<ExtendedBackburner, 'on' | 'off'> }).backburner) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentry/ember",
-  "version": "10.70.0",
+  "version": "11.0.0-alpha.1",
   "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",
@@ -21,9 +21,9 @@
     "clean": "yarn rimraf sentry-ember-*.tgz dist tmp build .node_modules.ember-try package.json.ember-try instance-initializers index.d.ts runloop.d.ts types.d.ts",
     "lint": "run-p lint:js lint:hbs lint:ts",
     "lint:hbs": "ember-template-lint .",
-    "lint:js": "OXLINT_TSGOLINT_DANGEROUSLY_SUPPRESS_PROGRAM_DIAGNOSTICS=true oxlint . --type-aware",
+    "lint:js": "oxlint . --type-aware",
     "lint:ts": "tsc",
-    "lint:fix": "OXLINT_TSGOLINT_DANGEROUSLY_SUPPRESS_PROGRAM_DIAGNOSTICS=true oxlint . --fix --type-aware",
+    "lint:fix": "oxlint . --fix --type-aware",
     "start": "ember serve",
     "test": "ember b --prod && ember test",
     "prepack": "ember ts:precompile",
@@ -32,9 +32,9 @@
   "dependencies": {
     "@babel/core": "^7.29.6",
     "@embroider/macros": "^1.16.0",
-    "@sentry/browser": "10.70.0",
-    "@sentry/core": "10.70.0",
-    "@sentry/conventions": "^0.16.0",
+    "@sentry/browser": "11.0.0-alpha.1",
+    "@sentry/core": "11.0.0-alpha.1",
+    "@sentry/conventions": "^0.19.0",
     "ember-auto-import": "^2.7.2",
     "ember-cli-babel": "^8.2.0",
     "ember-cli-htmlbars": "^6.1.1",
@@ -78,10 +78,11 @@
     "qunit": "~2.22.0",
     "qunit-dom": "~3.5.0",
     "sinon": "21.0.1",
+    "typescript": "~5.8.0",
     "webpack": "~5.104.1"
   },
   "engines": {
-    "node": ">=18"
+    "node": ">=20.19.0 <22.0.0 || >=22.12.0 <23.0.0 || >=23.2.0"
   },
   "ember": {
     "edition": "octane"

package/tsconfig.json

@@ -10,16 +10,15 @@
     "strictPropertyInitialization": true,
     "noEmitOnError": false,
     "noEmit": true,
-    "baseUrl": ".",
     "experimentalDecorators": true,
     "paths": {
-      "dummy/tests/*": ["tests/*"],
-      "dummy/*": ["tests/dummy/app/*", "app/*"],
-      "@sentry/ember": ["addon"],
-      "@sentry/ember/*": ["addon/*"],
-      "@sentry/ember/test-support": ["addon-test-support"],
-      "@sentry/ember/test-support/*": ["addon-test-support/*"],
-      "*": ["types/*"]
+      "dummy/tests/*": ["./tests/*"],
+      "dummy/*": ["./tests/dummy/app/*", "./app/*"],
+      "@sentry/ember": ["./addon"],
+      "@sentry/ember/*": ["./addon/*"],
+      "@sentry/ember/test-support": ["./addon-test-support"],
+      "@sentry/ember/test-support/*": ["./addon-test-support/*"],
+      "*": ["./types/*"]
     }
   },
   "include": ["app/**/*", "addon/**/*", "tests/**/*", "types/**/*", "test-support/**/*", "addon-test-support/**/*"]

package/utils/instrumentEmberGlobals.d.ts

@@ -1,3 +1,12 @@
+type Payload = {
+    containerKey: string;
+    initialRender: true;
+    object: string;
+};
+type RenderEntry = {
+    now: number;
+};
+export type RenderEntries = WeakMap<Payload, RenderEntry>;
 /** This is global, so should only be run once in tests! */
 export declare function instrumentGlobalsForPerformance(config: {
     disableRunloopPerformance?: boolean;
@@ -7,3 +16,6 @@ export declare function instrumentGlobalsForPerformance(config: {
     enableComponentDefinitions?: boolean;
     disableInitialLoadInstrumentation?: boolean;
 }): void;
+export declare function _processComponentRenderBefore(payload: Payload, beforeEntries: RenderEntries): void;
+export declare function _processComponentRenderAfter(payload: Payload, beforeEntries: RenderEntries, op: string, minComponentDuration: number): void;
+export {};