npm - @adjedaini/clockwork-node - Versions diffs - 0.0.1 - Mend

@adjedaini/clockwork-node 0.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (65) hide show

package/dist/public/index.html ADDED Viewed

@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Clockwork — Node.js Debugging &amp; Monitoring</title>
+    <script type="module" crossorigin src="/__clockwork/app/assets/index-KmGT-iQM.js"></script>
+    <link rel="stylesheet" crossorigin href="/__clockwork/app/assets/index-B2HEyS_P.css">
+  </head>
+  <body>
+    <div id="root"></div>
+  </body>
+</html>

package/node_modules/@adjedaini/clockwork-core/dist/index.d.ts ADDED Viewed

@@ -0,0 +1,53 @@
+import { CoreConfig, RequestSnapshot, LogData, QueryData, EventData, Snapshot } from '@adjedaini/clockwork-shared';
+export { CoreConfig, IRequestStorage, RequestMetadata, RequestSnapshot, Snapshot } from '@adjedaini/clockwork-shared';
+/**
+ * @adjedaini/clockwork-core
+ * Framework-agnostic monitoring engine. No Express, Fastify, or React.
+ */
+/** Context passed to every plugin. getRequestId() returns current request id when inside middleware. */
+interface IPluginContext {
+    core: MonitorCore;
+    getRequestId(): string | undefined;
+}
+/** Generic plugin: install patches and return a restore function. */
+interface ClockworkPlugin {
+    name: string;
+    install(ctx: IPluginContext): () => void;
+}
+declare class MonitorCore {
+    private buffer;
+    private current;
+    private startedAt;
+    private config;
+    constructor(config?: CoreConfig);
+    /** Start the monitor (call once at bootstrap). */
+    start(): void;
+    /** Begin capturing a request. Returns request id. */
+    captureRequest(initial: Partial<RequestSnapshot>): string;
+    /** Attach a log entry to a request. */
+    captureLog(requestId: string, level: LogData['level'], message: string, context?: Record<string, unknown>): void;
+    /** Attach a native (e.g. console) log entry. */
+    captureNativeLog(requestId: string, level: LogData['level'], message: string, context?: Record<string, unknown>, timeOffset?: number): void;
+    /** Capture an error. If requestId is set, also attach to that request's log. */
+    captureError(error: unknown, requestId?: string): void;
+    /** Add a query to a request. */
+    addQuery(requestId: string, data: QueryData): void;
+    /** Add a timeline event to a request. */
+    addEvent(requestId: string, data: EventData): void;
+    /** Update request data (e.g. response status, duration, body). */
+    finalizeRequest(requestId: string, update: {
+        responseStatus: number;
+        responseDuration: number;
+        responseData?: unknown;
+    }): void;
+    /** Get full request by id. */
+    getRequest(id: string): RequestSnapshot | undefined;
+    /** Get snapshot for UI: list of requests + optional metrics. */
+    getSnapshot(limit?: number): Snapshot;
+    /** For plugin/collector registration later. */
+    registerCollector(_name: string, _fn: () => unknown): void;
+}
+export { type ClockworkPlugin, type IPluginContext, MonitorCore };

package/node_modules/@adjedaini/clockwork-core/dist/index.js ADDED Viewed

