chore: additional logging around task execution (#1217)

Author: dhable

packages/api/src/tasks/checkAlerts.ts

@@ -463,11 +463,18 @@ export default class CheckAlertTask implements HdxTask<CheckAlertsTaskArgs> {
 
     this.provider = await loadProvider(this.args.provider);
     await this.provider.init();
+    logger.debug({
+      message: 'finished provider initialization',
+      provider: this.provider.constructor.name,
+      args: this.args,
+    });
 
     const alertTasks = await this.provider.getAlertTasks();
-    logger.info({
-      message: 'Fetched alert tasks to process',
-      taskCount: alertTasks.length,
+    const taskCount = alertTasks.length;
+    logger.debug({
+      message: `Fetched ${taskCount} alert tasks to process`,
+      taskCount,
+      args: this.args,
     });
 
     const teams = new Set(alertTasks.map(t => t.conn.team.toString()));
@@ -476,6 +483,12 @@ export default class CheckAlertTask implements HdxTask<CheckAlertsTaskArgs> {
       const teamWebhooksById = await this.provider.getWebhooks(teamId);
       teamToWebhooks.set(teamId, teamWebhooksById);
     }
+    logger.debug({
+      message: `Obtained teams and webhooks for all alertTasks`,
+      args: this.args,
+      teamCount: teams.size,
+      teamWebhookCount: teamToWebhooks.size,
+    });
 
     for (const task of alertTasks) {
       const teamWebhooksById =
@@ -484,8 +497,16 @@ export default class CheckAlertTask implements HdxTask<CheckAlertsTaskArgs> {
         this.processAlertTask(task, teamWebhooksById),
       );
     }
+    logger.debug({
+      message: 'finished scheduling alert tasks on the task_queue',
+      args: this.args,
+    });
 
     await this.task_queue.onIdle();
+    logger.info({
+      message: 'finished processing all tasks on task_queue',
+      args: this.args,
+    });
   }
 
   name(): string {

packages/api/src/tasks/index.ts

@@ -30,6 +30,12 @@ const main = async (argv: TaskArgs) => {
     logger.info(
       `Task [${task.name()}] finished in ${(performance.now() - t0).toFixed(2)} ms`,
     );
+  } catch (e: unknown) {
+    logger.error({
+      message: `Task [${task.name()}] failed: ${serializeError(e)}`,
+      cause: e,
+      task,
+    });
   } finally {
     await task.asyncDispose();
   }

packages/api/src/tasks/providers/default.ts

@@ -230,6 +230,7 @@ export default class DefaultAlertProvider implements AlertProvider {
           alertId: alert.id,
           team: alert.team,
           channel: alert.channel,
+          provider: 'default',
         });
       }
     }
@@ -306,6 +307,7 @@ export default class DefaultAlertProvider implements AlertProvider {
       logger.info({
         message: `connection password not found`,
         connectionId: id,
+        provider: 'default',
       });
     }
 

packages/api/src/tasks/providers/index.ts

@@ -10,6 +10,7 @@ import { ISavedSearch } from '@/models/savedSearch';
 import { ISource } from '@/models/source';
 import { IWebhook } from '@/models/webhook';
 import DefaultAlertProvider from '@/tasks/providers/default';
+import logger from '@/utils/logger';
 
 import { AggregatedAlertHistory } from '../checkAlerts';
 
@@ -107,13 +108,23 @@ export async function loadProvider(
         if (isValidProvider(providerInstance)) {
           return providerInstance;
         } else {
-          console.warn(`"${providerName}" does not implement AlertProvider`);
+          logger.warn({
+            message: `"${providerName}" does not implement AlertProvider`,
+            providerName,
+          });
         }
       } else {
-        console.warn(`"${providerName}" does not export default constructor`);
+        logger.warn({
+          message: `"${providerName}" does not export default constructor`,
+          providerName,
+        });
       }
     } catch (e) {
-      console.warn(`failed to load "${providerName}: ${e}"`);
+      logger.warn({
+        message: `failed to load "${providerName}: ${e}"`,
+        cause: e,
+        providerName,
+      });
     }
   }