@jennifersoft/jennifer5-instrumentation 5.6.5-1

package/dist/index.js

@@ -0,0 +1,3547 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  TransactionContextManager: () => TransactionContextManager,
+  contextManager: () => contextManager,
+  registerIitmHooks: () => registerIitmHooks,
+  registerRitmHooks: () => registerRitmHooks,
+  startGcMetricsCollection: () => startGcMetricsCollection,
+  startHeapMetricsCollection: () => startHeapMetricsCollection,
+  withJenniferNextRouteTx: () => withJenniferNextRouteTx
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/instrumentations/register-ritm.ts
+var import_require_in_the_middle = require("require-in-the-middle");
+
+// src/instrumentations/http-server.ts
+var import_jennifer5_agent4 = require("@jennifersoft/jennifer5-agent");
+
+// src/core/shimmer.ts
+var skipMethods = /* @__PURE__ */ new Set(["caller", "arguments", "name", "length"]);
+var skipMethodSize = skipMethods.size;
+var nonConfigurableModuleExports = /* @__PURE__ */ new WeakMap();
+function copyProperties(original, wrapped) {
+  if (original.constructor !== wrapped.constructor) {
+    const proto = Object.getPrototypeOf(original);
+    Object.setPrototypeOf(wrapped, proto);
+  }
+  const ownKeys = Reflect.ownKeys(original);
+  if (original.length !== wrapped.length) {
+    Object.defineProperty(wrapped, "length", { value: original.length, configurable: true });
+  }
+  if (original.name !== wrapped.name) {
+    Object.defineProperty(wrapped, "name", { value: original.name, configurable: true });
+  }
+  if (ownKeys.length !== 2) {
+    for (const key of ownKeys) {
+      if (skipMethods.has(key)) continue;
+      const descriptor = Object.getOwnPropertyDescriptor(original, key);
+      if (descriptor.writable && descriptor.enumerable && descriptor.configurable) {
+        wrapped[key] = original[key];
+      } else if (descriptor.writable || descriptor.configurable || !Object.hasOwn(wrapped, key)) {
+        Object.defineProperty(wrapped, key, descriptor);
+      }
+    }
+  }
+}
+function copyObjectProperties(original, wrapped, skipKey) {
+  const ownKeys = Reflect.ownKeys(original);
+  for (const key of ownKeys) {
+    if (key === skipKey) continue;
+    const descriptor = Object.getOwnPropertyDescriptor(original, key);
+    if (descriptor.writable && descriptor.enumerable && descriptor.configurable) {
+      wrapped[key] = original[key];
+    } else if (descriptor.writable || descriptor.configurable || !Object.hasOwn(wrapped, key)) {
+      Object.defineProperty(wrapped, key, descriptor);
+    }
+  }
+}
+function wrap(target, name, wrapper, options) {
+  if (typeof wrapper !== "function") {
+    throw new TypeError(wrapper ? "Target is not a function" : "No function provided");
+  }
+  if (target == null) {
+    return;
+  }
+  const descriptor = Object.getOwnPropertyDescriptor(target, name) ?? {
+    value: target[name],
+    writable: true,
+    configurable: true,
+    enumerable: false
+  };
+  if (descriptor.set && (!descriptor.get || options?.replaceGetter)) {
+    throw new Error(
+      options?.replaceGetter ? "Replacing a getter/setter pair is not supported. Implement if required." : "Replacing setters is not supported. Implement if required."
+    );
+  }
+  const original = descriptor.value ?? (options?.replaceGetter ? target[name] : descriptor.get);
+  assertMethod(target, name, original);
+  const wrapped = wrapper(original);
+  copyProperties(original, wrapped);
+  if (descriptor.writable) {
+    if (descriptor.configurable && descriptor.enumerable) {
+      target[name] = wrapped;
+      return target;
+    }
+    descriptor.value = wrapped;
+  } else {
+    if (descriptor.get) {
+      descriptor.get = options?.replaceGetter ? () => wrapped : wrapped;
+    } else {
+      descriptor.value = wrapped;
+    }
+    if (descriptor.configurable === false) {
+      let moduleExports = nonConfigurableModuleExports.get(target);
+      if (!moduleExports) {
+        if (typeof target === "function") {
+          const original2 = target;
+          moduleExports = function(...args) {
+            return original2.apply(original2, args);
+          };
+          skipMethods.add(name);
+          copyProperties(target, moduleExports);
+          if (skipMethods.size === skipMethodSize + 1) {
+            skipMethods.delete(name);
+          }
+        } else {
+          moduleExports = Object.create(target);
+          copyObjectProperties(target, moduleExports, name);
+        }
+        nonConfigurableModuleExports.set(target, moduleExports);
+      }
+      target = moduleExports;
+    }
+  }
+  Object.defineProperty(target, name, descriptor);
+  return target;
+}
+function assertMethod(target, name, method) {
+  if (typeof method !== "function") {
+    let message = "No target object provided";
+    if (target) {
+      if (typeof target !== "object" && typeof target !== "function") {
+        message = "Invalid target";
+      } else {
+        const nameStr = String(name);
+        message = method ? `Original method ${nameStr} is not a function` : `No original method ${nameStr}`;
+      }
+    }
+    throw new TypeError(message);
+  }
+}
+
+// src/core/context-manager.ts
+var import_node_async_hooks = require("async_hooks");
+var import_jennifer5_agent = require("@jennifersoft/jennifer5-agent");
+var TransactionContextManager = class {
+  constructor() {
+    this._asyncLocalStorage = new import_node_async_hooks.AsyncLocalStorage();
+  }
+  /**
+   * Create a new transaction context
+   */
+  start() {
+    const ctx = {
+      id: (0, import_jennifer5_agent.generateTxid)(),
+      enable: (0, import_jennifer5_agent.configEnable)()
+    };
+    return ctx;
+  }
+  /**
+   * Run a callback within a transaction context scope
+   * All async operations within this scope will automatically have access to the context
+   */
+  run(ctx, callback) {
+    return this._asyncLocalStorage.run(ctx, callback);
+  }
+  /**
+   * Get the current transaction context (if any)
+   * This works automatically across async boundaries thanks to AsyncLocalStorage
+   */
+  getCurrentContext() {
+    return this._asyncLocalStorage.getStore();
+  }
+};
+var contextManager = new TransactionContextManager();
+
+// src/feat/wmonid.ts
+var import_jennifer5_agent2 = require("@jennifersoft/jennifer5-agent");
+
+// src/dep/cookie.ts
+var cookieNameRegExp = /^[\u0021-\u003A\u003C\u003E-\u007E]+$/;
+var cookieValueRegExp = /^[\u0021-\u003A\u003C-\u007E]*$/;
+var domainValueRegExp = /^([.]?[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)([.][a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)*$/i;
+var pathValueRegExp = /^[\u0020-\u003A\u003D-\u007E]*$/;
+var __toString = Object.prototype.toString;
+var NullObject = /* @__PURE__ */ (() => {
+  const C = function() {
+  };
+  C.prototype = /* @__PURE__ */ Object.create(null);
+  return C;
+})();
+function parseCookie(str, options) {
+  const obj = new NullObject();
+  const len = str.length;
+  if (len < 2) return obj;
+  const dec = options?.decode || decode;
+  let index = 0;
+  do {
+    const eqIdx = eqIndex(str, index, len);
+    if (eqIdx === -1) break;
+    const endIdx = endIndex(str, index, len);
+    if (eqIdx > endIdx) {
+      index = str.lastIndexOf(";", eqIdx - 1) + 1;
+      continue;
+    }
+    const key = valueSlice(str, index, eqIdx);
+    if (obj[key] === void 0) {
+      obj[key] = dec(valueSlice(str, eqIdx + 1, endIdx));
+    }
+    index = endIdx + 1;
+  } while (index < len);
+  return obj;
+}
+function stringifySetCookie(_name, _val, _opts) {
+  const cookie = typeof _name === "object" ? _name : { ..._opts, name: _name, value: String(_val) };
+  const options = typeof _val === "object" ? _val : _opts;
+  const enc = options?.encode || encodeURIComponent;
+  if (!cookieNameRegExp.test(cookie.name)) {
+    throw new TypeError(`argument name is invalid: ${cookie.name}`);
+  }
+  const value = cookie.value ? enc(cookie.value) : "";
+  if (!cookieValueRegExp.test(value)) {
+    throw new TypeError(`argument val is invalid: ${cookie.value}`);
+  }
+  let str = cookie.name + "=" + value;
+  if (cookie.maxAge !== void 0) {
+    if (!Number.isInteger(cookie.maxAge)) {
+      throw new TypeError(`option maxAge is invalid: ${cookie.maxAge}`);
+    }
+    str += "; Max-Age=" + cookie.maxAge;
+  }
+  if (cookie.domain) {
+    if (!domainValueRegExp.test(cookie.domain)) {
+      throw new TypeError(`option domain is invalid: ${cookie.domain}`);
+    }
+    str += "; Domain=" + cookie.domain;
+  }
+  if (cookie.path) {
+    if (!pathValueRegExp.test(cookie.path)) {
+      throw new TypeError(`option path is invalid: ${cookie.path}`);
+    }
+    str += "; Path=" + cookie.path;
+  }
+  if (cookie.expires) {
+    if (!isDate(cookie.expires) || !Number.isFinite(cookie.expires.valueOf())) {
+      throw new TypeError(`option expires is invalid: ${cookie.expires}`);
+    }
+    str += "; Expires=" + cookie.expires.toUTCString();
+  }
+  if (cookie.httpOnly) {
+    str += "; HttpOnly";
+  }
+  if (cookie.secure) {
+    str += "; Secure";
+  }
+  if (cookie.partitioned) {
+    str += "; Partitioned";
+  }
+  if (cookie.priority) {
+    const priority = typeof cookie.priority === "string" ? cookie.priority.toLowerCase() : void 0;
+    switch (priority) {
+      case "low":
+        str += "; Priority=Low";
+        break;
+      case "medium":
+        str += "; Priority=Medium";
+        break;
+      case "high":
+        str += "; Priority=High";
+        break;
+      default:
+        throw new TypeError(`option priority is invalid: ${cookie.priority}`);
+    }
+  }
+  if (cookie.sameSite) {
+    const sameSite = typeof cookie.sameSite === "string" ? cookie.sameSite.toLowerCase() : cookie.sameSite;
+    switch (sameSite) {
+      case true:
+      case "strict":
+        str += "; SameSite=Strict";
+        break;
+      case "lax":
+        str += "; SameSite=Lax";
+        break;
+      case "none":
+        str += "; SameSite=None";
+        break;
+      default:
+        throw new TypeError(`option sameSite is invalid: ${cookie.sameSite}`);
+    }
+  }
+  return str;
+}
+function endIndex(str, min, len) {
+  const index = str.indexOf(";", min);
+  return index === -1 ? len : index;
+}
+function eqIndex(str, min, max) {
+  const index = str.indexOf("=", min);
+  return index < max ? index : -1;
+}
+function valueSlice(str, min, max) {
+  let start = min;
+  let end = max;
+  do {
+    const code = str.charCodeAt(start);
+    if (code !== 32 && code !== 9) break;
+  } while (++start < end);
+  while (end > start) {
+    const code = str.charCodeAt(end - 1);
+    if (code !== 32 && code !== 9) break;
+    end--;
+  }
+  return str.slice(start, end);
+}
+function decode(str) {
+  if (str.indexOf("%") === -1) return str;
+  try {
+    return decodeURIComponent(str);
+  } catch (e) {
+    return str;
+  }
+}
+function isDate(val) {
+  return __toString.call(val) === "[object Date]";
+}
+
+// src/feat/wmonid.ts
+var WMONID_COOKIE_NAME = "WMONID";
+var SECONDS_PER_YEAR = 365 * 24 * 60 * 60;
+function getCookie(req, name) {
+  const cookieHeader = req.headers?.cookie;
+  if (!cookieHeader) {
+    return void 0;
+  }
+  const cookieString = Array.isArray(cookieHeader) ? cookieHeader.join("; ") : cookieHeader;
+  const cookies = parseCookie(cookieString);
+  return cookies[name];
+}
+function setCookie(res, cookie) {
+  const cookieString = stringifySetCookie(cookie);
+  const existingSetCookie = res.getHeader("Set-Cookie");
+  if (existingSetCookie === void 0) {
+    res.setHeader("Set-Cookie", cookieString);
+  } else if (Array.isArray(existingSetCookie)) {
+    res.setHeader("Set-Cookie", [...existingSetCookie, cookieString]);
+  } else {
+    res.setHeader("Set-Cookie", [String(existingSetCookie), cookieString]);
+  }
+}
+function setNewWmonidCookie(res, txid) {
+  const cookieValue = (0, import_jennifer5_agent2.i64ToBase64)(txid);
+  setCookie(res, {
+    name: WMONID_COOKIE_NAME,
+    value: cookieValue,
+    maxAge: SECONDS_PER_YEAR,
+    path: "/",
+    secure: (0, import_jennifer5_agent2.configEnableSecureForWmonidCookie)(),
+    httpOnly: (0, import_jennifer5_agent2.configEnableHttpOnlyForWmonidCookie)()
+  });
+}
+function getWmonidInCookie(req, res, txid) {
+  try {
+    const wmonidCookie = getCookie(req, WMONID_COOKIE_NAME);
+    if (wmonidCookie) {
+      return (0, import_jennifer5_agent2.base64ToI64)(wmonidCookie);
+    }
+  } catch (e) {
+    (0, import_jennifer5_agent2.warn)(`Failed to get WMONID cookie: ${e}`);
+  }
+  try {
+    setNewWmonidCookie(res, txid);
+  } catch (e) {
+    (0, import_jennifer5_agent2.warn)(`Failed to set WMONID cookie: ${e}`);
+  }
+  return 0;
+}
+
+// src/feat/topology.ts
+var import_jennifer5_agent3 = require("@jennifersoft/jennifer5-agent");
+var X_DOMAIN_ID = "x-domainid";
+var X_AGENT_ID = "x-agentid";
+function getTopologyInfo(msg) {
+  if (!(0, import_jennifer5_agent3.configEnableHttpTopologyMode)()) {
+    return void 0;
+  }
+  try {
+    const topologyHeaderKey = (0, import_jennifer5_agent3.configTopologyHttpHeaderKey)();
+    const remoteCallKey = parseNumber(getHeader(msg, topologyHeaderKey));
+    const sid = parseNumber(getHeader(msg, X_DOMAIN_ID));
+    const oid = parseNumber(getHeader(msg, X_AGENT_ID));
+    if ([remoteCallKey, sid, oid].some((v) => v === void 0)) {
+      return void 0;
+    }
+    if (!(0, import_jennifer5_agent3.isAgentId)(oid)) {
+      return void 0;
+    }
+    return { remoteCallKey, domainId: sid, oid };
+  } catch {
+    return void 0;
+  }
+}
+function setTopologyResponseHeaders(incoming, res) {
+  if (!(0, import_jennifer5_agent3.configEnableHttpTopologyMode)()) {
+    return;
+  }
+  try {
+    if (!incoming) return;
+    if (res.headersSent || res.writableEnded) {
+      return;
+    }
+    const currentDomainId = (0, import_jennifer5_agent3.domainId)();
+    const currentAgentId = (0, import_jennifer5_agent3.agentId)();
+    if (!currentDomainId || !currentAgentId) {
+      return;
+    }
+    const topologyHeaderKey = (0, import_jennifer5_agent3.configTopologyHttpHeaderKey)();
+    res.setHeader(topologyHeaderKey, incoming.remoteCallKey);
+    res.setHeader(X_DOMAIN_ID, String(currentDomainId));
+    res.setHeader(X_AGENT_ID, String(currentAgentId));
+  } catch (error) {
+    (0, import_jennifer5_agent3.warn)(`Failed to set topology response headers: ${error}`);
+  }
+}
+function setTopologyRequestHeaders(req) {
+  if (!(0, import_jennifer5_agent3.configEnableHttpTopologyMode)()) {
+    return void 0;
+  }
+  try {
+    const remoteCallKey = (0, import_jennifer5_agent3.generateTxid)();
+    const currentDomainId = (0, import_jennifer5_agent3.domainId)();
+    const currentAgentId = (0, import_jennifer5_agent3.agentId)();
+    if (!currentDomainId || !currentAgentId) {
+      return void 0;
+    }
+    const topologyHeaderKey = (0, import_jennifer5_agent3.configTopologyHttpHeaderKey)();
+    if (!req.getHeader(topologyHeaderKey)) {
+      req.setHeader(topologyHeaderKey, String(remoteCallKey));
+      req.setHeader(X_DOMAIN_ID, String(currentDomainId));
+      req.setHeader(X_AGENT_ID, String(currentAgentId));
+    }
+    return {
+      remoteCallKey,
+      domainId: currentDomainId,
+      oid: currentAgentId
+    };
+  } catch (error) {
+    (0, import_jennifer5_agent3.warn)(`Failed to set topology request headers: ${error}`);
+    return void 0;
+  }
+}
+function setTopologyFetchHeaders(headers) {
+  if (!(0, import_jennifer5_agent3.configEnableHttpTopologyMode)()) {
+    return void 0;
+  }
+  try {
+    const remoteCallKey = (0, import_jennifer5_agent3.generateTxid)();
+    const currentDomainId = (0, import_jennifer5_agent3.domainId)();
+    const currentAgentId = (0, import_jennifer5_agent3.agentId)();
+    if (!currentDomainId || !currentAgentId) {
+      return void 0;
+    }
+    const topologyHeaderKey = (0, import_jennifer5_agent3.configTopologyHttpHeaderKey)();
+    if (!headers.get(topologyHeaderKey)) {
+      headers.set(topologyHeaderKey, String(remoteCallKey));
+      headers.set(X_DOMAIN_ID, String(currentDomainId));
+      headers.set(X_AGENT_ID, String(currentAgentId));
+    }
+    return {
+      remoteCallKey,
+      domainId: currentDomainId,
+      oid: currentAgentId
+    };
+  } catch (error) {
+    (0, import_jennifer5_agent3.warn)(`Failed to set topology fetch headers: ${error}`);
+    return void 0;
+  }
+}
+function getTopologyInfoFromFetch(response) {
+  if (!(0, import_jennifer5_agent3.configEnableHttpTopologyMode)()) {
+    return void 0;
+  }
+  try {
+    const topologyHeaderKey = (0, import_jennifer5_agent3.configTopologyHttpHeaderKey)();
+    const remoteCallKey = parseNumber(response.headers.get(topologyHeaderKey) || void 0);
+    const targetDomainId = parseNumber(response.headers.get(X_DOMAIN_ID) || void 0);
+    const targetAgentId = parseNumber(response.headers.get(X_AGENT_ID) || void 0);
+    if ([remoteCallKey, targetDomainId, targetAgentId].some((v) => v === void 0)) {
+      return void 0;
+    }
+    if (!(0, import_jennifer5_agent3.isAgentId)(targetAgentId)) {
+      return void 0;
+    }
+    return {
+      remoteCallKey,
+      domainId: targetDomainId,
+      oid: targetAgentId
+    };
+  } catch {
+    return void 0;
+  }
+}
+function getHeader(req, name) {
+  const value = req.headers?.[name.toLowerCase()];
+  if (!value) {
+    return void 0;
+  }
+  return Array.isArray(value) ? value[0] : value;
+}
+function parseNumber(value) {
+  if (!value) {
+    return void 0;
+  }
+  const parsed = Number(value);
+  return Number.isNaN(parsed) ? void 0 : parsed;
+}
+
+// src/instrumentations/http-server.ts
+var JENNIFER_WRAPPED = /* @__PURE__ */ Symbol.for("jennifer.http.wrapped");
+function collectResponseHeaders(res) {
+  if (!res?.getHeaders) return void 0;
+  return Object.entries(res.getHeaders()).map(([key, value]) => {
+    const valueStr = Array.isArray(value) ? value.join(", ") : String(value);
+    return `${key}:${valueStr}`;
+  });
+}
+function patchHttpServer(httpModule, moduleName) {
+  try {
+    if (instrumentServerEmit(httpModule)) {
+      (0, import_jennifer5_agent4.info)(`${moduleName} server instrumentation registered`);
+    }
+  } catch (error) {
+    (0, import_jennifer5_agent4.warn)(`Failed to register ${moduleName} server instrumentation: ${error}`);
+  }
+}
+function instrumentServerEmit(httpModule) {
+  const ServerPrototype = httpModule.Server.prototype;
+  if (ServerPrototype.emit?.[JENNIFER_WRAPPED]) {
+    return false;
+  }
+  wrap(ServerPrototype, "emit", (originalEmit) => {
+    const wrapper = function(eventName, ...args) {
+      if (eventName === "request") {
+        return handleRequestEvent(this, originalEmit, eventName, args);
+      }
+      if (eventName === "upgrade") {
+        return handleUpgradeEvent(this, originalEmit, eventName, args);
+      }
+      return originalEmit.apply(this, [eventName, ...args]);
+    };
+    wrapper[JENNIFER_WRAPPED] = true;
+    return wrapper;
+  });
+  return true;
+}
+function createHttpHeaders(req) {
+  return req?.headers ? Object.entries(req.headers).map(([key, value]) => `${key}:${value}`) : void 0;
+}
+function handleRequestEvent(server, originalEmit, eventName, args) {
+  const [req, res] = args;
+  const ctx = contextManager.start();
+  if (ctx.enable) {
+    const wmonidInCookie = !(0, import_jennifer5_agent4.configUsingRemoteAddressForWmonid)() ? getWmonidInCookie(req, res, ctx.id) : void 0;
+    const incomingRemotecallInfo = getTopologyInfo(req);
+    setTopologyResponseHeaders(incomingRemotecallInfo, res);
+    (0, import_jennifer5_agent4.createTransactionCtx)({
+      txId: ctx.id,
+      httpMethod: req?.method,
+      httpHeaders: createHttpHeaders(req),
+      httpUrl: req?.url,
+      clientIp: req?.socket?.remoteAddress,
+      wmonidInCookie,
+      incomingRemotecallInfo
+    });
+    return contextManager.run(ctx, () => {
+      let transactionEnded = false;
+      res.once("close", () => {
+        if (!transactionEnded) {
+          transactionEnded = true;
+          (0, import_jennifer5_agent4.releaseTransactionCtx)(ctx.id, {
+            httpStatusCode: res?.statusCode,
+            httpHeaders: collectResponseHeaders(res),
+            connectionAborted: true
+          });
+        }
+      });
+      wrap(res, "end", (originalEnd) => {
+        return function(...endArgs) {
+          if (!transactionEnded) {
+            transactionEnded = true;
+            (0, import_jennifer5_agent4.releaseTransactionCtx)(ctx.id, {
+              httpStatusCode: res?.statusCode,
+              httpHeaders: collectResponseHeaders(res)
+            });
+          }
+          return originalEnd.apply(this, endArgs);
+        };
+      });
+      return originalEmit.call(server, eventName, req, res);
+    });
+  } else {
+    return originalEmit.call(server, eventName, req, res);
+  }
+}
+function handleUpgradeEvent(server, originalEmit, eventName, args) {
+  const [req] = args;
+  const ctx = contextManager.start();
+  if (ctx.enable) {
+    (0, import_jennifer5_agent4.createTransactionCtx)({
+      txId: ctx.id,
+      method: "http.upgrade",
+      httpMethod: req?.method,
+      httpHeaders: createHttpHeaders(req),
+      httpUrl: req?.url,
+      clientIp: req?.socket?.remoteAddress
+    });
+  } else {
+    return originalEmit.apply(server, [eventName, ...args]);
+  }
+  return contextManager.run(ctx, () => {
+    try {
+      return originalEmit.apply(server, [eventName, ...args]);
+    } finally {
+      (0, import_jennifer5_agent4.releaseTransactionCtx)(ctx.id, {});
+    }
+  });
+}
+
+// src/instrumentations/apollo.ts
+var import_jennifer5_agent5 = require("@jennifersoft/jennifer5-agent");
+var JENNIFER_APOLLO_WRAPPED = /* @__PURE__ */ Symbol.for("jennifer.apollo.execute_http_graphql_request.wrapped");
+function extractGraphQLErrorsMessage(response) {
+  const body = response?.body;
+  if (!body || typeof body !== "object") {
+    return null;
+  }
+  let errors = [];
+  if (Array.isArray(body.errors)) {
+    errors = body.errors;
+  } else if (body.singleResult && Array.isArray(body.singleResult.errors)) {
+    errors = body.singleResult.errors;
+  } else if (typeof body.string === "string") {
+    try {
+      const parsed = JSON.parse(body.string);
+      if (Array.isArray(parsed?.errors)) {
+        errors = parsed.errors;
+      }
+    } catch {
+    }
+  }
+  if (!errors.length) {
+    return null;
+  }
+  const messages = errors.map((error) => typeof error?.message === "string" ? error.message : "Unknown GraphQL error").filter((message) => message.length > 0);
+  if (!messages.length) {
+    return "GraphQL: Unknown GraphQL error";
+  }
+  return messages.map((message) => `GraphQL: ${message}`).join(" | ");
+}
+function detectOperationType(query) {
+  const normalized = query?.trim().toLowerCase();
+  if (!normalized) {
+    return "unknown";
+  }
+  if (normalized.startsWith("mutation")) {
+    return "mutation";
+  }
+  if (normalized.startsWith("query") || normalized.startsWith("{")) {
+    return "query";
+  }
+  return "unknown";
+}
+function buildServiceName(requestContext) {
+  const body = requestContext?.httpGraphQLRequest?.body;
+  if (!body || typeof body !== "object") {
+    return null;
+  }
+  if (body.kind && body.kind !== "single") {
+    return "GraphQL - unknown anonymous";
+  }
+  const operationType = detectOperationType(body.query);
+  const operationName = body.operationName?.trim() || "anonymous";
+  return `GraphQL - ${operationType} ${operationName}`;
+}
+function patchApolloServerModule(apolloModule, moduleName) {
+  try {
+    const ApolloServer = apolloModule?.ApolloServer;
+    const proto = ApolloServer?.prototype;
+    if (!proto || typeof proto.executeHTTPGraphQLRequest !== "function") {
+      return;
+    }
+    if (proto.executeHTTPGraphQLRequest[JENNIFER_APOLLO_WRAPPED]) {
+      return;
+    }
+    wrap(proto, "executeHTTPGraphQLRequest", (original) => {
+      const wrapper = async function(...args) {
+        const ctx = contextManager.getCurrentContext();
+        if (ctx?.enable && (0, import_jennifer5_agent5.configServiceNamingByGraphqlOperation)()) {
+          const serviceName = buildServiceName(args[0]);
+          if (serviceName) {
+            (0, import_jennifer5_agent5.changeTransactionServiceName)(ctx.id, serviceName);
+          }
+        }
+        const response = await original.apply(this, args);
+        if (ctx?.enable) {
+          const errorsMessage = extractGraphQLErrorsMessage(response);
+          if (errorsMessage) {
+            (0, import_jennifer5_agent5.sendError)(ctx.id, errorsMessage);
+          }
+        }
+        return response;
+      };
+      wrapper[JENNIFER_APOLLO_WRAPPED] = true;
+      return wrapper;
+    });
+    (0, import_jennifer5_agent5.info)(`${moduleName}.ApolloServer instrumentation registered`);
+  } catch (error) {
+    (0, import_jennifer5_agent5.warn)(`Failed to register ${moduleName} Apollo instrumentation: ${error}`);
+  }
+}
+
+// src/instrumentations/http-client.ts
+var import_node_url = require("url");
+var import_jennifer5_agent6 = require("@jennifersoft/jennifer5-agent");
+var JENNIFER_WRAPPED2 = /* @__PURE__ */ Symbol.for("jennifer.http.wrapped");
+function patchHttpClient(httpModule, moduleName) {
+  try {
+    if (instrumentClientRequest(httpModule)) {
+      (0, import_jennifer5_agent6.info)(`${moduleName} client instrumentation registered`);
+    }
+  } catch (error) {
+    (0, import_jennifer5_agent6.warn)(`Failed to register ${moduleName} client instrumentation: ${error}`);
+  }
+}
+function instrumentClientRequest(httpModule) {
+  if (httpModule.request?.[JENNIFER_WRAPPED2]) {
+    return false;
+  }
+  wrap(httpModule, "request", (originalRequest) => {
+    const wrapper = function(...args) {
+      const req = originalRequest.apply(this, args);
+      const ctx = contextManager.getCurrentContext();
+      if (!ctx || !ctx.enable || !(0, import_jennifer5_agent6.configEnableHttpClientProfile)()) {
+        return req;
+      }
+      const { uri, options } = normalizeArgs(httpModule, args[0], args[1]);
+      const method = options.method || req.method || "GET";
+      setTopologyRequestHeaders(req);
+      const headers = {};
+      const rawHeaders = req.getHeaders();
+      for (const [key, value] of Object.entries(rawHeaders)) {
+        if (typeof value === "string") {
+          headers[key] = value;
+        } else if (Array.isArray(value)) {
+          headers[key] = value.join(", ");
+        } else if (value !== void 0) {
+          headers[key] = String(value);
+        }
+      }
+      const startCtx = (0, import_jennifer5_agent6.createHttpProfileCtx)(method, uri, headers, ctx.id);
+      let released = false;
+      const release = (endCtx) => {
+        if (!released) {
+          released = true;
+          (0, import_jennifer5_agent6.releaseHttpProfileCtx)(startCtx, endCtx);
+        }
+      };
+      const originalEmit = req.emit;
+      req.emit = function(eventName, ...emitArgs) {
+        switch (eventName) {
+          case "response": {
+            const res = emitArgs[0];
+            res.once("end", () => {
+              release({
+                statusCode: res.statusCode,
+                remoteCallInfo: getTopologyInfo(res)
+              });
+            });
+            break;
+          }
+          case "error":
+          case "timeout": {
+            const error = emitArgs[0];
+            release({
+              error: {
+                message: error?.message,
+                stack: error?.stack
+              }
+            });
+            break;
+          }
+          case "abort":
+          case "close":
+            break;
+        }
+        return originalEmit.apply(this, [eventName, ...emitArgs]);
+      };
+      return req;
+    };
+    wrapper[JENNIFER_WRAPPED2] = true;
+    return wrapper;
+  });
+  wrap(httpModule, "get", (originalGet) => {
+    return function(...args) {
+      const req = httpModule.request.apply(this, args);
+      req.end();
+      return req;
+    };
+  });
+  return true;
+}
+function normalizeOptions(httpModule, inputURL) {
+  if (typeof inputURL === "string") {
+    try {
+      return urlToOptions(httpModule, new URL(inputURL));
+    } catch {
+      return { path: inputURL };
+    }
+  }
+  if (inputURL instanceof URL) {
+    return urlToOptions(httpModule, inputURL);
+  }
+  if (inputURL) {
+    const result = { ...inputURL };
+    if (!result.protocol) {
+      result.protocol = httpModule.globalAgent?.protocol || "http:";
+    }
+    if (!result.pathname && result.path) {
+      const pathParts = result.path.split("?");
+      result.pathname = pathParts[0];
+      if (pathParts[1] && !result.search) {
+        result.search = `?${pathParts[1]}`;
+      }
+    }
+    return result;
+  }
+  return inputURL;
+}
+function urlToOptions(httpModule, urlObj) {
+  const agent = httpModule.globalAgent;
+  const options = {
+    protocol: urlObj.protocol || agent?.protocol,
+    hostname: urlObj.hostname.startsWith("[") ? urlObj.hostname.slice(1, -1) : urlObj.hostname || "localhost",
+    hash: urlObj.hash,
+    search: urlObj.search,
+    pathname: urlObj.pathname,
+    path: `${urlObj.pathname || ""}${urlObj.search || ""}`,
+    href: urlObj.href
+  };
+  if (urlObj.port !== "") {
+    options.port = Number(urlObj.port);
+  }
+  if (urlObj.username || urlObj.password) {
+    options.auth = `${urlObj.username}:${urlObj.password}`;
+  }
+  return options;
+}
+function combineOptions(inputURL, inputOptions) {
+  return inputOptions !== null && typeof inputOptions === "object" ? Object.assign(inputURL || {}, inputOptions) : inputURL;
+}
+function normalizeArgs(httpModule, inputURL, inputOptions) {
+  const normalizedURL = normalizeOptions(httpModule, inputURL);
+  const options = combineOptions(normalizedURL, inputOptions);
+  const uri = (0, import_node_url.format)(options);
+  return { uri, options };
+}
+
+// src/instrumentations/fs.ts
+var import_jennifer5_agent7 = require("@jennifersoft/jennifer5-agent");
+var JENNIFER_WRAPPED3 = /* @__PURE__ */ Symbol.for("jennifer.fs.wrapped");
+function patchFsSync(fs, _moduleName) {
+  const methods = [
+    ["readFileSync", import_jennifer5_agent7.FsActionType.SyncRead],
+    ["writeFileSync", import_jennifer5_agent7.FsActionType.SyncWrite]
+  ];
+  let patchedCount = 0;
+  for (const [method, event] of methods) {
+    if (fs[method]?.[JENNIFER_WRAPPED3]) {
+      continue;
+    }
+    wrap(fs, method, (original) => {
+      const wrapper = function(...args) {
+        const ctx = contextManager.getCurrentContext();
+        if (!ctx || !ctx.enable || !(0, import_jennifer5_agent7.configEnableFileProfile)()) {
+          return original.apply(this, args);
+        }
+        const filePathArg = args[0];
+        const filePath = filePathArg ? String(filePathArg) : "undefined";
+        const profileCtx = (0, import_jennifer5_agent7.createFsProfileCtx)(event, filePath, ctx.id);
+        try {
+          const result = original.apply(this, args);
+          (0, import_jennifer5_agent7.releaseFsProfileCtx)(profileCtx, {
+            fileSize: result?.length
+          });
+          return result;
+        } catch (error) {
+          (0, import_jennifer5_agent7.releaseFsProfileCtx)(profileCtx, {
+            error: {
+              message: error.toString()
+            }
+          });
+          throw error;
+        }
+      };
+      wrapper[JENNIFER_WRAPPED3] = true;
+      return wrapper;
+    });
+    patchedCount++;
+  }
+  if (patchedCount > 0) {
+    (0, import_jennifer5_agent7.info)(`fs sync: ${patchedCount} methods instrumented`);
+  }
+  return patchedCount > 0;
+}
+function patchFsAsync(fs, _moduleName) {
+  const asyncMethods = [
+    ["readFile", import_jennifer5_agent7.FsActionType.AsyncRead],
+    ["writeFile", import_jennifer5_agent7.FsActionType.AsyncWrite]
+  ];
+  let patchedCount = 0;
+  for (const [method, event] of asyncMethods) {
+    if (fs[method]?.[JENNIFER_WRAPPED3]) {
+      continue;
+    }
+    wrap(fs, method, (original) => {
+      const wrapper = function(...args) {
+        const callbackIndex = args.findIndex((arg) => typeof arg === "function");
+        if (callbackIndex === -1) {
+          return original.apply(this, args);
+        }
+        const ctx = contextManager.getCurrentContext();
+        if (!ctx || !ctx.enable || !(0, import_jennifer5_agent7.configEnableFileProfile)()) {
+          return original.apply(this, args);
+        }
+        const filePathArg = args[0];
+        const filePath = filePathArg ? String(filePathArg) : "undefined";
+        const perfCtx = (0, import_jennifer5_agent7.createFsProfileCtx)(event, filePath, ctx.id);
+        const originalCallback = args[callbackIndex];
+        args[callbackIndex] = function(err, data) {
+          (0, import_jennifer5_agent7.releaseFsProfileCtx)(perfCtx, {
+            error: err ? { message: err.message, stack: err.stack } : void 0,
+            fileSize: data?.length
+          });
+          return contextManager.run(ctx, () => originalCallback.call(this, err, data));
+        };
+        return original.apply(this, args);
+      };
+      wrapper[JENNIFER_WRAPPED3] = true;
+      return wrapper;
+    });
+    patchedCount++;
+  }
+  if (patchedCount > 0) {
+    (0, import_jennifer5_agent7.info)(`fs async: ${patchedCount} methods instrumented`);
+  }
+  return patchedCount > 0;
+}
+function patchFsPromise(fs, _moduleName) {
+  const fsPromises = fs.promises;
+  if (!fsPromises) {
+    return false;
+  }
+  const promiseMethods = [
+    ["readFile", import_jennifer5_agent7.FsActionType.PromiseRead],
+    ["writeFile", import_jennifer5_agent7.FsActionType.PromiseWrite]
+  ];
+  let patchedCount = 0;
+  for (const [method, event] of promiseMethods) {
+    if (fsPromises[method]?.[JENNIFER_WRAPPED3]) {
+      continue;
+    }
+    wrap(fsPromises, method, (original) => {
+      const wrapper = function(...args) {
+        const ctx = contextManager.getCurrentContext();
+        if (!ctx || !ctx.enable || !(0, import_jennifer5_agent7.configEnableFileProfile)()) {
+          return original.apply(this, args);
+        }
+        const filePathArg = args[0];
+        const filePath = filePathArg ? String(filePathArg) : "undefined";
+        const perfCtx = (0, import_jennifer5_agent7.createFsProfileCtx)(event, filePath, ctx.id);
+        try {
+          const result = original.apply(this, args);
+          if (result && typeof result.then === "function") {
+            return result.then(
+              (res) => {
+                (0, import_jennifer5_agent7.releaseFsProfileCtx)(perfCtx, {
+                  fileSize: res?.length
+                });
+                return res;
+              },
+              (err) => {
+                (0, import_jennifer5_agent7.releaseFsProfileCtx)(perfCtx, {
+                  error: {
+                    message: err.message,
+                    stack: err.stack
+                  }
+                });
+                throw err;
+              }
+            );
+          } else {
+            (0, import_jennifer5_agent7.releaseFsProfileCtx)(perfCtx, {});
+            return result;
+          }
+        } catch (error) {
+          (0, import_jennifer5_agent7.releaseFsProfileCtx)(perfCtx, {
+            error: { message: error.message, stack: error.stack }
+          });
+          throw error;
+        }
+      };
+      wrapper[JENNIFER_WRAPPED3] = true;
+      return wrapper;
+    });
+    patchedCount++;
+  }
+  if (patchedCount > 0) {
+    (0, import_jennifer5_agent7.info)(`fs.promises: ${patchedCount} methods instrumented`);
+  }
+  return patchedCount > 0;
+}
+
+// src/instrumentations/fetch.ts
+var import_jennifer5_agent8 = require("@jennifersoft/jennifer5-agent");
+var JENNIFER_WRAPPED4 = /* @__PURE__ */ Symbol.for("jennifer.fetch.wrapped");
+function handleRequestObject(originalFetch, request, init, txId) {
+  const normalizedRequest = init ? new Request(request, init) : request;
+  const url = normalizedRequest.url;
+  const method = normalizedRequest.method;
+  const fetchHeaders = new Headers(normalizedRequest.headers);
+  setTopologyFetchHeaders(fetchHeaders);
+  const headers = {};
+  fetchHeaders.forEach((value, key) => {
+    headers[key] = value;
+  });
+  const wrappedRequest = new Request(normalizedRequest, { headers: fetchHeaders });
+  const startCtx = (0, import_jennifer5_agent8.createHttpProfileCtx)(method, url, headers, txId);
+  const result = originalFetch(wrappedRequest);
+  return { result, startCtx };
+}
+function handleUrlString(originalFetch, input, init, txId) {
+  const url = typeof input === "string" ? input : input.href;
+  const method = init?.method || "GET";
+  const fetchHeaders = new Headers(init?.headers);
+  setTopologyFetchHeaders(fetchHeaders);
+  const headers = {};
+  fetchHeaders.forEach((value, key) => {
+    headers[key] = value;
+  });
+  const modifiedInit = {
+    ...init,
+    headers: fetchHeaders
+  };
+  const startCtx = (0, import_jennifer5_agent8.createHttpProfileCtx)(method, url, headers, txId);
+  const result = originalFetch(input, modifiedInit);
+  return { result, startCtx };
+}
+function createFetchWrapper(originalFetch) {
+  return function(...args) {
+    const ctx = contextManager.getCurrentContext();
+    if (!ctx || !ctx.enable || !(0, import_jennifer5_agent8.configEnableHttpClientProfile)()) {
+      return originalFetch(...args);
+    }
+    const [input, init] = args;
+    const { result, startCtx } = input instanceof Request ? handleRequestObject(originalFetch, input, init, ctx.id) : handleUrlString(originalFetch, input, init, ctx.id);
+    return result.then(
+      (response) => {
+        const contentLength = response.headers.get("content-length");
+        const responseSize = contentLength ? parseInt(contentLength, 10) : void 0;
+        const remoteCallInfo = getTopologyInfoFromFetch(response);
+        (0, import_jennifer5_agent8.releaseHttpProfileCtx)(startCtx, {
+          statusCode: response.status,
+          responseSize,
+          remoteCallInfo
+        });
+        return response;
+      },
+      (error) => {
+        (0, import_jennifer5_agent8.releaseHttpProfileCtx)(startCtx, {
+          error: {
+            message: error.message,
+            stack: error.stack
+          }
+        });
+        throw error;
+      }
+    );
+  };
+}
+function patchGlobalFetch() {
+  try {
+    if (typeof global.fetch !== "function") {
+      return;
+    }
+    if (global.fetch[JENNIFER_WRAPPED4]) {
+      return;
+    }
+    wrap(global, "fetch", (originalFetch) => {
+      const wrapper = createFetchWrapper(originalFetch);
+      wrapper[JENNIFER_WRAPPED4] = true;
+      return wrapper;
+    });
+    (0, import_jennifer5_agent8.info)("global.fetch instrumentation registered");
+  } catch (error) {
+    (0, import_jennifer5_agent8.warn)("Failed to register global.fetch instrumentation:" + error);
+  }
+}
+
+// src/instrumentations/n8n-workflow.ts
+var import_jennifer5_agent9 = require("@jennifersoft/jennifer5-agent");
+var JENNIFER_WRAPPED5 = /* @__PURE__ */ Symbol.for("jennifer.n8n.workflow.wrapped");
+var executionTxMap = /* @__PURE__ */ new Map();
+function registerWorkflowExecutionTx(executionId, txId) {
+  executionTxMap.set(executionId, txId);
+}
+function takeWorkflowExecutionTx(executionId) {
+  const txId = executionTxMap.get(executionId);
+  if (txId !== void 0) {
+    executionTxMap.delete(executionId);
+  }
+  return txId;
+}
+function patchN8nWorkflowRunner(workflowRunnerModule, moduleName) {
+  try {
+    if (!workflowRunnerModule?.WorkflowRunner) {
+      return;
+    }
+    instrumentWorkflowRunner(workflowRunnerModule.WorkflowRunner);
+    (0, import_jennifer5_agent9.info)(`${moduleName} WorkflowRunner instrumentation registered`);
+  } catch (error) {
+    (0, import_jennifer5_agent9.warn)(`Failed to register ${moduleName} WorkflowRunner instrumentation: ${error}`);
+  }
+}
+function instrumentWorkflowRunner(WorkflowRunnerClass) {
+  const prototype = WorkflowRunnerClass.prototype;
+  if (prototype?.run?.[JENNIFER_WRAPPED5]) {
+    return;
+  }
+  wrap(prototype, "run", (originalRun) => {
+    const wrapper = function(...args) {
+      const [data] = args;
+      const workflowData = data?.workflowData;
+      const workflowId = workflowData?.id;
+      const workflowName = workflowData?.name;
+      const executionMode = data?.executionMode;
+      const userId = data?.userId;
+      const ctx = contextManager.start();
+      if (ctx.enable) {
+        const serviceName = workflowName || workflowId || "unknown-workflow";
+        (0, import_jennifer5_agent9.createTransactionCtx)({
+          txId: ctx.id,
+          method: "n8n.workflow.run",
+          httpMethod: "EXECUTE",
+          httpUrl: `${serviceName}`,
+          httpHeaders: [
+            `execution-mode:${executionMode || "unknown"}`,
+            `workflow-id:${workflowId || "unknown"}`,
+            ...userId ? [`user-id:${userId}`] : []
+          ]
+        });
+      }
+      const result = contextManager.run(ctx, () => {
+        return originalRun.apply(this, args);
+      });
+      if (result && typeof result.then === "function") {
+        return result.then(
+          (executionId) => {
+            if (ctx.enable && typeof executionId === "string") {
+              registerWorkflowExecutionTx(executionId, ctx.id);
+            }
+            return executionId;
+          },
+          (error) => {
+            if (ctx.enable) {
+              (0, import_jennifer5_agent9.releaseTransactionCtx)(ctx.id, {
+                httpStatusCode: 500
+                // Error
+              });
+            }
+            throw error;
+          }
+        );
+      }
+      if (ctx.enable) {
+        (0, import_jennifer5_agent9.releaseTransactionCtx)(ctx.id, {
+          httpStatusCode: 200
+          // Success
+        });
+      }
+      return result;
+    };
+    wrapper[JENNIFER_WRAPPED5] = true;
+    return wrapper;
+  });
+}
+
+// src/instrumentations/n8n-active-executions.ts
+var import_jennifer5_agent10 = require("@jennifersoft/jennifer5-agent");
+var JENNIFER_WRAPPED6 = /* @__PURE__ */ Symbol.for("jennifer.n8n.active-executions.wrapped");
+function patchN8nActiveExecutions(activeExecutionsModule, moduleName) {
+  try {
+    if (!activeExecutionsModule?.ActiveExecutions) {
+      return;
+    }
+    instrumentActiveExecutions(activeExecutionsModule.ActiveExecutions);
+  } catch (error) {
+    (0, import_jennifer5_agent10.warn)(`Failed to register ${moduleName} ActiveExecutions instrumentation: ${error}`);
+  }
+}
+function instrumentActiveExecutions(ActiveExecutionsClass) {
+  const prototype = ActiveExecutionsClass.prototype;
+  if (prototype?.finalizeExecution?.[JENNIFER_WRAPPED6]) {
+    return;
+  }
+  wrap(prototype, "finalizeExecution", (originalFinalize) => {
+    const wrapper = function(executionId, fullRunData) {
+      const txId = typeof executionId === "string" ? takeWorkflowExecutionTx(executionId) : void 0;
+      try {
+        return originalFinalize.apply(this, arguments);
+      } finally {
+        if (txId !== void 0) {
+          const isError = fullRunData?.status === "error";
+          (0, import_jennifer5_agent10.releaseTransactionCtx)(txId, { httpStatusCode: isError ? 500 : 200 });
+        }
+      }
+    };
+    wrapper[JENNIFER_WRAPPED6] = true;
+    return wrapper;
+  });
+}
+
+// src/instrumentations/mariadb.ts
+var import_jennifer5_agent12 = require("@jennifersoft/jennifer5-agent");
+
+// src/instrumentations/db-utils.ts
+var import_jennifer5_agent11 = require("@jennifersoft/jennifer5-agent");
+function normalizeOptionalParams(value) {
+  if (value === void 0 || typeof value === "function") {
+    return void 0;
+  }
+  return value;
+}
+function buildSqlEndCtx(startCtx, error) {
+  return {
+    error: error ? {
+      message: error?.message,
+      stack: error?.stack
+    } : void 0,
+    id: startCtx?.id ?? 0,
+    txId: startCtx?.txId ?? 0
+  };
+}
+function releaseSqlProfile(startCtx, error) {
+  (0, import_jennifer5_agent11.releaseSqlProfileCtx)(startCtx, buildSqlEndCtx(startCtx, error));
+}
+function buildDbConnectionEndCtx(startCtx, error) {
+  return {
+    error: error ? {
+      message: error?.message,
+      stack: error?.stack
+    } : void 0,
+    id: startCtx?.id ?? 0,
+    txId: startCtx?.txId ?? 0
+  };
+}
+function releaseDbConnectionProfile(startCtx, error) {
+  (0, import_jennifer5_agent11.releaseDbConnectionProfileCtx)(startCtx, buildDbConnectionEndCtx(startCtx, error));
+}
+function toSqlParams(params, options) {
+  if (params === void 0 || params === null) {
+    return void 0;
+  }
+  if (Array.isArray(params)) {
+    return params.map((value) => buildSqlParam(value, options));
+  }
+  if (typeof params === "object") {
+    return Object.keys(params).map((key) => buildSqlParam(params[key], options));
+  }
+  return [buildSqlParam(params, options)];
+}
+function buildSqlParam(value, options) {
+  const normalized = normalizeSqlParamValue(value, options);
+  return {
+    value: normalized.value,
+    paramType: normalized.paramType
+  };
+}
+function normalizeSqlParamValue(input, options) {
+  const value = options?.unwrapValue ? options.unwrapValue(input) : input;
+  const bigintAsNumeric = options?.bigintAsNumeric ?? true;
+  if (value === null || value === void 0) {
+    return { value: "null", paramType: import_jennifer5_agent11.SqlParamType.String };
+  }
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return { value: String(value), paramType: import_jennifer5_agent11.SqlParamType.Numeric };
+  }
+  if (typeof value === "bigint") {
+    return {
+      value: value.toString(),
+      paramType: bigintAsNumeric ? import_jennifer5_agent11.SqlParamType.Numeric : import_jennifer5_agent11.SqlParamType.String
+    };
+  }
+  if (typeof value === "boolean") {
+    return { value: String(value), paramType: import_jennifer5_agent11.SqlParamType.String };
+  }
+  if (typeof value === "string") {
+    return { value, paramType: import_jennifer5_agent11.SqlParamType.String };
+  }
+  if (value instanceof Date) {
+    return { value: value.toISOString(), paramType: import_jennifer5_agent11.SqlParamType.String };
+  }
+  if (Buffer.isBuffer(value)) {
+    return { value: `[Buffer len=${value.length}]`, paramType: import_jennifer5_agent11.SqlParamType.String };
+  }
+  if (typeof value === "function") {
+    return { value: "[Function]", paramType: import_jennifer5_agent11.SqlParamType.String };
+  }
+  if (isStreamLike(value)) {
+    return { value: "[Stream]", paramType: import_jennifer5_agent11.SqlParamType.String };
+  }
+  if (typeof value === "object") {
+    try {
+      return {
+        value: JSON.stringify(value, jsonReplacer),
+        paramType: import_jennifer5_agent11.SqlParamType.String
+      };
+    } catch {
+      return {
+        value: Object.prototype.toString.call(value),
+        paramType: import_jennifer5_agent11.SqlParamType.String
+      };
+    }
+  }
+  return { value: String(value), paramType: import_jennifer5_agent11.SqlParamType.String };
+}
+function jsonReplacer(_key, input) {
+  if (typeof input === "bigint") {
+    return input.toString();
+  }
+  if (Buffer.isBuffer(input)) {
+    return `[Buffer len=${input.length}]`;
+  }
+  if (typeof input === "function") {
+    return "[Function]";
+  }
+  if (isStreamLike(input)) {
+    return "[Stream]";
+  }
+  if (typeof input === "symbol") {
+    return input.toString();
+  }
+  return input;
+}
+function isStreamLike(value) {
+  return Boolean(
+    value && typeof value === "object" && typeof value.pipe === "function" && typeof value.read === "function"
+  );
+}
+
+// src/instrumentations/mariadb.ts
+var JENNIFER_MARIADB_CREATE_CONNECTION_WRAPPED = /* @__PURE__ */ Symbol.for(
+  "jennifer.mariadb.create.connection.wrapped"
+);
+var JENNIFER_MARIADB_QUERY_START_WRAPPED = /* @__PURE__ */ Symbol.for("jennifer.mariadb.query.start.wrapped");
+var JENNIFER_MARIADB_EXECUTE_START_WRAPPED = /* @__PURE__ */ Symbol.for("jennifer.mariadb.execute.start.wrapped");
+function patchMariadbModule(mariadbModule, moduleName) {
+  try {
+    if (instrumentCreateConnection(mariadbModule)) {
+      (0, import_jennifer5_agent12.info)(`${moduleName}.createConnection instrumented`);
+    }
+  } catch (error) {
+    (0, import_jennifer5_agent12.warn)(`Failed to register ${moduleName} instrumentation: ${error}`);
+  }
+}
+function patchMariadbQueryCommandModule(queryCommandModule, moduleName) {
+  try {
+    if (instrumentCommandStart(
+      queryCommandModule?.prototype,
+      "start",
+      import_jennifer5_agent12.SqlExecuteMethod.ExecuteQuery,
+      JENNIFER_MARIADB_QUERY_START_WRAPPED
+    )) {
+      (0, import_jennifer5_agent12.info)(`${moduleName}.prototype.start instrumented`);
+    }
+  } catch (error) {
+    (0, import_jennifer5_agent12.warn)(`Failed to register ${moduleName} instrumentation: ${error}`);
+  }
+}
+function patchMariadbExecuteCommandModule(executeCommandModule, moduleName) {
+  try {
+    if (instrumentCommandStart(
+      executeCommandModule?.prototype,
+      "start",
+      import_jennifer5_agent12.SqlExecuteMethod.Execute,
+      JENNIFER_MARIADB_EXECUTE_START_WRAPPED
+    )) {
+      (0, import_jennifer5_agent12.info)(`${moduleName}.prototype.start instrumented`);
+    }
+  } catch (error) {
+    (0, import_jennifer5_agent12.warn)(`Failed to register ${moduleName} instrumentation: ${error}`);
+  }
+}
+function instrumentCommandStart(prototype, methodName, executeMethod, wrapMarker) {
+  if (!prototype || typeof prototype[methodName] !== "function" || prototype[methodName]?.[wrapMarker]) {
+    return false;
+  }
+  wrap(prototype, methodName, (originalMethod) => {
+    const wrapper = function(...args) {
+      const ctx = contextManager.getCurrentContext();
+      if (!ctx || !ctx.enable || !(0, import_jennifer5_agent12.configEnableMariadbProfile)()) {
+        return originalMethod.apply(this, args);
+      }
+      const sqlData = extractSqlAndParams(this);
+      if (!sqlData?.sql) {
+        return originalMethod.apply(this, args);
+      }
+      const startCtx = (0, import_jennifer5_agent12.createSqlProfileCtx)(
+        sqlData.sql,
+        executeMethod,
+        extractBoundParameters(sqlData.params),
+        ctx?.id
+      );
+      if (!startCtx) {
+        return originalMethod.apply(this, args);
+      }
+      let isReleased = false;
+      const releaseSuccess2 = () => {
+        if (isReleased) {
+          return;
+        }
+        isReleased = true;
+        releaseSqlProfile(startCtx);
+      };
+      const releaseError = (error) => {
+        if (isReleased) {
+          return;
+        }
+        isReleased = true;
+        releaseSqlProfile(startCtx, error);
+      };
+      const originalResolve = this?.resolve;
+      if (typeof originalResolve === "function") {
+        this.resolve = function(...resolveArgs) {
+          releaseSuccess2();
+          return originalResolve.apply(this, resolveArgs);
+        };
+      }
+      const originalReject = this?.reject;
+      if (typeof originalReject === "function") {
+        this.reject = function(error, ...rejectArgs) {
+          releaseError(error);
+          return originalReject.call(this, error, ...rejectArgs);
+        };
+      }
+      try {
+        return originalMethod.apply(this, args);
+      } catch (error) {
+        releaseError(error);
+        throw error;
+      }
+    };
+    wrapper[wrapMarker] = true;
+    return wrapper;
+  });
+  return true;
+}
+function instrumentCreateConnection(mariadbModule) {
+  if (!mariadbModule || typeof mariadbModule.createConnection !== "function" || mariadbModule.createConnection?.[JENNIFER_MARIADB_CREATE_CONNECTION_WRAPPED]) {
+    return false;
+  }
+  wrap(mariadbModule, "createConnection", (originalCreateConnection) => {
+    const wrapper = function(...args) {
+      const ctx = contextManager.getCurrentContext();
+      if (!ctx || !ctx.enable || !(0, import_jennifer5_agent12.configEnableMariadbProfile)()) {
+        return originalCreateConnection.apply(this, args);
+      }
+      const connectionInfo = extractConnectionInfo(args[0]);
+      const startCtx = (0, import_jennifer5_agent12.createDbConnectionProfileCtx)(connectionInfo, void 0, ctx.id);
+      try {
+        const result = originalCreateConnection.apply(this, args);
+        if (result && typeof result.then === "function") {
+          return result.then(
+            (connection) => {
+              releaseDbConnectionProfile(startCtx);
+              return connection;
+            },
+            (error) => {
+              releaseDbConnectionProfile(startCtx, error);
+              throw error;
+            }
+          );
+        }
+        releaseDbConnectionProfile(startCtx);
+        return result;
+      } catch (error) {
+        releaseDbConnectionProfile(startCtx, error);
+        throw error;
+      }
+    };
+    wrapper[JENNIFER_MARIADB_CREATE_CONNECTION_WRAPPED] = true;
+    return wrapper;
+  });
+  return true;
+}
+function extractSqlAndParams(command) {
+  const sql = command?.sql;
+  if (typeof sql !== "string") {
+    return void 0;
+  }
+  return {
+    sql,
+    params: command?.initialValues
+  };
+}
+function extractBoundParameters(params) {
+  return toSqlParams(params);
+}
+function extractConnectionInfo(config) {
+  if (!config) {
+    return void 0;
+  }
+  if (typeof config === "string") {
+    return parseMariadbConnectionString(config);
+  }
+  if (typeof config !== "object") {
+    return void 0;
+  }
+  return {
+    host: config.host || "localhost",
+    port: config.port || 3306,
+    user: config.user || "",
+    database: config.database || ""
+  };
+}
+function parseMariadbConnectionString(connectionString) {
+  try {
+    const parsed = new URL(connectionString);
+    return {
+      host: parsed.hostname || "localhost",
+      port: parsed.port ? Number(parsed.port) : 3306,
+      user: parsed.username || "",
+      database: parsed.pathname ? parsed.pathname.replace(/^\/+/, "") : ""
+    };
+  } catch {
+    return {
+      host: "localhost",
+      port: 3306,
+      user: "",
+      database: ""
+    };
+  }
+}
+
+// src/instrumentations/mysql2.ts
+var import_jennifer5_agent13 = require("@jennifersoft/jennifer5-agent");
+var JENNIFER_WRAPPED7 = /* @__PURE__ */ Symbol.for("jennifer.mysql2.wrapped");
+var JENNIFER_QUERY_WRAPPED = /* @__PURE__ */ Symbol.for("jennifer.mysql2.query.wrapped");
+var JENNIFER_EXECUTE_WRAPPED = /* @__PURE__ */ Symbol.for("jennifer.mysql2.execute.wrapped");
+function patchMysql2PromiseModule(mysql2Module, moduleName) {
+  patchMysql2CreateConnection(mysql2Module, moduleName, "promise");
+  patchMysql2ConnectionPrototype(mysql2Module, moduleName);
+}
+function patchMysql2Module(mysql2Module, moduleName) {
+  patchMysql2CreateConnection(mysql2Module, moduleName, "callback");
+  patchMysql2ConnectionPrototype(mysql2Module, moduleName);
+}
+function patchMysql2CreateConnection(mysql2Module, moduleName, mode) {
+  try {
+    if (instrumentCreateConnection2(mysql2Module, mode)) {
+      (0, import_jennifer5_agent13.info)(`${moduleName} instrumentation registered`);
+    }
+  } catch (error) {
+    (0, import_jennifer5_agent13.warn)(`Failed to register ${moduleName} instrumentation: ${error}`);
+  }
+}
+function patchMysql2ConnectionPrototype(mysql2Module, moduleName) {
+  try {
+    const instrumentedTargets = [];
+    if (instrumentConnectionPrototype(mysql2Module?.Connection)) {
+      instrumentedTargets.push("Connection.prototype");
+    }
+    if (instrumentConnectionPrototype(mysql2Module?.PoolConnection)) {
+      instrumentedTargets.push("PoolConnection.prototype");
+    }
+    if (instrumentConnectionPrototype(mysql2Module?.Pool)) {
+      instrumentedTargets.push("Pool.prototype");
+    }
+    if (instrumentedTargets.length > 0) {
+      (0, import_jennifer5_agent13.info)(`${moduleName}.${instrumentedTargets.join(", ")} instrumented`);
+    }
+  } catch (error) {
+    (0, import_jennifer5_agent13.warn)(`Failed to instrument ${moduleName} prototypes: ${error}`);
+  }
+}
+function instrumentCreateConnection2(mysql2Module, mode) {
+  if (typeof mysql2Module?.createConnection !== "function") {
+    return false;
+  }
+  if (mysql2Module.createConnection?.[JENNIFER_WRAPPED7]) {
+    return false;
+  }
+  wrap(mysql2Module, "createConnection", (originalCreateConnection) => {
+    const wrapper = function(...args) {
+      const ctx = contextManager.getCurrentContext();
+      if (!ctx || !ctx.enable || !(0, import_jennifer5_agent13.configEnableMysql2Profile)()) {
+        return originalCreateConnection.apply(this, args);
+      }
+      const connectionInfo = extractConnectionInfo2(args[0]);
+      const startCtx = (0, import_jennifer5_agent13.createDbConnectionProfileCtx)(connectionInfo, void 0, ctx?.id);
+      try {
+        const result = originalCreateConnection.apply(this, args);
+        if (mode === "callback") {
+          instrumentConnectionPrototype(result);
+          releaseDbConnectionProfile(startCtx);
+          return result;
+        }
+        if (result && typeof result.then === "function") {
+          return result.then(
+            (connection) => {
+              instrumentConnectionPrototype(connection?.connection ?? connection);
+              releaseDbConnectionProfile(startCtx);
+              return connection;
+            },
+            (error) => {
+              releaseDbConnectionProfile(startCtx, error);
+              throw error;
+            }
+          );
+        }
+        releaseDbConnectionProfile(startCtx);
+        return result;
+      } catch (error) {
+        releaseDbConnectionProfile(startCtx, error);
+        throw error;
+      }
+    };
+    wrapper[JENNIFER_WRAPPED7] = true;
+    return wrapper;
+  });
+  return true;
+}
+function instrumentConnectionPrototype(target) {
+  const prototype = resolveConnectionPrototype(target);
+  if (!prototype) {
+    return false;
+  }
+  const queryInstrumented = instrumentSqlMethod(
+    prototype,
+    "query",
+    import_jennifer5_agent13.SqlExecuteMethod.ExecuteQuery,
+    JENNIFER_QUERY_WRAPPED
+  );
+  const executeInstrumented = instrumentSqlMethod(
+    prototype,
+    "execute",
+    import_jennifer5_agent13.SqlExecuteMethod.Execute,
+    JENNIFER_EXECUTE_WRAPPED
+  );
+  return queryInstrumented || executeInstrumented;
+}
+function resolveConnectionPrototype(target) {
+  if (!target) {
+    return void 0;
+  }
+  if (target.prototype) {
+    return target.prototype;
+  }
+  return target.constructor?.prototype;
+}
+function instrumentSqlMethod(prototype, methodName, executeMethod, wrapMarker) {
+  if (typeof prototype?.[methodName] !== "function" || prototype[methodName]?.[wrapMarker]) {
+    return false;
+  }
+  wrap(prototype, methodName, (originalMethod) => {
+    const wrapper = function(...args) {
+      const ctx = contextManager.getCurrentContext();
+      if (!ctx || !ctx.enable || !(0, import_jennifer5_agent13.configEnableMysql2Profile)()) {
+        return originalMethod.apply(this, args);
+      }
+      const sqlData = extractSqlAndParams2(args);
+      if (!sqlData?.sql) {
+        return originalMethod.apply(this, args);
+      }
+      const startCtx = (0, import_jennifer5_agent13.createSqlProfileCtx)(
+        sqlData.sql,
+        executeMethod,
+        extractBoundParameters2(sqlData.params),
+        ctx?.id
+      );
+      if (!startCtx) {
+        return originalMethod.apply(this, args);
+      }
+      let isReleased = false;
+      const releaseSuccess2 = () => {
+        if (isReleased) return;
+        isReleased = true;
+        releaseSqlProfile(startCtx);
+      };
+      const releaseError = (error) => {
+        if (isReleased) return;
+        isReleased = true;
+        releaseSqlProfile(startCtx, error);
+      };
+      const lastArgIndex = args.length - 1;
+      const hasCallback = lastArgIndex >= 0 && typeof args[lastArgIndex] === "function";
+      if (hasCallback) {
+        const originalCallback = args[lastArgIndex];
+        args[lastArgIndex] = function(...callbackArgs) {
+          releaseError(callbackArgs[0]);
+          return contextManager.run(ctx, () => originalCallback.apply(this, callbackArgs));
+        };
+      }
+      try {
+        const result = originalMethod.apply(this, args);
+        if (hasCallback) {
+          return result;
+        }
+        if (result && typeof result.once === "function") {
+          result.once("error", (error) => releaseError(error));
+          result.once("end", () => releaseSuccess2());
+          return result;
+        }
+        if (result && typeof result.then === "function") {
+          return result.then(
+            (value) => {
+              releaseSuccess2();
+              return value;
+            },
+            (error) => {
+              releaseError(error);
+              throw error;
+            }
+          );
+        }
+        releaseSuccess2();
+        return result;
+      } catch (error) {
+        releaseError(error);
+        throw error;
+      }
+    };
+    wrapper[wrapMarker] = true;
+    return wrapper;
+  });
+  return true;
+}
+function extractConnectionInfo2(config) {
+  if (!config) {
+    return void 0;
+  }
+  const normalizedConfig = typeof config === "object" ? config : {};
+  return {
+    host: normalizedConfig.host || "localhost",
+    port: normalizedConfig.port || 3306,
+    user: normalizedConfig.user || "",
+    database: normalizedConfig.database || ""
+  };
+}
+function extractSqlAndParams2(args) {
+  if (!args.length) {
+    return void 0;
+  }
+  const firstArg = args[0];
+  const secondArg = args[1];
+  if (typeof firstArg === "string") {
+    return {
+      sql: firstArg,
+      params: normalizeOptionalParams(secondArg)
+    };
+  }
+  if (firstArg && typeof firstArg === "object" && typeof firstArg.sql === "string") {
+    const params = firstArg.values !== void 0 ? firstArg.values : normalizeOptionalParams(secondArg);
+    return {
+      sql: firstArg.sql,
+      params
+    };
+  }
+  return void 0;
+}
+function extractBoundParameters2(params) {
+  return toSqlParams(params);
+}
+
+// src/instrumentations/ioredis.ts
+var import_jennifer5_agent15 = require("@jennifersoft/jennifer5-agent");
+
+// src/instrumentations/redis-utils.ts
+var import_jennifer5_agent14 = require("@jennifersoft/jennifer5-agent");
+function normalizeRedisCommandName(name) {
+  if (typeof name === "string" && name) {
+    return name.toUpperCase();
+  }
+  if (Buffer.isBuffer(name) && name.length > 0) {
+    return name.toString("utf8").toUpperCase();
+  }
+  return void 0;
+}
+function isRedisCommandBlocked(commandName) {
+  const blockedCommands = (0, import_jennifer5_agent14.configRedisCommandBlocklist)();
+  if (!Array.isArray(blockedCommands) || blockedCommands.length === 0) {
+    return false;
+  }
+  return blockedCommands.some((blockedCommand) => {
+    if (typeof blockedCommand !== "string" || !blockedCommand) {
+      return false;
+    }
+    return blockedCommand.toUpperCase() === commandName;
+  });
+}
+function extractRedisMethodArguments(commandArgs, keyIndex) {
+  if (!Array.isArray(commandArgs) || commandArgs.length <= keyIndex) {
+    return [];
+  }
+  const key = stringifyRedisArgument(commandArgs[keyIndex]);
+  return key ? [key] : [];
+}
+function stringifyRedisArgument(value) {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  if (Buffer.isBuffer(value)) {
+    return `[Buffer len=${value.length}]`;
+  }
+  const normalized = String(value);
+  const maxArgLen = 256;
+  return normalized.length > maxArgLen ? `${normalized.slice(0, maxArgLen)}...` : normalized;
+}
+
+// src/instrumentations/ioredis.ts
+var JENNIFER_IOREDIS_CONNECT_WRAPPED = /* @__PURE__ */ Symbol.for("jennifer.ioredis.connect.wrapped");
+var JENNIFER_IOREDIS_SEND_COMMAND_WRAPPED = /* @__PURE__ */ Symbol.for("jennifer.ioredis.sendCommand.wrapped");
+function patchIoredisModule(ioredisModule, moduleName) {
+  try {
+    const connectInstrumented = instrumentRedisConnect(ioredisModule);
+    const commandInstrumented = instrumentRedisSendCommand(ioredisModule);
+    if (connectInstrumented) {
+      (0, import_jennifer5_agent15.info)(`${moduleName}.prototype.connect instrumented`);
+    }
+    if (commandInstrumented) {
+      (0, import_jennifer5_agent15.info)(`${moduleName}.prototype.sendCommand instrumented`);
+    }
+  } catch (error) {
+    (0, import_jennifer5_agent15.warn)(`Failed to register ${moduleName} instrumentation: ${error}`);
+  }
+}
+function instrumentRedisConnect(ioredisModule) {
+  const Redis = resolveRedisConstructor(ioredisModule);
+  const prototype = Redis?.prototype;
+  if (!prototype || typeof prototype.connect !== "function" || prototype.connect?.[JENNIFER_IOREDIS_CONNECT_WRAPPED]) {
+    return false;
+  }
+  wrap(prototype, "connect", (originalConnect) => {
+    const wrapper = function(...args) {
+      const ctx = contextManager.getCurrentContext();
+      if (!ctx || !ctx.enable || !(0, import_jennifer5_agent15.configEnableRedisProfile)()) {
+        return originalConnect.apply(this, args);
+      }
+      const connectionString = buildRedisConnectionString(this?.options);
+      const startCtx = (0, import_jennifer5_agent15.createDbConnectionProfileCtx)(void 0, connectionString, ctx.id);
+      try {
+        const result = originalConnect.apply(this, args);
+        if (result && typeof result.then === "function") {
+          return result.then(
+            (value) => {
+              releaseDbConnectionProfile(startCtx);
+              return value;
+            },
+            (error) => {
+              releaseDbConnectionProfile(startCtx, error);
+              throw error;
+            }
+          );
+        }
+        releaseDbConnectionProfile(startCtx);
+        return result;
+      } catch (error) {
+        releaseDbConnectionProfile(startCtx, error);
+        throw error;
+      }
+    };
+    wrapper[JENNIFER_IOREDIS_CONNECT_WRAPPED] = true;
+    return wrapper;
+  });
+  return true;
+}
+function instrumentRedisSendCommand(ioredisModule) {
+  const Redis = resolveRedisConstructor(ioredisModule);
+  const prototype = Redis?.prototype;
+  if (!prototype || typeof prototype.sendCommand !== "function" || prototype.sendCommand?.[JENNIFER_IOREDIS_SEND_COMMAND_WRAPPED]) {
+    return false;
+  }
+  wrap(prototype, "sendCommand", (originalSendCommand) => {
+    const wrapper = function(...args) {
+      const ctx = contextManager.getCurrentContext();
+      const command = args[0];
+      const commandName = normalizeRedisCommandName(command?.name);
+      if (!ctx || !ctx.enable || !(0, import_jennifer5_agent15.configEnableRedisProfile)() || !commandName || isRedisCommandBlocked(commandName)) {
+        return originalSendCommand.apply(this, args);
+      }
+      const methodArgs = extractRedisMethodArguments(command?.args, 0);
+      const startCtx = (0, import_jennifer5_agent15.createMethodProfileCtx)(`Redis.${commandName}`, methodArgs, ctx.id);
+      if (!startCtx) {
+        return originalSendCommand.apply(this, args);
+      }
+      let isReleased = false;
+      const releaseSuccess2 = () => {
+        if (isReleased) {
+          return;
+        }
+        isReleased = true;
+        (0, import_jennifer5_agent15.releaseMethodProfileCtx)(startCtx, {
+          id: startCtx?.id ?? 0,
+          txId: startCtx?.txId ?? 0
+        });
+      };
+      const releaseError = (error) => {
+        if (isReleased) {
+          return;
+        }
+        isReleased = true;
+        (0, import_jennifer5_agent15.releaseMethodProfileCtx)(startCtx, {
+          id: startCtx?.id ?? 0,
+          txId: startCtx?.txId ?? 0,
+          error: error ? {
+            message: error?.message,
+            stack: error?.stack
+          } : void 0
+        });
+      };
+      try {
+        const result = originalSendCommand.apply(this, args);
+        if (result && typeof result.then === "function") {
+          return result.then(
+            (value) => {
+              releaseSuccess2();
+              return value;
+            },
+            (error) => {
+              releaseError(error);
+              throw error;
+            }
+          );
+        }
+        releaseSuccess2();
+        return result;
+      } catch (error) {
+        releaseError(error);
+        throw error;
+      }
+    };
+    wrapper[JENNIFER_IOREDIS_SEND_COMMAND_WRAPPED] = true;
+    return wrapper;
+  });
+  return true;
+}
+function resolveRedisConstructor(ioredisModule) {
+  if (typeof ioredisModule === "function") {
+    return ioredisModule;
+  }
+  if (typeof ioredisModule?.default === "function") {
+    return ioredisModule.default;
+  }
+  if (typeof ioredisModule?.Redis === "function") {
+    return ioredisModule.Redis;
+  }
+  return void 0;
+}
+function buildRedisConnectionString(options) {
+  const { host, port, db } = extractConnectionOptions(options);
+  return `datasource : redis://${host}:${port}/${db}`;
+}
+function extractConnectionOptions(options) {
+  if (!options || typeof options !== "object") {
+    return { host: "localhost", port: 6379, db: "0" };
+  }
+  const rawDb = options.db;
+  const db = rawDb === void 0 || rawDb === null || rawDb === "" ? "0" : String(rawDb);
+  return {
+    host: options.host || options.sentinels?.[0]?.host || "localhost",
+    port: Number(options.port || options.sentinels?.[0]?.port || 6379),
+    db
+  };
+}
+
+// src/instrumentations/oracledb.ts
+var import_jennifer5_agent16 = require("@jennifersoft/jennifer5-agent");
+var JENNIFER_WRAPPED8 = /* @__PURE__ */ Symbol.for("jennifer.oracledb.wrapped");
+var JENNIFER_PROTO_WRAPPED = /* @__PURE__ */ Symbol.for("jennifer.oracledb.connection.prototype.wrapped");
+function patchOracleDbModule(oracledbModule, moduleName) {
+  try {
+    if (instrumentGetConnection(oracledbModule)) {
+      (0, import_jennifer5_agent16.info)(`${moduleName}.getConnection instrumented`);
+    }
+    if (instrumentConnectionPrototype2(oracledbModule)) {
+      (0, import_jennifer5_agent16.info)(`${moduleName}.Connection.prototype instrumented`);
+    }
+  } catch (error) {
+    (0, import_jennifer5_agent16.warn)(`Failed to register ${moduleName} instrumentation: ${error}`);
+  }
+}
+function instrumentGetConnection(oracledbModule) {
+  if (oracledbModule.getConnection?.[JENNIFER_WRAPPED8]) {
+    return false;
+  }
+  wrap(oracledbModule, "getConnection", (originalGetConnection) => {
+    const wrapper = function(...args) {
+      const config = args[0];
+      const ctx = contextManager.getCurrentContext();
+      if (!ctx || !ctx.enable || !(0, import_jennifer5_agent16.configEnableOracledbProfile)()) {
+        return originalGetConnection.apply(this, args);
+      }
+      const connectionInfo = extractConnectionInfo3(config);
+      const startCtx = (0, import_jennifer5_agent16.createDbConnectionProfileCtx)(connectionInfo, void 0, ctx?.id);
+      const lastArgIndex = args.length - 1;
+      const hasCallback = lastArgIndex >= 0 && typeof args[lastArgIndex] === "function";
+      if (hasCallback) {
+        const originalCallback = args[lastArgIndex];
+        args[lastArgIndex] = function(error, connection) {
+          releaseWithError(startCtx, error);
+          return contextManager.run(ctx, () => originalCallback.call(this, error, connection));
+        };
+      }
+      try {
+        const connectionResult = originalGetConnection.apply(this, args);
+        if (hasCallback) {
+          return connectionResult;
+        }
+        if (connectionResult && typeof connectionResult.then === "function") {
+          return handlePromise(connectionResult, startCtx);
+        }
+        releaseSuccess(startCtx);
+        return connectionResult;
+      } catch (error) {
+        releaseWithError(startCtx, error);
+        throw error;
+      }
+    };
+    wrapper[JENNIFER_WRAPPED8] = true;
+    return wrapper;
+  });
+  return true;
+}
+function handlePromise(connectionPromise, startCtx) {
+  return connectionPromise.then(
+    (connection) => {
+      releaseSuccess(startCtx);
+      return connection;
+    },
+    (error) => {
+      releaseWithError(startCtx, error);
+      throw error;
+    }
+  );
+}
+function releaseSuccess(startCtx) {
+  releaseDbConnectionProfile(startCtx);
+}
+function releaseWithError(startCtx, error) {
+  releaseDbConnectionProfile(startCtx, error);
+}
+function instrumentConnectionPrototype2(oracledbModule) {
+  const connectionProto = oracledbModule?.Connection?.prototype;
+  if (!connectionProto || connectionProto.execute?.[JENNIFER_PROTO_WRAPPED]) {
+    return false;
+  }
+  wrap(connectionProto, "execute", (originalExecute) => {
+    const wrapper = function(...args) {
+      const ctx = contextManager.getCurrentContext();
+      if (!ctx || !ctx.enable || !(0, import_jennifer5_agent16.configEnableOracledbProfile)()) {
+        return originalExecute.apply(this, args);
+      }
+      const sql = typeof args[0] === "string" ? args[0] : void 0;
+      if (!sql) {
+        return originalExecute.apply(this, args);
+      }
+      const boundParameters = extractBoundParameters3(args[1]);
+      const startCtx = (0, import_jennifer5_agent16.createSqlProfileCtx)(sql, import_jennifer5_agent16.SqlExecuteMethod.Execute, boundParameters, ctx?.id);
+      if (!startCtx) {
+        return originalExecute.apply(this, args);
+      }
+      const lastArgIndex = args.length - 1;
+      const hasCallback = lastArgIndex >= 0 && typeof args[lastArgIndex] === "function";
+      if (hasCallback) {
+        const originalCallback = args[lastArgIndex];
+        args[lastArgIndex] = function(error, result) {
+          releaseSqlWithError(startCtx, error);
+          return contextManager.run(ctx, () => originalCallback.call(this, error, result));
+        };
+      }
+      try {
+        const resultPromise = originalExecute.apply(this, args);
+        if (hasCallback) {
+          return resultPromise;
+        }
+        if (resultPromise && typeof resultPromise.then === "function") {
+          return handleSqlPromise(resultPromise, startCtx);
+        }
+        releaseSqlSuccess(startCtx);
+        return resultPromise;
+      } catch (error) {
+        releaseSqlWithError(startCtx, error);
+        throw error;
+      }
+    };
+    wrapper[JENNIFER_PROTO_WRAPPED] = true;
+    return wrapper;
+  });
+  return true;
+}
+function handleSqlPromise(resultPromise, startCtx) {
+  return resultPromise.then(
+    (result) => {
+      releaseSqlSuccess(startCtx);
+      return result;
+    },
+    (error) => {
+      releaseSqlWithError(startCtx, error);
+      throw error;
+    }
+  );
+}
+function releaseSqlSuccess(startCtx) {
+  releaseSqlProfile(startCtx);
+}
+function releaseSqlWithError(startCtx, error) {
+  releaseSqlProfile(startCtx, error);
+}
+function extractBoundParameters3(binds) {
+  if (!binds) {
+    return void 0;
+  }
+  if (!Array.isArray(binds) && typeof binds !== "object") {
+    return void 0;
+  }
+  return toSqlParams(binds, {
+    unwrapValue: (value) => value && typeof value === "object" && "val" in value ? value.val : value
+  });
+}
+function extractConnectionInfo3(config) {
+  if (!config || typeof config === "function") {
+    return getDefaultPoolInfo();
+  }
+  if (typeof config === "string") {
+    if (isLikelyPoolAlias(config)) {
+      return getPoolAliasInfo(config);
+    }
+    const parsed2 = parseOracleConnectString(config);
+    return {
+      host: parsed2.host,
+      port: parsed2.port,
+      user: "",
+      database: parsed2.serviceName
+    };
+  }
+  const connectString = typeof config.connectString === "string" ? config.connectString : "";
+  const parsed = connectString ? parseOracleConnectString(connectString) : void 0;
+  const poolAlias = typeof config.poolAlias === "string" ? config.poolAlias : "";
+  if (!parsed && poolAlias) {
+    return {
+      ...getPoolAliasInfo(poolAlias),
+      user: config.user || ""
+    };
+  }
+  return {
+    host: parsed?.host || "localhost",
+    port: parsed?.port || 1521,
+    user: config.user || "",
+    database: parsed?.serviceName || ""
+  };
+}
+function parseOracleConnectString(connectString) {
+  if (!connectString) {
+    return {
+      host: "localhost",
+      port: 1521,
+      serviceName: ""
+    };
+  }
+  const match = connectString.match(/^([^:/]+)(?::(\d+))?(?:\/([^\?]+))?/);
+  if (match) {
+    return {
+      host: match[1] || "localhost",
+      port: Number(match[2] || "1521"),
+      serviceName: match[3] || ""
+    };
+  }
+  return {
+    host: connectString,
+    port: 1521,
+    serviceName: ""
+  };
+}
+function isLikelyPoolAlias(value) {
+  return !/[/:]/.test(value);
+}
+function getDefaultPoolInfo() {
+  return getPoolAliasInfo("default");
+}
+function getPoolAliasInfo(alias) {
+  return {
+    host: `alias:${alias}`,
+    port: 1521,
+    user: "",
+    database: ""
+  };
+}
+
+// src/instrumentations/pg.ts
+var import_jennifer5_agent17 = require("@jennifersoft/jennifer5-agent");
+var JENNIFER_PG_CLIENT_QUERY_WRAPPED = /* @__PURE__ */ Symbol.for("jennifer.pg.client.query.wrapped");
+function patchPgClientModule(clientModule, moduleName) {
+  try {
+    const clientPrototype = resolveClientPrototype(clientModule);
+    if (!instrumentQueryMethod(clientPrototype, "query", JENNIFER_PG_CLIENT_QUERY_WRAPPED)) {
+      return;
+    }
+    (0, import_jennifer5_agent17.info)(`${moduleName}.Client.prototype.query instrumented`);
+  } catch (error) {
+    (0, import_jennifer5_agent17.warn)(`Failed to register ${moduleName} instrumentation: ${error}`);
+  }
+}
+function resolveClientPrototype(clientModule) {
+  if (!clientModule) {
+    return void 0;
+  }
+  if (clientModule?.Client?.prototype) {
+    return clientModule.Client.prototype;
+  }
+  if (clientModule?.prototype) {
+    return clientModule.prototype;
+  }
+  if (clientModule?.default?.prototype) {
+    return clientModule.default.prototype;
+  }
+  if (clientModule?.default?.Client?.prototype) {
+    return clientModule.default.Client.prototype;
+  }
+  return void 0;
+}
+function instrumentQueryMethod(prototype, methodName, wrapMarker) {
+  if (!prototype || typeof prototype[methodName] !== "function" || prototype[methodName]?.[wrapMarker]) {
+    return false;
+  }
+  wrap(prototype, methodName, (originalMethod) => {
+    const wrapper = function(...args) {
+      const ctx = contextManager.getCurrentContext();
+      if (!ctx || !ctx.enable || !(0, import_jennifer5_agent17.configEnablePgProfile)()) {
+        return originalMethod.apply(this, args);
+      }
+      const sqlData = extractSqlAndParams3(args);
+      if (!sqlData?.sql) {
+        return originalMethod.apply(this, args);
+      }
+      const startCtx = (0, import_jennifer5_agent17.createSqlProfileCtx)(
+        sqlData.sql,
+        import_jennifer5_agent17.SqlExecuteMethod.ExecuteQuery,
+        extractBoundParameters4(sqlData.params),
+        ctx?.id
+      );
+      if (!startCtx) {
+        return originalMethod.apply(this, args);
+      }
+      let isReleased = false;
+      const releaseSuccess2 = () => {
+        if (isReleased) {
+          return;
+        }
+        isReleased = true;
+        releaseSqlProfile(startCtx);
+      };
+      const releaseError = (error) => {
+        if (isReleased) {
+          return;
+        }
+        isReleased = true;
+        releaseSqlProfile(startCtx, error);
+      };
+      const lastArgIndex = args.length - 1;
+      const hasCallback = lastArgIndex >= 0 && typeof args[lastArgIndex] === "function";
+      if (hasCallback) {
+        const originalCallback = args[lastArgIndex];
+        args[lastArgIndex] = function(...callbackArgs) {
+          const callbackError = callbackArgs[0];
+          if (callbackError) {
+            releaseError(callbackError);
+          } else {
+            releaseSuccess2();
+          }
+          return contextManager.run(ctx, () => originalCallback.apply(this, callbackArgs));
+        };
+      }
+      try {
+        const result = originalMethod.apply(this, args);
+        if (hasCallback) {
+          return result;
+        }
+        if (result && typeof result.then === "function") {
+          return result.then(
+            (value) => {
+              releaseSuccess2();
+              return value;
+            },
+            (error) => {
+              releaseError(error);
+              throw error;
+            }
+          );
+        }
+        if (result && typeof result.once === "function") {
+          result.once("end", releaseSuccess2);
+          result.once("error", releaseError);
+          return result;
+        }
+        releaseSuccess2();
+        return result;
+      } catch (error) {
+        releaseError(error);
+        throw error;
+      }
+    };
+    wrapper[wrapMarker] = true;
+    return wrapper;
+  });
+  return true;
+}
+function extractSqlAndParams3(args) {
+  if (!args.length) {
+    return void 0;
+  }
+  const firstArg = args[0];
+  const secondArg = args[1];
+  if (firstArg && typeof firstArg === "object" && typeof firstArg.submit === "function") {
+    return void 0;
+  }
+  if (typeof firstArg === "string") {
+    return {
+      sql: firstArg,
+      params: normalizeOptionalParams(secondArg)
+    };
+  }
+  if (firstArg && typeof firstArg === "object" && typeof firstArg.text === "string") {
+    return {
+      sql: firstArg.text,
+      params: normalizeOptionalParams(firstArg.values)
+    };
+  }
+  return void 0;
+}
+function extractBoundParameters4(params) {
+  return toSqlParams(params);
+}
+
+// src/instrumentations/prisma.ts
+var import_jennifer5_agent18 = require("@jennifersoft/jennifer5-agent");
+var JENNIFER_WRAPPED9 = /* @__PURE__ */ Symbol.for("jennifer.prisma.wrapped");
+var JENNIFER_INSTANCE_WRAPPED = /* @__PURE__ */ Symbol.for("jennifer.prisma.instance.wrapped");
+function patchPrismaModule(prismaModule, moduleName) {
+  try {
+    if (instrumentPrismaClient(prismaModule)) {
+      (0, import_jennifer5_agent18.info)(`${moduleName}.PrismaClient instrumented`);
+    }
+  } catch (error) {
+    (0, import_jennifer5_agent18.warn)(`Failed to register ${moduleName} instrumentation: ${error}`);
+  }
+}
+function instrumentPrismaClient(prismaModule) {
+  if (!prismaModule?.PrismaClient || prismaModule.PrismaClient[JENNIFER_WRAPPED9]) {
+    return false;
+  }
+  wrap(prismaModule, "PrismaClient", (originalConstructor) => {
+    const wrapper = function(...args) {
+      const instance = Reflect.construct(originalConstructor, args);
+      const patchedInstance = patchPrismaInstance(instance);
+      return patchedInstance ?? instance;
+    };
+    wrapper[JENNIFER_WRAPPED9] = true;
+    return wrapper;
+  });
+  return true;
+}
+function patchPrismaInstance(prismaInstance) {
+  if (!prismaInstance || prismaInstance[JENNIFER_INSTANCE_WRAPPED]) {
+    return prismaInstance;
+  }
+  prismaInstance[JENNIFER_INSTANCE_WRAPPED] = true;
+  hookUseMiddleware(prismaInstance);
+  return hookQueryExtension(prismaInstance) ?? prismaInstance;
+}
+function safeStringify(args) {
+  if (!args) return "";
+  try {
+    const stringified = JSON.stringify(args);
+    return stringified.length > 1e3 ? `${stringified.substring(0, 1e3)}...` : stringified;
+  } catch {
+    return "[Unserializable Args]";
+  }
+}
+function hookUseMiddleware(prismaInstance) {
+  if (typeof prismaInstance.$use !== "function") {
+    return;
+  }
+  prismaInstance.$use(async (params, next) => {
+    const ctx = contextManager.getCurrentContext();
+    if (!ctx || !ctx.enable || !(0, import_jennifer5_agent18.configEnablePrismaProfile)()) {
+      return next(params);
+    }
+    const modelName = params?.model;
+    const action = params?.operation || params?.action || "unknown";
+    const argsStr = safeStringify(params?.args);
+    const queryInfo = modelName ? `Prisma ${modelName}.${action}`.trim() : `Prisma.${action}`.trim();
+    const startCtx = (0, import_jennifer5_agent18.createSqlProfileCtx)(
+      queryInfo,
+      import_jennifer5_agent18.SqlExecuteMethod.Execute,
+      [
+        {
+          value: argsStr,
+          paramType: import_jennifer5_agent18.SqlParamType.String
+        }
+      ],
+      ctx.id
+    );
+    if (!startCtx) {
+      return next(params);
+    }
+    try {
+      const result = await next(params);
+      releaseSqlProfile(startCtx);
+      return result;
+    } catch (error) {
+      releaseSqlProfile(startCtx, error);
+      throw error;
+    }
+  });
+}
+function hookQueryExtension(prismaInstance) {
+  if (typeof prismaInstance.$extends !== "function") {
+    return prismaInstance;
+  }
+  const traceOperation = async (params) => {
+    const ctx = contextManager.getCurrentContext();
+    if (!ctx || !ctx.enable || !(0, import_jennifer5_agent18.configEnablePrismaProfile)()) {
+      return params.query(params.args);
+    }
+    const modelName = params?.model;
+    const action = params?.operation || params?.action || "unknown";
+    const argsStr = safeStringify(params?.args);
+    const queryInfo = modelName ? `Prisma ${modelName}.${action} ?`.trim() : `Prisma.${action} ?`.trim();
+    const startCtx = (0, import_jennifer5_agent18.createSqlProfileCtx)(
+      queryInfo,
+      import_jennifer5_agent18.SqlExecuteMethod.Execute,
+      [
+        {
+          value: argsStr,
+          paramType: import_jennifer5_agent18.SqlParamType.String
+        }
+      ],
+      ctx.id
+    );
+    if (!startCtx) {
+      return params.query(params.args);
+    }
+    try {
+      const result = await params.query(params.args);
+      releaseSqlProfile(startCtx);
+      return result;
+    } catch (error) {
+      releaseSqlProfile(startCtx, error);
+      throw error;
+    }
+  };
+  const extended = prismaInstance.$extends({
+    query: {
+      $allModels: {
+        $allOperations: async (params) => traceOperation(params)
+      },
+      // Raw queries
+      $queryRaw: async (params) => traceOperation(params),
+      $executeRaw: async (params) => traceOperation(params),
+      $queryRawUnsafe: async (params) => traceOperation(params),
+      $executeRawUnsafe: async (params) => traceOperation(params)
+    }
+  });
+  extended[JENNIFER_INSTANCE_WRAPPED] = true;
+  return extended;
+}
+
+// src/instrumentations/redis.ts
+var import_jennifer5_agent19 = require("@jennifersoft/jennifer5-agent");
+var JENNIFER_REDIS_CONNECT_WRAPPED = /* @__PURE__ */ Symbol.for("jennifer.redis.connect.wrapped");
+var JENNIFER_REDIS_ADD_COMMAND_WRAPPED = /* @__PURE__ */ Symbol.for("jennifer.redis.addCommand.wrapped");
+var JENNIFER_REDIS_CREATE_CLIENT_WRAPPED = /* @__PURE__ */ Symbol.for("jennifer.redis.createClient.wrapped");
+function patchRedisModule(redisModule, moduleName) {
+  try {
+    const instrumented = instrumentRedisCreateClient(redisModule);
+    if (instrumented) {
+      (0, import_jennifer5_agent19.info)(`${moduleName}.createClient instrumented`);
+    }
+  } catch (error) {
+    (0, import_jennifer5_agent19.warn)(`Failed to register ${moduleName} instrumentation: ${error}`);
+  }
+}
+function patchRedisCommandsQueueModule(redisCommandsQueueModule, moduleName) {
+  try {
+    const instrumented = instrumentRedisAddCommand(redisCommandsQueueModule);
+    if (instrumented) {
+      (0, import_jennifer5_agent19.info)(`${moduleName}.prototype.addCommand instrumented`);
+    }
+  } catch (error) {
+    (0, import_jennifer5_agent19.warn)(`Failed to register ${moduleName} instrumentation: ${error}`);
+  }
+}
+function instrumentRedisCreateClient(redisModule) {
+  if (!redisModule || typeof redisModule.createClient !== "function" || redisModule.createClient[JENNIFER_REDIS_CREATE_CLIENT_WRAPPED]) {
+    return false;
+  }
+  wrap(redisModule, "createClient", (originalCreateClient) => {
+    const wrapper = function(...args) {
+      const client = originalCreateClient.apply(this, args);
+      instrumentRedisConnect2(client);
+      return client;
+    };
+    wrapper[JENNIFER_REDIS_CREATE_CLIENT_WRAPPED] = true;
+    return wrapper;
+  });
+  return true;
+}
+function instrumentRedisConnect2(client) {
+  const prototype = resolveRedisConnectPrototype(client);
+  if (!prototype || prototype.connect[JENNIFER_REDIS_CONNECT_WRAPPED]) {
+    return false;
+  }
+  wrap(prototype, "connect", (originalConnect) => {
+    const wrapper = function(...args) {
+      const ctx = contextManager.getCurrentContext();
+      if (!ctx || !ctx.enable || !(0, import_jennifer5_agent19.configEnableRedisProfile)()) {
+        return originalConnect.apply(this, args);
+      }
+      const connectionString = buildRedisConnectionString2(this?.options);
+      const startCtx = (0, import_jennifer5_agent19.createDbConnectionProfileCtx)(void 0, connectionString, ctx.id);
+      try {
+        const result = originalConnect.apply(this, args);
+        if (result && typeof result.then === "function") {
+          return result.then(
+            (value) => {
+              releaseDbConnectionProfile(startCtx);
+              return value;
+            },
+            (error) => {
+              releaseDbConnectionProfile(startCtx, error);
+              throw error;
+            }
+          );
+        }
+        releaseDbConnectionProfile(startCtx);
+        return result;
+      } catch (error) {
+        releaseDbConnectionProfile(startCtx, error);
+        throw error;
+      }
+    };
+    wrapper[JENNIFER_REDIS_CONNECT_WRAPPED] = true;
+    return wrapper;
+  });
+  return true;
+}
+function instrumentRedisAddCommand(redisCommandsQueueModule) {
+  const RedisCommandsQueue = resolveRedisCommandsQueueConstructor(redisCommandsQueueModule);
+  const prototype = RedisCommandsQueue?.prototype;
+  if (!prototype || typeof prototype.addCommand !== "function" || prototype.addCommand[JENNIFER_REDIS_ADD_COMMAND_WRAPPED]) {
+    return false;
+  }
+  wrap(prototype, "addCommand", (originalAddCommand) => {
+    const wrapper = function(...args) {
+      const ctx = contextManager.getCurrentContext();
+      const commandArgs = args[0];
+      const commandName = normalizeRedisCommandName(commandArgs?.[0]);
+      if (!ctx || !ctx.enable || !(0, import_jennifer5_agent19.configEnableRedisProfile)() || !commandName || isRedisCommandBlocked(commandName)) {
+        return originalAddCommand.apply(this, args);
+      }
+      const methodArgs = extractRedisMethodArguments(commandArgs, 1);
+      const startCtx = (0, import_jennifer5_agent19.createMethodProfileCtx)(`Redis.${commandName}`, methodArgs, ctx.id);
+      if (!startCtx) {
+        return originalAddCommand.apply(this, args);
+      }
+      let isReleased = false;
+      const releaseSuccess2 = () => {
+        if (isReleased) {
+          return;
+        }
+        isReleased = true;
+        (0, import_jennifer5_agent19.releaseMethodProfileCtx)(startCtx, {
+          id: startCtx?.id ?? 0,
+          txId: startCtx?.txId ?? 0
+        });
+      };
+      const releaseError = (error) => {
+        if (isReleased) {
+          return;
+        }
+        isReleased = true;
+        (0, import_jennifer5_agent19.releaseMethodProfileCtx)(startCtx, {
+          id: startCtx?.id ?? 0,
+          txId: startCtx?.txId ?? 0,
+          error: error ? {
+            message: error?.message,
+            stack: error?.stack
+          } : void 0
+        });
+      };
+      try {
+        const result = originalAddCommand.apply(this, args);
+        if (result && typeof result.then === "function") {
+          return result.then(
+            (value) => {
+              releaseSuccess2();
+              return value;
+            },
+            (error) => {
+              releaseError(error);
+              throw error;
+            }
+          );
+        }
+        releaseSuccess2();
+        return result;
+      } catch (error) {
+        releaseError(error);
+        throw error;
+      }
+    };
+    wrapper[JENNIFER_REDIS_ADD_COMMAND_WRAPPED] = true;
+    return wrapper;
+  });
+  return true;
+}
+function resolveRedisConnectPrototype(client) {
+  let current = client;
+  while (current) {
+    const descriptor = Object.getOwnPropertyDescriptor(current, "connect");
+    if (descriptor && typeof descriptor.value === "function") {
+      return current;
+    }
+    current = Object.getPrototypeOf(current);
+  }
+  return void 0;
+}
+function resolveRedisCommandsQueueConstructor(redisCommandsQueueModule) {
+  if (typeof redisCommandsQueueModule === "function") {
+    return redisCommandsQueueModule;
+  }
+  if (typeof redisCommandsQueueModule?.default === "function") {
+    return redisCommandsQueueModule.default;
+  }
+  return void 0;
+}
+function buildRedisConnectionString2(options) {
+  const socket = options?.socket;
+  const host = socket?.host || options?.host || "localhost";
+  const port = Number(socket?.port || options?.port || 6379);
+  const rawDb = options?.database ?? options?.db ?? 0;
+  const db = rawDb === void 0 || rawDb === null || rawDb === "" ? "0" : String(rawDb);
+  return `datasource : redis://${host}:${port}/${db}`;
+}
+
+// src/instrumentations/tedious.ts
+var import_jennifer5_agent20 = require("@jennifersoft/jennifer5-agent");
+var JENNIFER_TEDIOUS_MAKE_REQUEST_WRAPPED = /* @__PURE__ */ Symbol.for(
+  "jennifer.tedious.connection.makeRequest.wrapped"
+);
+function patchTediousModule(tediousModule, moduleName) {
+  try {
+    if (instrumentConnectionPrototype3(tediousModule?.Connection?.prototype)) {
+      (0, import_jennifer5_agent20.info)(`${moduleName}.Connection.prototype.makeRequest instrumented`);
+    }
+  } catch (error) {
+    (0, import_jennifer5_agent20.warn)(`Failed to register ${moduleName} instrumentation: ${error}`);
+  }
+}
+function instrumentConnectionPrototype3(connectionPrototype) {
+  if (!connectionPrototype || typeof connectionPrototype.makeRequest !== "function" || connectionPrototype.makeRequest?.[JENNIFER_TEDIOUS_MAKE_REQUEST_WRAPPED]) {
+    return false;
+  }
+  wrap(connectionPrototype, "makeRequest", (originalMakeRequest) => {
+    const wrapper = function(request, ...args) {
+      const ctx = contextManager.getCurrentContext();
+      if (!ctx || !ctx.enable || !(0, import_jennifer5_agent20.configEnableTediousProfile)()) {
+        return originalMakeRequest.call(this, request, ...args);
+      }
+      const sqlInfo = extractSqlInfo(request);
+      if (!sqlInfo?.sql) {
+        return originalMakeRequest.call(this, request, ...args);
+      }
+      const startCtx = (0, import_jennifer5_agent20.createSqlProfileCtx)(
+        sqlInfo.sql,
+        import_jennifer5_agent20.SqlExecuteMethod.Execute,
+        extractBoundParameters5(request),
+        ctx?.id
+      );
+      if (!startCtx) {
+        return originalMakeRequest.call(this, request, ...args);
+      }
+      let isReleased = false;
+      const releaseSuccess2 = () => {
+        if (isReleased) {
+          return;
+        }
+        isReleased = true;
+        releaseSqlProfile(startCtx);
+      };
+      const releaseError = (error) => {
+        if (isReleased) {
+          return;
+        }
+        isReleased = true;
+        releaseSqlProfile(startCtx, error);
+      };
+      const originalCallback = request?.callback;
+      if (typeof originalCallback === "function") {
+        request.callback = function(error, ...callbackArgs) {
+          if (error) {
+            releaseError(error);
+          } else {
+            releaseSuccess2();
+          }
+          return contextManager.run(ctx, () => originalCallback.call(this, error, ...callbackArgs));
+        };
+      }
+      try {
+        const result = originalMakeRequest.call(this, request, ...args);
+        if (typeof originalCallback !== "function") {
+          releaseSuccess2();
+        }
+        return result;
+      } catch (error) {
+        releaseError(error);
+        throw error;
+      }
+    };
+    wrapper[JENNIFER_TEDIOUS_MAKE_REQUEST_WRAPPED] = true;
+    return wrapper;
+  });
+  return true;
+}
+function extractSqlInfo(request) {
+  if (!request || typeof request !== "object") {
+    return void 0;
+  }
+  const statement = request?.parametersByName?.statement;
+  if (statement && typeof statement.value === "string") {
+    return { sql: statement.value, sqlContainer: statement, sqlField: "value" };
+  }
+  const stmt = request?.parametersByName?.stmt;
+  if (stmt && typeof stmt.value === "string") {
+    return { sql: stmt.value, sqlContainer: stmt, sqlField: "value" };
+  }
+  if (typeof request.sqlTextOrProcedure === "string") {
+    return {
+      sql: request.sqlTextOrProcedure,
+      sqlContainer: request,
+      sqlField: "sqlTextOrProcedure"
+    };
+  }
+  return void 0;
+}
+function extractBoundParameters5(request) {
+  const parameters = request?.parameters;
+  if (!Array.isArray(parameters) || parameters.length === 0) {
+    return void 0;
+  }
+  const values = parameters.filter((parameter) => parameter && typeof parameter === "object").map((parameter) => parameter.value);
+  return toSqlParams(values);
+}
+
+// src/instrumentations/typeorm.ts
+var import_jennifer5_agent21 = require("@jennifersoft/jennifer5-agent");
+var JENNIFER_DATASOURCE_WRAPPED = /* @__PURE__ */ Symbol.for("jennifer.typeorm.datasource.wrapped");
+var JENNIFER_QUERYRUNNER_WRAPPED = /* @__PURE__ */ Symbol.for("jennifer.typeorm.queryrunner.wrapped");
+function patchTypeormModule(typeormModule, moduleName) {
+  try {
+    if (instrumentDataSource(typeormModule?.DataSource)) {
+      (0, import_jennifer5_agent21.info)(`${moduleName}.DataSource instrumented`);
+    }
+  } catch (error) {
+    (0, import_jennifer5_agent21.warn)(`Failed to register ${moduleName} instrumentation: ${error}`);
+  }
+}
+function instrumentDataSource(dataSourceClass) {
+  const prototype = dataSourceClass?.prototype;
+  if (!prototype || prototype.createQueryRunner?.[JENNIFER_DATASOURCE_WRAPPED]) {
+    return false;
+  }
+  wrap(prototype, "createQueryRunner", (originalCreateQueryRunner) => {
+    const wrapper = function(...args) {
+      const queryRunner = originalCreateQueryRunner.apply(this, args);
+      instrumentQueryRunner(queryRunner);
+      return queryRunner;
+    };
+    wrapper[JENNIFER_DATASOURCE_WRAPPED] = true;
+    return wrapper;
+  });
+  return true;
+}
+function instrumentQueryRunner(queryRunner) {
+  if (!queryRunner || typeof queryRunner.query !== "function" || queryRunner.query?.[JENNIFER_QUERYRUNNER_WRAPPED]) {
+    return;
+  }
+  wrap(queryRunner, "query", (originalQuery) => {
+    const wrapper = function(...args) {
+      const ctx = contextManager.getCurrentContext();
+      if (!ctx || !ctx.enable || !(0, import_jennifer5_agent21.configEnableTypeormProfile)()) {
+        return originalQuery.apply(this, args);
+      }
+      const sql = args[0];
+      if (typeof sql !== "string") {
+        return originalQuery.apply(this, args);
+      }
+      const params = extractBoundParameters6(args[1]);
+      const startCtx = (0, import_jennifer5_agent21.createSqlProfileCtx)(sql, import_jennifer5_agent21.SqlExecuteMethod.Execute, params, ctx?.id);
+      if (!startCtx) {
+        return originalQuery.apply(this, args);
+      }
+      try {
+        const result = originalQuery.apply(this, args);
+        if (result && typeof result.then === "function") {
+          return result.then(
+            (value) => {
+              releaseSqlProfile(startCtx);
+              return value;
+            },
+            (error) => {
+              releaseSqlProfile(startCtx, error);
+              throw error;
+            }
+          );
+        }
+        releaseSqlProfile(startCtx);
+        return result;
+      } catch (error) {
+        releaseSqlProfile(startCtx, error);
+        throw error;
+      }
+    };
+    wrapper[JENNIFER_QUERYRUNNER_WRAPPED] = true;
+    return wrapper;
+  });
+}
+function extractBoundParameters6(params) {
+  return toSqlParams(params);
+}
+
+// src/instrumentations/undici.ts
+var import_jennifer5_agent22 = require("@jennifersoft/jennifer5-agent");
+var JENNIFER_UNDICI_FETCH_WRAPPED = /* @__PURE__ */ Symbol.for("jennifer.undici.fetch.wrapped");
+var JENNIFER_UNDICI_REQUEST_WRAPPED = /* @__PURE__ */ Symbol.for("jennifer.undici.request.wrapped");
+var X_DOMAIN_ID2 = "x-domainid";
+var X_AGENT_ID2 = "x-agentid";
+function resolveHeadersCtor(undiciModule) {
+  return undiciModule.Headers ?? globalThis.Headers;
+}
+function resolveRequestCtor(undiciModule) {
+  return undiciModule.Request ?? globalThis.Request;
+}
+function patchUndiciModule(undiciModule, moduleName) {
+  try {
+    let patched = false;
+    if (typeof undiciModule?.fetch === "function" && !undiciModule.fetch[JENNIFER_UNDICI_FETCH_WRAPPED]) {
+      wrap(undiciModule, "fetch", (originalFetch) => {
+        const wrapper = createUndiciFetchWrapper(originalFetch, undiciModule);
+        wrapper[JENNIFER_UNDICI_FETCH_WRAPPED] = true;
+        return wrapper;
+      });
+      patched = true;
+    }
+    if (typeof undiciModule?.request === "function" && !undiciModule.request[JENNIFER_UNDICI_REQUEST_WRAPPED]) {
+      wrap(undiciModule, "request", (originalRequest) => {
+        const wrapper = createUndiciRequestWrapper(
+          originalRequest,
+          resolveHeadersCtor(undiciModule)
+        );
+        wrapper[JENNIFER_UNDICI_REQUEST_WRAPPED] = true;
+        return wrapper;
+      });
+      patched = true;
+    }
+    if (patched) {
+      (0, import_jennifer5_agent22.info)(`${moduleName} instrumentation registered`);
+    }
+  } catch (error) {
+    (0, import_jennifer5_agent22.warn)(`Failed to register ${moduleName} instrumentation: ${error}`);
+  }
+}
+function createUndiciFetchWrapper(originalFetch, undiciModule) {
+  return function(...args) {
+    const ctx = contextManager.getCurrentContext();
+    if (!ctx || !ctx.enable || !(0, import_jennifer5_agent22.configEnableHttpClientProfile)()) {
+      return originalFetch(...args);
+    }
+    const [input, init] = args;
+    const HeadersCtor = resolveHeadersCtor(undiciModule);
+    const RequestCtor = resolveRequestCtor(undiciModule);
+    let startCtx = null;
+    try {
+      if (RequestCtor && input instanceof RequestCtor) {
+        const normalizedRequest = init ? new RequestCtor(input, init) : input;
+        const fetchHeaders2 = toHeaders(normalizedRequest.headers, HeadersCtor);
+        setTopologyFetchHeaders(fetchHeaders2);
+        const headers2 = headersToRecord(fetchHeaders2);
+        const wrappedRequest = new RequestCtor(normalizedRequest, { headers: fetchHeaders2 });
+        startCtx = (0, import_jennifer5_agent22.createHttpProfileCtx)(
+          normalizedRequest.method || "GET",
+          normalizedRequest.url,
+          headers2,
+          ctx.id
+        );
+        return handleFetchResult(originalFetch(wrappedRequest), startCtx);
+      }
+      const url = typeof input === "string" ? input : input?.href || String(input);
+      const method = init?.method || "GET";
+      const fetchHeaders = toHeaders(init?.headers, HeadersCtor);
+      setTopologyFetchHeaders(fetchHeaders);
+      const headers = headersToRecord(fetchHeaders);
+      const modifiedInit = {
+        ...init,
+        headers: fetchHeaders
+      };
+      startCtx = (0, import_jennifer5_agent22.createHttpProfileCtx)(method, url, headers, ctx.id);
+      return handleFetchResult(originalFetch(input, modifiedInit), startCtx);
+    } catch (error) {
+      (0, import_jennifer5_agent22.releaseHttpProfileCtx)(startCtx, {
+        error: {
+          message: error?.message,
+          stack: error?.stack
+        }
+      });
+      throw error;
+    }
+  };
+}
+function handleFetchResult(result, startCtx) {
+  return result.then(
+    (response) => {
+      const contentLength = response.headers.get("content-length");
+      const responseSize = contentLength ? parseInt(contentLength, 10) : void 0;
+      const remoteCallInfo = getTopologyInfoFromFetch(response);
+      (0, import_jennifer5_agent22.releaseHttpProfileCtx)(startCtx, {
+        statusCode: response.status,
+        responseSize,
+        remoteCallInfo
+      });
+      return response;
+    },
+    (error) => {
+      (0, import_jennifer5_agent22.releaseHttpProfileCtx)(startCtx, {
+        error: {
+          message: error?.message,
+          stack: error?.stack
+        }
+      });
+      throw error;
+    }
+  );
+}
+function createUndiciRequestWrapper(originalRequest, HeadersCtor) {
+  return function(...args) {
+    const ctx = contextManager.getCurrentContext();
+    if (!ctx || !ctx.enable || !(0, import_jennifer5_agent22.configEnableHttpClientProfile)()) {
+      return originalRequest(...args);
+    }
+    const { callArgs, method, url, headers } = normalizeUndiciRequestCall(args, HeadersCtor);
+    const startCtx = (0, import_jennifer5_agent22.createHttpProfileCtx)(method, url, headers, ctx.id);
+    try {
+      return originalRequest(...callArgs).then(
+        (response) => {
+          const responseSize = getResponseSizeFromUndiciHeaders(response?.headers);
+          const remoteCallInfo = getTopologyInfoFromUndiciHeaders(response?.headers);
+          (0, import_jennifer5_agent22.releaseHttpProfileCtx)(startCtx, {
+            statusCode: response?.statusCode,
+            responseSize,
+            remoteCallInfo
+          });
+          return response;
+        },
+        (error) => {
+          (0, import_jennifer5_agent22.releaseHttpProfileCtx)(startCtx, {
+            error: {
+              message: error?.message,
+              stack: error?.stack
+            }
+          });
+          throw error;
+        }
+      );
+    } catch (error) {
+      (0, import_jennifer5_agent22.releaseHttpProfileCtx)(startCtx, {
+        error: {
+          message: error?.message,
+          stack: error?.stack
+        }
+      });
+      throw error;
+    }
+  };
+}
+function normalizeUndiciRequestCall(args, HeadersCtor) {
+  const [firstArg, secondArg] = args;
+  if (typeof firstArg === "string" || firstArg instanceof URL) {
+    const options = secondArg && typeof secondArg === "object" ? secondArg : {};
+    const requestHeaders = toHeaders(options.headers, HeadersCtor);
+    setTopologyFetchHeaders(requestHeaders);
+    const headersRecord = headersToRecord(requestHeaders);
+    const callArgs = [
+      firstArg,
+      {
+        ...options,
+        headers: headersRecord
+      }
+    ];
+    return {
+      callArgs,
+      method: options.method || "GET",
+      url: typeof firstArg === "string" ? firstArg : firstArg.href,
+      headers: headersRecord
+    };
+  }
+  if (firstArg && typeof firstArg === "object") {
+    const requestHeaders = toHeaders(firstArg.headers, HeadersCtor);
+    setTopologyFetchHeaders(requestHeaders);
+    const headersRecord = headersToRecord(requestHeaders);
+    const callArg = {
+      ...firstArg,
+      headers: headersRecord
+    };
+    return {
+      callArgs: [callArg],
+      method: firstArg.method || "GET",
+      url: getRequestUrlFromOptions(firstArg),
+      headers: headersRecord
+    };
+  }
+  return {
+    callArgs: args,
+    method: "GET",
+    url: String(firstArg),
+    headers: {}
+  };
+}
+function getRequestUrlFromOptions(options) {
+  if (!options || typeof options !== "object") {
+    return String(options);
+  }
+  if (typeof options.href === "string") {
+    return options.href;
+  }
+  if (typeof options.origin === "string" && typeof options.path === "string") {
+    return `${options.origin}${options.path}`;
+  }
+  if (options.origin instanceof URL && typeof options.path === "string") {
+    return `${options.origin.href.replace(/\/$/, "")}${options.path}`;
+  }
+  if (typeof options.path === "string") {
+    return options.path;
+  }
+  return "[undici.request]";
+}
+function toHeaders(input, HeadersCtor) {
+  const headers = new HeadersCtor();
+  if (!input) {
+    return headers;
+  }
+  try {
+    if (input instanceof HeadersCtor) {
+      input.forEach((value, key) => {
+        headers.append(key, value);
+      });
+      return headers;
+    }
+  } catch {
+  }
+  if (Array.isArray(input)) {
+    for (const entry of input) {
+      if (!Array.isArray(entry) || entry.length < 2) {
+        continue;
+      }
+      headers.append(String(entry[0]), String(entry[1]));
+    }
+    return headers;
+  }
+  if (typeof input === "object") {
+    for (const [key, value] of Object.entries(input)) {
+      if (value === void 0 || value === null) {
+        continue;
+      }
+      if (Array.isArray(value)) {
+        headers.set(key, value.map(String).join(", "));
+      } else {
+        headers.set(key, String(value));
+      }
+    }
+    return headers;
+  }
+  return headers;
+}
+function headersToRecord(headers) {
+  const record = {};
+  headers.forEach((value, key) => {
+    record[key] = value;
+  });
+  return record;
+}
+function getResponseSizeFromUndiciHeaders(headers) {
+  const contentLength = getHeaderValue(headers, "content-length");
+  if (!contentLength) {
+    return void 0;
+  }
+  const parsed = Number(contentLength);
+  return Number.isNaN(parsed) ? void 0 : parsed;
+}
+function getTopologyInfoFromUndiciHeaders(headers) {
+  if (!(0, import_jennifer5_agent22.configEnableHttpTopologyMode)()) {
+    return void 0;
+  }
+  const topologyHeaderKey = (0, import_jennifer5_agent22.configTopologyHttpHeaderKey)();
+  const remoteCallKey = parseNumber2(getHeaderValue(headers, topologyHeaderKey));
+  const sid = parseNumber2(getHeaderValue(headers, X_DOMAIN_ID2));
+  const oid = parseNumber2(getHeaderValue(headers, X_AGENT_ID2));
+  if ([remoteCallKey, sid, oid].some((v) => v === void 0)) {
+    return void 0;
+  }
+  if (!(0, import_jennifer5_agent22.isAgentId)(oid)) {
+    return void 0;
+  }
+  return {
+    remoteCallKey,
+    domainId: sid,
+    oid
+  };
+}
+function getHeaderValue(headers, key) {
+  if (!headers) {
+    return void 0;
+  }
+  const value = headers[key.toLowerCase()] ?? headers[key];
+  if (Array.isArray(value)) {
+    return value[0];
+  }
+  return typeof value === "string" ? value : void 0;
+}
+function parseNumber2(value) {
+  if (!value) {
+    return void 0;
+  }
+  const parsed = Number(value);
+  return Number.isNaN(parsed) ? void 0 : parsed;
+}
+
+// src/instrumentations/register-ritm.ts
+function registerHook(definition) {
+  new import_require_in_the_middle.Hook(definition.modules, (module2, moduleName) => {
+    for (const patch of definition.patches) {
+      patch(module2, moduleName);
+    }
+    return module2;
+  });
+}
+function registerRitmHooks() {
+  const hookDefinitions = [
+    {
+      modules: ["http", "https", "node:http", "node:https"],
+      patches: [patchHttpServer, patchHttpClient]
+    },
+    {
+      modules: ["@apollo/server"],
+      patches: [patchApolloServerModule]
+    },
+    {
+      modules: ["fs", "node:fs"],
+      patches: [patchFsSync, patchFsAsync, patchFsPromise]
+    },
+    {
+      modules: ["mariadb", "mariadb/callback.js"],
+      patches: [patchMariadbModule]
+    },
+    {
+      modules: ["mariadb/lib/cmd/query.js", "mariadb/lib/cmd/query"],
+      patches: [patchMariadbQueryCommandModule]
+    },
+    {
+      modules: ["mariadb/lib/cmd/execute.js", "mariadb/lib/cmd/execute"],
+      patches: [patchMariadbExecuteCommandModule]
+    },
+    {
+      modules: ["mysql2/promise"],
+      patches: [patchMysql2PromiseModule]
+    },
+    {
+      modules: ["mysql2"],
+      patches: [patchMysql2Module]
+    },
+    {
+      modules: ["ioredis"],
+      patches: [patchIoredisModule]
+    },
+    {
+      modules: ["redis"],
+      patches: [patchRedisModule]
+    },
+    {
+      modules: [
+        "@redis/client/dist/lib/client/commands-queue.js",
+        "@redis/client/dist/lib/client/commands-queue"
+      ],
+      patches: [patchRedisCommandsQueueModule]
+    },
+    {
+      modules: ["oracledb"],
+      patches: [patchOracleDbModule]
+    },
+    {
+      modules: ["pg/lib/client.js", "pg/lib/client"],
+      patches: [patchPgClientModule]
+    },
+    {
+      modules: ["pg/lib/native/client.js", "pg/lib/native/client"],
+      patches: [patchPgClientModule]
+    },
+    {
+      modules: ["tedious"],
+      patches: [patchTediousModule]
+    },
+    {
+      modules: ["@prisma/client"],
+      patches: [patchPrismaModule]
+    },
+    {
+      modules: ["typeorm", "@n8n/typeorm"],
+      patches: [patchTypeormModule]
+    },
+    {
+      modules: ["undici"],
+      patches: [patchUndiciModule]
+    }
+  ];
+  for (const definition of hookDefinitions) {
+    registerHook(definition);
+  }
+  patchGlobalFetch();
+  new import_require_in_the_middle.Hook(
+    null,
+    // null = intercept all modules
+    { internals: true },
+    // include internal/relative requires
+    (exports2, moduleName) => {
+      if (moduleName.includes("workflow-runner")) {
+        patchN8nWorkflowRunner(exports2, moduleName);
+      }
+      if (moduleName.includes("active-executions")) {
+        patchN8nActiveExecutions(exports2, moduleName);
+      }
+      return exports2;
+    }
+  );
+}
+
+// src/instrumentations/register-iitm.ts
+var import_import_in_the_middle = require("import-in-the-middle");
+var import_jennifer5_agent23 = require("@jennifersoft/jennifer5-agent");
+function patchWithDefaultExport(module2, patcher) {
+  const defaultExport = module2?.default;
+  if (defaultExport && defaultExport !== module2) {
+    patcher(defaultExport);
+  }
+  patcher(module2);
+}
+function registerDefaultExportHook(definition) {
+  new import_import_in_the_middle.Hook(definition.modules, (module2, moduleName) => {
+    patchWithDefaultExport(module2, (target) => {
+      for (const patch of definition.patches) {
+        patch(target, moduleName);
+      }
+    });
+    return module2;
+  });
+}
+function registerIitmHooks() {
+  const hookDefinitions = [
+    {
+      modules: ["http", "https", "node:http", "node:https"],
+      patches: [patchHttpServer, patchHttpClient]
+    },
+    {
+      modules: ["@apollo/server"],
+      patches: [patchApolloServerModule]
+    },
+    {
+      modules: ["fs", "node:fs"],
+      patches: [patchFsSync, patchFsAsync, patchFsPromise]
+    },
+    {
+      modules: ["mariadb", "mariadb/callback.js"],
+      patches: [patchMariadbModule]
+    },
+    {
+      modules: ["mariadb/lib/cmd/query.js", "mariadb/lib/cmd/query"],
+      patches: [patchMariadbQueryCommandModule]
+    },
+    {
+      modules: ["mariadb/lib/cmd/execute.js", "mariadb/lib/cmd/execute"],
+      patches: [patchMariadbExecuteCommandModule]
+    },
+    {
+      modules: ["mysql2/promise"],
+      patches: [patchMysql2PromiseModule]
+    },
+    {
+      modules: ["mysql2"],
+      patches: [patchMysql2Module]
+    },
+    {
+      modules: ["ioredis"],
+      patches: [patchIoredisModule]
+    },
+    {
+      modules: ["redis"],
+      patches: [patchRedisModule]
+    },
+    {
+      modules: [
+        "@redis/client/dist/lib/client/commands-queue.js",
+        "@redis/client/dist/lib/client/commands-queue"
+      ],
+      patches: [patchRedisCommandsQueueModule]
+    },
+    {
+      modules: ["oracledb"],
+      patches: [patchOracleDbModule]
+    },
+    {
+      modules: ["pg/lib/client.js", "pg/lib/client"],
+      patches: [patchPgClientModule]
+    },
+    {
+      modules: ["pg/lib/native/client.js", "pg/lib/native/client"],
+      patches: [patchPgClientModule]
+    },
+    {
+      modules: ["tedious"],
+      patches: [patchTediousModule]
+    },
+    {
+      modules: ["@prisma/client"],
+      patches: [patchPrismaModule]
+    },
+    {
+      modules: ["typeorm", "@n8n/typeorm"],
+      patches: [patchTypeormModule]
+    },
+    {
+      modules: ["undici"],
+      patches: [patchUndiciModule]
+    }
+  ];
+  for (const definition of hookDefinitions) {
+    registerDefaultExportHook(definition);
+  }
+  patchGlobalFetch();
+  (0, import_jennifer5_agent23.info)("IITM hooks registered");
+}
+
+// src/feat/heap-collector.ts
+var import_jennifer5_agent24 = require("@jennifersoft/jennifer5-agent");
+var HEAP_COLLECTOR_STARTED = /* @__PURE__ */ Symbol.for("jennifer.heap-collector.started");
+function startHeapMetricsCollection(intervalMs = 1e3, callback) {
+  if (global[HEAP_COLLECTOR_STARTED]) {
+    return () => {
+    };
+  }
+  global[HEAP_COLLECTOR_STARTED] = true;
+  const sendMetrics = callback || import_jennifer5_agent24.sendHeapMetrics;
+  let hasErrored = false;
+  const cleanup = () => {
+    global[HEAP_COLLECTOR_STARTED] = false;
+    clearInterval(timer);
+  };
+  const timer = setInterval(() => {
+    if (hasErrored) {
+      return;
+    }
+    try {
+      const mem = process.memoryUsage();
+      sendMetrics(mem.heapUsed, mem.heapTotal, mem.external, mem.arrayBuffers);
+    } catch (error) {
+      hasErrored = true;
+      (0, import_jennifer5_agent24.trace)(`Failed to collect heap metrics, stopping collection: ${error}`);
+      cleanup();
+    }
+  }, intervalMs);
+  timer.unref();
+  return cleanup;
+}
+
+// src/feat/gc-collector.ts
+var import_jennifer5_agent25 = require("@jennifersoft/jennifer5-agent");
+var import_node_perf_hooks = require("perf_hooks");
+var GC_COLLECTOR_STARTED = /* @__PURE__ */ Symbol.for("jennifer.gc-collector.started");
+function startGcMetricsCollection(intervalMs = 1e3, callback) {
+  if (global[GC_COLLECTOR_STARTED]) {
+    return null;
+  }
+  global[GC_COLLECTOR_STARTED] = true;
+  const sendMetrics = callback || ((gcCount, gcTime, gcCountDelta) => (0, import_jennifer5_agent25.sendGcMetrics)(gcCount, gcTime, gcCountDelta));
+  if (typeof import_node_perf_hooks.PerformanceObserver === "undefined") {
+    (0, import_jennifer5_agent25.trace)(
+      "PerformanceObserver not available, GC metrics collection disabled (requires Node 16.7+)"
+    );
+    return null;
+  }
+  let accumulatedGcCount = 0;
+  let accumulatedGcTimeMs = 0;
+  let lastSentGcCount = 0;
+  let hasErrored = false;
+  let observer = null;
+  let timer = null;
+  const disableCollection = (message, error, log = true) => {
+    if (!hasErrored) {
+      hasErrored = true;
+      if (log) {
+        (0, import_jennifer5_agent25.trace)(error ? `${message}: ${error}` : message);
+      }
+    }
+    if (observer) {
+      observer.disconnect();
+      observer = null;
+    }
+    if (timer) {
+      clearInterval(timer);
+      timer = null;
+    }
+  };
+  try {
+    observer = new import_node_perf_hooks.PerformanceObserver((list) => {
+      try {
+        const entries = list.getEntries();
+        for (const entry of entries) {
+          if (entry.entryType === "gc") {
+            accumulatedGcCount++;
+            accumulatedGcTimeMs += entry.duration;
+          }
+        }
+      } catch (error) {
+        disableCollection("Error processing GC entries", error);
+      }
+    });
+    observer.observe({ entryTypes: ["gc"] });
+  } catch (error) {
+    disableCollection(
+      "Failed to create PerformanceObserver for GC events (requires Node 16.7+)",
+      error
+    );
+    return null;
+  }
+  timer = setInterval(() => {
+    if (hasErrored) {
+      return;
+    }
+    try {
+      const gcCountDelta = Math.max(0, accumulatedGcCount - lastSentGcCount);
+      lastSentGcCount = accumulatedGcCount;
+      sendMetrics(accumulatedGcCount, Math.round(accumulatedGcTimeMs), gcCountDelta);
+    } catch (error) {
+      disableCollection("Failed to send GC metrics", error);
+    }
+  }, intervalMs);
+  timer.unref();
+  const cleanup = () => {
+    global[GC_COLLECTOR_STARTED] = false;
+    disableCollection("GC metrics collection stopped", void 0, false);
+  };
+  return cleanup;
+}
+
+// src/helpers/nextjs/with-jennifer-route-tx.ts
+var import_jennifer5_agent26 = require("@jennifersoft/jennifer5-agent");
+function toHeaderLines(headers) {
+  const entries = [];
+  headers.forEach((value, key) => {
+    entries.push(`${key}:${value}`);
+  });
+  return entries;
+}
+function resolveHttpUrl(request) {
+  if (request.nextUrl) {
+    return `${request.nextUrl.pathname}${request.nextUrl.search}`;
+  }
+  const parsed = new URL(request.url);
+  return `${parsed.pathname}${parsed.search}`;
+}
+function withJenniferNextRouteTx(handler) {
+  return async function wrappedHandler(request) {
+    const ctx = contextManager.start();
+    const txId = ctx.id;
+    const httpUrl = resolveHttpUrl(request);
+    if (!ctx.enable) {
+      return handler(request);
+    }
+    (0, import_jennifer5_agent26.createTransactionCtx)({
+      txId,
+      method: "next.route",
+      httpMethod: request.method,
+      httpUrl,
+      httpHeaders: toHeaderLines(request.headers)
+    });
+    return contextManager.run(ctx, async () => {
+      try {
+        const response = await handler(request);
+        (0, import_jennifer5_agent26.releaseTransactionCtx)(txId, {
+          httpStatusCode: response.status
+        });
+        return response;
+      } catch (error) {
+        (0, import_jennifer5_agent26.releaseTransactionCtx)(txId, {
+          httpStatusCode: 500
+        });
+        throw error;
+      }
+    });
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TransactionContextManager,
+  contextManager,
+  registerIitmHooks,
+  registerRitmHooks,
+  startGcMetricsCollection,
+  startHeapMetricsCollection,
+  withJenniferNextRouteTx
+});