@sentry/ember 7.1.1 → 7.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentry/ember",
-  "version": "7.1.1",
+  "version": "7.2.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",
@@ -30,10 +30,10 @@
   },
   "dependencies": {
     "@embroider/macros": "~0.47.2",
-    "@sentry/browser": "7.1.1",
-    "@sentry/tracing": "7.1.1",
-    "@sentry/types": "7.1.1",
-    "@sentry/utils": "7.1.1",
+    "@sentry/browser": "7.2.0",
+    "@sentry/tracing": "7.2.0",
+    "@sentry/types": "7.2.0",
+    "@sentry/utils": "7.2.0",
     "ember-auto-import": "~1.12.1 || ~2.2.0",
     "ember-cli-babel": "~7.26.6",
     "ember-cli-htmlbars": "^6.0.1",

package/addon/ember.d.ts

@@ -1,6 +0,0 @@
-import Ember from 'ember';
-declare module 'ember' {
-  namespace Ember {
-    export function subscribe(pattern: string, object: {}): any;
-  }
-}

package/addon/index.ts

@@ -1,122 +0,0 @@
-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 Ember from 'ember';
-import { timestampWithMs } from '@sentry/utils';
-import { GlobalConfig, OwnConfig } from './types';
-import { getGlobalObject } from '@sentry/utils';
-
-function _getSentryInitConfig() {
-  const _global = getGlobalObject<GlobalConfig>();
-  _global.__sentryEmberConfig = _global.__sentryEmberConfig ?? {};
-  return _global.__sentryEmberConfig;
-}
-
-export function InitSentryForEmber(_runtimeConfig?: BrowserOptions) {
-  const environmentConfig = getOwnConfig<OwnConfig>().sentryConfig;
-
-  assert('Missing configuration.', environmentConfig);
-  assert('Missing configuration for Sentry.', environmentConfig.sentry || _runtimeConfig);
-
-  if (!environmentConfig.sentry) {
-    // If environment config is not specified but the above assertion passes, use runtime config.
-    environmentConfig.sentry = { ..._runtimeConfig } as any;
-  }
-
-  // Merge runtime config into environment config, preferring runtime.
-  Object.assign(environmentConfig.sentry, _runtimeConfig || {});
-  const initConfig = Object.assign({}, environmentConfig.sentry);
-
-  initConfig._metadata = initConfig._metadata || {};
-  initConfig._metadata.sdk = {
-    name: 'sentry.javascript.ember',
-    packages: [
-      {
-        name: 'npm:@sentry/ember',
-        version: SDK_VERSION,
-      },
-    ],
-    version: SDK_VERSION,
-  };
-
-  // Persist Sentry init options so they are identical when performance initializers call init again.
-  const sentryInitConfig = _getSentryInitConfig();
-  Object.assign(sentryInitConfig, initConfig);
-
-  Sentry.init(initConfig);
-
-  if (macroCondition(isDevelopingApp())) {
-    if (environmentConfig.ignoreEmberOnErrorWarning) {
-      return;
-    }
-    next(null, function () {
-      warn(
-        'Ember.onerror found. Using Ember.onerror can hide some errors (such as flushed runloop errors) from Sentry. Use Sentry.captureException to capture errors within Ember.onError or remove it to have errors caught by Sentry directly. This error can be silenced via addon configuration.',
-        !Ember.onerror,
-        {
-          id: '@sentry/ember.ember-onerror-detected',
-        },
-      );
-    });
-  }
-}
-
-export const getActiveTransaction = () => {
-  return Sentry.getCurrentHub()?.getScope()?.getTransaction();
-};
-
-export const instrumentRoutePerformance = (BaseRoute: any) => {
-  const instrumentFunction = async (op: string, description: string, fn: Function, args: any) => {
-    const startTimestamp = timestampWithMs();
-    const result = await fn(...args);
-
-    const currentTransaction = getActiveTransaction();
-    if (!currentTransaction) {
-      return result;
-    }
-    currentTransaction.startChild({ op, description, startTimestamp }).finish();
-    return result;
-  };
-
-  return {
-    [BaseRoute.name]: class extends BaseRoute {
-      beforeModel(...args: any[]) {
-        return instrumentFunction(
-          'ember.route.beforeModel',
-          (<any>this).fullRouteName,
-          super.beforeModel.bind(this),
-          args,
-        );
-      }
-
-      async model(...args: any[]) {
-        return instrumentFunction('ember.route.model', (<any>this).fullRouteName, super.model.bind(this), args);
-      }
-
-      async afterModel(...args: any[]) {
-        return instrumentFunction(
-          'ember.route.afterModel',
-          (<any>this).fullRouteName,
-          super.afterModel.bind(this),
-          args,
-        );
-      }
-
-      async setupController(...args: any[]) {
-        return instrumentFunction(
-          'ember.route.setupController',
-          (<any>this).fullRouteName,
-          super.setupController.bind(this),
-          args,
-        );
-      }
-    },
-  }[BaseRoute.name];
-};
-
-export * from '@sentry/browser';
-
-// init is now the preferred way to call initialization for this addon.
-export const init = InitSentryForEmber;

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

@@ -1,412 +0,0 @@
-import ApplicationInstance from '@ember/application/instance';
-import Ember from 'ember';
-import { run, _backburner, scheduleOnce } from '@ember/runloop';
-import * as Sentry from '@sentry/browser';
-import { ExtendedBackburner } from '@sentry/ember/runloop';
-import { Span, Transaction, Integration } from '@sentry/types';
-import { EmberRunQueues } from '@ember/runloop/-private/types';
-import { getActiveTransaction } from '..';
-import { browserPerformanceTimeOrigin, getGlobalObject, timestampWithMs } from '@sentry/utils';
-import { macroCondition, isTesting, getOwnConfig } from '@embroider/macros';
-import { EmberSentryConfig, GlobalConfig, OwnConfig } from '../types';
-
-function getSentryConfig() {
-  const _global = getGlobalObject<GlobalConfig>();
-  _global.__sentryEmberConfig = _global.__sentryEmberConfig ?? {};
-  const environmentConfig = getOwnConfig<OwnConfig>().sentryConfig;
-  if (!environmentConfig.sentry) {
-    environmentConfig.sentry = {
-      browserTracingOptions: {},
-    };
-  }
-  Object.assign(environmentConfig.sentry, _global.__sentryEmberConfig);
-  return environmentConfig;
-}
-
-export function initialize(appInstance: ApplicationInstance): void {
-  const config = getSentryConfig();
-  if (config['disablePerformance']) {
-    return;
-  }
-  const performancePromise = instrumentForPerformance(appInstance);
-  if (macroCondition(isTesting())) {
-    (<any>window)._sentryPerformanceLoad = performancePromise;
-  }
-}
-
-function getBackburner(): Pick<ExtendedBackburner, 'on' | 'off'> {
-  if (_backburner) {
-    return _backburner;
-  }
-
-  if (run.backburner) {
-    return run.backburner;
-  }
-
-  return {
-    on() {},
-    off() {},
-  };
-}
-
-function getTransitionInformation(transition: any, router: any) {
-  const fromRoute = transition?.from?.name;
-  const toRoute = transition && transition.to ? transition.to.name : router.currentRouteName;
-  return {
-    fromRoute,
-    toRoute,
-  };
-}
-
-function getLocationURL(location: any) {
-  if (!location || !location.getURL || !location.formatURL) {
-    return '';
-  }
-  const url = location.formatURL(location.getURL());
-
-  if (location.implementation === 'hash') {
-    return `${location.rootURL}${url}`;
-  }
-  return url;
-}
-
-export function _instrumentEmberRouter(
-  routerService: any,
-  routerMain: any,
-  config: EmberSentryConfig,
-  startTransaction: Function,
-  startTransactionOnPageLoad?: boolean,
-) {
-  const { disableRunloopPerformance } = config;
-  const location = routerMain.location;
-  let activeTransaction: Transaction;
-  let transitionSpan: Span;
-
-  const url = getLocationURL(location);
-
-  if (macroCondition(isTesting())) {
-    routerService._sentryInstrumented = true;
-    routerService._startTransaction = startTransaction;
-  }
-
-  if (startTransactionOnPageLoad && url) {
-    const routeInfo = routerService.recognize(url);
-    activeTransaction = startTransaction({
-      name: `route:${routeInfo.name}`,
-      op: 'pageload',
-      tags: {
-        url,
-        toRoute: routeInfo.name,
-        'routing.instrumentation': '@sentry/ember',
-      },
-    });
-  }
-
-  const finishActiveTransaction = function (_: any, nextInstance: any) {
-    if (nextInstance) {
-      return;
-    }
-    activeTransaction.finish();
-    getBackburner().off('end', finishActiveTransaction);
-  };
-
-  routerService.on('routeWillChange', (transition: any) => {
-    const { fromRoute, toRoute } = getTransitionInformation(transition, routerService);
-    activeTransaction?.finish();
-    activeTransaction = startTransaction({
-      name: `route:${toRoute}`,
-      op: 'navigation',
-      tags: {
-        fromRoute,
-        toRoute,
-        'routing.instrumentation': '@sentry/ember',
-      },
-    });
-    transitionSpan = activeTransaction.startChild({
-      op: 'ui.ember.transition',
-      description: `route:${fromRoute} -> route:${toRoute}`,
-    });
-  });
-
-  routerService.on('routeDidChange', () => {
-    if (!transitionSpan || !activeTransaction) {
-      return;
-    }
-    transitionSpan.finish();
-
-    if (disableRunloopPerformance) {
-      activeTransaction.finish();
-      return;
-    }
-
-    getBackburner().on('end', finishActiveTransaction);
-  });
-
-  return {
-    startTransaction,
-  };
-}
-
-function _instrumentEmberRunloop(config: EmberSentryConfig) {
-  const { disableRunloopPerformance, minimumRunloopQueueDuration } = config;
-  if (disableRunloopPerformance) {
-    return;
-  }
-
-  let currentQueueStart: number | undefined;
-  let currentQueueSpan: Span | undefined;
-  const instrumentedEmberQueues = [
-    'actions',
-    'routerTransitions',
-    'render',
-    'afterRender',
-    'destroy',
-  ] as EmberRunQueues[];
-
-  getBackburner().on('begin', (_: any, previousInstance: any) => {
-    if (previousInstance) {
-      return;
-    }
-    const activeTransaction = getActiveTransaction();
-    if (!activeTransaction) {
-      return;
-    }
-    if (currentQueueSpan) {
-      currentQueueSpan.finish();
-    }
-    currentQueueStart = timestampWithMs();
-
-    instrumentedEmberQueues.forEach(queue => {
-      scheduleOnce(queue, null, () => {
-        scheduleOnce(queue, null, () => {
-          // Process this queue using the end of the previous queue.
-          if (currentQueueStart) {
-            const now = timestampWithMs();
-            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 = timestampWithMs();
-        });
-      });
-    });
-  });
-  getBackburner().on('end', (_: any, nextInstance: any) => {
-    if (nextInstance) {
-      return;
-    }
-    if (currentQueueSpan) {
-      currentQueueSpan.finish();
-      currentQueueSpan = undefined;
-    }
-  });
-}
-
-type Payload = {
-  containerKey: string;
-  initialRender: true;
-  object: string;
-};
-
-type RenderEntry = {
-  payload: Payload;
-  now: number;
-};
-
-interface RenderEntries {
-  [name: string]: RenderEntry;
-}
-
-function processComponentRenderBefore(payload: Payload, beforeEntries: RenderEntries) {
-  const info = {
-    payload,
-    now: timestampWithMs(),
-  };
-  beforeEntries[payload.object] = info;
-}
-
-function processComponentRenderAfter(
-  payload: Payload,
-  beforeEntries: RenderEntries,
-  op: string,
-  minComponentDuration: number,
-) {
-  const begin = beforeEntries[payload.object];
-
-  if (!begin) {
-    return;
-  }
-
-  const now = timestampWithMs();
-  const componentRenderDuration = now - begin.now;
-
-  if (componentRenderDuration * 1000 >= minComponentDuration) {
-    const activeTransaction = getActiveTransaction();
-
-    activeTransaction?.startChild({
-      op,
-      description: payload.containerKey || payload.object,
-      startTimestamp: begin.now,
-      endTimestamp: now,
-    });
-  }
-}
-
-function _instrumentComponents(config: EmberSentryConfig) {
-  const { disableInstrumentComponents, minimumComponentRenderDuration, enableComponentDefinitions } = config;
-  if (disableInstrumentComponents) {
-    return;
-  }
-
-  const minComponentDuration = minimumComponentRenderDuration ?? 2;
-
-  const beforeEntries = {} as RenderEntries;
-  const beforeComponentDefinitionEntries = {} as RenderEntries;
-
-  const subscribe = Ember.subscribe;
-  function _subscribeToRenderEvents() {
-    subscribe('render.component', {
-      before(_name: string, _timestamp: number, payload: Payload) {
-        processComponentRenderBefore(payload, beforeEntries);
-      },
-
-      after(_name: string, _timestamp: number, payload: any, _beganIndex: number) {
-        processComponentRenderAfter(payload, beforeEntries, 'ui.ember.component.render', minComponentDuration);
-      },
-    });
-    if (enableComponentDefinitions) {
-      subscribe('render.getComponentDefinition', {
-        before(_name: string, _timestamp: number, payload: Payload) {
-          processComponentRenderBefore(payload, beforeComponentDefinitionEntries);
-        },
-
-        after(_name: string, _timestamp: number, payload: any, _beganIndex: number) {
-          processComponentRenderAfter(payload, beforeComponentDefinitionEntries, 'ui.ember.component.definition', 0);
-        },
-      });
-    }
-  }
-  _subscribeToRenderEvents();
-}
-
-function _instrumentInitialLoad(config: EmberSentryConfig) {
-  const startName = '@sentry/ember:initial-load-start';
-  const endName = '@sentry/ember:initial-load-end';
-
-  const { performance } = window;
-  const HAS_PERFORMANCE = performance && performance.clearMarks && performance.clearMeasures;
-
-  if (!HAS_PERFORMANCE) {
-    return;
-  }
-
-  if (config.disableInitialLoadInstrumentation) {
-    performance.clearMarks(startName);
-    performance.clearMarks(endName);
-    return;
-  }
-
-  // Split performance check in two so clearMarks still happens even if timeOrigin isn't available.
-  const HAS_PERFORMANCE_TIMING =
-    performance.measure && performance.getEntriesByName && browserPerformanceTimeOrigin !== undefined;
-  if (!HAS_PERFORMANCE_TIMING) {
-    return;
-  }
-  const measureName = '@sentry/ember:initial-load';
-
-  const startMarkExists = performance.getEntriesByName(startName).length > 0;
-  const endMarkExists = performance.getEntriesByName(endName).length > 0;
-  if (!startMarkExists || !endMarkExists) {
-    return;
-  }
-
-  performance.measure(measureName, startName, endName);
-  const measures = performance.getEntriesByName(measureName);
-  const measure = measures[0];
-
-  const startTimestamp = (measure.startTime + browserPerformanceTimeOrigin!) / 1000;
-  const endTimestamp = startTimestamp + measure.duration / 1000;
-
-  const transaction = getActiveTransaction();
-  const span = transaction?.startChild({
-    op: 'ui.ember.init',
-    startTimestamp,
-  });
-  span?.finish(endTimestamp);
-  performance.clearMarks(startName);
-  performance.clearMarks(endName);
-
-  performance.clearMeasures(measureName);
-}
-
-export async function instrumentForPerformance(appInstance: ApplicationInstance) {
-  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 || {};
-
-  const tracing = await import('@sentry/tracing');
-
-  const idleTimeout = config.transitionTimeout || 5000;
-
-  const existingIntegrations = (sentryConfig['integrations'] || []) as Integration[];
-
-  sentryConfig['integrations'] = [
-    ...existingIntegrations,
-    new tracing.Integrations.BrowserTracing({
-      routingInstrumentation: (customStartTransaction, startTransactionOnPageLoad) => {
-        const routerMain = appInstance.lookup('router:main');
-        const routerService = appInstance.lookup('service:router');
-        _instrumentEmberRouter(routerService, routerMain, config, customStartTransaction, startTransactionOnPageLoad);
-      },
-      idleTimeout,
-      ...browserTracingOptions,
-    }),
-  ];
-
-  class FakeBrowserTracingClass {
-    static id = tracing.BROWSER_TRACING_INTEGRATION_ID;
-    public name = FakeBrowserTracingClass.id;
-    setupOnce() {
-      // noop - We're just faking  this class for a lookup
-    }
-  }
-
-  if (
-    isTesting() &&
-    Sentry.getCurrentHub()?.getIntegration(
-      // This is a temporary hack because the BrowserTracing integration cannot have a static `id` field for tree
-      // shaking reasons. However, `getIntegration` needs that field.
-      FakeBrowserTracingClass,
-    )
-  ) {
-    // Initializers are called more than once in tests, causing the integrations to not be setup correctly.
-    return;
-  }
-
-  Sentry.init(sentryConfig); // Call init again to rebind client with new integration list in addition to the defaults
-
-  _instrumentEmberRunloop(config);
-  _instrumentComponents(config);
-  _instrumentInitialLoad(config);
-}
-
-export default {
-  initialize,
-};

package/addon/runloop.d.ts

@@ -1,19 +0,0 @@
-import { 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;
-}
-
-/**
- * Runloop needs to be extended to expose backburner as suggested here:
- * https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/ember__runloop/ember__runloop-tests.ts#L9
- */
-declare module '@ember/runloop' {
-  interface RunNamespace {
-    backburner?: ExtendedBackburner;
-  }
-  export const _backburner: ExtendedBackburner; // Ember 4.0
-}

package/addon/types.ts

@@ -1,24 +0,0 @@
-import { BrowserOptions } from '@sentry/browser';
-
-export type EmberSentryConfig = {
-  sentry: BrowserOptions & { browserTracingOptions: Object };
-  transitionTimeout: number;
-  ignoreEmberOnErrorWarning: boolean;
-  disableInstrumentComponents: boolean;
-  disablePerformance: boolean;
-  disablePostTransitionRender: boolean;
-  disableRunloopPerformance: boolean;
-  disableInitialLoadInstrumentation: boolean;
-  enableComponentDefinitions: boolean;
-  minimumRunloopQueueDuration: number;
-  minimumComponentRenderDuration: number;
-  browserTracingOptions: Object;
-};
-
-export type OwnConfig = {
-  sentryConfig: EmberSentryConfig;
-};
-
-export type GlobalConfig = {
-  __sentryEmberConfig: EmberSentryConfig['sentry'];
-};

package/app/instance-initializers/sentry-performance.js

@@ -1 +0,0 @@
-export { default, initialize } from '@sentry/ember/instance-initializers/sentry-performance';

package/config/environment.js

@@ -1,5 +0,0 @@
-'use strict';
-
-module.exports = function (/* environment, appConfig */) {
-  return {};
-};

package/ember.d.ts

@@ -1,6 +0,0 @@
-import Ember from 'ember';
-declare module 'ember' {
-  namespace Ember {
-    export function subscribe(pattern: string, object: {}): any;
-  }
-}

package/index.d.ts

@@ -1,15 +0,0 @@
-import { BrowserOptions } from '@sentry/browser';
-export declare function InitSentryForEmber(_runtimeConfig?: BrowserOptions): void;
-export declare const getActiveTransaction: () => import("@sentry/types").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 * from '@sentry/browser';
-export declare const init: typeof InitSentryForEmber;

package/index.js

@@ -1,52 +0,0 @@
-'use strict';
-const fs = require('fs');
-const crypto = require('crypto');
-
-function readSnippet(fileName) {
-  return fs.readFileSync(`${__dirname}/vendor/${fileName}`, 'utf8');
-}
-
-function hashSha256base64(string) {
-  return crypto.createHash('sha256').update(string).digest('base64');
-}
-
-const initialLoadHeadSnippet = readSnippet('initial-load-head.js');
-const initialLoadBodySnippet = readSnippet('initial-load-body.js');
-
-const initialLoadHeadSnippetHash = hashSha256base64(initialLoadHeadSnippet);
-const initialLoadBodySnippetHash = hashSha256base64(initialLoadBodySnippet);
-
-module.exports = {
-  name: require('./package').name,
-  options: {
-    babel: {
-      plugins: [require.resolve('ember-auto-import/babel-plugin')],
-    },
-    '@embroider/macros': {
-      setOwnConfig: {},
-    },
-  },
-
-  config(_, appConfig) {
-    const addonConfig = appConfig['@sentry/ember'];
-    this.options['@embroider/macros'].setOwnConfig.sentryConfig = { ...addonConfig };
-    return this._super(...arguments);
-  },
-
-  contentFor(type, config) {
-    const addonConfig = config['@sentry/ember'] || {};
-    const { disablePerformance, disableInitialLoadInstrumentation } = addonConfig;
-
-    if (disablePerformance || disableInitialLoadInstrumentation) {
-      return;
-    }
-
-    if (type === 'head') {
-      return `<script type="text/javascript">${initialLoadHeadSnippet}</script>`;
-    } else if (type === 'body-footer') {
-      return `<script type="text/javascript">${initialLoadBodySnippet}</script>`;
-    }
-  },
-
-  injectedScriptHashes: [initialLoadHeadSnippetHash, initialLoadBodySnippetHash],
-};

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

@@ -1,11 +0,0 @@
-import ApplicationInstance from '@ember/application/instance';
-import { EmberSentryConfig } 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 instrumentForPerformance(appInstance: ApplicationInstance): Promise<void>;
-declare const _default: {
-    initialize: typeof initialize;
-};
-export default _default;

package/runloop.d.ts

@@ -1,19 +0,0 @@
-import { 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;
-}
-
-/**
- * Runloop needs to be extended to expose backburner as suggested here:
- * https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/ember__runloop/ember__runloop-tests.ts#L9
- */
-declare module '@ember/runloop' {
-  interface RunNamespace {
-    backburner?: ExtendedBackburner;
-  }
-  export const _backburner: ExtendedBackburner; // Ember 4.0
-}

package/scripts/run-CI-tests.js

@@ -1,17 +0,0 @@
-/*eslint-env node*/
-const { spawnSync } = require('child_process');
-
-console.log('Mimicking the CI environment in order to run tests against multiple versions of Ember');
-
-const result = spawnSync('yarn test', {
-  shell: true,
-  stdio: 'inherit',
-  env: {
-    ...process.env,
-    GITHUB_ACTIONS: true,
-    GITHUB_EVENT_NAME: 'push',
-    GITHUB_HEAD_REF: 'master',
-  },
-});
-
-process.exit(result.status);

package/tsconfig.json

@@ -1,28 +0,0 @@
-{
-  "extends": "../../tsconfig.json",
-  "compilerOptions": {
-    "target": "es2017",
-    "allowJs": true,
-    "moduleResolution": "node",
-    "allowSyntheticDefaultImports": true,
-    "alwaysStrict": true,
-    "noImplicitUseStrict": false,
-    "strictNullChecks": true,
-    "strictPropertyInitialization": true,
-    "noEmitOnError": false,
-    "noEmit": true,
-    "baseUrl": ".",
-    "module": "esnext",
-    "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/*"]
-    }
-  },
-  "include": ["app/**/*", "addon/**/*", "types/**/*", "addon-test-support/**/*"]
-}

