@adjedaini/clockwork-node 0.0.1

package/node_modules/@adjedaini/clockwork-db-interceptor/dist/index.js

@@ -0,0 +1,163 @@
+"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, {
+  defaultDbPlugins: () => defaultDbPlugins,
+  mysql2Plugin: () => mysql2Plugin,
+  patchMysql2: () => patchMysql2,
+  patchPg: () => patchPg,
+  pgPlugin: () => pgPlugin
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/pg.ts
+var restored = false;
+function patchPg(core, getRequestId) {
+  let pg = null;
+  try {
+    pg = require("pg");
+  } catch {
+    return () => {
+    };
+  }
+  if (!pg?.Client?.prototype?.query) return () => {
+  };
+  if (restored) return () => {
+  };
+  const Client = pg.Client;
+  const originalQuery = Client.prototype.query;
+  Client.prototype.query = function(...args) {
+    const start = performance.now();
+    const firstArg = args[0];
+    const queryText = typeof firstArg === "string" ? firstArg : firstArg?.text ?? String(firstArg);
+    const bindings = typeof firstArg === "object" && firstArg !== null && "values" in firstArg ? firstArg.values : void 0;
+    const result = originalQuery.apply(this, args);
+    const onDone = () => {
+      const duration = performance.now() - start;
+      const requestId = getRequestId();
+      if (requestId) {
+        core.addQuery(requestId, {
+          query: queryText,
+          bindings,
+          duration,
+          connection: "pg"
+        });
+      }
+    };
+    if (result && typeof result.then === "function") result.finally(onDone);
+    else setTimeout(onDone, 0);
+    return result;
+  };
+  return function restore() {
+    if (Client.prototype.query === originalQuery) return;
+    Client.prototype.query = originalQuery;
+    restored = true;
+  };
+}
+
+// src/mysql2.ts
+function patchMysql2(core, getRequestId) {
+  let mysql2 = null;
+  try {
+    mysql2 = require("mysql2");
+  } catch {
+    return () => {
+    };
+  }
+  if (!mysql2?.createConnection) return () => {
+  };
+  const originalCreateConnection = mysql2.createConnection.bind(mysql2);
+  function wrapQuery(conn) {
+    const origQuery = conn.query;
+    const origExecute = conn.execute;
+    if (typeof origQuery === "function") {
+      conn.query = function(sql, ...args) {
+        const start = performance.now();
+        const queryText = typeof sql === "string" ? sql : String(sql);
+        const bindings = Array.isArray(args[0]) ? args[0] : void 0;
+        const result = origQuery.apply(this, [sql, ...args]);
+        const onDone = () => {
+          const requestId = getRequestId();
+          if (requestId) {
+            core.addQuery(requestId, {
+              query: queryText,
+              bindings,
+              duration: performance.now() - start,
+              connection: "mysql2"
+            });
+          }
+        };
+        if (result?.then) result.finally(onDone);
+        else setTimeout(onDone, 0);
+        return result;
+      };
+    }
+    if (typeof origExecute === "function") {
+      conn.execute = function(sql, ...args) {
+        const start = performance.now();
+        const queryText = typeof sql === "string" ? sql : String(sql);
+        const bindings = Array.isArray(args[0]) ? args[0] : void 0;
+        const result = origExecute.apply(this, [sql, ...args]);
+        const onDone = () => {
+          const requestId = getRequestId();
+          if (requestId) {
+            core.addQuery(requestId, {
+              query: queryText,
+              bindings,
+              duration: performance.now() - start,
+              connection: "mysql2"
+            });
+          }
+        };
+        if (result?.then) result.finally(onDone);
+        else setTimeout(onDone, 0);
+        return result;
+      };
+    }
+  }
+  mysql2.createConnection = function(opts) {
+    const conn = originalCreateConnection(opts);
+    wrapQuery(conn);
+    return conn;
+  };
+  return function restore() {
+    mysql2.createConnection = originalCreateConnection;
+  };
+}
+
+// src/index.ts
+var pgPlugin = {
+  name: "pg",
+  install: (ctx) => patchPg(ctx.core, ctx.getRequestId)
+};
+var mysql2Plugin = {
+  name: "mysql2",
+  install: (ctx) => patchMysql2(ctx.core, ctx.getRequestId)
+};
+var defaultDbPlugins = [pgPlugin, mysql2Plugin];
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  defaultDbPlugins,
+  mysql2Plugin,
+  patchMysql2,
+  patchPg,
+  pgPlugin
+});

