s/startTransaction/customStartTransaction

Author: lobsterkatie

packages/angular/src/tracing.ts

@@ -14,16 +14,16 @@ let stashedStartTransactionOnLocationChange: boolean;
  * Creates routing instrumentation for Angular Router.
  */
 export function routingInstrumentation(
-  startTransaction: (context: TransactionContext) => Transaction | undefined,
+  customStartTransaction: (context: TransactionContext) => Transaction | undefined,
   startTransactionOnPageLoad: boolean = true,
   startTransactionOnLocationChange: boolean = true,
 ): void {
   instrumentationInitialized = true;
-  stashedStartTransaction = startTransaction;
+  stashedStartTransaction = customStartTransaction;
   stashedStartTransactionOnLocationChange = startTransactionOnLocationChange;
 
   if (startTransactionOnPageLoad) {
-    startTransaction({
+    customStartTransaction({
       name: window.location.pathname,
       op: 'pageload',
     });

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

@@ -337,10 +337,10 @@ export async function instrumentForPerformance(appInstance: ApplicationInstance)
   sentryConfig['integrations'] = [
     ...existingIntegrations,
     new tracing.Integrations.BrowserTracing({
-      routingInstrumentation: (startTransaction, startTransactionOnPageLoad) => {
+      routingInstrumentation: (customStartTransaction, startTransactionOnPageLoad) => {
         const routerMain = appInstance.lookup('router:main');
         const routerService = appInstance.lookup('service:router');
-        _instrumentEmberRouter(routerService, routerMain, config, startTransaction, startTransactionOnPageLoad);
+        _instrumentEmberRouter(routerService, routerMain, config, customStartTransaction, startTransactionOnPageLoad);
       },
       idleTimeout,
     }),

packages/react/src/reactrouter.tsx

@@ -80,9 +80,9 @@ function reactRouterInstrumentation(
     return pathname;
   }
 
-  return (startTransaction, startTransactionOnPageLoad = true, startTransactionOnLocationChange = true): void => {
+  return (customStartTransaction, startTransactionOnPageLoad = true, startTransactionOnLocationChange = true): void => {
     if (startTransactionOnPageLoad && global && global.location) {
-      activeTransaction = startTransaction({
+      activeTransaction = customStartTransaction({
         name: getName(global.location.pathname),
         op: 'pageload',
         tags: {
@@ -101,7 +101,7 @@ function reactRouterInstrumentation(
             'routing.instrumentation': name,
           };
 
-          activeTransaction = startTransaction({
+          activeTransaction = customStartTransaction({
             name: getName(location.pathname),
             op: 'navigation',
             tags,

packages/tracing/src/browser/browsertracing.ts

@@ -77,7 +77,7 @@ export interface BrowserTracingOptions extends RequestInstrumentationOptions {
    * pageload and navigation transactions.
    */
   routingInstrumentation<T extends Transaction>(
-    startTransaction: (context: TransactionContext) => T | undefined,
+    customStartTransaction: (context: TransactionContext) => T | undefined,
     startTransactionOnPageLoad?: boolean,
     startTransactionOnLocationChange?: boolean,
   ): void;

packages/tracing/src/browser/router.ts

@@ -7,7 +7,7 @@ const global = getGlobalObject<Window>();
  * Default function implementing pageload and navigation transactions
  */
 export function defaultRoutingInstrumentation<T extends Transaction>(
-  startTransaction: (context: TransactionContext) => T | undefined,
+  customStartTransaction: (context: TransactionContext) => T | undefined,
   startTransactionOnPageLoad: boolean = true,
   startTransactionOnLocationChange: boolean = true,
 ): void {
@@ -20,7 +20,7 @@ export function defaultRoutingInstrumentation<T extends Transaction>(
 
   let activeTransaction: T | undefined;
   if (startTransactionOnPageLoad) {
-    activeTransaction = startTransaction({ name: global.location.pathname, op: 'pageload' });
+    activeTransaction = customStartTransaction({ name: global.location.pathname, op: 'pageload' });
   }
 
   if (startTransactionOnLocationChange) {
@@ -47,7 +47,7 @@ export function defaultRoutingInstrumentation<T extends Transaction>(
             // If there's an open transaction on the scope, we need to finish it before creating an new one.
             activeTransaction.finish();
           }
-          activeTransaction = startTransaction({ name: global.location.pathname, op: 'navigation' });
+          activeTransaction = customStartTransaction({ name: global.location.pathname, op: 'navigation' });
         }
       },
       type: 'history',

packages/tracing/test/browser/browsertracing.test.ts

@@ -96,8 +96,8 @@ describe('BrowserTracing', () => {
    * so that we can show this functionality works independent of the default routing integration.
    */
   describe('route transaction', () => {
-    const customRoutingInstrumentation = (startTransaction: (obj: any) => void) => {
-      startTransaction({ name: 'a/path', op: 'pageload' });
+    const customRoutingInstrumentation = (customStartTransaction: (obj: any) => void) => {
+      customStartTransaction({ name: 'a/path', op: 'pageload' });
     };
 
     it('calls custom routing instrumenation', () => {

packages/tracing/test/browser/router.test.ts

@@ -17,7 +17,7 @@ jest.mock('@sentry/utils', () => {
 
 describe('defaultRoutingInstrumentation', () => {
   const mockFinish = jest.fn();
-  const startTransaction = jest.fn().mockReturnValue({ finish: mockFinish });
+  const customStartTransaction = jest.fn().mockReturnValue({ finish: mockFinish });
   beforeEach(() => {
     const dom = new JSDOM();
     // @ts-ignore need to override global document
@@ -27,26 +27,26 @@ describe('defaultRoutingInstrumentation', () => {
     // @ts-ignore need to override global document
     global.location = dom.window.location;
 
-    startTransaction.mockClear();
+    customStartTransaction.mockClear();
     mockFinish.mockClear();
   });
 
   it('does not start transactions if global location is undefined', () => {
     // @ts-ignore need to override global document
     global.location = undefined;
-    defaultRoutingInstrumentation(startTransaction);
-    expect(startTransaction).toHaveBeenCalledTimes(0);
+    defaultRoutingInstrumentation(customStartTransaction);
+    expect(customStartTransaction).toHaveBeenCalledTimes(0);
   });
 
   it('starts a pageload transaction', () => {
-    defaultRoutingInstrumentation(startTransaction);
-    expect(startTransaction).toHaveBeenCalledTimes(1);
-    expect(startTransaction).toHaveBeenLastCalledWith({ name: 'blank', op: 'pageload' });
+    defaultRoutingInstrumentation(customStartTransaction);
+    expect(customStartTransaction).toHaveBeenCalledTimes(1);
+    expect(customStartTransaction).toHaveBeenLastCalledWith({ name: 'blank', op: 'pageload' });
   });
 
   it('does not start a pageload transaction if startTransactionOnPageLoad is false', () => {
-    defaultRoutingInstrumentation(startTransaction, false);
-    expect(startTransaction).toHaveBeenCalledTimes(0);
+    defaultRoutingInstrumentation(customStartTransaction, false);
+    expect(customStartTransaction).toHaveBeenCalledTimes(0);
   });
 
   describe('navigation transaction', () => {
@@ -56,37 +56,37 @@ describe('defaultRoutingInstrumentation', () => {
     });
 
     it('it is not created automatically', () => {
-      defaultRoutingInstrumentation(startTransaction);
-      expect(startTransaction).not.toHaveBeenLastCalledWith({ name: 'blank', op: 'navigation' });
+      defaultRoutingInstrumentation(customStartTransaction);
+      expect(customStartTransaction).not.toHaveBeenLastCalledWith({ name: 'blank', op: 'navigation' });
     });
 
     it('is created on location change', () => {
-      defaultRoutingInstrumentation(startTransaction);
+      defaultRoutingInstrumentation(customStartTransaction);
       mockChangeHistory({ to: 'here', from: 'there' });
       expect(addInstrumentationHandlerType).toBe('history');
 
-      expect(startTransaction).toHaveBeenCalledTimes(2);
-      expect(startTransaction).toHaveBeenLastCalledWith({ name: 'blank', op: 'navigation' });
+      expect(customStartTransaction).toHaveBeenCalledTimes(2);
+      expect(customStartTransaction).toHaveBeenLastCalledWith({ name: 'blank', op: 'navigation' });
     });
 
     it('is not created if startTransactionOnLocationChange is false', () => {
-      defaultRoutingInstrumentation(startTransaction, true, false);
+      defaultRoutingInstrumentation(customStartTransaction, true, false);
       mockChangeHistory({ to: 'here', from: 'there' });
       expect(addInstrumentationHandlerType).toBe('');
 
-      expect(startTransaction).toHaveBeenCalledTimes(1);
+      expect(customStartTransaction).toHaveBeenCalledTimes(1);
     });
 
     it('finishes the last active transaction', () => {
-      defaultRoutingInstrumentation(startTransaction);
+      defaultRoutingInstrumentation(customStartTransaction);
 
       expect(mockFinish).toHaveBeenCalledTimes(0);
       mockChangeHistory({ to: 'here', from: 'there' });
       expect(mockFinish).toHaveBeenCalledTimes(1);
     });
 
     it('will finish active transaction multiple times', () => {
-      defaultRoutingInstrumentation(startTransaction);
+      defaultRoutingInstrumentation(customStartTransaction);
 
       expect(mockFinish).toHaveBeenCalledTimes(0);
       mockChangeHistory({ to: 'here', from: 'there' });
@@ -98,12 +98,12 @@ describe('defaultRoutingInstrumentation', () => {
     });
 
     it('not created if `from` is equal to `to`', () => {
-      defaultRoutingInstrumentation(startTransaction);
+      defaultRoutingInstrumentation(customStartTransaction);
       mockChangeHistory({ to: 'first/path', from: 'first/path' });
       expect(addInstrumentationHandlerType).toBe('history');
 
-      expect(startTransaction).toHaveBeenCalledTimes(1);
-      expect(startTransaction).not.toHaveBeenLastCalledWith('navigation');
+      expect(customStartTransaction).toHaveBeenCalledTimes(1);
+      expect(customStartTransaction).not.toHaveBeenLastCalledWith('navigation');
     });
   });
 });