@sentry/ember 7.61.0 → 7.62.0

package/addon/index.ts

@@ -1,19 +1,23 @@
-import * as Sentry from '@sentry/browser';
-import { SDK_VERSION, BrowserOptions } from '@sentry/browser';
-import { macroCondition, isDevelopingApp, getOwnConfig } from '@embroider/macros';
-import { next } from '@ember/runloop';
 import { assert, warn } from '@ember/debug';
+import type Route from '@ember/routing/route';
+import { next } from '@ember/runloop';
+import { getOwnConfig, isDevelopingApp, macroCondition } from '@embroider/macros';
+import type { BrowserOptions } from '@sentry/browser';
+import * as Sentry from '@sentry/browser';
+import { SDK_VERSION } from '@sentry/browser';
+import type { Transaction } from '@sentry/types';
+import { GLOBAL_OBJ, timestampInSeconds } from '@sentry/utils';
 import Ember from 'ember';
-import { timestampInSeconds, GLOBAL_OBJ } from '@sentry/utils';
-import { GlobalConfig, OwnConfig } from './types';
 
-function _getSentryInitConfig() {
+import type { EmberSentryConfig, GlobalConfig, OwnConfig } from './types';
+
+function _getSentryInitConfig(): EmberSentryConfig['sentry'] {
   const _global = GLOBAL_OBJ as typeof GLOBAL_OBJ & GlobalConfig;
   _global.__sentryEmberConfig = _global.__sentryEmberConfig ?? {};
   return _global.__sentryEmberConfig;
 }
 
-export function InitSentryForEmber(_runtimeConfig?: BrowserOptions) {
+export function InitSentryForEmber(_runtimeConfig?: BrowserOptions): void {
   const environmentConfig = getOwnConfig<OwnConfig>().sentryConfig;
 
   assert('Missing configuration.', environmentConfig);
@@ -21,7 +25,7 @@ export function InitSentryForEmber(_runtimeConfig?: BrowserOptions) {
 
   if (!environmentConfig.sentry) {
     // If environment config is not specified but the above assertion passes, use runtime config.
-    environmentConfig.sentry = { ..._runtimeConfig } as any;
+    environmentConfig.sentry = { ..._runtimeConfig };
   }
 
   // Merge runtime config into environment config, preferring runtime.
@@ -62,12 +66,20 @@ export function InitSentryForEmber(_runtimeConfig?: BrowserOptions) {
   }
 }
 
-export const getActiveTransaction = () => {
+export const getActiveTransaction = (): Transaction | undefined => {
   return Sentry.getCurrentHub().getScope().getTransaction();
 };
 
-export const instrumentRoutePerformance = (BaseRoute: any) => {
-  const instrumentFunction = async (op: string, description: string, fn: Function, args: any) => {
+type RouteConstructor = new (...args: ConstructorParameters<typeof Route>) => Route;
+
+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,
+    description: string,
+    fn: X,
+    args: Parameters<X>,
+  ): Promise<ReturnType<X>> => {
     const startTimestamp = timestampInSeconds();
     const result = await fn(...args);
 
@@ -79,40 +91,38 @@ export const instrumentRoutePerformance = (BaseRoute: any) => {
     return result;
   };
 
+  const routeName = BaseRoute.name;
+
   return {
-    [BaseRoute.name]: class extends BaseRoute {
-      beforeModel(...args: any[]) {
+    // @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',
-          (<any>this).fullRouteName,
+          this.fullRouteName,
           super.beforeModel.bind(this),
           args,
         );
       }
 
-      async model(...args: any[]) {
-        return instrumentFunction('ui.ember.route.model', (<any>this).fullRouteName, super.model.bind(this), args);
+      public async model(...args: unknown[]): Promise<unknown> {
+        return instrumentFunction('ui.ember.route.model', this.fullRouteName, super.model.bind(this), args);
       }
 
-      async afterModel(...args: any[]) {
-        return instrumentFunction(
-          'ui.ember.route.after_model',
-          (<any>this).fullRouteName,
-          super.afterModel.bind(this),
-          args,
-        );
+      public afterModel(...args: unknown[]): void | Promise<unknown> {
+        return instrumentFunction('ui.ember.route.after_model', this.fullRouteName, super.afterModel.bind(this), args);
       }
 
-      async setupController(...args: any[]) {
+      public setupController(...args: unknown[]): void | Promise<unknown> {
         return instrumentFunction(
           'ui.ember.route.setup_controller',
-          (<any>this).fullRouteName,
+          this.fullRouteName,
           super.setupController.bind(this),
           args,
         );
       }
     },
-  }[BaseRoute.name];
+  }[routeName] as T;
 };
 
 export * from '@sentry/browser';

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

@@ -1,18 +1,26 @@
-import ApplicationInstance from '@ember/application/instance';
-import { run, _backburner, scheduleOnce } from '@ember/runloop';
+/* eslint-disable max-lines */
+import type ApplicationInstance from '@ember/application/instance';
 import { subscribe } from '@ember/instrumentation';
+import type Transition from '@ember/routing/-private/transition';
+import type RouterService from '@ember/routing/router-service';
+import { _backburner, run, scheduleOnce } from '@ember/runloop';
+import type { EmberRunQueues } from '@ember/runloop/-private/types';
+import { getOwnConfig, isTesting, macroCondition } from '@embroider/macros';
 import * as Sentry from '@sentry/browser';
-import { ExtendedBackburner } from '@sentry/ember/runloop';
-import { Span, Transaction } from '@sentry/types';
-import { EmberRunQueues } from '@ember/runloop/-private/types';
-import { getActiveTransaction } from '..';
+import type { ExtendedBackburner } from '@sentry/ember/runloop';
+import type { Span, Transaction } from '@sentry/types';
 import { browserPerformanceTimeOrigin, GLOBAL_OBJ, timestampInSeconds } from '@sentry/utils';
-import { macroCondition, isTesting, getOwnConfig } from '@embroider/macros';
-import { EmberSentryConfig, GlobalConfig, OwnConfig } from '../types';
-import RouterService from '@ember/routing/router-service';
-import type { BaseClient } from '@sentry/core';
 
-function getSentryConfig() {
+import type { BrowserClient } from '..';
+import { getActiveTransaction } from '..';
+import type { EmberRouterMain, EmberSentryConfig, GlobalConfig, OwnConfig, StartTransactionFunction } from '../types';
+
+type SentryTestRouterService = RouterService & {
+  _startTransaction?: StartTransactionFunction;
+  _sentryInstrumented?: boolean;
+};
+
+function getSentryConfig(): EmberSentryConfig {
   const _global = GLOBAL_OBJ as typeof GLOBAL_OBJ & GlobalConfig;
   _global.__sentryEmberConfig = _global.__sentryEmberConfig ?? {};
   const environmentConfig = getOwnConfig<OwnConfig>().sentryConfig;
@@ -27,7 +35,7 @@ function getSentryConfig() {
 
 export function initialize(appInstance: ApplicationInstance): void {
   // Disable in fastboot - we only want to run Sentry client-side
-  const fastboot = appInstance.lookup('service:fastboot') as { isFastBoot: boolean } | undefined;
+  const fastboot = appInstance.lookup('service:fastboot') as unknown as { isFastBoot: boolean } | undefined;
   if (fastboot?.isFastBoot) {
     return;
   }
@@ -38,35 +46,42 @@ export function initialize(appInstance: ApplicationInstance): void {
   }
   const performancePromise = instrumentForPerformance(appInstance);
   if (macroCondition(isTesting())) {
-    (<any>window)._sentryPerformanceLoad = performancePromise;
+    (window as typeof window & { _sentryPerformanceLoad?: Promise<void> })._sentryPerformanceLoad = performancePromise;
   }
 }
 
 function getBackburner(): Pick<ExtendedBackburner, 'on' | 'off'> {
   if (_backburner) {
-    return _backburner;
+    return _backburner as unknown as Pick<ExtendedBackburner, 'on' | 'off'>;
   }
 
-  if (run.backburner) {
-    return run.backburner;
+  if ((run as unknown as { backburner?: Pick<ExtendedBackburner, 'on' | 'off'> }).backburner) {
+    return (run as unknown as { backburner: Pick<ExtendedBackburner, 'on' | 'off'> }).backburner;
   }
 
   return {
-    on() {},
-    off() {},
+    on() {
+      // noop
+    },
+    off() {
+      // noop
+    },
   };
 }
 
-function getTransitionInformation(transition: any, router: any) {
+function getTransitionInformation(
+  transition: Transition | undefined,
+  router: RouterService,
+): { fromRoute?: string; toRoute?: string } {
   const fromRoute = transition?.from?.name;
-  const toRoute = transition && transition.to ? transition.to.name : router.currentRouteName;
+  const toRoute = transition?.to?.name || router.currentRouteName;
   return {
     fromRoute,
     toRoute,
   };
 }
 
-function getLocationURL(location: any) {
+function getLocationURL(location: EmberRouterMain['location']): string {
   if (!location || !location.getURL || !location.formatURL) {
     return '';
   }
@@ -79,22 +94,24 @@ function getLocationURL(location: any) {
 }
 
 export function _instrumentEmberRouter(
-  routerService: any,
-  routerMain: any,
+  routerService: RouterService,
+  routerMain: EmberRouterMain,
   config: EmberSentryConfig,
-  startTransaction: Function,
+  startTransaction: StartTransactionFunction,
   startTransactionOnPageLoad?: boolean,
-) {
+): {
+  startTransaction: StartTransactionFunction;
+} {
   const { disableRunloopPerformance } = config;
   const location = routerMain.location;
-  let activeTransaction: Transaction;
-  let transitionSpan: Span;
+  let activeTransaction: Transaction | undefined;
+  let transitionSpan: Span | undefined;
 
   const url = getLocationURL(location);
 
   if (macroCondition(isTesting())) {
-    routerService._sentryInstrumented = true;
-    routerService._startTransaction = startTransaction;
+    (routerService as SentryTestRouterService)._sentryInstrumented = true;
+    (routerService as SentryTestRouterService)._startTransaction = startTransaction;
   }
 
   if (startTransactionOnPageLoad && url) {
@@ -110,15 +127,15 @@ export function _instrumentEmberRouter(
     });
   }
 
-  const finishActiveTransaction = function (_: any, nextInstance: any) {
+  const finishActiveTransaction = (_: unknown, nextInstance: unknown): void => {
     if (nextInstance) {
       return;
     }
-    activeTransaction.finish();
+    activeTransaction?.finish();
     getBackburner().off('end', finishActiveTransaction);
   };
 
-  routerService.on('routeWillChange', (transition: any) => {
+  routerService.on('routeWillChange', (transition: Transition) => {
     const { fromRoute, toRoute } = getTransitionInformation(transition, routerService);
     activeTransaction?.finish();
     activeTransaction = startTransaction({
@@ -130,7 +147,7 @@ export function _instrumentEmberRouter(
         'routing.instrumentation': '@sentry/ember',
       },
     });
-    transitionSpan = activeTransaction.startChild({
+    transitionSpan = activeTransaction?.startChild({
       op: 'ui.ember.transition',
       description: `route:${fromRoute} -> route:${toRoute}`,
     });
@@ -155,7 +172,7 @@ export function _instrumentEmberRouter(
   };
 }
 
-function _instrumentEmberRunloop(config: EmberSentryConfig) {
+function _instrumentEmberRunloop(config: EmberSentryConfig): void {
   const { disableRunloopPerformance, minimumRunloopQueueDuration } = config;
   if (disableRunloopPerformance) {
     return;
@@ -171,7 +188,7 @@ function _instrumentEmberRunloop(config: EmberSentryConfig) {
     'destroy',
   ] as EmberRunQueues[];
 
-  getBackburner().on('begin', (_: any, previousInstance: any) => {
+  getBackburner().on('begin', (_: unknown, previousInstance: unknown) => {
     if (previousInstance) {
       return;
     }
@@ -184,38 +201,38 @@ function _instrumentEmberRunloop(config: EmberSentryConfig) {
     }
     currentQueueStart = timestampInSeconds();
 
+    const processQueue = (queue: EmberRunQueues): void => {
+      // Process this queue using the end of the previous queue.
+      if (currentQueueStart) {
+        const now = timestampInSeconds();
+        const minQueueDuration = minimumRunloopQueueDuration ?? 5;
+
+        if ((now - currentQueueStart) * 1000 >= minQueueDuration) {
+          activeTransaction
+            ?.startChild({
+              op: `ui.ember.runloop.${queue}`,
+              startTimestamp: currentQueueStart,
+              endTimestamp: now,
+            })
+            .finish();
+        }
+        currentQueueStart = undefined;
+      }
+
+      // Setup for next queue
+
+      const stillActiveTransaction = getActiveTransaction();
+      if (!stillActiveTransaction) {
+        return;
+      }
+      currentQueueStart = timestampInSeconds();
+    };
+
     instrumentedEmberQueues.forEach(queue => {
-      scheduleOnce(queue, null, () => {
-        scheduleOnce(queue, null, () => {
-          // Process this queue using the end of the previous queue.
-          if (currentQueueStart) {
-            const now = timestampInSeconds();
-            const minQueueDuration = minimumRunloopQueueDuration ?? 5;
-
-            if ((now - currentQueueStart) * 1000 >= minQueueDuration) {
-              activeTransaction
-                ?.startChild({
-                  op: `ui.ember.runloop.${queue}`,
-                  startTimestamp: currentQueueStart,
-                  endTimestamp: now,
-                })
-                .finish();
-            }
-            currentQueueStart = undefined;
-          }
-
-          // Setup for next queue
-
-          const stillActiveTransaction = getActiveTransaction();
-          if (!stillActiveTransaction) {
-            return;
-          }
-          currentQueueStart = timestampInSeconds();
-        });
-      });
+      scheduleOnce(queue, null, processQueue, queue);
     });
   });
-  getBackburner().on('end', (_: any, nextInstance: any) => {
+  getBackburner().on('end', (_: unknown, nextInstance: unknown) => {
     if (nextInstance) {
       return;
     }
@@ -241,7 +258,7 @@ interface RenderEntries {
   [name: string]: RenderEntry;
 }
 
-function processComponentRenderBefore(payload: Payload, beforeEntries: RenderEntries) {
+function processComponentRenderBefore(payload: Payload, beforeEntries: RenderEntries): void {
   const info = {
     payload,
     now: timestampInSeconds(),
@@ -254,7 +271,7 @@ function processComponentRenderAfter(
   beforeEntries: RenderEntries,
   op: string,
   minComponentDuration: number,
-) {
+): void {
   const begin = beforeEntries[payload.object];
 
   if (!begin) {
@@ -276,7 +293,7 @@ function processComponentRenderAfter(
   }
 }
 
-function _instrumentComponents(config: EmberSentryConfig) {
+function _instrumentComponents(config: EmberSentryConfig): void {
   const { disableInstrumentComponents, minimumComponentRenderDuration, enableComponentDefinitions } = config;
   if (disableInstrumentComponents) {
     return;
@@ -287,13 +304,13 @@ function _instrumentComponents(config: EmberSentryConfig) {
   const beforeEntries = {} as RenderEntries;
   const beforeComponentDefinitionEntries = {} as RenderEntries;
 
-  function _subscribeToRenderEvents() {
+  function _subscribeToRenderEvents(): void {
     subscribe('render.component', {
       before(_name: string, _timestamp: number, payload: Payload) {
         processComponentRenderBefore(payload, beforeEntries);
       },
 
-      after(_name: string, _timestamp: number, payload: any, _beganIndex: number) {
+      after(_name: string, _timestamp: number, payload: Payload, _beganIndex: number) {
         processComponentRenderAfter(payload, beforeEntries, 'ui.ember.component.render', minComponentDuration);
       },
     });
@@ -303,7 +320,7 @@ function _instrumentComponents(config: EmberSentryConfig) {
           processComponentRenderBefore(payload, beforeComponentDefinitionEntries);
         },
 
-        after(_name: string, _timestamp: number, payload: any, _beganIndex: number) {
+        after(_name: string, _timestamp: number, payload: Payload, _beganIndex: number) {
           processComponentRenderAfter(payload, beforeComponentDefinitionEntries, 'ui.ember.component.definition', 0);
         },
       });
@@ -312,11 +329,11 @@ function _instrumentComponents(config: EmberSentryConfig) {
   _subscribeToRenderEvents();
 }
 
-function _instrumentInitialLoad(config: EmberSentryConfig) {
+function _instrumentInitialLoad(config: EmberSentryConfig): void {
   const startName = '@sentry/ember:initial-load-start';
   const endName = '@sentry/ember:initial-load-end';
 
-  let { HAS_PERFORMANCE, HAS_PERFORMANCE_TIMING } = _hasPerformanceSupport();
+  const { HAS_PERFORMANCE, HAS_PERFORMANCE_TIMING } = _hasPerformanceSupport();
 
   if (!HAS_PERFORMANCE) {
     return;
@@ -331,7 +348,7 @@ function _instrumentInitialLoad(config: EmberSentryConfig) {
   }
 
   // Split performance check in two so clearMarks still happens even if timeOrigin isn't available.
-  if (!HAS_PERFORMANCE_TIMING) {
+  if (!HAS_PERFORMANCE_TIMING || browserPerformanceTimeOrigin === undefined) {
     return;
   }
   const measureName = '@sentry/ember:initial-load';
@@ -344,9 +361,10 @@ function _instrumentInitialLoad(config: EmberSentryConfig) {
 
   performance.measure(measureName, startName, endName);
   const measures = performance.getEntriesByName(measureName);
-  const measure = measures[0];
+  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+  const measure = measures[0]!;
 
-  const startTimestamp = (measure.startTime + browserPerformanceTimeOrigin!) / 1000;
+  const startTimestamp = (measure.startTime + browserPerformanceTimeOrigin) / 1000;
   const endTimestamp = startTimestamp + measure.duration / 1000;
 
   const transaction = getActiveTransaction();
@@ -361,7 +379,7 @@ function _instrumentInitialLoad(config: EmberSentryConfig) {
   performance.clearMeasures(measureName);
 }
 
-function _hasPerformanceSupport() {
+function _hasPerformanceSupport(): { HAS_PERFORMANCE: boolean; HAS_PERFORMANCE_TIMING: boolean } {
   // TS says that all of these methods are always available, but some of them may not be supported in older browsers
   // So we "pretend" they are all optional in order to be able to check this properly without TS complaining
   const _performance = window.performance as {
@@ -381,9 +399,8 @@ function _hasPerformanceSupport() {
   };
 }
 
-export async function instrumentForPerformance(appInstance: ApplicationInstance) {
+export async function instrumentForPerformance(appInstance: ApplicationInstance): Promise<void> {
   const config = getSentryConfig();
-  const sentryConfig = config.sentry;
   // Maintaining backwards compatibility with config.browserTracingOptions, but passing it with Sentry options is preferred.
   const browserTracingOptions = config.browserTracingOptions || config.sentry.browserTracingOptions || {};
 
@@ -393,7 +410,8 @@ export async function instrumentForPerformance(appInstance: ApplicationInstance)
 
   const browserTracing = new BrowserTracing({
     routingInstrumentation: (customStartTransaction, startTransactionOnPageLoad) => {
-      const routerMain = appInstance.lookup('router:main');
+      // 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 };
 
@@ -421,8 +439,8 @@ export async function instrumentForPerformance(appInstance: ApplicationInstance)
 
     if (
       client &&
-      (client as BaseClient<any>).getIntegrationById &&
-      (client as BaseClient<any>).getIntegrationById('BrowserTracing')
+      (client as BrowserClient).getIntegrationById &&
+      (client as BrowserClient).getIntegrationById('BrowserTracing')
     ) {
       // Initializers are called more than once in tests, causing the integrations to not be setup correctly.
       return;

package/addon/runloop.d.ts

@@ -1,10 +1,10 @@
-import { Backburner } from '@ember/runloop/-private/backburner';
+import type { Backburner } from '@ember/runloop/-private/backburner';
 
 /**
  * Backburner needs to be extended as it's missing the 'off' method.
  */
 interface ExtendedBackburner extends Backburner {
-  off(...args: any[]): void;
+  off(...args: unknown[]): void;
 }
 
 /**

package/addon/types.ts

@@ -1,7 +1,10 @@
-import { BrowserOptions } from '@sentry/browser';
+import type { BrowserOptions, BrowserTracing } from '@sentry/browser';
+import type { Transaction, TransactionContext } from '@sentry/types';
+
+type BrowserTracingOptions = ConstructorParameters<typeof BrowserTracing>[0];
 
 export type EmberSentryConfig = {
-  sentry: BrowserOptions & { browserTracingOptions: Object };
+  sentry: BrowserOptions & { browserTracingOptions?: BrowserTracingOptions };
   transitionTimeout: number;
   ignoreEmberOnErrorWarning: boolean;
   disableInstrumentComponents: boolean;
@@ -12,13 +15,25 @@ export type EmberSentryConfig = {
   enableComponentDefinitions: boolean;
   minimumRunloopQueueDuration: number;
   minimumComponentRenderDuration: number;
-  browserTracingOptions: Object;
+  browserTracingOptions: BrowserTracingOptions;
 };
 
 export type OwnConfig = {
   sentryConfig: EmberSentryConfig;
 };
 
+// This is private in Ember and not really exported, so we "mock" these types here.
+export interface EmberRouterMain {
+  location: {
+    getURL?: () => string;
+    formatURL?: (url: string) => string;
+    implementation: string;
+    rootURL: string;
+  };
+}
+
+export type StartTransactionFunction = (context: TransactionContext) => Transaction | undefined;
+
 export type GlobalConfig = {
   __sentryEmberConfig: EmberSentryConfig['sentry'];
 };

package/index.d.ts

@@ -1,16 +1,9 @@
-import * as Sentry from '@sentry/browser';
-import { BrowserOptions } from '@sentry/browser';
+import type Route from '@ember/routing/route';
+import type { BrowserOptions } from '@sentry/browser';
+import type { Transaction } from '@sentry/types';
 export declare function InitSentryForEmber(_runtimeConfig?: BrowserOptions): void;
-export declare const getActiveTransaction: () => Sentry.Transaction | undefined;
-export declare const instrumentRoutePerformance: (BaseRoute: any) => {
-    new (): {
-        [x: string]: any;
-        beforeModel(...args: any[]): Promise<any>;
-        model(...args: any[]): Promise<any>;
-        afterModel(...args: any[]): Promise<any>;
-        setupController(...args: any[]): Promise<any>;
-    };
-    [x: string]: any;
-};
+export declare const getActiveTransaction: () => Transaction | undefined;
+type RouteConstructor = new (...args: ConstructorParameters<typeof Route>) => Route;
+export declare const instrumentRoutePerformance: <T extends RouteConstructor>(BaseRoute: T) => T;
 export * from '@sentry/browser';
 export declare const init: typeof InitSentryForEmber;

package/index.js

@@ -33,6 +33,7 @@ module.exports = {
     const addonConfig = config['@sentry/ember'] || {};
 
     if (!isSerializable(addonConfig)) {
+      // eslint-disable-next-line no-console
       console.warn(
         `Warning: You passed a non-serializable config to \`ENV['@sentry/ember'].sentry\`.
 Non-serializable config (e.g. RegExp, ...) can only be passed directly to \`Sentry.init()\`, which is usually defined in app/app.js.
@@ -73,6 +74,7 @@ function isSerializable(obj) {
   }
 
   if (isPlainObject(obj)) {
+    // eslint-disable-next-line guard-for-in
     for (let property in obj) {
       let value = obj[property];
       if (!isSerializable(value)) {

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentry/ember",
-  "version": "7.61.0",
+  "version": "7.62.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",
@@ -23,15 +23,20 @@
     "lint:hbs": "ember-template-lint .",
     "lint:js": "eslint .",
     "lint:ts": "tsc",
+    "fix": "run-s fix:eslint fix:prettier",
+    "fix:eslint": "eslint . --format stylish --fix",
+    "fix:prettier": "prettier --write \"{addon,app,tests,config}/**/**.{ts,js}\"",
     "start": "ember serve",
     "test": "ember test",
-    "test:all": "ember try:each"
+    "test:all": "ember try:each",
+    "prepack": "ember ts:precompile",
+    "postpack": "ember ts:clean"
   },
   "dependencies": {
     "@embroider/macros": "^1.9.0",
-    "@sentry/browser": "7.61.0",
-    "@sentry/types": "7.61.0",
-    "@sentry/utils": "7.61.0",
+    "@sentry/browser": "7.62.0",
+    "@sentry/types": "7.62.0",
+    "@sentry/utils": "7.62.0",
     "ember-auto-import": "^1.12.1 || ^2.4.3",
     "ember-cli-babel": "^7.26.11",
     "ember-cli-htmlbars": "^6.1.1",
@@ -39,14 +44,14 @@
   },
   "devDependencies": {
     "@ember/optional-features": "~1.3.0",
-    "@ember/test-helpers": "~2.8.1",
+    "@ember/test-helpers": "2.9.4",
     "@embroider/test-setup": "~1.8.3",
     "@glimmer/component": "~1.1.2",
     "@glimmer/tracking": "~1.1.2",
     "@types/ember": "~3.16.5",
     "@types/ember-qunit": "~3.4.9",
+    "@types/ember-resolver": "5.0.13",
     "@types/ember__debug": "^3.16.5",
-    "@types/ember__test-helpers": "~1.7.0",
     "@types/qunit": "~2.9.1",
     "@types/rsvp": "~4.0.3",
     "babel-eslint": "~10.1.0",
@@ -61,20 +66,21 @@
     "ember-load-initializers": "~2.1.1",
     "ember-maybe-import-regenerator": "~1.0.0",
     "ember-qunit": "~6.0.0",
-    "ember-resolver": "~8.0.3",
-    "ember-sinon-qunit": "~6.0.0",
+    "ember-resolver": "11.0.0",
+    "ember-sinon-qunit": "7.1.4",
     "ember-source": "~4.8.0",
     "ember-source-channel-url": "~2.0.1",
     "ember-template-lint": "~4.16.1",
     "ember-test-selectors": "~6.0.0",
     "ember-try": "~2.0.0",
     "ember-window-mock": "~0.8.1",
-    "eslint-plugin-ember": "~11.1.0",
-    "eslint-plugin-node": "~11.1.0",
-    "eslint-plugin-qunit": "~7.3.1",
+    "eslint-plugin-ember": "11.9.0",
+    "eslint-plugin-n": "16.0.1",
+    "eslint-plugin-qunit": "8.0.0",
     "loader.js": "~4.7.0",
     "qunit": "~2.19.2",
     "qunit-dom": "~2.0.0",
+    "sinon": "15.2.0",
     "webpack": "~5.74.0"
   },
   "engines": {

package/runloop.d.ts

@@ -1,10 +1,10 @@
-import { Backburner } from '@ember/runloop/-private/backburner';
+import type { Backburner } from '@ember/runloop/-private/backburner';
 
 /**
  * Backburner needs to be extended as it's missing the 'off' method.
  */
 interface ExtendedBackburner extends Backburner {
-  off(...args: any[]): void;
+  off(...args: unknown[]): void;
 }
 
 /**

package/tsconfig.json

@@ -1,7 +1,7 @@
 {
   "extends": "../../tsconfig.json",
   "compilerOptions": {
-    "target": "es2017",
+    "target": "es2022",
     "allowJs": true,
     "moduleResolution": "node",
     "allowSyntheticDefaultImports": true,
@@ -24,5 +24,5 @@
       "*": ["types/*"]
     }
   },
-  "include": ["app/**/*", "addon/**/*", "types/**/*", "addon-test-support/**/*"]
+  "include": ["app/**/*", "addon/**/*", "tests/**/*", "types/**/*", "test-support/**/*", "addon-test-support/**/*"]
 }

package/types.d.ts

@@ -1,7 +1,9 @@
-import { BrowserOptions } from '@sentry/browser';
+import type { BrowserOptions, BrowserTracing } from '@sentry/browser';
+import type { Transaction, TransactionContext } from '@sentry/types';
+type BrowserTracingOptions = ConstructorParameters<typeof BrowserTracing>[0];
 export type EmberSentryConfig = {
     sentry: BrowserOptions & {
-        browserTracingOptions: Object;
+        browserTracingOptions?: BrowserTracingOptions;
     };
     transitionTimeout: number;
     ignoreEmberOnErrorWarning: boolean;
@@ -13,11 +15,21 @@ export type EmberSentryConfig = {
     enableComponentDefinitions: boolean;
     minimumRunloopQueueDuration: number;
     minimumComponentRenderDuration: number;
-    browserTracingOptions: Object;
+    browserTracingOptions: BrowserTracingOptions;
 };
 export type OwnConfig = {
     sentryConfig: EmberSentryConfig;
 };
+export interface EmberRouterMain {
+    location: {
+        getURL?: () => string;
+        formatURL?: (url: string) => string;
+        implementation: string;
+        rootURL: string;
+    };
+}
+export type StartTransactionFunction = (context: TransactionContext) => Transaction | undefined;
 export type GlobalConfig = {
     __sentryEmberConfig: EmberSentryConfig['sentry'];
 };
+export {};