multiple before finishes

Author: AbhiPrasad

packages/tracing/src/browser/browsertracing.ts

@@ -123,6 +123,8 @@ export class BrowserTracing implements Integration {
 
   private _getCurrentHub?: () => Hub;
 
+  // navigationTransactionInvoker() -> Uses history API NavigationTransaction[]
+
   public constructor(_options?: Partial<BrowserTracingOptions>) {
     this.options = {
       ...this.options,
@@ -156,6 +158,7 @@ export class BrowserTracing implements Integration {
 
     let startingUrl: string | undefined = global.location.href;
 
+    // Could this be the one that changes?
     addInstrumentationHandler({
       callback: ({ to, from }: { to: string; from?: string }) => {
         /**

packages/tracing/src/idletransaction.ts

@@ -45,6 +45,8 @@ export class IdleTransactionSpanRecorder extends SpanRecorder {
   }
 }
 
+export type BeforeFinishCallback = (transactionSpan: IdleTransaction) => void;
+
 /**
  * An IdleTransaction is a transaction that automatically finishes. It does this by tracking child spans as activities.
  * You can have multiple IdleTransactions active, but if the `onScope` option is specified, the idle transaction will
@@ -66,7 +68,7 @@ export class IdleTransaction extends Transaction {
   // We should not use heartbeat if we finished a transaction
   private _finished: boolean = false;
 
-  private _finishCallback?: (transactionSpan: IdleTransaction) => void;
+  private readonly _beforeFinishCallbacks: BeforeFinishCallback[] = [];
 
   public constructor(
     transactionContext: TransactionContext,
@@ -142,8 +144,8 @@ export class IdleTransaction extends Transaction {
     if (this.spanRecorder) {
       logger.log('[Tracing] finishing IdleTransaction', new Date(endTimestamp * 1000).toISOString(), this.op);
 
-      if (this._finishCallback) {
-        this._finishCallback(this);
+      for (const callback of this._beforeFinishCallbacks) {
+        callback(this);
       }
 
       this.spanRecorder.spans = this.spanRecorder.spans.filter((span: Span) => {
@@ -224,8 +226,8 @@ export class IdleTransaction extends Transaction {
    * This is exposed because users have no other way of running something before an idle transaction
    * finishes.
    */
-  public beforeFinish(callback: (transactionSpan: IdleTransaction) => void): void {
-    this._finishCallback = callback;
+  public registerBeforeFinishCallback(callback: BeforeFinishCallback): void {
+    this._beforeFinishCallbacks.push(callback);
   }
 
   /**

packages/tracing/test/hub.test.ts

@@ -57,4 +57,5 @@ describe('Hub', () => {
         expect(child.sampled).toBeFalsy();
       });
     });
+  });
 });

packages/tracing/test/idletransaction.test.ts

@@ -95,19 +95,24 @@ describe('IdleTransaction', () => {
   });
 
   it('calls beforeFinish callback before finishing', () => {
-    const mockCallback = jest.fn();
+    const mockCallback1 = jest.fn();
+    const mockCallback2 = jest.fn();
     const transaction = new IdleTransaction({ name: 'foo' }, hub, 1000);
     transaction.initSpanRecorder(10);
-    transaction.beforeFinish(mockCallback);
+    transaction.registerBeforeFinishCallback(mockCallback1);
+    transaction.registerBeforeFinishCallback(mockCallback2);
 
-    expect(mockCallback).toHaveBeenCalledTimes(0);
+    expect(mockCallback1).toHaveBeenCalledTimes(0);
+    expect(mockCallback2).toHaveBeenCalledTimes(0);
 
     const span = transaction.startChild();
     span.finish();
 
     jest.runOnlyPendingTimers();
-    expect(mockCallback).toHaveBeenCalledTimes(1);
-    expect(mockCallback).toHaveBeenLastCalledWith(transaction);
+    expect(mockCallback1).toHaveBeenCalledTimes(1);
+    expect(mockCallback1).toHaveBeenLastCalledWith(transaction);
+    expect(mockCallback2).toHaveBeenCalledTimes(1);
+    expect(mockCallback2).toHaveBeenLastCalledWith(transaction);
   });
 
   it('filters spans on finish', () => {