@senzops/apm-node 1.1.12 → 1.1.15

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
+    );
+
+  };

package/src/utils/sdkMeta.ts

@@ -0,0 +1,6 @@
+import pkg from '../../package.json';
+
+export const SDK_META = {
+  name: pkg.name,
+  version: pkg.version
+};

package/tsconfig.json

@@ -7,6 +7,7 @@
     "strict": true,
     "esModuleInterop": true,
     "skipLibCheck": true,
+    "resolveJsonModule": true,
     "forceConsistentCasingInFileNames": true
   },
   "include": ["src/**/*"],