react-native: add and use factory for FileBreadcrumbsStorage and pass size limitations to AlternatingFileWriter

Author: perf2711

packages/react-native/src/BacktraceClient.ts

@@ -10,15 +10,15 @@ import {
 } from '@backtrace/sdk-core';
 import { NativeModules, Platform } from 'react-native';
 import { type BacktraceConfiguration } from './BacktraceConfiguration';
+import { ReactNativeRequestHandler } from './ReactNativeRequestHandler';
+import { ReactStackTraceConverter } from './ReactStackTraceConverter';
 import { FileBreadcrumbsStorage } from './breadcrumbs/FileBreadcrumbsStorage';
 import { BacktraceClientBuilder } from './builder/BacktraceClientBuilder';
 import type { BacktraceClientSetup } from './builder/BacktraceClientSetup';
 import { version } from './common/platformHelper';
 import { CrashReporter } from './crashReporter/CrashReporter';
 import { generateUnhandledExceptionHandler } from './handlers';
 import { type ExceptionHandler } from './handlers/ExceptionHandler';
-import { ReactNativeRequestHandler } from './ReactNativeRequestHandler';
-import { ReactStackTraceConverter } from './ReactStackTraceConverter';
 import { type FileSystem } from './storage/FileSystem';
 
 export class BacktraceClient extends BacktraceCoreClient<BacktraceConfiguration> {
@@ -55,13 +55,7 @@ export class BacktraceClient extends BacktraceCoreClient<BacktraceConfiguration>
 
         const breadcrumbsManager = this.modules.get(BreadcrumbsManager);
         if (breadcrumbsManager && this.sessionFiles) {
-            breadcrumbsManager.setStorage(
-                FileBreadcrumbsStorage.create(
-                    fileSystem,
-                    this.sessionFiles,
-                    clientSetup.options.breadcrumbs?.maximumBreadcrumbs ?? 100,
-                ),
-            );
+            breadcrumbsManager.setStorage(FileBreadcrumbsStorage.factory(fileSystem, this.sessionFiles));
         }
 
         this.attributeManager.attributeEvents.on(

packages/react-native/src/attachment/BacktraceFileAttachment.ts

@@ -2,7 +2,7 @@ import { type BacktraceFileAttachment as CoreBacktraceFileAttachment } from '@ba
 import { Platform } from 'react-native';
 import { type FileSystem } from '../storage/';
 import { type FileLocation } from '../types/FileLocation';
-export class BacktraceFileAttachment implements CoreBacktraceFileAttachment {
+export class BacktraceFileAttachment implements CoreBacktraceFileAttachment<FileLocation> {
     public readonly name: string;
     public readonly mimeType: string;
 
@@ -18,7 +18,7 @@ export class BacktraceFileAttachment implements CoreBacktraceFileAttachment {
         this._uploadUri = Platform.OS === 'android' ? `file://${this.filePath}` : this.filePath;
     }
 
-    public get(): FileLocation | string | undefined {
+    public get(): FileLocation | undefined {
         const exists = this._fileSystemProvider.existsSync(this.filePath);
 
         if (!exists) {

packages/react-native/src/breadcrumbs/FileBreadcrumbsStorage.ts

@@ -1,16 +1,19 @@
 import {
     BreadcrumbLogLevel,
     BreadcrumbType,
-    jsonEscaper,
     SessionFiles,
     TimeHelper,
+    jsonEscaper,
     type BacktraceAttachment,
     type Breadcrumb,
     type BreadcrumbsStorage,
+    type BreadcrumbsStorageFactory,
+    type BreadcrumbsStorageLimits,
     type RawBreadcrumb,
 } from '@backtrace/sdk-core';
 import { BacktraceFileAttachment } from '..';
 import { type FileSystem } from '../storage';
+import type { FileLocation } from '../types/FileLocation';
 import { AlternatingFileWriter } from './AlternatingFileWriter';
 
 const FILE_PREFIX = 'bt-breadcrumbs';
@@ -27,23 +30,26 @@ export class FileBreadcrumbsStorage implements BreadcrumbsStorage {
         private readonly _fileSystem: FileSystem,
         private readonly _mainFile: string,
         private readonly _fallbackFile: string,
-        maximumBreadcrumbs: number,
+        private readonly _limits: BreadcrumbsStorageLimits,
     ) {
         this._writer = new AlternatingFileWriter(
+            _fileSystem,
             _mainFile,
             _fallbackFile,
-            Math.floor(maximumBreadcrumbs / 2),
-            _fileSystem,
+            Math.floor((this._limits.maximumBreadcrumbs ?? 100) / 2),
+            this._limits.maximumTotalBreadcrumbsSize,
         );
     }
 
-    public static create(fileSystem: FileSystem, session: SessionFiles, maximumBreadcrumbs: number) {
-        const file1 = session.getFileName(this.getFileName(0));
-        const file2 = session.getFileName(this.getFileName(1));
-        return new FileBreadcrumbsStorage(fileSystem, file1, file2, maximumBreadcrumbs);
+    public static factory(fileSystem: FileSystem, session: SessionFiles): BreadcrumbsStorageFactory {
+        return ({ limits }) => {
+            const file1 = session.getFileName(this.getFileName(0));
+            const file2 = session.getFileName(this.getFileName(1));
+            return new FileBreadcrumbsStorage(fileSystem, file1, file2, limits);
+        };
     }
 
-    public getAttachments(): BacktraceAttachment<unknown>[] {
+    public getAttachments(): [BacktraceAttachment<FileLocation>, BacktraceAttachment<FileLocation>] {
         return [
             new BacktraceFileAttachment(this._fileSystem, this._mainFile, 'bt-breadcrumbs-0'),
             new BacktraceFileAttachment(this._fileSystem, this._fallbackFile, 'bt-breadcrumbs-1'),
@@ -73,6 +79,14 @@ export class FileBreadcrumbsStorage implements BreadcrumbsStorage {
         };
 
         const breadcrumbJson = JSON.stringify(breadcrumb, jsonEscaper());
+        const jsonLength = breadcrumbJson.length + 1; // newline
+        const sizeLimit = this._limits.maximumTotalBreadcrumbsSize;
+        if (sizeLimit !== undefined) {
+            if (jsonLength > sizeLimit) {
+                return id;
+            }
+        }
+
         this._writer.writeLine(breadcrumbJson);
 
         return id;

packages/react-native/tests/_mocks/fileSystem.ts

@@ -0,0 +1,66 @@
+import { MockedFileSystem, mockFileSystem } from '@backtrace/sdk-core/tests/_mocks/fileSystem';
+import { randomUUID } from 'crypto';
+import path from 'path';
+import { StreamWriter } from '../../src';
+import { FileSystem } from '../../src/storage/FileSystem';
+
+function mockStreamWriter(files: Record<string, string>): StreamWriter {
+    const streams = new Map<string, string>();
+    return {
+        create(source) {
+            const id = randomUUID();
+            const fullPath = path.resolve(source);
+            streams.set(id, fullPath);
+            files[fullPath] = '';
+            return id;
+        },
+        append(key, content) {
+            const source = streams.get(key);
+            if (!source) {
+                return Promise.resolve(false);
+            }
+            files[source] += content;
+            return Promise.resolve(true);
+        },
+        close(key) {
+            const source = streams.get(key);
+            if (!source) {
+                return false;
+            }
+
+            streams.delete(key);
+            return true;
+        },
+    };
+}
+
+export function mockReactFileSystem(files?: Record<string, string>): MockedFileSystem<FileSystem> {
+    const fs = mockFileSystem(files);
+
+    return {
+        ...fs,
+
+        copy: jest.fn().mockImplementation((sourceFile: string, destinationFile: string) => {
+            const src = fs.files[path.resolve(sourceFile)];
+            if (!src) {
+                return Promise.resolve(false);
+            }
+
+            fs.files[path.resolve(destinationFile)] = src;
+            return Promise.resolve(true);
+        }),
+
+        copySync: jest.fn().mockImplementation((sourceFile: string, destinationFile: string) => {
+            const src = fs.files[path.resolve(sourceFile)];
+            if (!src) {
+                return false;
+            }
+
+            fs.files[path.resolve(destinationFile)] = src;
+            return true;
+        }),
+
+        applicationDirectory: jest.fn().mockReturnValue(path.resolve('.')),
+        streamWriter: mockStreamWriter(fs.files),
+    };
+}