ref(tracing): Use new addInstrumentationHandler

Author: AbhiPrasad

packages/tracing/src/browser/request.ts

@@ -118,20 +118,14 @@ export function instrumentOutgoingRequests(_options?: Partial<RequestInstrumenta
   const spans: Record<string, Span> = {};
 
   if (traceFetch) {
-    addInstrumentationHandler({
-      callback: (handlerData: FetchData) => {
-        fetchCallback(handlerData, shouldCreateSpan, spans);
-      },
-      type: 'fetch',
+    addInstrumentationHandler('fetch', (handlerData: FetchData) => {
+      fetchCallback(handlerData, shouldCreateSpan, spans);
     });
   }
 
   if (traceXHR) {
-    addInstrumentationHandler({
-      callback: (handlerData: XHRData) => {
-        xhrCallback(handlerData, shouldCreateSpan, spans);
-      },
-      type: 'xhr',
+    addInstrumentationHandler('xhr', (handlerData: XHRData) => {
+      xhrCallback(handlerData, shouldCreateSpan, spans);
     });
   }
 }

packages/tracing/src/browser/router.ts

@@ -24,33 +24,30 @@ export function instrumentRoutingWithDefaults<T extends Transaction>(
   }
 
   if (startTransactionOnLocationChange) {
-    addInstrumentationHandler({
-      callback: ({ to, from }: { to: string; from?: string }) => {
-        /**
-         * This early return is there to account for some cases where a navigation transaction starts right after
-         * long-running pageload. We make sure that if `from` is undefined and a valid `startingURL` exists, we don't
-         * create an uneccessary navigation transaction.
-         *
-         * This was hard to duplicate, but this behavior stopped as soon as this fix was applied. This issue might also
-         * only be caused in certain development environments where the usage of a hot module reloader is causing
-         * errors.
-         */
-        if (from === undefined && startingUrl && startingUrl.indexOf(to) !== -1) {
-          startingUrl = undefined;
-          return;
-        }
+    addInstrumentationHandler('history', ({ to, from }: { to: string; from?: string }) => {
+      /**
+       * This early return is there to account for some cases where a navigation transaction starts right after
+       * long-running pageload. We make sure that if `from` is undefined and a valid `startingURL` exists, we don't
+       * create an uneccessary navigation transaction.
+       *
+       * This was hard to duplicate, but this behavior stopped as soon as this fix was applied. This issue might also
+       * only be caused in certain development environments where the usage of a hot module reloader is causing
+       * errors.
+       */
+      if (from === undefined && startingUrl && startingUrl.indexOf(to) !== -1) {
+        startingUrl = undefined;
+        return;
+      }
 
-        if (from !== to) {
-          startingUrl = undefined;
-          if (activeTransaction) {
-            logger.log(`[Tracing] Finishing current transaction with op: ${activeTransaction.op}`);
-            // If there's an open transaction on the scope, we need to finish it before creating an new one.
-            activeTransaction.finish();
-          }
-          activeTransaction = customStartTransaction({ name: global.location.pathname, op: 'navigation' });
+      if (from !== to) {
+        startingUrl = undefined;
+        if (activeTransaction) {
+          logger.log(`[Tracing] Finishing current transaction with op: ${activeTransaction.op}`);
+          // If there's an open transaction on the scope, we need to finish it before creating an new one.
+          activeTransaction.finish();
         }
-      },
-      type: 'history',
+        activeTransaction = customStartTransaction({ name: global.location.pathname, op: 'navigation' });
+      }
     });
   }
 }

packages/tracing/src/errors.ts

@@ -7,14 +7,8 @@ import { getActiveTransaction } from './utils';
  * Configures global error listeners
  */
 export function registerErrorInstrumentation(): void {
-  addInstrumentationHandler({
-    callback: errorCallback,
-    type: 'error',
-  });
-  addInstrumentationHandler({
-    callback: errorCallback,
-    type: 'unhandledrejection',
-  });
+  addInstrumentationHandler('error', errorCallback);
+  addInstrumentationHandler('unhandledrejection', errorCallback);
 }
 
 /**