feat: maintain and print notion API stats

Author: JohannesRudolph

src/NotionApiFacade.ts

@@ -13,22 +13,28 @@ const debug = require("debug")("notion-api");
 export class NotionApiFacade {
   private readonly client: Client;
 
+  private readonly stats = {
+    totalRequests: 0,
+    totalRetries: 0,
+    retriesByErrorCode: new Map<string, number>(),
+  };
+
   constructor(notionApiToken: string) {
     this.client = new Client({
       auth: notionApiToken,
     });
   }
 
   async retrieveDatabase(databaseId: string) {
-    return await withRetry(async () =>
+    return await this.withRetry(async () =>
       this.client.databases.retrieve({
         database_id: databaseId,
       })
     );
   }
 
   async queryDatabase(query: DatabasesQueryParameters) {
-    const result = await withRetry(
+    const result = await this.withRetry(
       async () => await this.client.databases.query(query)
     ); // todo: paging
 
@@ -42,13 +48,13 @@ export class NotionApiFacade {
   }
 
   async retrievePage(pageId: string) {
-    return await withRetry(
+    return await this.withRetry(
       async () => await this.client.pages.retrieve({ page_id: pageId })
     );
   }
 
   async listBlockChildren(blockId: string) {
-    const result = await withRetry(
+    const result = await this.withRetry(
       async () =>
         await this.client.blocks.children.list({
           block_id: blockId,
@@ -63,52 +69,71 @@ export class NotionApiFacade {
 
     return result;
   }
-}
 
+  printStats() {
+    console.log("Notion API request statistics", this.stats);
+  }
 
-function sleep(ms: number) {
-    return new Promise(resolve => setTimeout(resolve, ms));
-}
-
-async function withRetry<T>(
-  f: () => Promise<T>,
-  maxRetries: number = 3,
-  retriableApiErrorCodes: APIErrorCode[] = [
-    APIErrorCode.ServiceUnavailable,
-    APIErrorCode.RateLimited,
-  ],
-  retriableUnknownHTTPStatusCodes: number[] = [502]
-) {
-  let lastError: any;
-
-  for (let i = 1; i <= maxRetries; i++) {
-    try {
-      return await f();
-    } catch (error: any) {
-      lastError = error;
-      const isRetriable =
-        (APIResponseError.isAPIResponseError(error) &&
-          error.code in retriableApiErrorCodes) ||
-        (UnknownHTTPResponseError.isUnknownHTTPResponseError(error) &&
-          error.status in retriableUnknownHTTPStatusCodes) ||
-        (RequestTimeoutError.isRequestTimeoutError(error));
-
-      if (!isRetriable) {
-        // throw any other error immediately
-        throw error;
+  private async withRetry<T>(
+    f: () => Promise<T>,
+    maxRetries: number = 3,
+    retriableApiErrorCodes: APIErrorCode[] = [
+      APIErrorCode.ServiceUnavailable,
+      APIErrorCode.RateLimited,
+    ],
+    retriableUnknownHTTPStatusCodes: number[] = [502]
+  ) {
+    let lastError: any;
+
+    for (let i = 1; i <= maxRetries; i++) {
+      try {
+        this.stats.totalRequests++;
+        return await f();
+      } catch (error: any) {
+        lastError = error;
+
+        const apiError = APIResponseError.isAPIResponseError(error) && error;
+        const unknownError =
+          UnknownHTTPResponseError.isUnknownHTTPResponseError(error) && error;
+        const timeoutError =
+          RequestTimeoutError.isRequestTimeoutError(error) && error;
+
+        const isRetriable =
+          (apiError && error.code in retriableApiErrorCodes) ||
+          (unknownError && error.status in retriableUnknownHTTPStatusCodes) ||
+          timeoutError;
+
+        if (!isRetriable) {
+          // throw any other error immediately
+          throw error;
+        }
+
+        this.stats.totalRetries++;
+        const key =
+          (apiError && apiError.code) ||
+          (unknownError && `${unknownError.code}.${unknownError.status}`) ||
+          (timeoutError && `${timeoutError.code}`) ||
+          "unknown";
+
+        const count = this.stats.retriesByErrorCode.get(key) || 0;
+        this.stats.retriesByErrorCode.set(key, count + 1);
+
+        debug(
+          `Notion API request failed with error ${error.code},  ${
+            maxRetries - i
+          } retries left`
+        );
+
+        await sleep(1000 * i); // chosen by fair dice roll
       }
-
-      debug(
-        `Notion API request failed with error ${error.code},  ${
-          maxRetries - i
-        } retries left`
-      );
-
-      await sleep(1000 * i); // chosen by fair dice roll
     }
+
+    throw new Error(
+      `Failed to execute Notion API request, even after ${maxRetries} retries. Original error was ${lastError}`
+    );
   }
+}
 
-  throw new Error(
-    `Failed to execute Notion API request, even after ${maxRetries} retries. Original error was ${lastError}`
-  );
-}
+function sleep(ms: number) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}

src/sync.ts

@@ -58,5 +58,7 @@ export async function sync(notionApiToken: string, config: SyncConfig) {
 
   const rendered = deferredRenderer.getRenderedPages();
 
+  publicApi.printStats();
+
   return rendered;
 }