sdk-core: add BacktraceAttachmentProvider

Author: perf2711

packages/sdk-core/src/BacktraceCoreClient.ts

@@ -259,8 +259,10 @@ export abstract class BacktraceCoreClient<O extends BacktraceConfiguration = Bac
      * Add attachment to the client
      * @param attachment attachment
      */
-    public addAttachment(attachment: BacktraceAttachment): void {
-        this.attachmentManager.add(attachment);
+    public addAttachment(...attachments: BacktraceAttachment[]): void;
+    public addAttachment(...attachments: Array<() => BacktraceAttachment>): void;
+    public addAttachment(...attachments: Array<BacktraceAttachment | (() => BacktraceAttachment)>): void {
+        this.attachmentManager.add(...attachments);
     }
 
     /**

packages/sdk-core/src/events/AttachmentEvents.ts

@@ -1,5 +1,5 @@
 import { BacktraceAttachment } from '../model/attachment';
 
 export type AttachmentEvents = {
-    'attachments-updated'(attachments: BacktraceAttachment[]): void;
+    'scoped-attachments-updated'(attachments: BacktraceAttachment[]): void;
 };

packages/sdk-core/src/modules/attachments/AttachmentManager.ts

@@ -1,22 +1,62 @@
 import { Events } from '../../common/Events';
 import { AttachmentEvents } from '../../events/AttachmentEvents';
 import { BacktraceAttachment } from '../../model/attachment';
+import { BacktraceAttachmentProvider } from './BacktraceAttachmentProvider';
 
 export class AttachmentManager {
     public readonly attachmentEvents: Events<AttachmentEvents>;
 
-    private readonly _attachments: BacktraceAttachment[] = [];
+    private readonly _attachmentProviders: BacktraceAttachmentProvider[] = [];
 
     constructor() {
         this.attachmentEvents = new Events();
     }
 
-    public add(...attachments: BacktraceAttachment[]) {
-        this._attachments.push(...attachments);
-        this.attachmentEvents.emit('attachments-updated', this.get());
+    public add(...attachments: Array<BacktraceAttachment | (() => BacktraceAttachment)>) {
+        this.addProviders(
+            ...attachments.map<BacktraceAttachmentProvider>((a) =>
+                typeof a === 'function'
+                    ? {
+                          type: 'dynamic',
+                          get: a,
+                      }
+                    : {
+                          type: 'scoped',
+                          get: () => a,
+                      },
+            ),
+        );
     }
 
-    public get(): BacktraceAttachment[] {
-        return [...this._attachments];
+    public addProviders(...attachmentProviders: BacktraceAttachmentProvider[]) {
+        let anyScoped = false;
+        for (const provider of attachmentProviders) {
+            if (provider.type === 'dynamic') {
+                this._attachmentProviders.push(provider);
+            } else {
+                const attachment = provider.get();
+                this._attachmentProviders.push({
+                    type: 'scoped',
+                    get: () => attachment,
+                });
+                anyScoped = true;
+            }
+        }
+
+        if (anyScoped) {
+            this.attachmentEvents.emit('scoped-attachments-updated', this.get('scoped'));
+        }
+    }
+
+    public get(type?: 'scoped' | 'dynamic'): BacktraceAttachment[] {
+        const result: BacktraceAttachment[] = [];
+        for (const provider of this._attachmentProviders) {
+            if (type && provider.type !== type) {
+                continue;
+            }
+
+            result.push(provider.get());
+        }
+        return result;
     }
 }

packages/sdk-core/src/modules/attachments/BacktraceAttachmentProvider.ts

@@ -0,0 +1,17 @@
+import { BacktraceAttachment } from '../../model/attachment';
+
+export interface BacktraceAttachmentProvider {
+    /**
+     * Return attachment provider type. Based on the type, attachment provider is being invoked
+     * once or per every report.
+     * - scoped: means the attachment provider will be invoked only once just after adding the
+     *  provider to the client.
+     * - dynamic: means the attachment provider will be invoked every time before the report data generation
+     */
+    get type(): 'scoped' | 'dynamic';
+
+    /**
+     * Generate provider attributes
+     */
+    get(): BacktraceAttachment;
+}

packages/sdk-core/src/modules/breadcrumbs/BreadcrumbsManager.ts

@@ -66,10 +66,13 @@ export class BreadcrumbsManager implements BacktraceBreadcrumbs, BacktraceModule
         }
     }
 
-    public bind({ client, reportEvents }: BacktraceModuleBindData): void {
-        for (const attachment of this._storage.getAttachments()) {
-            client.addAttachment(attachment);
+    public bind({ client, reportEvents, attachmentManager }: BacktraceModuleBindData): void {
+        if (this._storage.getAttachmentProviders) {
+            attachmentManager.addProviders(...this._storage.getAttachmentProviders());
+        } else {
+            attachmentManager.add(...this._storage.getAttachments());
         }
+
         client.addAttribute(() => ({
             [BREADCRUMB_ATTRIBUTE_NAME]: this._storage.lastBreadcrumbId,
         }));