package/node_modules/@adjedaini/clockwork-db-interceptor/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "@adjedaini/clockwork-db-interceptor",
+  "version": "0.0.1",
+  "private": true,
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsup"
+  },
+  "dependencies": {
+    "@adjedaini/clockwork-core": "*",
+    "@adjedaini/clockwork-shared": "*"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.5.0"
+  }
+}

package/node_modules/@adjedaini/clockwork-db-interceptor/src/index.ts

@@ -0,0 +1,28 @@
+/**
+ * @adjedaini/clockwork-db-interceptor
+ * Optional DB query instrumentation as pluggable plugins (pg, mysql2).
+ * Implements generic ClockworkPlugin from core (IPluginContext).
+ */
+
+import type { ClockworkPlugin, IPluginContext } from '@adjedaini/clockwork-core';
+import { patchPg } from './pg';
+import { patchMysql2 } from './mysql2';
+
+export type GetRequestId = () => string | undefined;
+
+/** DB plugins conform to generic ClockworkPlugin. */
+export const pgPlugin: ClockworkPlugin = {
+  name: 'pg',
+  install: (ctx: IPluginContext) => patchPg(ctx.core, ctx.getRequestId),
+};
+
+export const mysql2Plugin: ClockworkPlugin = {
+  name: 'mysql2',
+  install: (ctx: IPluginContext) => patchMysql2(ctx.core, ctx.getRequestId),
+};
+
+/** Default set of DB plugins (pg + mysql2). */
+export const defaultDbPlugins: ClockworkPlugin[] = [pgPlugin, mysql2Plugin];
+
+export { patchPg, patchMysql2 };
+export type { ClockworkPlugin, IPluginContext } from '@adjedaini/clockwork-core';

package/node_modules/@adjedaini/clockwork-db-interceptor/src/mysql2.ts

@@ -0,0 +1,84 @@
+/**
+ * Patch mysql2 so Connection.query/execute are tracked. Only applied if 'mysql2' is installed.
+ * Wraps createConnection to patch the returned connection.
+ */
+
+import type { MonitorCore } from '@adjedaini/clockwork-core';
+
+export type GetRequestId = () => string | undefined;
+
+export function patchMysql2(core: MonitorCore, getRequestId: GetRequestId): () => void {
+  let mysql2: { createConnection: (opts?: unknown) => Connection } | null = null;
+  try {
+    mysql2 = require('mysql2');
+  } catch {
+    return () => {};
+  }
+  if (!mysql2?.createConnection) return () => {};
+
+  interface Connection {
+    query: (sql: unknown, ...args: unknown[]) => unknown;
+    execute?: (sql: unknown, ...args: unknown[]) => unknown;
+  }
+
+  const originalCreateConnection = mysql2.createConnection.bind(mysql2);
+
+  function wrapQuery(conn: Connection): void {
+    const origQuery = conn.query;
+    const origExecute = conn.execute;
+    if (typeof origQuery === 'function') {
+      conn.query = function (this: Connection, sql: unknown, ...args: unknown[]) {
+        const start = performance.now();
+        const queryText = typeof sql === 'string' ? sql : String(sql);
+        const bindings = Array.isArray(args[0]) ? args[0] : undefined;
+        const result = (origQuery as Function).apply(this, [sql, ...args]);
+        const onDone = () => {
+          const requestId = getRequestId();
+          if (requestId) {
+            core.addQuery(requestId, {
+              query: queryText,
+              bindings,
+              duration: performance.now() - start,
+              connection: 'mysql2',
+            });
+          }
+        };
+        if (result?.then) (result as Promise<unknown>).finally(onDone);
+        else setTimeout(onDone, 0);
+        return result;
+      };
+    }
+    if (typeof origExecute === 'function') {
+      conn.execute = function (this: Connection, sql: unknown, ...args: unknown[]) {
+        const start = performance.now();
+        const queryText = typeof sql === 'string' ? sql : String(sql);
+        const bindings = Array.isArray(args[0]) ? args[0] : undefined;
+        const result = (origExecute as Function).apply(this, [sql, ...args]);
+        const onDone = () => {
+          const requestId = getRequestId();
+          if (requestId) {
+            core.addQuery(requestId, {
+              query: queryText,
+              bindings,
+              duration: performance.now() - start,
+              connection: 'mysql2',
+            });
+          }
+        };
+        if (result?.then) (result as Promise<unknown>).finally(onDone);
+        else setTimeout(onDone, 0);
+        return result;
+      };
+    }
+  }
+
+  (mysql2 as { createConnection: (opts?: unknown) => Connection }).createConnection = function (opts?: unknown) {
+    const conn = originalCreateConnection(opts) as Connection;
+    wrapQuery(conn);
+    return conn;
+  };
+
+  return function restore() {
+    (mysql2 as { createConnection: (opts?: unknown) => Connection }).createConnection = originalCreateConnection;
+  };
+}

