@senzops/apm-node 1.2.1 → 1.2.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@senzops/apm-node",
-  "version": "1.2.1",
+  "version": "1.2.3",
   "description": "Universal APM SDK for Senzor",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/instrumentation/express.ts

@@ -273,6 +273,16 @@ const patchRouteMethodHandlers = (
   }
 };
 
+const getSafeRouter = (app: any) => {
+  if (!app) return undefined;
+  if (app._router) return app._router;
+  try {
+    return app.router;
+  } catch {
+    return undefined;
+  }
+};
+
 const patchExpress = (
   expressModule: any,
   options?: SenzorOptions
@@ -320,9 +330,9 @@ const patchExpress = (
     'senzor.express.application.use',
     (original) =>
       function patchedExpressApplicationUse(this: any, ...args: any[]) {
-        const router = this?.router || this?._router;
+        const router = getSafeRouter(this);
         const result = original.apply(this, args);
-        const activeRouter = this?.router || this?._router || router;
+        const activeRouter = getSafeRouter(this) || router;
         const layer = activeRouter?.stack?.[activeRouter.stack.length - 1];
         patchLayer(layer, getLayerPath(args), options);
         return result;

package/src/instrumentation/hook.ts

@@ -1,265 +1,134 @@
 import Module from 'module';
 
-const SENZOR_PATCHED =
-  Symbol.for('senzor.require.patched');
+const SENZOR_PATCHED = Symbol.for('senzor.require.patched');
+const SENZOR_HOOKS = Symbol.for('senzor.require.hooks');
 
-const SENZOR_HOOKS =
-  Symbol.for('senzor.require.hooks');
+type HookFn = (exports: unknown) => unknown | void;
+type HookMap = Map<string, HookFn[]>;
 
-type HookFn =
-  (exports: unknown) => unknown | void;
-
-type HookMap =
-  Map<string, HookFn[]>;
+// Module.createRequire works in both CJS and ESM contexts,
+// unlike bare `require` which is unavailable in ESM builds.
+const safeRequire: NodeRequire = Module.createRequire(
+  typeof __filename !== 'undefined'
+    ? __filename
+    : process.cwd() + '/'
+);
 
 function getHookRegistry(): HookMap {
-
-  const mod =
-    Module as unknown as Record<
-      symbol,
-      HookMap
-    >;
+  const mod = Module as unknown as Record<symbol, HookMap>;
 
   if (!mod[SENZOR_HOOKS]) {
-
-    Object.defineProperty(
-      mod,
-      SENZOR_HOOKS,
-      {
-        value: new Map(),
-        enumerable: false
-      }
-    );
-
+    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];
+function runHooks(moduleName: string, exports: unknown) {
+  const registry = (Module as unknown as Record<symbol, HookMap>)[SENZOR_HOOKS];
+  if (!registry) return exports;
 
-  if (!registry) return exports;
+  const hooks = registry.get(moduleName);
+  if (!hooks?.length) return exports;
 
-  const hooks =
-    registry.get(moduleName);
-
-  if (!hooks?.length) return exports;
-
-  let currentExports =
-    exports;
-
-  for (const hook of hooks) {
-
-    try {
-      const nextExports =
-        hook(currentExports);
-
-      if (nextExports !== undefined) {
-        currentExports =
-          nextExports;
-      }
-    }
-    catch (err) {
-
-      console.error(
-        `[Senzor] instrumentation failed for ${moduleName}`,
-        err
-      );
+  let currentExports = exports;
 
+  for (const hook of hooks) {
+    try {
+      const nextExports = hook(currentExports);
+      if (nextExports !== undefined) {
+        currentExports = nextExports;
+      }
+    } catch (err) {
+      console.error(`[Senzor] instrumentation failed for ${moduleName}`, err);
     }
-
-  }
-
-  return currentExports;
-
-}
-
-function patchLoaderOnce() {
-
-  const mod =
-    Module as unknown as any;
-
-  if (mod[SENZOR_PATCHED]) {
-    return;
   }
 
-  const previousLoad =
-    mod._load;
+  return currentExports;
+}
 
-  mod._load =
-    function patchedLoad(
-      request: string,
-      parent: unknown,
-      isMain: boolean
-    ) {
+function patchLoaderOnce() {
+  const mod = Module as unknown as any;
 
-      const exports =
-        previousLoad.apply(
-          this,
-          arguments
-        );
+  if (mod[SENZOR_PATCHED]) return;
 
-      const patchedExports =
-        runHooks(
-        request,
-        exports
-      );
-
-      return patchedExports;
+  const previousLoad = mod._load;
 
-    };
-
-  Object.defineProperty(
-    mod,
-    SENZOR_PATCHED,
-    {
-      value: true,
-      enumerable: false
-    }
-  );
+  mod._load = function patchedLoad(
+    request: string,
+    parent: unknown,
+    isMain: boolean
+  ) {
+    const exports = previousLoad.apply(this, arguments);
+    return runHooks(request, exports);
+  };
 
+  Object.defineProperty(mod, SENZOR_PATCHED, {
+    value: true,
+    enumerable: false
+  });
 }
 
-function patchCached(
-  moduleName: string,
-  hook: HookFn
-) {
-
+function patchCached(moduleName: string, hook: HookFn) {
   try {
-
-    const resolved =
-      require.resolve(
-        moduleName
-      );
-
-    const cached =
-      require.cache?.[
-      resolved
-      ];
+    const resolved = safeRequire.resolve(moduleName);
+    const cached = safeRequire.cache?.[resolved];
 
     if (cached?.exports) {
-
-      const replacement =
-        hook(
-        cached.exports
-      );
-
-      if (replacement !== undefined) {
-        cached.exports =
-          replacement;
-      }
-
-    }
-
-  }
-  catch { }
-
+      const replacement = hook(cached.exports);
+      if (replacement !== undefined) {
+        cached.exports = replacement;
+      }
+    }
+  } catch { }
 }
 
-function tryRequire(
-  moduleName: string,
-  hook: HookFn
-) {
-
+function tryRequire(moduleName: string, hook: HookFn) {
   try {
-
-    const mod =
-      require(moduleName);
-
+    const mod = safeRequire(moduleName);
     if (mod) {
-      hook(mod);
+      hook(mod);
     }
-
-  }
-  catch { }
-
+  } catch { }
 }
 
-function retryPatch(
-  moduleName: string,
-  hook: HookFn
-) {
-
+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);
+  const timer = setInterval(() => {
+    attempts++;
 
-          clearInterval(timer);
-
-        }
-
-      }
-      catch { }
-
-      if (attempts >= max) {
+    try {
+      const mod = safeRequire(moduleName);
+      if (mod) {
+        hook(mod);
         clearInterval(timer);
       }
+    } catch { }
 
-    }, 200);
-
-}
-
-export const hookRequire =
-  (
-    moduleName: string,
-    onRequire: HookFn
-  ) => {
-
-    const registry =
-      getHookRegistry();
-
-    if (!registry.has(moduleName)) {
-
-      registry.set(
-        moduleName,
-        []
-      );
-
+    if (attempts >= max) {
+      clearInterval(timer);
     }
+  }, 200);
 
-    registry
-      .get(moduleName)!
-      .push(onRequire);
-
-    patchLoaderOnce();
+  if (typeof timer.unref === 'function') timer.unref();
+}
 
-    patchCached(
-      moduleName,
-      onRequire
-    );
+export const hookRequire = (moduleName: string, onRequire: HookFn) => {
+  const registry = getHookRegistry();
 
-    tryRequire(
-      moduleName,
-      onRequire
-    );
+  if (!registry.has(moduleName)) {
+    registry.set(moduleName, []);
+  }
 
-    retryPatch(
-      moduleName,
-      onRequire
-    );
+  registry.get(moduleName)!.push(onRequire);
 
-  };
+  patchLoaderOnce();
+  patchCached(moduleName, onRequire);
+  tryRequire(moduleName, onRequire);
+  retryPatch(moduleName, onRequire);
+};