package/types.d.ts

@@ -1,23 +0,0 @@
-import { BrowserOptions } from '@sentry/browser';
-export declare type EmberSentryConfig = {
-    sentry: BrowserOptions & {
-        browserTracingOptions: Object;
-    };
-    transitionTimeout: number;
-    ignoreEmberOnErrorWarning: boolean;
-    disableInstrumentComponents: boolean;
-    disablePerformance: boolean;
-    disablePostTransitionRender: boolean;
-    disableRunloopPerformance: boolean;
-    disableInitialLoadInstrumentation: boolean;
-    enableComponentDefinitions: boolean;
-    minimumRunloopQueueDuration: number;
-    minimumComponentRenderDuration: number;
-    browserTracingOptions: Object;
-};
-export declare type OwnConfig = {
-    sentryConfig: EmberSentryConfig;
-};
-export declare type GlobalConfig = {
-    __sentryEmberConfig: EmberSentryConfig['sentry'];
-};

package/vendor/initial-load-body.js

@@ -1,3 +0,0 @@
-if (window.performance && window.performance.mark) {
-  window.performance.mark('@sentry/ember:initial-load-end');
-}

package/vendor/initial-load-head.js

@@ -1,3 +0,0 @@
-if (window.performance && window.performance.mark) {
-  window.performance.mark('@sentry/ember:initial-load-start');
-}