package/node_modules/@adjedaini/clockwork-db-interceptor/src/pg.ts

@@ -0,0 +1,56 @@
+/**
+ * Patch pg Client.query so queries are attached to the current request (when in context).
+ * Only applied if the 'pg' module is installed.
+ */
+
+import type { MonitorCore } from '@adjedaini/clockwork-core';
+
+export type GetRequestId = () => string | undefined;
+
+let restored = false;
+
+export function patchPg(core: MonitorCore, getRequestId: GetRequestId): () => void {
+  let pg: { Client?: { prototype: { query: (...args: unknown[]) => unknown } } } | null = null;
+  try {
+    pg = require('pg');
+  } catch {
+    return () => {};
+  }
+  if (!pg?.Client?.prototype?.query) return () => {};
+  if (restored) return () => {};
+
+  const Client = pg.Client!;
+  const originalQuery = Client.prototype.query;
+
+  Client.prototype.query = function (this: unknown, ...args: unknown[]) {
+    const start = performance.now();
+    const firstArg = args[0];
+    const queryText = typeof firstArg === 'string' ? firstArg : (firstArg as { text?: string })?.text ?? String(firstArg);
+    const bindings = typeof firstArg === 'object' && firstArg !== null && 'values' in firstArg
+      ? (firstArg as { values?: unknown[] }).values
+      : undefined;
+
+    const result = originalQuery.apply(this, args);
+    const onDone = () => {
+      const duration = performance.now() - start;
+      const requestId = getRequestId();
+      if (requestId) {
+        core.addQuery(requestId, {
+          query: queryText,
+          bindings,
+          duration,
+          connection: 'pg',
+        });
+      }
+    };
+    if (result && typeof (result as { then?: unknown }).then === 'function') (result as Promise<unknown>).finally(onDone);
+    else setTimeout(onDone, 0);
+    return result;
+  };
+
+  return function restore() {
+    if (Client.prototype.query === originalQuery) return;
+    Client.prototype.query = originalQuery;
+    restored = true;
+  };
+}

package/node_modules/@adjedaini/clockwork-db-interceptor/tsconfig.build.json

@@ -0,0 +1,6 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "composite": false
+  }
+}

package/node_modules/@adjedaini/clockwork-db-interceptor/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src",
+    "composite": true
+  },
+  "include": ["src/**/*"],
+  "references": [{ "path": "../core" }, { "path": "../shared" }]
+}

package/node_modules/@adjedaini/clockwork-db-interceptor/tsup.config.ts

@@ -0,0 +1,13 @@
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { defineConfig } from 'tsup';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+export default defineConfig({
+  entry: ['src/index.ts'],
+  format: ['cjs'],
+  dts: true,
+  outDir: 'dist',
+  tsconfig: path.join(__dirname, 'tsconfig.build.json'),
+});

package/node_modules/@adjedaini/clockwork-log-interceptor/dist/index.d.ts