@@ -0,0 +1,192 @@
+"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, {
+  MonitorCore: () => MonitorCore
+});
+module.exports = __toCommonJS(index_exports);
+// src/ring-buffer.ts
+var RequestRingBuffer = class {
+  constructor(capacity = 100) {
+    this.buffer = /* @__PURE__ */ new Map();
+    this.order = [];
+    this.capacity = Math.max(1, capacity);
+  }
+  push(id, request) {
+    if (this.buffer.has(id)) {
+      this.buffer.set(id, request);
+      return;
+    }
+    while (this.order.length >= this.capacity && this.order.length > 0) {
+      const oldest = this.order.shift();
+      this.buffer.delete(oldest);
+    }
+    this.order.push(id);
+    this.buffer.set(id, request);
+  }
+  get(id) {
+    return this.buffer.get(id);
+  }
+  getAll(limit = 100) {
+    const ids = this.order.slice(-limit).reverse();
+    return ids.map((id) => this.buffer.get(id)).filter(Boolean);
+  }
+  getLatest() {
+    if (this.order.length === 0) return void 0;
+    return this.buffer.get(this.order[this.order.length - 1]);
+  }
+  count() {
+    return this.buffer.size;
+  }
+};
+// src/index.ts
+var DEFAULT_MAX_REQUESTS = 100;
+var MonitorCore = class {
+  constructor(config = {}) {
+    this.current = /* @__PURE__ */ new Map();
+    this.startedAt = 0;
+    this.config = {
+      maxRequests: config.maxRequests ?? DEFAULT_MAX_REQUESTS
+    };
+    this.buffer = config.storage ?? new RequestRingBuffer(this.config.maxRequests);
+  }
+  /** Start the monitor (call once at bootstrap). */
+  start() {
+    this.startedAt = Date.now();
+  }
+  /** Begin capturing a request. Returns request id. */
+  captureRequest(initial) {
+    const id = initial.id || `${Date.now().toString(36)}${Math.random().toString(36).slice(2, 9)}`;
+    const startTime = Date.now();
+    const heapAtStart = process.memoryUsage().heapUsed;
+    const snapshot = {
+      id,
+      type: "http",
+      method: initial.method ?? "",
+      uri: initial.uri ?? "",
+      headers: initial.headers ?? {},
+      getData: initial.getData ?? {},
+      postData: initial.postData,
+      cookies: initial.cookies,
+      responseStatus: 0,
+      responseTime: startTime,
+      responseDuration: 0,
+      memoryUsage: heapAtStart,
+      time: startTime / 1e3,
+      log: [],
+      databaseQueries: [],
+      timelineData: [],
+      controller: initial.controller
+    };
+    this.current.set(id, snapshot);
+    return id;
+  }
+  /** Attach a log entry to a request. */
+  captureLog(requestId, level, message, context) {
+    const req = this.current.get(requestId);
+    if (!req) return;
+    const startTime = req.time * 1e3;
+    req.log.push({
+      level,
+      message,
+      context,
+      time: (Date.now() - startTime) / 1e3,
+      source: "clockwork"
+    });
+  }
+  /** Attach a native (e.g. console) log entry. */
+  captureNativeLog(requestId, level, message, context, timeOffset) {
+    const req = this.current.get(requestId);
+    if (!req) return;
+    const startTime = req.time * 1e3;
+    req.log.push({
+      level,
+      message,
+      context,
+      time: timeOffset ?? (Date.now() - startTime) / 1e3,
+      source: "native"
+    });
+  }
+  /** Capture an error. If requestId is set, also attach to that request's log. */
+  captureError(error, requestId) {
+    const message = error instanceof Error ? error.message : String(error);
+    const context = error instanceof Error ? { name: error.name, stack: error.stack } : void 0;
+    if (requestId) {
+      this.captureLog(requestId, "error", message, context);
+    }
+  }
+  /** Add a query to a request. */
+  addQuery(requestId, data) {
+    const req = this.current.get(requestId);
+    if (!req) return;
+    req.databaseQueries.push(data);
+  }
+  /** Add a timeline event to a request. */
+  addEvent(requestId, data) {
+    const req = this.current.get(requestId);
+    if (!req) return;
+    req.timelineData.push(data);
+  }
+  /** Update request data (e.g. response status, duration, body). */
+  finalizeRequest(requestId, update) {
+    const req = this.current.get(requestId);
+    if (!req) return;
+    req.responseStatus = update.responseStatus;
+    req.responseDuration = update.responseDuration;
+    if (update.responseData !== void 0) req.responseData = update.responseData;
+    req.memoryUsage = process.memoryUsage().heapUsed - req.memoryUsage;
+    this.buffer.push(requestId, req);
+    this.current.delete(requestId);
+  }
+  /** Get full request by id. */
+  getRequest(id) {
+    return this.current.get(id) ?? this.buffer.get(id);
+  }
+  /** Get snapshot for UI: list of requests + optional metrics. */
+  getSnapshot(limit = 50) {
+    const all = this.buffer.getAll(limit);
+    const requests = all.map((r) => ({
+      id: r.id,
+      method: r.method,
+      uri: r.uri,
+      controller: r.controller,
+      responseStatus: r.responseStatus,
+      responseDuration: r.responseDuration,
+      time: r.time
+    }));
+    return {
+      requests,
+      metrics: {
+        timestamp: Date.now() / 1e3,
+        spans: []
+      }
+    };
+  }
+  /** For plugin/collector registration later. */
+  registerCollector(_name, _fn) {
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MonitorCore
+});

package/node_modules/@adjedaini/clockwork-core/package.json ADDED Viewed

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

package/node_modules/@adjedaini/clockwork-core/src/index.ts ADDED Viewed

