@protontech/drive-sdk 0.9.8 → 0.10.0

package/src/interface/telemetry.ts

@@ -24,6 +24,7 @@ export interface MetricAPIRetrySucceededEvent {
     eventName: 'apiRetrySucceeded';
     url: string;
     failedAttempts: number;
+    previousError?: unknown;
 }
 
 export interface MetricDebounceLongWaitEvent {

package/src/interface/thumbnail.ts

@@ -1,6 +1,6 @@
 export type Thumbnail = {
     type: ThumbnailType;
-    thumbnail: Uint8Array;
+    thumbnail: Uint8Array<ArrayBuffer>;
 };
 
 export enum ThumbnailType {
@@ -9,5 +9,5 @@ export enum ThumbnailType {
 }
 
 export type ThumbnailResult =
-    | { nodeUid: string; ok: true; thumbnail: Uint8Array }
+    | { nodeUid: string; ok: true; thumbnail: Uint8Array<ArrayBuffer> }
     | { nodeUid: string; ok: false; error: string };

package/src/internal/apiService/apiService.test.ts

@@ -1,5 +1,5 @@
 import { AbortError } from '../../errors';
-import { ProtonDriveHTTPClient, SDKEvent } from '../../interface';
+import { ProtonDriveHTTPClient, SDKEvent, Telemetry, MetricEvent } from '../../interface';
 import { getMockTelemetry } from '../../tests/telemetry';
 import { SDKEvents } from '../sdkEvents';
 import { DriveAPIService } from './apiService';
@@ -12,13 +12,17 @@ function generateOkResponse() {
 }
 
 describe('DriveAPIService', () => {
+    let telemetry: Telemetry<MetricEvent>;
     let sdkEvents: SDKEvents;
     let httpClient: ProtonDriveHTTPClient;
     let api: DriveAPIService;
 
+    const baseUrl = 'https://drive.proton.me';
+
     beforeEach(() => {
         void jest.runAllTimersAsync();
 
+        telemetry = getMockTelemetry();
         // @ts-expect-error: No need to implement all methods for mocking
         sdkEvents = {
             transfersPaused: jest.fn(),
@@ -30,7 +34,7 @@ describe('DriveAPIService', () => {
             fetchJson: jest.fn(() => Promise.resolve(generateOkResponse())),
             fetchBlob: jest.fn(() => Promise.resolve(new Response(new Uint8Array([1, 2, 3])))),
         };
-        api = new DriveAPIService(getMockTelemetry(), sdkEvents, httpClient, 'http://drive.proton.me', 'en');
+        api = new DriveAPIService(telemetry, sdkEvents, httpClient, baseUrl, 'en');
     });
 
     function expectSDKEvents(...events: SDKEvent[]) {
@@ -42,6 +46,15 @@ describe('DriveAPIService', () => {
         );
     }
 
+    function expectMetricEvent(previousError: unknown, failedAttempts: number) {
+        expect(telemetry.recordMetric).toHaveBeenCalledWith({
+            eventName: 'apiRetrySucceeded',
+            failedAttempts,
+            url: `${baseUrl}/test`,
+            previousError,
+        });
+    }
+
     describe('should make', () => {
         it('GET request', async () => {
             const result = await api.get('test');
@@ -78,6 +91,7 @@ describe('DriveAPIService', () => {
             );
             expect(await request.json).toEqual(data);
             expectSDKEvents();
+            expect(telemetry.recordMetric).not.toHaveBeenCalled();
         }
 
         it('storage GET request', async () => {
@@ -109,6 +123,7 @@ describe('DriveAPIService', () => {
             );
             expect(request.body).toEqual(data);
             expectSDKEvents();
+            expect(telemetry.recordMetric).not.toHaveBeenCalled();
         }
     });
 
@@ -121,6 +136,7 @@ describe('DriveAPIService', () => {
 
             await expect(api.get('test')).rejects.toThrow(new AbortError('Request aborted'));
             expectSDKEvents();
+            expect(telemetry.recordMetric).not.toHaveBeenCalled();
         });
 
         it('APIHTTPError on 4xx response without JSON body', async () => {
@@ -129,6 +145,7 @@ describe('DriveAPIService', () => {
             );
             await expect(api.get('test')).rejects.toThrow(new Error('Not found'));
             expectSDKEvents();
+            expect(telemetry.recordMetric).not.toHaveBeenCalled();
         });
 
         it('APIError on 4xx response with JSON body', async () => {
@@ -137,6 +154,7 @@ describe('DriveAPIService', () => {
             );
             await expect(api.get('test')).rejects.toThrow('General error');
             expectSDKEvents();
+            expect(telemetry.recordMetric).not.toHaveBeenCalled();
         });
     });
 
@@ -155,6 +173,7 @@ describe('DriveAPIService', () => {
             await expect(result).resolves.toEqual({ Code: ErrorCode.OK });
             expect(httpClient.fetchJson).toHaveBeenCalledTimes(3);
             expectSDKEvents();
+            expect(telemetry.recordMetric).not.toHaveBeenCalled();
         });
 
         it('on timeout error', async () => {
@@ -171,19 +190,19 @@ describe('DriveAPIService', () => {
             await expect(result).resolves.toEqual({ Code: ErrorCode.OK });
             expect(httpClient.fetchJson).toHaveBeenCalledTimes(3);
             expectSDKEvents();
+            expect(telemetry.recordMetric).not.toHaveBeenCalled();
         });
 
         it('on general error', async () => {
-            httpClient.fetchJson = jest
-                .fn()
-                .mockRejectedValueOnce(new Error('Error'))
-                .mockResolvedValueOnce(generateOkResponse());
+            const error = new Error('Error');
+            httpClient.fetchJson = jest.fn().mockRejectedValueOnce(error).mockResolvedValueOnce(generateOkResponse());
 
             const result = api.get('test');
 
             await expect(result).resolves.toEqual({ Code: ErrorCode.OK });
             expect(httpClient.fetchJson).toHaveBeenCalledTimes(2);
             expectSDKEvents();
+            expectMetricEvent(error, 1);
         });
 
         it('only once on general error', async () => {
@@ -198,6 +217,7 @@ describe('DriveAPIService', () => {
             await expect(result).rejects.toThrow('Second error');
             expect(httpClient.fetchJson).toHaveBeenCalledTimes(2);
             expectSDKEvents();
+            expect(telemetry.recordMetric).not.toHaveBeenCalled();
         });
 
         it('on 429 response with default timeout', async () => {
@@ -231,6 +251,7 @@ describe('DriveAPIService', () => {
 
             await expect(result).resolves.toEqual({ Code: ErrorCode.OK });
             expectSDKEvents();
+            expectMetricEvent(429, 2);
         });
 
         it('on 429 response with retry-after header', async () => {
@@ -272,6 +293,7 @@ describe('DriveAPIService', () => {
 
             await expect(result).resolves.toEqual({ Code: ErrorCode.OK });
             expectSDKEvents();
+            expectMetricEvent(429, 2);
         });
 
         it('on 5xx response', async () => {
@@ -287,6 +309,7 @@ describe('DriveAPIService', () => {
             await expect(result).resolves.toEqual({ Code: ErrorCode.OK });
             expect(httpClient.fetchJson).toHaveBeenCalledTimes(2);
             expectSDKEvents();
+            expectMetricEvent(500, 1);
         });
 
         it('only once on 5xx response', async () => {
@@ -301,6 +324,7 @@ describe('DriveAPIService', () => {
             await expect(result).rejects.toThrow('Some error');
             expect(httpClient.fetchJson).toHaveBeenCalledTimes(2);
             expectSDKEvents();
+            expect(telemetry.recordMetric).not.toHaveBeenCalled();
         });
     });
 
@@ -314,6 +338,7 @@ describe('DriveAPIService', () => {
             await expect(api.get('test')).rejects.toThrow(error);
             expect(httpClient.fetchJson).toHaveBeenCalledTimes(3);
             expectSDKEvents();
+            expect(telemetry.recordMetric).not.toHaveBeenCalled();
         });
 
         it('limit 429 errors', async () => {
@@ -336,6 +361,8 @@ describe('DriveAPIService', () => {
             httpClient.fetchJson = jest.fn().mockResolvedValue(generateOkResponse());
             await api.get('test');
             expect(sdkEvents.requestsThrottled).toHaveBeenCalledTimes(1);
+
+            expect(telemetry.recordMetric).not.toHaveBeenCalled();
         });
 
         it('do not limit 429s when some pass', async () => {
@@ -355,6 +382,7 @@ describe('DriveAPIService', () => {
             // 20 calls * 5 retries till OK response + 1 last successful call
             expect(httpClient.fetchJson).toHaveBeenCalledTimes(101);
             expectSDKEvents();
+            expectMetricEvent(429, 4);
         });
 
         it('limit server errors', async () => {
@@ -371,6 +399,7 @@ describe('DriveAPIService', () => {
             await expect(api.get('test')).rejects.toThrow('Too many server errors, please try again later');
             expect(httpClient.fetchJson).toHaveBeenCalledTimes(10);
             expectSDKEvents();
+            expect(telemetry.recordMetric).not.toHaveBeenCalled();
         });
 
         it('do not limit server errors when some pass', async () => {
@@ -390,6 +419,7 @@ describe('DriveAPIService', () => {
             // 15 erroring calls * 2 attempts + 5 successful calls
             expect(httpClient.fetchJson).toHaveBeenCalledTimes(35);
             expectSDKEvents();
+            expect(telemetry.recordMetric).not.toHaveBeenCalled();
         });
 
         it('notify about offline error', async () => {
@@ -428,6 +458,8 @@ describe('DriveAPIService', () => {
             expectSDKEvents(SDKEvent.TransfersPaused, SDKEvent.TransfersResumed);
 
             await promise;
+
+            expect(telemetry.recordMetric).not.toHaveBeenCalled();
         });
     });
 });

package/src/internal/apiService/apiService.ts

@@ -245,7 +245,15 @@ export class DriveAPIService {
     private async fetch(
         request: { method: string; url: string; signal?: AbortSignal },
         callback: () => Promise<Response>,
-        attempt = 0,
+        {
+            attempt,
+            previousError,
+        }: {
+            attempt: number;
+            previousError?: unknown;
+        } = {
+            attempt: 0,
+        },
     ): Promise<Response> {
         if (request.signal?.aborted) {
             throw new AbortError(c('Error').t`Request aborted`);
@@ -282,19 +290,19 @@ export class DriveAPIService {
                     this.offlineErrorHappened();
                     this.logger.info(`${request.method} ${request.url}: Offline error, retrying`);
                     await waitSeconds(OFFLINE_RETRY_DELAY_SECONDS);
-                    return this.fetch(request, callback, attempt + 1);
+                    return this.fetch(request, callback, { attempt: attempt + 1, previousError: error });
                 }
 
                 if (error.name === 'TimeoutError' && attempt + 1 < MAX_TIMEOUT_ERROR_RETRY_ATTEMPTS) {
                     this.logger.warn(`${request.method} ${request.url}: Timeout error, retrying`);
                     await waitSeconds(SERVER_ERROR_RETRY_DELAY_SECONDS);
-                    return this.fetch(request, callback, attempt + 1);
+                    return this.fetch(request, callback, { attempt: attempt + 1, previousError: error });
                 }
             }
             if (attempt === 0) {
                 this.logger.error(`${request.method} ${request.url}: failed, retrying once`, error);
                 await waitSeconds(GENERAL_RETRY_DELAY_SECONDS);
-                return this.fetch(request, callback, attempt + 1);
+                return this.fetch(request, callback, { attempt: attempt + 1, previousError: error });
             }
             this.logger.error(`${request.method} ${request.url}: failed`, error);
             throw error;
@@ -315,7 +323,7 @@ export class DriveAPIService {
             this.tooManyRequestsErrorHappened();
             const timeout = parseInt(response.headers.get('retry-after') || '0', 10) || DEFAULT_429_RETRY_DELAY_SECONDS;
             await waitSeconds(timeout);
-            return this.fetch(request, callback, attempt + 1);
+            return this.fetch(request, callback, { attempt: attempt + 1, previousError: response.status });
         } else {
             this.clearSubsequentTooManyRequestsError();
         }
@@ -329,16 +337,29 @@ export class DriveAPIService {
                 this.logger.warn(`${request.method} ${request.url}: ${response.status} - retry failed`);
             } else {
                 await waitSeconds(SERVER_ERROR_RETRY_DELAY_SECONDS);
-                return this.fetch(request, callback, attempt + 1);
+                return this.fetch(request, callback, { attempt: attempt + 1, previousError: response.status });
             }
         } else {
             if (attempt > 0) {
-                this.telemetry.recordMetric({
-                    eventName: 'apiRetrySucceeded',
-                    failedAttempts: attempt,
-                    url: request.url,
-                });
-                this.logger.warn(`${request.method} ${request.url}: ${response.status} - retry helped`);
+                const previousErrorMessage =
+                    previousError instanceof Error ? previousError.message : String(previousError);
+                const isWarning =
+                    !(previousError instanceof Error) ||
+                    (previousError instanceof Error &&
+                        previousError.name !== 'TimeoutError' &&
+                        previousError.name !== 'OfflineError');
+
+                if (isWarning) {
+                    this.telemetry.recordMetric({
+                        eventName: 'apiRetrySucceeded',
+                        failedAttempts: attempt,
+                        url: request.url,
+                        previousError,
+                    });
+                    this.logger.warn(`${request.method} ${request.url}: ${previousErrorMessage} - retry helped`);
+                } else {
+                    this.logger.debug(`${request.method} ${request.url}: ${previousErrorMessage} - retry helped`);
+                }
             }
             this.clearSubsequentServerErrors();
         }