@@ -0,0 +1,25 @@
+import { ClockworkPlugin } from '@adjedaini/clockwork-core';
+export { ClockworkPlugin, IPluginContext } from '@adjedaini/clockwork-core';
+
+/**
+ * Pino plugin: intercepts pino logger output and attaches to current request.
+ * Only applied if the 'pino' module is installed.
+ */
+
+declare const pinoPlugin: ClockworkPlugin;
+
+/**
+ * Winston plugin: intercepts winston logger output and attaches to current request.
+ * Only applied if the 'winston' module is installed.
+ */
+
+declare const winstonPlugin: ClockworkPlugin;
+
+/**
+ * @adjedaini/clockwork-log-interceptor
+ * Optional log library instrumentation (pino, winston). Implements ClockworkPlugin.
+ */
+
+declare const defaultLogPlugins: ClockworkPlugin[];
+
+export { defaultLogPlugins, pinoPlugin, winstonPlugin };

package/node_modules/@adjedaini/clockwork-log-interceptor/dist/index.js

@@ -0,0 +1,153 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  defaultLogPlugins: () => defaultLogPlugins,
+  pinoPlugin: () => pinoPlugin,
+  winstonPlugin: () => winstonPlugin
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/pino.ts
+var LEVEL_MAP = {
+  trace: "debug",
+  debug: "debug",
+  info: "info",
+  warn: "warning",
+  warning: "warning",
+  error: "error",
+  fatal: "error"
+};
+function wrapPino(ctx) {
+  let pinoId;
+  try {
+    pinoId = require.resolve("pino");
+  } catch {
+    return () => {
+    };
+  }
+  const mod = require.cache[pinoId];
+  if (!mod?.exports || typeof mod.exports !== "function") return () => {
+  };
+  const original = mod.exports;
+  function wrapLogger(logger) {
+    const levels = ["trace", "debug", "info", "warn", "error", "fatal"];
+    const wrapped = { ...logger };
+    for (const level of levels) {
+      const orig = logger[level];
+      if (typeof orig !== "function") continue;
+      wrapped[level] = function(...args) {
+        const requestId = ctx.getRequestId();
+        if (requestId) {
+          const msg = typeof args[0] === "string" ? args[0] : JSON.stringify(args[0] ?? "");
+          const levelMapped = LEVEL_MAP[level] ?? "info";
+          ctx.core.captureNativeLog(requestId, levelMapped, msg, void 0);
+        }
+        return orig.apply(this, args);
+      };
+    }
+    if (typeof logger.child === "function") {
+      const origChild = logger.child.bind(logger);
+      wrapped.child = function(bindings) {
+        return wrapLogger(origChild(bindings));
+      };
+    }
+    return wrapped;
+  }
+  mod.exports = function(opts) {
+    return wrapLogger(original(opts));
+  };
+  return function restore() {
+    mod.exports = original;
+  };
+}
+var pinoPlugin = {
+  name: "pino",
+  install: wrapPino
+};
+
+// src/winston.ts
+var LEVEL_MAP2 = {
+  error: "error",
+  warn: "warning",
+  warning: "warning",
+  info: "info",
+  http: "info",
+  verbose: "debug",
+  debug: "debug",
+  silly: "debug"
+};
+function wrapWinston(ctx) {
+  let winstonId;
+  try {
+    winstonId = require.resolve("winston");
+  } catch {
+    return () => {
+    };
+  }
+  const mod = require.cache[winstonId];
+  if (!mod?.exports?.createLogger) return () => {
+  };
+  const winston = mod.exports;
+  const originalCreateLogger = winston.createLogger.bind(winston);
+  winston.createLogger = function(opts) {
+    const logger = originalCreateLogger(opts);
+    const origLog = logger.log?.bind(logger);
+    if (typeof origLog !== "function") return logger;
+    logger.log = function(levelOrMeta, msg, ...args) {
+      const requestId = ctx.getRequestId();
+      if (requestId) {
+        const level = typeof levelOrMeta === "string" ? levelOrMeta : "info";
+        const message = typeof msg === "string" ? msg : typeof levelOrMeta === "object" && levelOrMeta !== null && "message" in levelOrMeta ? String(levelOrMeta.message) : String(msg ?? levelOrMeta);
+        const levelMapped = LEVEL_MAP2[level] ?? "info";
+        ctx.core.captureNativeLog(requestId, levelMapped, message, void 0);
+      }
+      return origLog(levelOrMeta, msg, ...args);
+    };
+    return logger;
+  };
+  return function restore() {
+    winston.createLogger = originalCreateLogger;
+  };
+}
+var winstonPlugin = {
+  name: "winston",
+  install: wrapWinston
+};
+
+// src/index.ts
+var defaultLogPlugins = [pinoPlugin, winstonPlugin];
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  defaultLogPlugins,
+  pinoPlugin,
+  winstonPlugin
+});