@@ -0,0 +1,194 @@
+/**
+ * @adjedaini/clockwork-core
+ * Framework-agnostic monitoring engine. No Express, Fastify, or React.
+ */
+import type {
+  RequestSnapshot,
+  RequestMetadata,
+  LogData,
+  QueryData,
+  EventData,
+  Snapshot,
+  CoreConfig,
+  IRequestStorage,
+} from '@adjedaini/clockwork-shared';
+import { RequestRingBuffer } from './ring-buffer';
+export type { RequestSnapshot, RequestMetadata, Snapshot, CoreConfig, IRequestStorage } from '@adjedaini/clockwork-shared';
+/** Context passed to every plugin. getRequestId() returns current request id when inside middleware. */
+export interface IPluginContext {
+  core: MonitorCore;
+  getRequestId(): string | undefined;
+}
+/** Generic plugin: install patches and return a restore function. */
+export interface ClockworkPlugin {
+  name: string;
+  install(ctx: IPluginContext): () => void;
+}
+const DEFAULT_MAX_REQUESTS = 100;
+export class MonitorCore {
+  private buffer: IRequestStorage;
+  private current: Map<string, RequestSnapshot> = new Map();
+  private startedAt: number = 0;
+  private config: Required<Pick<CoreConfig, 'maxRequests'>>;
+  constructor(config: CoreConfig = {}) {
+    this.config = {
+      maxRequests: config.maxRequests ?? DEFAULT_MAX_REQUESTS,
+    };
+    this.buffer = config.storage ?? new RequestRingBuffer(this.config.maxRequests);
+  }
+  /** Start the monitor (call once at bootstrap). */
+  start(): void {
+    this.startedAt = Date.now();
+  }
+  /** Begin capturing a request. Returns request id. */
+  captureRequest(initial: Partial<RequestSnapshot>): string {
+    const id =
+      (initial.id as string) ||
+      `${Date.now().toString(36)}${Math.random().toString(36).slice(2, 9)}`;
+    const startTime = Date.now();
+    const heapAtStart = process.memoryUsage().heapUsed;
+    const snapshot: RequestSnapshot = {
+      id,
+      type: 'http',
+      method: initial.method ?? '',
+      uri: initial.uri ?? '',
+      headers: initial.headers ?? {},
+      getData: initial.getData ?? {},
+      postData: initial.postData,
+      cookies: initial.cookies,
+      responseStatus: 0,
+      responseTime: startTime,
+      responseDuration: 0,
+      memoryUsage: heapAtStart,
+      time: startTime / 1000,
+      log: [],
+      databaseQueries: [],
+      timelineData: [],
+      controller: initial.controller,
+    };
+    this.current.set(id, snapshot);
+    return id;
+  }
+  /** Attach a log entry to a request. */
+  captureLog(
+    requestId: string,
+    level: LogData['level'],
+    message: string,
+    context?: Record<string, unknown>
+  ): void {
+    const req = this.current.get(requestId);
+    if (!req) return;
+    const startTime = req.time * 1000;
+    req.log.push({
+      level,
+      message,
+      context,
+      time: (Date.now() - startTime) / 1000,
+      source: 'clockwork',
+    });
+  }
+  /** Attach a native (e.g. console) log entry. */
+  captureNativeLog(
+    requestId: string,
+    level: LogData['level'],
+    message: string,
+    context?: Record<string, unknown>,
+    timeOffset?: number
+  ): void {
+    const req = this.current.get(requestId);
+    if (!req) return;
+    const startTime = req.time * 1000;
+    req.log.push({
+      level,
+      message,
+      context,
+      time: timeOffset ?? (Date.now() - startTime) / 1000,
+      source: 'native',
+    });
+  }
+  /** Capture an error. If requestId is set, also attach to that request's log. */
+  captureError(error: unknown, requestId?: string): void {
+    const message = error instanceof Error ? error.message : String(error);
+    const context = error instanceof Error ? { name: error.name, stack: error.stack } : undefined;
+    if (requestId) {
+      this.captureLog(requestId, 'error', message, context as Record<string, unknown>);
+    }
+    // Global errors could be stored in a ring buffer here for getSnapshot(); optional for later.
+  }
+  /** Add a query to a request. */
+  addQuery(requestId: string, data: QueryData): void {
+    const req = this.current.get(requestId);
+    if (!req) return;
+    req.databaseQueries.push(data);
+  }
+  /** Add a timeline event to a request. */
+  addEvent(requestId: string, data: EventData): void {
+    const req = this.current.get(requestId);
+    if (!req) return;
+    req.timelineData.push(data);
+  }
+  /** Update request data (e.g. response status, duration, body). */
+  finalizeRequest(
+    requestId: string,
+    update: {
+      responseStatus: number;
+      responseDuration: number;
+      responseData?: unknown;
+    }
+  ): void {
+    const req = this.current.get(requestId);
+    if (!req) return;
+    req.responseStatus = update.responseStatus;
+    req.responseDuration = update.responseDuration;
+    if (update.responseData !== undefined) req.responseData = update.responseData;
+    req.memoryUsage = process.memoryUsage().heapUsed - req.memoryUsage;
+    this.buffer.push(requestId, req);
+    this.current.delete(requestId);
+  }
+  /** Get full request by id. */
+  getRequest(id: string): RequestSnapshot | undefined {
+    return this.current.get(id) ?? this.buffer.get(id);
+  }
+  /** Get snapshot for UI: list of requests + optional metrics. */
+  getSnapshot(limit: number = 50): Snapshot {
+    const all = this.buffer.getAll(limit);
+    const requests: RequestMetadata[] = all.map((r) => ({
+      id: r.id,
+      method: r.method,
+      uri: r.uri,
+      controller: r.controller,
+      responseStatus: r.responseStatus,
+      responseDuration: r.responseDuration,
+      time: r.time,
+    }));
+    return {
+      requests,
+      metrics: {
+        timestamp: Date.now() / 1000,
+        spans: [],
+      },
+    };
+  }
+  /** For plugin/collector registration later. */
+  registerCollector(_name: string, _fn: () => unknown): void {
+    // no-op for now; extend for plugins
+  }
+}

