@senzops/apm-node 1.1.11 → 1.1.14

package/src/instrumentation/bullmq.ts

@@ -1,45 +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 attempts = (job.attemptsMade || 0) + 1;
-        const taskName = job.name === '__default__' ? job.queueName : `${job.queueName}:${job.name}`;
+  const proto =
+    target.Worker.prototype;
+
+  const original =
+    proto.processJob;
+
+  if (
+    typeof original !==
+    'function' ||
+    original[PATCHED]
+  ) {
+    return;
+  }
+
+  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, metadata: { jobId: job.id, queueName: job.queueName } },
-          async () => {
             try {
-              const result = await originalProcessJob.apply(this, arguments);
-              client.endTask('success');
-              return result;
-            } catch (error) {
-              client.captureError(error, { queueName: job.queueName, jobId: job.id });
-              client.endTask('failed');
-              throw error;
+
+              const ctx =
+                Context.current();
+
+              if (
+                ctx &&
+                ctx.contextType === 'task' &&
+                isFinal
+              ) {
+
+                ctx.data
+                  .isDeadLetter =
+                  true;
+
+              }
+
             }
+            catch { }
+
+            client.captureError(
+              error,
+              {
+                queueName:
+                  job.queueName,
+                jobId: job.id,
+                isDeadLetter:
+                  isFinal
+              }
+            );
+
+            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');
-    };
+        }
+
+      );
 
-    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
+          );
+
+        }
+
+      }
+    );
+
+  };

package/src/instrumentation/hook.ts

@@ -1,24 +1,247 @@
 import Module from 'module';
 
-export const hookRequire = (moduleName: string, onRequire: (exports: any) => void) => {
-  // 1. If it was already loaded (e.g., imported at the top of the file before init)
+const SENZOR_PATCHED =
+  Symbol.for('senzor.require.patched');
+
+const SENZOR_HOOKS =
+  Symbol.for('senzor.require.hooks');
+
+type HookFn =
+  (exports: unknown) => void;
+
+type HookMap =
+  Map<string, HookFn[]>;
+
+function getHookRegistry(): HookMap {
+
+  const mod =
+    Module as unknown as Record<
+      symbol,
+      HookMap
+    >;
+
+  if (!mod[SENZOR_HOOKS]) {
+
+    Object.defineProperty(
+      mod,
+      SENZOR_HOOKS,
+      {
+        value: new Map(),
+        enumerable: false
+      }
+    );
+
+  }
+
+  return mod[SENZOR_HOOKS];
+
+}
+
+function runHooks(
+  moduleName: string,
+  exports: unknown
+) {
+
+  const registry =
+    (Module as unknown as Record<
+      symbol,
+      HookMap
+    >)[SENZOR_HOOKS];
+
+  if (!registry) return;
+
+  const hooks =
+    registry.get(moduleName);
+
+  if (!hooks?.length) return;
+
+  for (const hook of hooks) {
+
+    try {
+      hook(exports);
+    }
+    catch (err) {
+
+      console.error(
+        `[Senzor] instrumentation failed for ${moduleName}`,
+        err
+      );
+
+    }
+
+  }
+
+}
+
+function patchLoaderOnce() {
+
+  const mod =
+    Module as unknown as any;
+
+  if (mod[SENZOR_PATCHED]) {
+    return;
+  }
+
+  const previousLoad =
+    mod._load;
+
+  mod._load =
+    function patchedLoad(
+      request: string,
+      parent: unknown,
+      isMain: boolean
+    ) {
+
+      const exports =
+        previousLoad.apply(
+          this,
+          arguments
+        );
+
+      runHooks(
+        request,
+        exports
+      );
+
+      return exports;
+
+    };
+
+  Object.defineProperty(
+    mod,
+    SENZOR_PATCHED,
+    {
+      value: true,
+      enumerable: false
+    }
+  );
+
+}
+
+function patchCached(
+  moduleName: string,
+  hook: HookFn
+) {
+
   try {
-    const resolvedPath = require.resolve(moduleName);
-    const cached = require.cache[resolvedPath];
-    if (cached && cached.exports) {
-      onRequire(cached.exports);
+
+    const resolved =
+      require.resolve(
+        moduleName
+      );
+
+    const cached =
+      require.cache?.[
+      resolved
+      ];
+
+    if (cached?.exports) {
+
+      hook(
+        cached.exports
+      );
+
+    }
+
+  }
+  catch { }
+
+}
+
+function tryRequire(
+  moduleName: string,
+  hook: HookFn
+) {
+
+  try {
+
+    const mod =
+      require(moduleName);
+
+    if (mod) {
+      hook(mod);
     }
-  } catch (e) {
-    // Silently ignore if module is not installed
+
   }
+  catch { }
+
+}
+
+function retryPatch(
+  moduleName: string,
+  hook: HookFn
+) {
+
+  let attempts = 0;
+
+  const max = 5;
+
+  const timer =
+    setInterval(() => {
+
+      attempts++;
+
+      try {
+
+        const mod =
+          require(moduleName);
+
+        if (mod) {
+
+          hook(mod);
+
+          clearInterval(timer);
+
+        }
+
+      }
+      catch { }
+
+      if (attempts >= max) {
+        clearInterval(timer);
+      }
+
+    }, 200);
+
+}
+
+export const hookRequire =
+  (
+    moduleName: string,
+    onRequire: HookFn
+  ) => {
+
+    const registry =
+      getHookRegistry();
+
+    if (!registry.has(moduleName)) {
+
+      registry.set(
+        moduleName,
+        []
+      );
 
-  // 2. Intercept future requires
-  const originalLoad = (Module as any)._load;
-  (Module as any)._load = function (request: string, parent: any, isMain: boolean) {
-    const exports = originalLoad.apply(this, arguments);
-    if (request === moduleName && exports) {
-      onRequire(exports);
     }
-    return exports;
-  };
-};
+
+    registry
+      .get(moduleName)!
+      .push(onRequire);
+
+    patchLoaderOnce();
+
+    patchCached(
+      moduleName,
+      onRequire
+    );
+
+    tryRequire(
+      moduleName,
+      onRequire
+    );
+
+    retryPatch(
+      moduleName,
+      onRequire
+    );
+
+  };