@senzops/apm-node 1.1.12 → 1.1.15

package/src/instrumentation/bullmq.ts

@@ -1,70 +1,195 @@
 import type { SenzorClient } from '../core/client';
 import { hookRequire } from './hook';
+import { Context } from '../core/context';
 
-export const instrumentBullMQ = (client: SenzorClient, debug: boolean) => {
-  hookRequire('bullmq', (bullExports) => {
+const PATCHED =
+  Symbol.for(
+    'senzor.bullmq.patched'
+  );
 
-    const patchWorker = (target: any) => {
-      if (!target || !target.Worker || !target.Worker.prototype.processJob || target.Worker.prototype.processJob.__senzorPatched) return;
+function patchWorker(
+  target: any,
+  client: SenzorClient,
+  debug: boolean
+) {
 
-      const originalProcessJob = target.Worker.prototype.processJob;
+  if (
+    !target?.Worker?.prototype
+  ) {
+    return;
+  }
 
-      target.Worker.prototype.processJob = async function (job: any) {
-        const queueDelay = job.timestamp ? Date.now() - job.timestamp : 0;
+  const proto =
+    target.Worker.prototype;
 
-        // BullMQ increments attemptsMade *after* a failure. 
-        // So the current run attempt is attemptsMade + 1.
-        const currentAttempt = (job.attemptsMade || 0) + 1;
-        const maxAttempts = job.opts?.attempts || 1;
+  const original =
+    proto.processJob;
 
-        // If it fails on this run, and it's >= the max allowed attempts, it's entering the DLQ.
-        const isFinalAttempt = currentAttempt >= maxAttempts;
+  if (
+    typeof original !==
+    'function' ||
+    original[PATCHED]
+  ) {
+    return;
+  }
 
-        const taskName = job.name === '__default__' ? job.queueName : `${job.queueName}:${job.name}`;
+  proto.processJob =
+    async function (
+      job: any
+    ) {
+
+      const queueDelay =
+        job.timestamp
+          ? Date.now() -
+          job.timestamp
+          : 0;
+
+      const currentAttempt =
+        (job.attemptsMade || 0)
+        + 1;
+
+      const maxAttempts =
+        job.opts?.attempts
+        ?? 1;
+
+      const isFinal =
+        currentAttempt >=
+        maxAttempts;
+
+      const taskName =
+        job.name ===
+          '__default__'
+          ? job.queueName
+          : `${job.queueName}:${job.name}`;
+
+      return client.startTask(
+
+        taskName,
+
+        'queue',
+
+        {
+          queueDelay,
+          attempts:
+            currentAttempt,
+          isDeadLetter: false,
+          metadata: {
+            jobId: job.id,
+            queueName:
+              job.queueName,
+            maxAttempts
+          }
+        },
+
+        async () => {
+
+          try {
+
+            const result =
+              await original.call(
+                this,
+                job
+              );
+
+            client.endTask(
+              'success'
+            );
+
+            return result;
+
+          }
+          catch (error) {
 
-        return client.startTask(
-          taskName,
-          'queue',
-          {
-            queueDelay,
-            attempts: currentAttempt,
-            // We preset isDeadLetter to false, but if it throws an error and isFinalAttempt is true, 
-            // we will mutate this in the catch block.
-            isDeadLetter: false,
-            metadata: { jobId: job.id, queueName: job.queueName, maxAttempts }
-          },
-          async () => {
             try {
-              const result = await originalProcessJob.apply(this, arguments);
-              client.endTask('success');
-              return result;
-            } catch (error) {
-              const context = require('../core/context').Context.current();
-              if (context && context.contextType === 'task' && isFinalAttempt) {
-                context.data.isDeadLetter = true; // Flag it as a permanent failure
+
+              const ctx =
+                Context.current();
+
+              if (
+                ctx &&
+                ctx.contextType === 'task' &&
+                isFinal
+              ) {
+
+                ctx.data
+                  .isDeadLetter =
+                  true;
+
               }
 
-              client.captureError(error, {
-                queueName: job.queueName,
+            }
+            catch { }
+
+            client.captureError(
+              error,
+              {
+                queueName:
+                  job.queueName,
                 jobId: job.id,
-                isDeadLetter: isFinalAttempt
-              });
+                isDeadLetter:
+                  isFinal
+              }
+            );
+
+            client.endTask(
+              'failed'
+            );
+
+            throw error;
 
-              client.endTask('failed');
-              throw error;
-            }
           }
-        );
-      };
 
-      Object.defineProperty(target.Worker.prototype.processJob, '__senzorPatched', { value: true, enumerable: false, writable: true });
-      if (debug) console.log('[Senzor] BullMQ Worker successfully instrumented with DLQ tracking');
-    };
+        }
+
+      );
 
-    patchWorker(bullExports);
+    };
 
-    if (bullExports.default) {
-      patchWorker(bullExports.default);
+  Object.defineProperty(
+    proto.processJob,
+    PATCHED,
+    {
+      value: true
     }
-  });
-};
+  );
+
+  if (debug) {
+
+    console.log(
+      '[Senzor] BullMQ instrumented'
+    );
+
+  }
+
+}
+
+export const instrumentBullMQ =
+  (
+    client: SenzorClient,
+    debug: boolean
+  ) => {
+
+    hookRequire(
+      'bullmq',
+      (exports: any) => {
+
+        patchWorker(
+          exports,
+          client,
+          debug
+        );
+
+        if (exports?.default) {
+
+          patchWorker(
+            exports.default,
+            client,
+            debug
+          );
+
+        }
+
+      }
+    );
+
+  };

package/src/instrumentation/cron.ts

@@ -1,41 +1,204 @@
 import type { SenzorClient } from '../core/client';
 import { hookRequire } from './hook';
 
-export const instrumentNodeCron = (client: SenzorClient, debug: boolean) => {
-  hookRequire('node-cron', (cronExports) => {
+const PATCHED =
+  Symbol.for('senzor.cron.patched');
 
-    // Abstracted patcher so we can apply it to both the root and the .default export
-    const patchSchedule = (target: any) => {
-      if (!target || typeof target.schedule !== 'function' || target.__senzorPatched) return;
+type CronHandler =
+  (...args: unknown[]) => unknown;
 
-      const originalSchedule = target.schedule;
+type CronSchedule =
+  (
+    expression: string,
+    handler: CronHandler,
+    options?: unknown
+  ) => unknown;
 
-      target.schedule = function (expression: string, func: (...args: any[]) => any, options: any) {
-        // Handle node-cron's dynamic options argument (can be string or object)
-        const optsObj = typeof options === 'object' ? options : { timezone: options };
-        const taskName = optsObj?.name || `cron: ${expression}`;
+function normalizeOptions(
+  options: unknown
+): Record<string, unknown> {
 
-        const wrappedFunc = client.wrapTask(
-          taskName,
-          'cron',
-          { metadata: optsObj },
-          func
+  if (
+    typeof options === 'object' &&
+    options !== null
+  ) {
+    return options as Record<
+      string,
+      unknown
+    >;
+  }
+
+  // backward compatibility with:
+  // cron.schedule(expr, fn, "UTC")
+  if (options) {
+    return { timezone: options };
+  }
+
+  return {};
+
+}
+
+function patchTarget(
+  target: Record<string, unknown>,
+  client: SenzorClient,
+  debug: boolean
+): void {
+
+  const schedule =
+    target.schedule as
+    CronSchedule | undefined;
+
+  if (
+    typeof schedule !== 'function' ||
+    (schedule as any)[PATCHED]
+  ) {
+    return;
+  }
+
+  const original =
+    schedule;
+
+  const wrapped: CronSchedule =
+    function (
+      this: unknown,
+      expression,
+      handler,
+      options
+    ) {
+
+      if (
+        typeof handler !==
+        'function'
+      ) {
+
+        return original.call(
+          this,
+          expression,
+          handler,
+          options
+        );
+
+      }
+
+      try {
+
+        const opts =
+          normalizeOptions(
+            options
+          );
+
+        const taskName =
+          (opts as any)?.name ??
+          `cron: ${expression}`;
+
+        const wrappedHandler =
+          client.wrapTask(
+            taskName,
+            'cron',
+            {
+              expression,
+              metadata: opts
+            },
+            handler
+          );
+
+        return original.call(
+          this,
+          expression,
+          wrappedHandler,
+          options
+        );
+
+      }
+      catch (err) {
+
+        if (debug) {
+
+          console.error(
+            '[Senzor] cron wrap failed',
+            err
+          );
+
+        }
+
+        return original.call(
+          this,
+          expression,
+          handler,
+          options
         );
 
-        return originalSchedule.call(this, expression, wrappedFunc, options);
-      };
+      }
 
-      // Safely mark as patched to prevent infinite loops
-      Object.defineProperty(target, '__senzorPatched', { value: true, enumerable: false, writable: true });
-      if (debug) console.log('[Senzor] Node-Cron successfully instrumented');
     };
 
-    // Apply patch to root (for const cron = require('node-cron'))
-    patchSchedule(cronExports);
+  Object.defineProperty(
+    wrapped,
+    PATCHED,
+    {
+      value: true,
+      enumerable: false
+    }
+  );
+
+  // Some ESM namespace exports are frozen
+  try {
+
+    target.schedule =
+      wrapped;
+
+  }
+  catch {
+
+    if (debug) {
+
+      console.warn(
+        '[Senzor] unable to patch cron schedule (readonly export)'
+      );
 
-    // Apply patch to default (for import cron from 'node-cron')
-    if (cronExports.default) {
-      patchSchedule(cronExports.default);
     }
-  });
-};
+
+  }
+
+  if (debug) {
+
+    console.log(
+      '[Senzor] node-cron instrumented'
+    );
+
+  }
+
+}
+
+export const instrumentNodeCron =
+  (
+    client: SenzorClient,
+    debug: boolean
+  ): void => {
+
+    hookRequire(
+      'node-cron',
+      (exports: any) => {
+
+        if (!exports) return;
+
+        patchTarget(
+          exports,
+          client,
+          debug
+        );
+
+        if (exports.default) {
+
+          patchTarget(
+            exports.default,
+            client,
+            debug
+          );
+
+        }
+
+      }
+    );
+
+  };