package/node_modules/@adjedaini/clockwork-core/src/ring-buffer.ts ADDED Viewed

@@ -0,0 +1,47 @@
+/**
+ * In-memory ring buffer for request storage. Evicts oldest when at capacity.
+ * Implements IRequestStorage for pluggable backends.
+ */
+import type { RequestSnapshot, IRequestStorage } from '@adjedaini/clockwork-shared';
+export class RequestRingBuffer implements IRequestStorage {
+  private buffer: Map<string, RequestSnapshot> = new Map();
+  private order: string[] = [];
+  private readonly capacity: number;
+  constructor(capacity: number = 100) {
+    this.capacity = Math.max(1, capacity);
+  }
+  push(id: string, request: RequestSnapshot): void {
+    if (this.buffer.has(id)) {
+      this.buffer.set(id, request);
+      return;
+    }
+    while (this.order.length >= this.capacity && this.order.length > 0) {
+      const oldest = this.order.shift()!;
+      this.buffer.delete(oldest);
+    }
+    this.order.push(id);
+    this.buffer.set(id, request);
+  }
+  get(id: string): RequestSnapshot | undefined {
+    return this.buffer.get(id);
+  }
+  getAll(limit: number = 100): RequestSnapshot[] {
+    const ids = this.order.slice(-limit).reverse();
+    return ids.map((id) => this.buffer.get(id)!).filter(Boolean);
+  }
+  getLatest(): RequestSnapshot | undefined {
+    if (this.order.length === 0) return undefined;
+    return this.buffer.get(this.order[this.order.length - 1]);
+  }
+  count(): number {
+    return this.buffer.size;
+  }
+}

package/node_modules/@adjedaini/clockwork-core/tsconfig.build.json ADDED Viewed

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

package/node_modules/@adjedaini/clockwork-core/tsconfig.json ADDED Viewed

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

package/node_modules/@adjedaini/clockwork-core/tsup.config.ts ADDED Viewed

@@ -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-db-interceptor/dist/index.d.ts ADDED Viewed

@@ -0,0 +1,33 @@
+import { MonitorCore, ClockworkPlugin } from '@adjedaini/clockwork-core';
+export { ClockworkPlugin, IPluginContext } from '@adjedaini/clockwork-core';
+/**
+ * Patch pg Client.query so queries are attached to the current request (when in context).
+ * Only applied if the 'pg' module is installed.
+ */
+type GetRequestId$2 = () => string | undefined;
+declare function patchPg(core: MonitorCore, getRequestId: GetRequestId$2): () => void;
+/**
+ * Patch mysql2 so Connection.query/execute are tracked. Only applied if 'mysql2' is installed.
+ * Wraps createConnection to patch the returned connection.
+ */
+type GetRequestId$1 = () => string | undefined;
+declare function patchMysql2(core: MonitorCore, getRequestId: GetRequestId$1): () => void;
+/**
+ * @adjedaini/clockwork-db-interceptor
+ * Optional DB query instrumentation as pluggable plugins (pg, mysql2).
+ * Implements generic ClockworkPlugin from core (IPluginContext).
+ */
+type GetRequestId = () => string | undefined;
+/** DB plugins conform to generic ClockworkPlugin. */
+declare const pgPlugin: ClockworkPlugin;
+declare const mysql2Plugin: ClockworkPlugin;
+/** Default set of DB plugins (pg + mysql2). */
+declare const defaultDbPlugins: ClockworkPlugin[];
+export { type GetRequestId, defaultDbPlugins, mysql2Plugin, patchMysql2, patchPg, pgPlugin };