@protontech/drive-sdk 0.9.0 → 0.9.1

package/src/internal/download/seekableStream.test.ts

@@ -1,4 +1,4 @@
-import { SeekableReadableStream, BufferedSeekableStream } from './seekableStream';
+import { SeekableReadableStream, BufferedSeekableStream, UnderlyingSeekableSource } from './seekableStream';
 
 describe('SeekableReadableStream', () => {
     it('should call the seek callback when seek is called', async () => {
@@ -32,6 +32,7 @@ describe('SeekableReadableStream', () => {
 describe('BufferedSeekableStream', () => {
     let startWithCloseMock: jest.Mock;
     let pullMock: jest.Mock;
+    let seekableSource: UnderlyingSeekableSource;
 
     const data1 = new Uint8Array([1, 2, 3, 4, 5]);
     const data2 = new Uint8Array([6, 7, 8, 9, 10]);
@@ -53,6 +54,26 @@ describe('BufferedSeekableStream', () => {
             }
             readIndex++;
         });
+
+        // Simulates a real seekable source where seek repositions the read pointer
+        const fileData = new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]);
+        let readPosition = 0;
+        const chunkSize = 5;
+
+        seekableSource = {
+            pull: jest.fn().mockImplementation((controller) => {
+                if (readPosition >= fileData.length) {
+                    controller.close();
+                    return;
+                }
+                const chunk = fileData.slice(readPosition, readPosition + chunkSize);
+                readPosition += chunk.length;
+                controller.enqueue(chunk);
+            }),
+            seek: jest.fn().mockImplementation((position: number) => {
+                readPosition = position;
+            }),
+        };
     });
 
     it('should throw error if highWaterMark is not 0', () => {
@@ -184,4 +205,108 @@ describe('BufferedSeekableStream', () => {
         const result4 = await stream.read(2);
         expect(result4).toEqual({ value: new Uint8Array([10]), done: true });
     });
+
+    it('should catch and ignore TypeError from releaseLock during seek', async () => {
+        const stream = new BufferedSeekableStream({
+            pull: pullMock,
+            seek: jest.fn(),
+        });
+
+        await stream.read(2);
+
+        const reader = (stream as any).reader;
+        const originalReleaseLock = reader.releaseLock.bind(reader);
+        jest.spyOn(reader, 'releaseLock').mockImplementation(() => {
+            originalReleaseLock();
+            throw new TypeError('Reader has pending read requests');
+        });
+
+        await expect(stream.seek(0)).resolves.not.toThrow();
+    });
+
+    it('should re-throw non-TypeError errors from releaseLock during seek', async () => {
+        const stream = new BufferedSeekableStream({
+            pull: pullMock,
+            seek: jest.fn(),
+        });
+
+        await stream.read(2);
+
+        const reader = (stream as any).reader;
+        const customError = new Error('Custom error');
+        jest.spyOn(reader, 'releaseLock').mockImplementation(() => {
+            throw customError;
+        });
+
+        await expect(stream.seek(0)).rejects.toThrow(customError);
+    });
+
+    it('should not call underlying seek when seeking within buffer range', async () => {
+        const seekMock = jest.fn();
+        const stream = new BufferedSeekableStream({
+            pull: pullMock,
+            seek: seekMock,
+        });
+
+        await stream.read(2);
+        expect(seekMock).not.toHaveBeenCalled();
+
+        // Seek within buffer range (buffer has bytes for positions 2-4)
+        await stream.seek(3);
+        expect(seekMock).not.toHaveBeenCalled();
+
+        // Seek to current position (still within buffer)
+        await stream.seek(3);
+        expect(seekMock).not.toHaveBeenCalled();
+    });
+
+    it('should not corrupt data when seeking to current position with seekable underlying source', async () => {
+        const stream = new BufferedSeekableStream(seekableSource);
+
+        // Read first 3 bytes [0, 1, 2], buffer will have [0, 1, 2, 3, 4]
+        const result1 = await stream.read(3);
+        expect(result1.value).toEqual(new Uint8Array([0, 1, 2]));
+        expect(seekableSource.seek).not.toHaveBeenCalled();
+
+        // Seek to position 3 (current position), should use buffer without seeking underlying source
+        await stream.seek(3);
+        expect(seekableSource.seek).not.toHaveBeenCalled();
+
+        // Buffer has [3, 4], needs 2 more from underlying source
+        // Underlying source stays at position 5, giving [5, 6, 7, 8, 9]
+        // Buffer becomes [3, 4, 5, 6, 7, 8, 9]
+        const result2 = await stream.read(4);
+        expect(result2.value).toEqual(new Uint8Array([3, 4, 5, 6]));
+        expect(seekableSource.seek).not.toHaveBeenCalled();
+
+        // Continue reading to verify stream integrity
+        const result3 = await stream.read(3);
+        expect(result3.value).toEqual(new Uint8Array([7, 8, 9]));
+    });
+
+    it('should call underlying seek only when seeking outside buffer range', async () => {
+        const stream = new BufferedSeekableStream(seekableSource);
+
+        // Read first 3 bytes [0, 1, 2], buffer will have [0, 1, 2, 3, 4]
+        await stream.read(3);
+        expect(seekableSource.seek).not.toHaveBeenCalled();
+
+        // Seek backward (outside buffer range) - should call underlying seek
+        await stream.seek(0);
+        expect(seekableSource.seek).toHaveBeenCalledWith(0);
+        expect(seekableSource.seek).toHaveBeenCalledTimes(1);
+
+        // Read and verify data is correct after backward seek
+        const result1 = await stream.read(3);
+        expect(result1.value).toEqual(new Uint8Array([0, 1, 2]));
+
+        // Seek forward past buffer end - should call underlying seek
+        await stream.seek(10);
+        expect(seekableSource.seek).toHaveBeenCalledWith(10);
+        expect(seekableSource.seek).toHaveBeenCalledTimes(2);
+
+        // Read and verify data is correct after forward seek
+        const result2 = await stream.read(3);
+        expect(result2.value).toEqual(new Uint8Array([10, 11, 12]));
+    });
 });

package/src/internal/download/seekableStream.ts

@@ -1,4 +1,4 @@
-interface UnderlyingSeekableSource extends UnderlyingDefaultSource<Uint8Array> {
+export interface UnderlyingSeekableSource extends UnderlyingDefaultSource<Uint8Array> {
     seek: (position: number) => void | Promise<void>;
 }
 
@@ -22,7 +22,10 @@ interface UnderlyingSeekableSource extends UnderlyingDefaultSource<Uint8Array> {
 export class SeekableReadableStream extends ReadableStream<Uint8Array> {
     private seekCallback: (position: number) => void | Promise<void>;
 
-    constructor({ seek, ...underlyingSource }: UnderlyingSeekableSource, queuingStrategy?: QueuingStrategy<Uint8Array>) {
+    constructor(
+        { seek, ...underlyingSource }: UnderlyingSeekableSource,
+        queuingStrategy?: QueuingStrategy<Uint8Array>,
+    ) {
         super(underlyingSource, queuingStrategy);
         this.seekCallback = seek;
     }
@@ -160,23 +163,41 @@ export class BufferedSeekableStream extends SeekableReadableStream {
     async seek(position: number): Promise<void> {
         const endOfBufferPosition = this.currentPosition + (this.buffer.length - this.bufferPosition);
 
-        if (position > endOfBufferPosition) {
-            this.buffer = new Uint8Array(0);
-            this.bufferPosition = 0;
-        } else if (position < this.currentPosition) {
+        if (position > endOfBufferPosition || position < this.currentPosition) {
             this.buffer = new Uint8Array(0);
             this.bufferPosition = 0;
+
+            await super.seek(position);
+
+            if (this.reader) {
+                try {
+                    this.reader.releaseLock();
+                } catch (error) {
+                    // Streams API spec-compliant behavior: releaseLock() only throws TypeError when
+                    // there are pending read requests. This can occur due to timing differences between
+                    // when read() promises resolve on the client side vs when the browser's internal
+                    // stream mechanism fully completes.
+                    //
+                    // This manifests more frequently in Firefox than Chrome due to implementation
+                    // timing differences, but both are following the spec correctly.
+                    //
+                    // References:
+                    // - https://github.com/whatwg/streams/issues/1000
+                    // - https://developer.mozilla.org/en-US/docs/Web/API/ReadableStreamDefaultReader/releaseLock
+                    //
+                    // Safe to ignore since we're acquiring a new reader immediately after.
+                    if (!(error instanceof TypeError)) {
+                        throw error;
+                    }
+                }
+            }
+            this.reader = super.getReader();
+            this.streamClosed = false;
         } else {
+            // Position is within buffer range, just update buffer position.
             this.bufferPosition += position - this.currentPosition;
         }
 
-        await super.seek(position);
-
-        if (this.reader) {
-            this.reader.releaseLock();
-        }
-        this.reader = super.getReader();
-        this.streamClosed = false;
         this.currentPosition = position;
     }
 }

package/src/internal/photos/index.ts

@@ -159,10 +159,10 @@ export function initPhotoUploadModule(
         metadata: PhotoUploadMetadata,
         signal?: AbortSignal,
     ): Promise<PhotoFileUploader> {
-        await queue.waitForCapacity(signal);
+        await queue.waitForCapacity(metadata.expectedSize, signal);
 
         const onFinish = () => {
-            queue.releaseCapacity();
+            queue.releaseCapacity(metadata.expectedSize);
         };
 
         return new PhotoFileUploader(

package/src/internal/upload/index.ts

@@ -45,10 +45,10 @@ export function initUploadModule(
         metadata: UploadMetadata,
         signal?: AbortSignal,
     ): Promise<FileUploader> {
-        await queue.waitForCapacity(signal);
+        await queue.waitForCapacity(metadata.expectedSize, signal);
 
         const onFinish = () => {
-            queue.releaseCapacity();
+            queue.releaseCapacity(metadata.expectedSize);
         };
 
         return new FileUploader(
@@ -76,10 +76,10 @@ export function initUploadModule(
         metadata: UploadMetadata,
         signal?: AbortSignal,
     ): Promise<FileRevisionUploader> {
-        await queue.waitForCapacity(signal);
+        await queue.waitForCapacity(metadata.expectedSize, signal);
 
         const onFinish = () => {
-            queue.releaseCapacity();
+            queue.releaseCapacity(metadata.expectedSize);
         };
 
         return new FileRevisionUploader(

package/src/internal/upload/queue.test.ts

@@ -0,0 +1,130 @@
+import { AbortError } from '../../errors';
+import { UploadQueue } from './queue';
+import { FILE_CHUNK_SIZE } from './streamUploader';
+
+describe('UploadQueue', () => {
+    let queue: UploadQueue;
+
+    beforeEach(() => {
+        queue = new UploadQueue();
+        jest.useFakeTimers();
+    });
+
+    afterEach(() => {
+        jest.useRealTimers();
+    });
+
+    it('should resolve immediately when queue is empty', async () => {
+        const promise = queue.waitForCapacity(0);
+        await promise;
+    });
+
+    it('should resolve immediately when under file upload limit', async () => {
+        // Fill queue with 4 uploads (limit is 5)
+        for (let i = 0; i < 4; i++) {
+            await queue.waitForCapacity(0);
+        }
+
+        const promise = queue.waitForCapacity(0);
+        await promise;
+    });
+
+    it('should wait when max concurrent file uploads is reached', async () => {
+        // Fill queue to max (5 uploads)
+        for (let i = 0; i < 5; i++) {
+            await queue.waitForCapacity(0);
+        }
+
+        let resolved = false;
+        const promise = queue.waitForCapacity(0).then(() => {
+            resolved = true;
+        });
+
+        await jest.advanceTimersByTimeAsync(100);
+        expect(resolved).toBe(false);
+
+        queue.releaseCapacity(0);
+
+        await jest.advanceTimersByTimeAsync(100);
+        await promise;
+        expect(resolved).toBe(true);
+    });
+
+    it('should wait when max concurrent upload size is reached', async () => {
+        // Fill queue with one large file that exceeds size limit
+        const largeSize = 10 * FILE_CHUNK_SIZE;
+        await queue.waitForCapacity(largeSize);
+
+        let resolved = false;
+        const promise = queue.waitForCapacity(0).then(() => {
+            resolved = true;
+        });
+
+        await jest.advanceTimersByTimeAsync(100);
+        expect(resolved).toBe(false);
+
+        queue.releaseCapacity(largeSize);
+
+        await jest.advanceTimersByTimeAsync(100);
+        await promise;
+        expect(resolved).toBe(true);
+    });
+
+    it('should track expected size correctly', async () => {
+        const size1 = 5 * FILE_CHUNK_SIZE;
+        const size2 = 4 * FILE_CHUNK_SIZE;
+
+        await queue.waitForCapacity(size1);
+        await queue.waitForCapacity(size2);
+
+        // Total is 9 * FILE_CHUNK_SIZE, limit is 10 * FILE_CHUNK_SIZE
+        // So next upload should still be allowed immediately
+        const promise = queue.waitForCapacity(3 * FILE_CHUNK_SIZE);
+        await promise;
+
+        // But now we're at limit, next one should wait
+        let resolved = false;
+        const waitingPromise = queue.waitForCapacity(0).then(() => {
+            resolved = true;
+        });
+
+        await jest.advanceTimersByTimeAsync(100);
+        expect(resolved).toBe(false);
+
+        queue.releaseCapacity(size1);
+        await jest.advanceTimersByTimeAsync(100);
+        await waitingPromise;
+        expect(resolved).toBe(true);
+    });
+
+    it('should reject when signal is aborted', async () => {
+        // Fill queue to max
+        for (let i = 0; i < 5; i++) {
+            await queue.waitForCapacity(0);
+        }
+
+        const controller = new AbortController();
+        const promise = queue.waitForCapacity(0, controller.signal);
+
+        controller.abort();
+
+        // Attach rejection handler BEFORE advancing timers to avoid unhandled rejection
+        const expectation = expect(promise).rejects.toThrow(AbortError);
+        await jest.advanceTimersByTimeAsync(50);
+        await expectation;
+    });
+
+    it('should reject immediately if signal is already aborted', async () => {
+        // Fill queue to max
+        for (let i = 0; i < 5; i++) {
+            await queue.waitForCapacity(0);
+        }
+
+        const controller = new AbortController();
+        controller.abort();
+
+        const promise = queue.waitForCapacity(0, controller.signal);
+        await expect(promise).rejects.toThrow(AbortError);
+    });
+});
+

package/src/internal/upload/queue.ts

@@ -1,4 +1,23 @@
 import { waitForCondition } from '../wait';
+import { FILE_CHUNK_SIZE } from './streamUploader';
+
+/**
+ * Maximum number of concurrent file uploads.
+ *
+ * It avoids uploading too many files at the same time. The total file size
+ * below also limits that, but if the file is empty, we still need to make
+ * a reasonable number of requests.
+ */
+const MAX_CONCURRENT_FILE_UPLOADS = 5;
+
+/**
+ * Maximum total file size that can be uploaded concurrently.
+ *
+ * It avoids uploading too many blocks at the same time, ensuring that on poor
+ * connection we don't do too many things at the same time that all fail due
+ * to network issues.
+ */
+const MAX_CONCURRENT_UPLOAD_SIZE = 10 * FILE_CHUNK_SIZE;
 
 /**
  * A queue that limits the number of concurrent uploads.
@@ -14,18 +33,24 @@ import { waitForCondition } from '../wait';
  * uploaded. That is something we want to add in the future to be
  * more performant for many small file uploads.
  */
-const MAX_CONCURRENT_UPLOADS = 5;
-
 export class UploadQueue {
-    private capacity = 0;
+    private totalFileUploads = 0;
+
+    private totalExpectedSize = 0;
 
-    // TODO: use expected size to control the size of the queue
-    async waitForCapacity(signal?: AbortSignal) {
-        await waitForCondition(() => this.capacity < MAX_CONCURRENT_UPLOADS, signal);
-        this.capacity++;
+    async waitForCapacity(expectedSize: number, signal?: AbortSignal) {
+        await waitForCondition(
+            () =>
+                this.totalFileUploads < MAX_CONCURRENT_FILE_UPLOADS &&
+                this.totalExpectedSize < MAX_CONCURRENT_UPLOAD_SIZE,
+            signal,
+        );
+        this.totalFileUploads++;
+        this.totalExpectedSize += expectedSize;
     }
 
-    releaseCapacity() {
-        this.capacity--;
+    releaseCapacity(expectedSize: number) {
+        this.totalFileUploads--;
+        this.totalExpectedSize -= expectedSize;
     }
 }

package/src/internal/upload/streamUploader.test.ts

@@ -1,5 +1,6 @@
-import { Thumbnail, ThumbnailType, UploadMetadata } from '../../interface';
+import { Logger, Thumbnail, ThumbnailType, UploadMetadata } from '../../interface';
 import { IntegrityError } from '../../errors';
+import { getMockLogger } from '../../tests/logger';
 import { APIHTTPError, HTTPErrorCode } from '../apiService';
 import { FILE_CHUNK_SIZE, StreamUploader } from './streamUploader';
 import { UploadTelemetry } from './telemetry';
@@ -40,6 +41,7 @@ function mockUploadBlock(
 }
 
 describe('StreamUploader', () => {
+    let logger: Logger;
     let telemetry: UploadTelemetry;
     let apiService: jest.Mocked<UploadAPIService>;
     let cryptoService: UploadCryptoService;
@@ -54,14 +56,11 @@ describe('StreamUploader', () => {
     let uploader: StreamUploader;
 
     beforeEach(() => {
+        logger = getMockLogger();
+
         // @ts-expect-error No need to implement all methods for mocking
         telemetry = {
-            getLoggerForRevision: jest.fn().mockReturnValue({
-                debug: jest.fn(),
-                info: jest.fn(),
-                warn: jest.fn(),
-                error: jest.fn(),
-            }),
+            getLoggerForRevision: jest.fn().mockReturnValue(logger),
             logBlockVerificationError: jest.fn(),
             uploadFailed: jest.fn(),
             uploadFinished: jest.fn(),
@@ -403,6 +402,80 @@ describe('StreamUploader', () => {
             await verifyOnProgress([1024, 4 * 1024 * 1024, 2 * 1024 * 1024, 4 * 1024 * 1024]);
         });
 
+        it('should handle timeout when uploading block', async () => {
+            const error = new Error('TimeoutError');
+            error.name = 'TimeoutError';
+
+            let count = 0;
+            apiService.uploadBlock = jest.fn().mockImplementation(async function (bareUrl, token, block, onProgress) {
+                if (token === 'token/block:1' && count === 0) {
+                    count++;
+                    throw error;
+                }
+                return mockUploadBlock(bareUrl, token, block, onProgress);
+            });
+
+            expect((uploader as any).maxUploadingBlocks).toEqual(5);
+            await verifySuccess();
+            expect(apiService.requestBlockUpload).toHaveBeenCalledTimes(1);
+            // 3 blocks + 1 timeout retry + 1 thumbnail
+            expect(apiService.uploadBlock).toHaveBeenCalledTimes(5);
+            expect(logger.warn).toHaveBeenCalledTimes(2);
+            expect(logger.warn).toHaveBeenCalledWith(
+                'block 1:token/block:1: Upload timeout, limiting upload capacity to 1 block',
+            );
+            expect(logger.warn).toHaveBeenCalledWith('block 1:token/block:1: Upload timeout, retrying');
+            expect((uploader as any).maxUploadingBlocks).toEqual(1);
+        });
+
+        it('limitUploadCapacity should wait for the previous blocks to finish', async () => {
+            const error = new Error('TimeoutError');
+            error.name = 'TimeoutError';
+
+            const events: string[] = [];
+            let block1Resolver: (() => void) | undefined;
+            let block2FirstAttempt = true;
+
+            apiService.uploadBlock = jest.fn().mockImplementation(async function (bareUrl, token, block, onProgress) {
+                if (token === 'token/block:1') {
+                    events.push('block1:upload:start');
+                    await new Promise<void>((resolve) => {
+                        block1Resolver = resolve;
+                    });
+                    events.push('block1:upload:end');
+                    return mockUploadBlock(bareUrl, token, block, onProgress);
+                }
+                if (token === 'token/block:2') {
+                    if (block2FirstAttempt) {
+                        block2FirstAttempt = false;
+                        events.push('block2:timeout');
+                        // Resolve block 1 after a small delay to simulate real-world conditions
+                        setTimeout(() => block1Resolver?.(), 100);
+                        throw error;
+                    }
+                    events.push('block2:retry');
+                    return mockUploadBlock(bareUrl, token, block, onProgress);
+                }
+                // Block 3 and thumbnails proceed normally
+                return mockUploadBlock(bareUrl, token, block, onProgress);
+            });
+
+            await verifySuccess();
+
+            expect(events).toMatchObject([
+                'block1:upload:start',
+                'block2:timeout',
+                'block1:upload:end',
+                'block2:retry',
+            ]);
+
+            // Also verify the warning messages were logged
+            expect(logger.warn).toHaveBeenCalledWith(
+                'block 2:token/block:2: Upload timeout, limiting upload capacity to 1 block',
+            );
+            expect(logger.warn).toHaveBeenCalledWith('block 2:token/block:2: Upload timeout, retrying');
+        });
+
         it('should handle expired token when uploading block', async () => {
             let count = 0;
             apiService.uploadBlock = jest.fn().mockImplementation(async function (bareUrl, token, block, onProgress) {

package/src/internal/upload/streamUploader.ts

@@ -55,6 +55,8 @@ const MAX_BLOCK_UPLOAD_RETRIES = 3;
  * that the upload process is efficient and does not overload the server.
  */
 export class StreamUploader {
+    protected maxUploadingBlocks = MAX_UPLOADING_BLOCKS;
+
     protected logger: Logger;
 
     protected digests: UploadDigests;
@@ -67,6 +69,7 @@ export class StreamUploader {
     protected ongoingUploads = new Map<
         string,
         {
+            index?: number;
             uploadPromise: Promise<void>;
             encryptedBlock: EncryptedBlock | EncryptedThumbnail;
         }
@@ -376,6 +379,7 @@ export class StreamUploader {
 
             const uploadKey = `block:${blockToken.index}`;
             this.ongoingUploads.set(uploadKey, {
+                index: blockToken.index,
                 uploadPromise: this.uploadBlock(blockToken, encryptedBlock, onProgress).finally(() => {
                     this.ongoingUploads.delete(uploadKey);
 
@@ -500,6 +504,13 @@ export class StreamUploader {
                     blockProgress = 0;
                 }
 
+                if (error instanceof Error && error.name === 'TimeoutError') {
+                    logger.warn(`Upload timeout, limiting upload capacity to 1 block`);
+                    await this.limitUploadCapacity(uploadToken.index);
+                    logger.warn(`Upload timeout, retrying`);
+                    continue;
+                }
+
                 if (
                     (error instanceof APIHTTPError && error.statusCode === HTTPErrorCode.NOT_FOUND) ||
                     error instanceof NotFoundAPIError
@@ -542,6 +553,27 @@ export class StreamUploader {
         logger.info(`Uploaded`);
     }
 
+    private async limitUploadCapacity(index: number) {
+        this.maxUploadingBlocks = 1;
+
+        // This ensures that when the upload is downscaled, all ongoing block
+        // uploads are waiting for their turn one by one.
+        try {
+            await waitForCondition(() => {
+                const ongoingIndexes = Array.from(this.ongoingUploads.values())
+                    .map(({ index: ongoingIndex }) => ongoingIndex)
+                    .filter((ongoingIndex) => ongoingIndex !== undefined);
+                ongoingIndexes.sort((a, b) => a - b);
+                return ongoingIndexes[0] === index;
+            }, this.abortController.signal);
+        } catch (error: unknown) {
+            if (error instanceof AbortError) {
+                return;
+            }
+            throw error;
+        }
+    }
+
     private async waitForBufferCapacity() {
         if (this.encryptedBlocks.size >= MAX_BUFFERED_BLOCKS) {
             try {
@@ -559,7 +591,7 @@ export class StreamUploader {
     }
 
     private async waitForUploadCapacityAndBufferedBlocks() {
-        while (this.ongoingUploads.size >= MAX_UPLOADING_BLOCKS) {
+        while (this.ongoingUploads.size >= this.maxUploadingBlocks) {
             await Promise.race(this.ongoingUploads.values().map(({ uploadPromise }) => uploadPromise));
         }
         try {

package/src/internal/upload/telemetry.ts

@@ -13,13 +13,12 @@ export class UploadTelemetry {
         private sharesService: SharesService,
     ) {
         this.telemetry = telemetry;
-        this.logger = this.telemetry.getLogger('download');
+        this.logger = this.telemetry.getLogger('upload');
         this.sharesService = sharesService;
     }
 
     getLoggerForRevision(revisionUid: string) {
-        const logger = this.telemetry.getLogger('upload');
-        return new LoggerWithPrefix(logger, `revision ${revisionUid}`);
+        return new LoggerWithPrefix(this.logger, `revision ${revisionUid}`);
     }
 
     logBlockVerificationError(retryHelped: boolean) {