react-native: add size limitation to AlternatingFileWriter

Author: perf2711

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

@@ -4,6 +4,7 @@ import { type StreamWriter } from '../storage/StreamWriter';
 export class AlternatingFileWriter {
     private _streamId?: string;
     private _count = 0;
+    private _size = 0;
     private _disposed = false;
 
     private readonly _streamWriter: StreamWriter;
@@ -13,12 +14,13 @@ export class AlternatingFileWriter {
     private _currentAppendedLog?: string;
 
     constructor(
+        private readonly _fileSystem: FileSystem,
         private readonly _mainFile: string,
         private readonly _fallbackFile: string,
-        private readonly _fileCapacity: number,
-        private readonly _fileSystem: FileSystem,
+        private readonly _maxLines: number,
+        private readonly _maxSize?: number,
     ) {
-        if (this._fileCapacity <= 0) {
+        if (this._maxLines <= 0) {
             throw new Error('File capacity may not be less or equal to 0.');
         }
         this._streamWriter = this._fileSystem.streamWriter;
@@ -42,7 +44,8 @@ export class AlternatingFileWriter {
             return;
         }
 
-        this.prepareBreadcrumbStream();
+        const appendLength = this._currentAppendedLog.length + 1;
+        this.prepareBreadcrumbStream(appendLength);
 
         if (!this._streamId) {
             this._logQueue.unshift(this._currentAppendedLog);
@@ -53,10 +56,39 @@ export class AlternatingFileWriter {
         // if the queue is full and we can save more item in a batch
         // try to save as much as possible to speed up potential native operations
         this._count += 1;
+        this._size += appendLength;
+
         const logsToAppend = [this._currentAppendedLog];
 
-        const restAppendingLogs = this._logQueue.splice(0, this._fileCapacity - this._count);
+        let logsToTake = 0;
+        let currentCount = this._count;
+        let currentSize = this._size;
+
+        for (let i = 0; i < this._logQueue.length; i++) {
+            const log = this._logQueue[i];
+            if (!log) {
+                continue;
+            }
+
+            const logLength = log.length + 1;
+
+            if (currentCount + 1 > this._maxLines) {
+                break;
+            }
+
+            if (this._maxSize && currentSize + logLength >= this._maxSize) {
+                break;
+            }
+
+            logsToTake++;
+            currentCount++;
+            currentSize += logLength;
+        }
+
+        const restAppendingLogs = this._logQueue.splice(0, logsToTake);
         this._count = this._count + restAppendingLogs.length;
+        this._size += restAppendingLogs.reduce((sum, l) => sum + l.length + 1, 0);
+
         logsToAppend.push(...restAppendingLogs);
 
         this._streamWriter
@@ -76,24 +108,32 @@ export class AlternatingFileWriter {
             });
     }
 
-    private prepareBreadcrumbStream() {
+    private prepareBreadcrumbStream(newSize: number) {
         if (!this._streamId) {
             this._streamId = this._streamWriter.create(this._mainFile);
-        } else if (this._count >= this._fileCapacity) {
+        } else if (this._count >= this._maxLines || (this._maxSize && this._size + newSize >= this._maxSize)) {
+            this.switchFile();
+        }
+    }
+
+    private switchFile() {
+        if (this._streamId) {
             const closeResult = this._streamWriter.close(this._streamId);
             if (!closeResult) {
                 return;
             }
-            this._streamId = undefined;
+        }
 
-            const renameResult = this._fileSystem.copySync(this._mainFile, this._fallbackFile);
-            if (!renameResult) {
-                return;
-            }
-            this._streamId = this._streamWriter.create(this._mainFile);
+        this._streamId = undefined;
 
-            this._count = 0;
+        const renameResult = this._fileSystem.copySync(this._mainFile, this._fallbackFile);
+        if (!renameResult) {
+            return;
         }
+        this._streamId = this._streamWriter.create(this._mainFile);
+
+        this._count = 0;
+        this._size = 0;
     }
 
     public dispose() {