Client dispose

packages/browser/src/BacktraceClient.ts

@@ -15,6 +15,8 @@ import { BacktraceConfiguration } from './BacktraceConfiguration';
 import { BacktraceClientBuilder } from './builder/BacktraceClientBuilder';
 
 export class BacktraceClient extends BacktraceCoreClient {
+    private readonly _disposeController: AbortController = new AbortController();
+
     protected static _instance?: BacktraceClient;
     constructor(
         options: BacktraceConfiguration,
@@ -72,32 +74,53 @@ export class BacktraceClient extends BacktraceCoreClient {
         return this._instance;
     }
 
+    /**
+     * Disposes the client and all client callbacks
+     */
+    public dispose(): void {
+        this._disposeController.abort();
+        super.dispose();
+        BacktraceClient._instance = undefined;
+    }
+
     private captureUnhandledErrors(captureUnhandledExceptions = true, captureUnhandledRejections = true) {
         if (captureUnhandledExceptions) {
-            window.addEventListener('error', async (errorEvent: ErrorEvent) => {
-                await this.send(
-                    new BacktraceReport(errorEvent.error, {
-                        'error.type': 'Unhandled exception',
-                    }),
-                );
-            });
+            window.addEventListener(
+                'error',
+                async (errorEvent: ErrorEvent) => {
+                    await this.send(
+                        new BacktraceReport(errorEvent.error, {
+                            'error.type': 'Unhandled exception',
+                        }),
+                    );
+                },
+                {
+                    signal: this._disposeController.signal,
+                },
+            );
         }
 
         if (captureUnhandledRejections) {
-            window.addEventListener('unhandledrejection', async (errorEvent: PromiseRejectionEvent) => {
-                await this.send(
-                    new BacktraceReport(
-                        errorEvent.reason,
-                        {
-                            'error.type': 'Unhandled exception',
-                        },
-                        [],
-                        {
-                            classifiers: ['UnhandledPromiseRejection'],
-                        },
-                    ),
-                );
-            });
+            window.addEventListener(
+                'unhandledrejection',
+                async (errorEvent: PromiseRejectionEvent) => {
+                    await this.send(
+                        new BacktraceReport(
+                            errorEvent.reason,
+                            {
+                                'error.type': 'Unhandled exception',
+                            },
+                            [],
+                            {
+                                classifiers: ['UnhandledPromiseRejection'],
+                            },
+                        ),
+                    );
+                },
+                {
+                    signal: this._disposeController.signal,
+                },
+            );
         }
     }
 }

packages/node/src/BacktraceClient.ts

@@ -19,6 +19,8 @@ import { NodeDiagnosticReportConverter } from './converter/NodeDiagnosticReportC
 import { BacktraceDatabaseFileStorageProvider } from './database/BacktraceDatabaseFileStorageProvider';
 
 export class BacktraceClient extends BacktraceCoreClient {
+    private _listeners: Record<string, NodeJS.UnhandledRejectionListener | NodeJS.UncaughtExceptionListener> = {};
+
     private static _instance?: BacktraceClient;
     constructor(
         options: CoreConfiguration,
@@ -77,6 +79,18 @@ export class BacktraceClient extends BacktraceCoreClient {
         return this._instance;
     }
 
+    /**
+     * Disposes the client and all client callbacks
+     */
+    public dispose(): void {
+        for (const [name, listener] of Object.entries(this._listeners)) {
+            process.removeListener(name, listener);
+        }
+
+        super.dispose();
+        BacktraceClient._instance = undefined;
+    }
+
     private captureUnhandledErrors(captureUnhandledExceptions = true, captureUnhandledRejections = true) {
         if (!captureUnhandledExceptions && !captureUnhandledRejections) {
             return;
@@ -97,7 +111,7 @@ export class BacktraceClient extends BacktraceCoreClient {
         };
 
         process.prependListener('uncaughtExceptionMonitor', captureUncaughtException);
-
+        this._listeners['uncaughtExceptionMonitor'] = captureUncaughtException;
         if (!captureUnhandledRejections) {
             return;
         }
@@ -180,6 +194,7 @@ export class BacktraceClient extends BacktraceCoreClient {
             process.emitWarning(warning);
         };
         process.prependListener('unhandledRejection', captureUnhandledRejectionsCallback);
+        this._listeners['unhandledRejection'] = captureUnhandledRejectionsCallback;
     }
 
     private captureNodeCrashes() {

packages/node/tests/client/disposeTests.spec.ts

@@ -0,0 +1,23 @@
+import { BacktraceClient } from '../../src/';
+describe('Client Dispose tests', () => {
+    it('Should dispose process callbacks', () => {
+        const expectedUnhandledRejectionListenerCount = process.listenerCount('unhandledRejection');
+        const expectedUncaughtExceptionListenerCount = process.listenerCount('uncaughtExceptionMonitor');
+        const client = BacktraceClient.initialize({
+            url: 'https://submit.backtrace.io/foo/bar/baz',
+            metrics: {
+                enable: false,
+            },
+            breadcrumbs: {
+                enable: false,
+            },
+        });
+
+        expect(
+            process.listenerCount('unhandledRejection') + process.listenerCount('uncaughtExceptionMonitor'),
+        ).toBeGreaterThan(expectedUnhandledRejectionListenerCount + expectedUncaughtExceptionListenerCount);
+        client.dispose();
+        expect(process.listenerCount('unhandledRejection')).toBe(expectedUnhandledRejectionListenerCount);
+        expect(process.listenerCount('uncaughtExceptionMonitor')).toBe(expectedUncaughtExceptionListenerCount);
+    });
+});

packages/sdk-core/src/BacktraceCoreClient.ts

@@ -22,6 +22,13 @@ import { MetricsBuilder } from './modules/metrics/MetricsBuilder';
 import { SingleSessionProvider } from './modules/metrics/SingleSessionProvider';
 import { RateLimitWatcher } from './modules/rateLimiter/RateLimitWatcher';
 export abstract class BacktraceCoreClient {
+    /**
+     * Determines if the client is enabled.
+     */
+    public get enabled() {
+        return this._enabled;
+    }
+
     /**
      * Current session id
      */
@@ -87,6 +94,8 @@ export abstract class BacktraceCoreClient {
     private readonly _sdkOptions: SdkOptions;
     protected readonly options: BacktraceConfiguration;
 
+    private _enabled = false;
+
     protected constructor(private readonly _setup: CoreClientSetup) {
         this.options = _setup.options;
         this._sdkOptions = _setup.sdkOptions;
@@ -140,6 +149,7 @@ export abstract class BacktraceCoreClient {
         }
 
         this.initialize();
+        this._enabled = true;
     }
 
     /**
@@ -182,6 +192,9 @@ export abstract class BacktraceCoreClient {
         reportAttributes: Record<string, unknown> = {},
         reportAttachments: BacktraceAttachment[] = [],
     ): Promise<void> {
+        if (!this._enabled) {
+            return;
+        }
         if (this._rateLimitWatcher.skipReport()) {
             return;
         }
@@ -215,6 +228,16 @@ export abstract class BacktraceCoreClient {
         }
     }
 
+    /**
+     * Disposes the client and all client callbacks
+     */
+    public dispose() {
+        this._enabled = false;
+        this.database?.dispose();
+        this.breadcrumbsManager?.dispose();
+        this._metrics?.dispose();
+    }
+
     private addToDatabase(
         data: BacktraceData,
         attachments: BacktraceAttachment[],

packages/sdk-core/src/modules/metrics/BacktraceMetrics.ts

@@ -96,7 +96,7 @@ export class BacktraceMetrics {
     /**
      * Cleans up metrics interface.
      */
-    public close() {
+    public dispose() {
         if (this._updateIntervalId) {
             clearInterval(this._updateIntervalId);
         }