package/node_modules/@adjedaini/clockwork-log-interceptor/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "@adjedaini/clockwork-log-interceptor",
+  "version": "0.0.1",
+  "private": true,
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": { "build": "tsup" },
+  "dependencies": {
+    "@adjedaini/clockwork-core": "*",
+    "@adjedaini/clockwork-shared": "*"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.5.0"
+  }
+}

package/node_modules/@adjedaini/clockwork-log-interceptor/src/index.ts

@@ -0,0 +1,14 @@
+/**
+ * @adjedaini/clockwork-log-interceptor
+ * Optional log library instrumentation (pino, winston). Implements ClockworkPlugin.
+ */
+
+import type { ClockworkPlugin } from '@adjedaini/clockwork-core';
+import { pinoPlugin } from './pino';
+import { winstonPlugin } from './winston';
+
+export { pinoPlugin, winstonPlugin };
+
+export const defaultLogPlugins: ClockworkPlugin[] = [pinoPlugin, winstonPlugin];
+
+export type { ClockworkPlugin, IPluginContext } from '@adjedaini/clockwork-core';

package/node_modules/@adjedaini/clockwork-log-interceptor/src/pino.ts

@@ -0,0 +1,78 @@
+/**
+ * Pino plugin: intercepts pino logger output and attaches to current request.
+ * Only applied if the 'pino' module is installed.
+ */
+
+import type { ClockworkPlugin, IPluginContext } from '@adjedaini/clockwork-core';
+import type { LogData } from '@adjedaini/clockwork-shared';
+
+const LEVEL_MAP: Record<string, LogData['level']> = {
+  trace: 'debug',
+  debug: 'debug',
+  info: 'info',
+  warn: 'warning',
+  warning: 'warning',
+  error: 'error',
+  fatal: 'error',
+};
+
+function wrapPino(ctx: IPluginContext): () => void {
+  let pinoId: string;
+  try {
+    pinoId = require.resolve('pino');
+  } catch {
+    return () => {};
+  }
+  const mod = require.cache[pinoId] as { exports: (opts?: unknown) => PinoLogger } | undefined;
+  if (!mod?.exports || typeof mod.exports !== 'function') return () => {};
+
+  const original = mod.exports;
+
+  function wrapLogger(logger: PinoLogger): PinoLogger {
+    const levels = ['trace', 'debug', 'info', 'warn', 'error', 'fatal'] as const;
+    const wrapped = { ...logger };
+    for (const level of levels) {
+      const orig = logger[level];
+      if (typeof orig !== 'function') continue;
+      (wrapped as Record<string, unknown>)[level] = function (this: PinoLogger, ...args: unknown[]) {
+        const requestId = ctx.getRequestId();
+        if (requestId) {
+          const msg = typeof args[0] === 'string' ? args[0] : JSON.stringify(args[0] ?? '');
+          const levelMapped = LEVEL_MAP[level] ?? 'info';
+          ctx.core.captureNativeLog(requestId, levelMapped, msg, undefined);
+        }
+        return (orig as (...a: unknown[]) => unknown).apply(this, args);
+      };
+    }
+    if (typeof logger.child === 'function') {
+      const origChild = logger.child.bind(logger);
+      wrapped.child = function (bindings: unknown) {
+        return wrapLogger(origChild(bindings));
+      };
+    }
+    return wrapped as PinoLogger;
+  }
+
+  mod.exports = function (opts?: unknown) {
+    return wrapLogger(original(opts));
+  };
+
+  return function restore() {
+    mod.exports = original;
+  };
+}
+
+interface PinoLogger {
+  trace?(...args: unknown[]): void;
+  debug?(...args: unknown[]): void;
+  info?(...args: unknown[]): void;
+  warn?(...args: unknown[]): void;
+  error?(...args: unknown[]): void;
+  fatal?(...args: unknown[]): void;
+  child?(bindings: unknown): PinoLogger;
+}
+
+export const pinoPlugin: ClockworkPlugin = {
+  name: 'pino',
+  install: wrapPino,
+};