feat(node): Instrumentation for node-schedule library

Author: timfish

packages/node/src/cron/cron.ts

@@ -56,6 +56,8 @@ const ERROR_TEXT = 'Automatic instrumentation of CronJob only supports crontab s
  * ```
  */
 export function instrumentCron<T>(lib: T & CronJobConstructor, monitorSlug: string): T {
+  let jobScheduled = false;
+
   return new Proxy(lib, {
     construct(target, args: ConstructorParameters<CronJobConstructor>) {
       const [cronTime, onTick, onComplete, start, timeZone, ...rest] = args;
@@ -64,6 +66,12 @@ export function instrumentCron<T>(lib: T & CronJobConstructor, monitorSlug: stri
         throw new Error(ERROR_TEXT);
       }
 
+      if (jobScheduled) {
+        throw new Error(`A job named '${monitorSlug}' has already been scheduled`);
+      }
+
+      jobScheduled = true;
+
       const cronString = replaceCronNames(cronTime);
 
       function monitoredTick(context: unknown, onComplete?: unknown): void | Promise<void> {
@@ -90,6 +98,12 @@ export function instrumentCron<T>(lib: T & CronJobConstructor, monitorSlug: stri
             throw new Error(ERROR_TEXT);
           }
 
+          if (jobScheduled) {
+            throw new Error(`A job named '${monitorSlug}' has already been scheduled`);
+          }
+
+          jobScheduled = true;
+
           const cronString = replaceCronNames(cronTime);
 
           param.onTick = (context: unknown, onComplete?: unknown) => {

packages/node/src/cron/node-schedule.ts

@@ -0,0 +1,59 @@
+import { withMonitor } from '@sentry/core';
+import { replaceCronNames } from './common';
+
+export interface NodeSchedule {
+  scheduleJob(expression: string | Date | object, callback: () => void): unknown;
+}
+
+/**
+ * Instruments the `node-schedule` library to send a check-in event to Sentry for each job execution.
+ *
+ * ```ts
+ * import * as Sentry from '@sentry/node';
+ * import * as schedule from 'node-schedule';
+ *
+ * const scheduleWithCheckIn = Sentry.cron.instrumentNodeSchedule(schedule, 'my-cron-job');
+ *
+ * const job = scheduleWithCheckIn.scheduleJob('* * * * *', () => {
+ *  console.log('You will see this message every minute');
+ * });
+ * ```
+ */
+export function instrumentNodeSchedule<T>(lib: T & NodeSchedule, monitorSlug: string): T {
+  let jobScheduled = false;
+
+  return new Proxy(lib, {
+    get(target, prop: keyof NodeSchedule) {
+      if (prop === 'scheduleJob') {
+        // eslint-disable-next-line @typescript-eslint/unbound-method
+        return new Proxy(target.scheduleJob, {
+          apply(target, thisArg, argArray: Parameters<NodeSchedule['scheduleJob']>) {
+            const [expression] = argArray;
+
+            if (typeof expression !== 'string') {
+              throw new Error('Automatic instrumentation of "node-schedule" only supports crontab string');
+            }
+
+            if (jobScheduled) {
+              throw new Error(`A job named '${monitorSlug}' has already been scheduled`);
+            }
+
+            jobScheduled = true;
+
+            return withMonitor(
+              monitorSlug,
+              () => {
+                return target.apply(thisArg, argArray);
+              },
+              {
+                schedule: { type: 'crontab', value: replaceCronNames(expression) },
+              },
+            );
+          },
+        });
+      }
+
+      return target[prop];
+    },
+  });
+}

packages/node/src/index.ts

@@ -124,9 +124,11 @@ export { hapiErrorPlugin } from './integrations/hapi';
 
 import { instrumentCron } from './cron/cron';
 import { instrumentNodeCron } from './cron/node-cron';
+import { instrumentNodeSchedule } from './cron/node-schedule';
 
 /** Methods to instrument cron libraries for Sentry check-ins */
 export const cron = {
   instrumentCron,
   instrumentNodeCron,
+  instrumentNodeSchedule,
 };

packages/node/test/cron.test.ts

@@ -78,6 +78,26 @@ describe('cron check-ins', () => {
         },
       });
     });
+
+    test('throws with multiple jobs same name', () => {
+      const CronJobWithCheckIn = cron.instrumentCron(CronJobMock, 'my-cron-job');
+
+      CronJobWithCheckIn.from({
+        cronTime: '* * * Jan,Sep Sun',
+        onTick: () => {
+          //
+        },
+      });
+
+      expect(() => {
+        CronJobWithCheckIn.from({
+          cronTime: '* * * Jan,Sep Sun',
+          onTick: () => {
+            //
+          },
+        });
+      }).toThrowError("A job named 'my-cron-job' has already been scheduled");
+    });
   });
 
   describe('node-cron', () => {
@@ -125,4 +145,64 @@ describe('cron check-ins', () => {
       }).toThrowError('Missing "name" for scheduled job. A name is required for Sentry check-in monitoring.');
     });
   });
+
+  describe('node-schedule', () => {
+    test('calls withMonitor', done => {
+      expect.assertions(4);
+
+      class NodeScheduleMock {
+        scheduleJob(expression: string, callback: () => void): unknown {
+          expect(expression).toBe('* * * Jan,Sep Sun');
+          expect(callback).toBeInstanceOf(Function);
+          return callback();
+        }
+      }
+
+      const scheduleWithCheckIn = cron.instrumentNodeSchedule(new NodeScheduleMock(), 'my-cron-job');
+
+      scheduleWithCheckIn.scheduleJob('* * * Jan,Sep Sun', () => {
+        expect(withMonitorSpy).toHaveBeenCalledTimes(1);
+        expect(withMonitorSpy).toHaveBeenLastCalledWith('my-cron-job', expect.anything(), {
+          schedule: { type: 'crontab', value: '* * * 1,9 0' },
+        });
+        done();
+      });
+    });
+
+    test('throws without crontab string', () => {
+      class NodeScheduleMock {
+        scheduleJob(_: string | Date, __: () => void): unknown {
+          return undefined;
+        }
+      }
+
+      const scheduleWithCheckIn = cron.instrumentNodeSchedule(new NodeScheduleMock(), 'my-cron-job');
+
+      expect(() => {
+        scheduleWithCheckIn.scheduleJob(new Date(), () => {
+          //
+        });
+      }).toThrowError('Automatic instrumentation of "node-schedule" only supports crontab string');
+    });
+
+    test('throws with multiple jobs same name', () => {
+      class NodeScheduleMock {
+        scheduleJob(_: string, __: () => void): unknown {
+          return undefined;
+        }
+      }
+
+      const scheduleWithCheckIn = cron.instrumentNodeSchedule(new NodeScheduleMock(), 'my-cron-job');
+
+      scheduleWithCheckIn.scheduleJob('* * * * *', () => {
+        //
+      });
+
+      expect(() => {
+        scheduleWithCheckIn.scheduleJob('* * * * *', () => {
+          //
+        });
+      }).toThrowError("A job named 'my-cron-job' has already been scheduled");
+    });
+  });
 });