brakit 0.6.0

package/dist/instrument/preload.js

@@ -0,0 +1,739 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/constants/routes.ts
+var DASHBOARD_API_INGEST;
+var init_routes = __esm({
+  "src/constants/routes.ts"() {
+    "use strict";
+    DASHBOARD_API_INGEST = "/__brakit/api/ingest";
+  }
+});
+
+// src/constants/limits.ts
+var init_limits = __esm({
+  "src/constants/limits.ts"() {
+    "use strict";
+  }
+});
+
+// src/constants/thresholds.ts
+var init_thresholds = __esm({
+  "src/constants/thresholds.ts"() {
+    "use strict";
+  }
+});
+
+// src/constants/transport.ts
+var TRANSPORT_FLUSH_INTERVAL_MS, TRANSPORT_FLUSH_BATCH_SIZE, NOISE_HOSTS;
+var init_transport = __esm({
+  "src/constants/transport.ts"() {
+    "use strict";
+    TRANSPORT_FLUSH_INTERVAL_MS = 50;
+    TRANSPORT_FLUSH_BATCH_SIZE = 20;
+    NOISE_HOSTS = [
+      "registry.npmjs.org",
+      "telemetry.nextjs.org"
+    ];
+  }
+});
+
+// src/constants/metrics.ts
+var init_metrics = __esm({
+  "src/constants/metrics.ts"() {
+    "use strict";
+  }
+});
+
+// src/constants/headers.ts
+var BRAKIT_REQUEST_ID_HEADER;
+var init_headers = __esm({
+  "src/constants/headers.ts"() {
+    "use strict";
+    BRAKIT_REQUEST_ID_HEADER = "x-brakit-request-id";
+  }
+});
+
+// src/constants/index.ts
+var init_constants = __esm({
+  "src/constants/index.ts"() {
+    "use strict";
+    init_routes();
+    init_limits();
+    init_thresholds();
+    init_transport();
+    init_metrics();
+    init_headers();
+  }
+});
+
+// src/instrument/transport.ts
+var transport_exports = {};
+__export(transport_exports, {
+  send: () => send
+});
+import { request } from "http";
+function flush() {
+  if (buffer.length === 0 || !brakitPort) return;
+  const batch = { _brakit: true, events: buffer };
+  buffer = [];
+  const body = JSON.stringify(batch);
+  try {
+    const req = request(
+      {
+        hostname: "127.0.0.1",
+        port: brakitPort,
+        path: DASHBOARD_API_INGEST,
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          "content-length": Buffer.byteLength(body)
+        }
+      },
+      // Discard response — fire and forget
+      (res) => res.resume()
+    );
+    req.on("error", () => {
+    });
+    req.end(body);
+  } catch {
+  }
+}
+function scheduleFlush() {
+  if (timer !== null) return;
+  timer = setTimeout(() => {
+    timer = null;
+    flush();
+  }, TRANSPORT_FLUSH_INTERVAL_MS);
+  if (timer && typeof timer === "object" && "unref" in timer) {
+    timer.unref();
+  }
+}
+function send(event) {
+  buffer.push(event);
+  if (buffer.length >= TRANSPORT_FLUSH_BATCH_SIZE) {
+    if (timer !== null) {
+      clearTimeout(timer);
+      timer = null;
+    }
+    flush();
+  } else {
+    scheduleFlush();
+  }
+}
+var brakitPort, buffer, timer;
+var init_transport2 = __esm({
+  "src/instrument/transport.ts"() {
+    "use strict";
+    init_constants();
+    brakitPort = parseInt(process.env.BRAKIT_PORT ?? "0", 10);
+    buffer = [];
+    timer = null;
+  }
+});
+
+// src/instrument/hooks/context.ts
+import { AsyncLocalStorage } from "async_hooks";
+import { randomUUID } from "crypto";
+function getRequestContext() {
+  return storage.getStore();
+}
+var storage;
+var init_context = __esm({
+  "src/instrument/hooks/context.ts"() {
+    "use strict";
+    storage = new AsyncLocalStorage();
+  }
+});
+
+// src/instrument/hooks/fetch.ts
+var fetch_exports = {};
+__export(fetch_exports, {
+  setupFetchHook: () => setupFetchHook
+});
+import { subscribe } from "diagnostics_channel";
+function isNoise(origin) {
+  try {
+    const host = new URL(origin).hostname;
+    return NOISE_HOSTS.some((h) => host === h || host.endsWith("." + h));
+  } catch {
+    return false;
+  }
+}
+function setupFetchHook() {
+  subscribe("undici:request:create", (message) => {
+    const msg = message;
+    const req = msg.request;
+    const origin = req.origin ?? "";
+    if (isNoise(origin)) return;
+    const ctx = getRequestContext();
+    pending.set(msg.request, {
+      origin,
+      method: req.method ?? "GET",
+      path: req.path ?? "/",
+      startTime: performance.now(),
+      parentRequestId: ctx?.requestId ?? null
+    });
+  });
+  subscribe("undici:request:headers", (message) => {
+    const msg = message;
+    const info = pending.get(msg.request);
+    if (!info) return;
+    pending.delete(msg.request);
+    send({
+      type: "fetch",
+      data: {
+        url: info.origin + info.path,
+        method: info.method,
+        statusCode: msg.response.statusCode ?? 0,
+        durationMs: Math.round(performance.now() - info.startTime),
+        parentRequestId: info.parentRequestId,
+        timestamp: Date.now()
+      }
+    });
+  });
+  subscribe("undici:request:error", (message) => {
+    const msg = message;
+    pending.delete(msg.request);
+  });
+}
+var pending;
+var init_fetch = __esm({
+  "src/instrument/hooks/fetch.ts"() {
+    "use strict";
+    init_transport2();
+    init_context();
+    init_constants();
+    pending = /* @__PURE__ */ new WeakMap();
+  }
+});
+
+// src/instrument/hooks/console.ts
+var console_exports = {};
+__export(console_exports, {
+  setupConsoleHook: () => setupConsoleHook
+});
+import { format } from "util";
+function setupConsoleHook() {
+  for (const level of LEVELS) {
+    const original = originals[level];
+    console[level] = (...args) => {
+      original.apply(console, args);
+      const ctx = getRequestContext();
+      const message = format(...args);
+      const timestamp = Date.now();
+      const parentRequestId = ctx?.requestId ?? null;
+      if (level === "error") {
+        const errorArg = args.find((a) => a instanceof Error);
+        if (errorArg) {
+          send({
+            type: "error",
+            data: {
+              name: errorArg.name,
+              message: errorArg.message,
+              stack: errorArg.stack ?? "",
+              parentRequestId,
+              timestamp
+            }
+          });
+          return;
+        }
+        const match = message.match(/(\w*Error):\s+(.+)/s);
+        if (match) {
+          send({
+            type: "error",
+            data: {
+              name: match[1],
+              message: match[2].split("\n")[0],
+              stack: message,
+              parentRequestId,
+              timestamp
+            }
+          });
+          return;
+        }
+      }
+      send({
+        type: "log",
+        data: { level, message, parentRequestId, timestamp }
+      });
+    };
+  }
+}
+var LEVELS, originals;
+var init_console = __esm({
+  "src/instrument/hooks/console.ts"() {
+    "use strict";
+    init_transport2();
+    init_context();
+    LEVELS = ["log", "warn", "error", "info", "debug"];
+    originals = {
+      log: console.log,
+      warn: console.warn,
+      error: console.error,
+      info: console.info,
+      debug: console.debug
+    };
+  }
+});
+
+// src/instrument/hooks/errors.ts
+var errors_exports = {};
+__export(errors_exports, {
+  setupErrorHook: () => setupErrorHook
+});
+function captureError(err) {
+  const error = err instanceof Error ? err : new Error(String(err));
+  const ctx = getRequestContext();
+  send({
+    type: "error",
+    data: {
+      name: error.name,
+      message: error.message,
+      stack: error.stack ?? "",
+      parentRequestId: ctx?.requestId ?? null,
+      timestamp: Date.now()
+    }
+  });
+}
+function setupErrorHook() {
+  process.on("uncaughtException", (err) => {
+    captureError(err);
+    process.removeAllListeners("uncaughtException");
+    throw err;
+  });
+  process.on("unhandledRejection", (reason) => {
+    captureError(reason);
+  });
+}
+var init_errors = __esm({
+  "src/instrument/hooks/errors.ts"() {
+    "use strict";
+    init_transport2();
+    init_context();
+  }
+});
+
+// src/instrument/hooks/http-context.ts
+var http_context_exports = {};
+__export(http_context_exports, {
+  setupHttpContextHook: () => setupHttpContextHook
+});
+import http from "http";
+import { randomUUID as randomUUID2 } from "crypto";
+function setupHttpContextHook() {
+  const originalEmit = http.Server.prototype.emit;
+  http.Server.prototype.emit = function(event, ...args) {
+    if (event === "request") {
+      const req = args[0];
+      const ctx = {
+        requestId: req.headers[BRAKIT_REQUEST_ID_HEADER] ?? randomUUID2(),
+        url: req.url ?? "/",
+        method: req.method ?? "GET"
+      };
+      return storage.run(
+        ctx,
+        () => originalEmit.apply(this, [event, ...args])
+      );
+    }
+    return originalEmit.apply(this, [event, ...args]);
+  };
+}
+var init_http_context = __esm({
+  "src/instrument/hooks/http-context.ts"() {
+    "use strict";
+    init_context();
+    init_constants();
+  }
+});
+
+// src/instrument/adapter-registry.ts
+var AdapterRegistry;
+var init_adapter_registry = __esm({
+  "src/instrument/adapter-registry.ts"() {
+    "use strict";
+    AdapterRegistry = class {
+      adapters = [];
+      active = [];
+      register(adapter) {
+        this.adapters.push(adapter);
+      }
+      patchAll(emit) {
+        for (const adapter of this.adapters) {
+          try {
+            if (adapter.detect()) {
+              adapter.patch(emit);
+              this.active.push(adapter);
+            }
+          } catch {
+          }
+        }
+      }
+      unpatchAll() {
+        for (const adapter of this.active) {
+          try {
+            adapter.unpatch?.();
+          } catch {
+          }
+        }
+        this.active = [];
+      }
+      getActive() {
+        return this.active;
+      }
+    };
+  }
+});
+
+// src/instrument/adapters/shared.ts
+import { createRequire } from "module";
+function tryRequire(id) {
+  try {
+    return appRequire(id);
+  } catch {
+    return null;
+  }
+}
+function captureRequestId() {
+  return getRequestContext()?.requestId ?? null;
+}
+var appRequire;
+var init_shared = __esm({
+  "src/instrument/adapters/shared.ts"() {
+    "use strict";
+    init_context();
+    appRequire = createRequire(process.cwd() + "/index.js");
+  }
+});
+
+// src/instrument/adapters/normalize.ts
+function normalizeSQL(sql) {
+  if (!sql) return { op: "OTHER", table: "" };
+  const trimmed = sql.trim();
+  const op = trimmed.split(/\s+/)[0].toUpperCase();
+  if (/SELECT\s+COUNT/i.test(trimmed)) {
+    const match = trimmed.match(/FROM\s+"?\w+"?\."?(\w+)"?/i);
+    return { op: "SELECT", table: match?.[1] ?? "" };
+  }
+  const tableMatch = trimmed.match(/(?:FROM|INTO|UPDATE)\s+"?\w+"?\."?(\w+)"?/i);
+  const table = tableMatch?.[1] ?? "";
+  switch (op) {
+    case "SELECT":
+      return { op: "SELECT", table };
+    case "INSERT":
+      return { op: "INSERT", table };
+    case "UPDATE":
+      return { op: "UPDATE", table };
+    case "DELETE":
+      return { op: "DELETE", table };
+    default:
+      return { op: "OTHER", table };
+  }
+}
+function normalizePrismaOp(operation) {
+  return PRISMA_OP_MAP[operation] ?? "OTHER";
+}
+var PRISMA_OP_MAP;
+var init_normalize = __esm({
+  "src/instrument/adapters/normalize.ts"() {
+    "use strict";
+    PRISMA_OP_MAP = {
+      findUnique: "SELECT",
+      findUniqueOrThrow: "SELECT",
+      findFirst: "SELECT",
+      findFirstOrThrow: "SELECT",
+      findMany: "SELECT",
+      count: "SELECT",
+      aggregate: "SELECT",
+      groupBy: "SELECT",
+      create: "INSERT",
+      createMany: "INSERT",
+      createManyAndReturn: "INSERT",
+      update: "UPDATE",
+      updateMany: "UPDATE",
+      upsert: "UPDATE",
+      delete: "DELETE",
+      deleteMany: "DELETE"
+    };
+  }
+});
+
+// src/instrument/adapters/pg.ts
+var origQuery, proto, pgAdapter;
+var init_pg = __esm({
+  "src/instrument/adapters/pg.ts"() {
+    "use strict";
+    init_shared();
+    init_normalize();
+    origQuery = null;
+    proto = null;
+    pgAdapter = {
+      name: "pg",
+      detect() {
+        return tryRequire("pg") !== null;
+      },
+      patch(emit) {
+        const pg = tryRequire("pg");
+        if (!pg) return;
+        const Client = pg.default?.Client ?? pg.Client;
+        if (!Client || typeof Client !== "function") return;
+        proto = Client.prototype ?? null;
+        if (!proto?.query) return;
+        origQuery = proto.query;
+        const saved = origQuery;
+        proto.query = function(...args) {
+          const first = args[0];
+          const sql = typeof first === "string" ? first : typeof first === "object" && first !== null && "text" in first ? first.text : void 0;
+          const start = performance.now();
+          const requestId = captureRequestId();
+          const { op, table } = normalizeSQL(sql ?? "");
+          const emitQuery = (rowCount) => {
+            emit({
+              type: "query",
+              data: {
+                driver: "pg",
+                source: "pg",
+                sql,
+                normalizedOp: op,
+                table,
+                durationMs: Math.round(performance.now() - start),
+                rowCount: rowCount ?? void 0,
+                parentRequestId: requestId,
+                timestamp: Date.now()
+              }
+            });
+          };
+          const lastIdx = args.length - 1;
+          if (lastIdx >= 0 && typeof args[lastIdx] === "function") {
+            const origCb = args[lastIdx];
+            args[lastIdx] = function(err, res) {
+              emitQuery(res?.rowCount ?? void 0);
+              return origCb.call(this, err, res);
+            };
+            return saved.apply(this, args);
+          }
+          const result = saved.apply(this, args);
+          if (result && typeof result.then === "function") {
+            return result.then((res) => {
+              emitQuery(res?.rowCount ?? void 0);
+              return res;
+            });
+          }
+          if (result && typeof result.on === "function") {
+            result.on("end", (res) => emitQuery(res?.rowCount ?? void 0));
+            return result;
+          }
+          return result;
+        };
+      },
+      unpatch() {
+        if (proto && origQuery) {
+          proto.query = origQuery;
+          origQuery = null;
+          proto = null;
+        }
+      }
+    };
+  }
+});
+
+// src/instrument/adapters/mysql2.ts
+var originals2, proto2, mysql2Adapter;
+var init_mysql2 = __esm({
+  "src/instrument/adapters/mysql2.ts"() {
+    "use strict";
+    init_shared();
+    init_normalize();
+    originals2 = /* @__PURE__ */ new Map();
+    proto2 = null;
+    mysql2Adapter = {
+      name: "mysql2",
+      detect() {
+        return tryRequire("mysql2") !== null;
+      },
+      patch(emit) {
+        const mysql2 = tryRequire("mysql2");
+        if (!mysql2) return;
+        proto2 = mysql2.Connection?.prototype ?? null;
+        if (!proto2) return;
+        for (const method of ["query", "execute"]) {
+          const orig = proto2[method];
+          if (typeof orig !== "function") continue;
+          originals2.set(method, orig);
+          proto2[method] = function(...args) {
+            const first = args[0];
+            const sql = typeof first === "string" ? first : void 0;
+            const start = performance.now();
+            const requestId = captureRequestId();
+            const { op, table } = normalizeSQL(sql ?? "");
+            const emitQuery = () => {
+              emit({
+                type: "query",
+                data: {
+                  driver: "mysql2",
+                  source: "mysql2",
+                  sql,
+                  normalizedOp: op,
+                  table,
+                  durationMs: Math.round(performance.now() - start),
+                  parentRequestId: requestId,
+                  timestamp: Date.now()
+                }
+              });
+            };
+            const lastIdx = args.length - 1;
+            if (lastIdx >= 0 && typeof args[lastIdx] === "function") {
+              const origCb = args[lastIdx];
+              args[lastIdx] = function() {
+                emitQuery();
+                return origCb.apply(this, arguments);
+              };
+              return orig.apply(this, args);
+            }
+            const result = orig.apply(this, args);
+            if (result && typeof result.then === "function") {
+              return result.then((res) => {
+                emitQuery();
+                return res;
+              });
+            }
+            return result;
+          };
+        }
+      },
+      unpatch() {
+        if (proto2) {
+          for (const [method, orig] of originals2) {
+            proto2[method] = orig;
+          }
+          originals2.clear();
+          proto2 = null;
+        }
+      }
+    };
+  }
+});
+
+// src/instrument/adapters/prisma.ts
+var origConnect, prismaProto, prismaAdapter;
+var init_prisma = __esm({
+  "src/instrument/adapters/prisma.ts"() {
+    "use strict";
+    init_shared();
+    init_normalize();
+    origConnect = null;
+    prismaProto = null;
+    prismaAdapter = {
+      name: "prisma",
+      detect() {
+        return tryRequire("@prisma/client") !== null;
+      },
+      patch(emit) {
+        const prismaModule = tryRequire("@prisma/client");
+        if (!prismaModule) return;
+        const PrismaClient = prismaModule.default?.PrismaClient ?? prismaModule.PrismaClient;
+        if (!PrismaClient || typeof PrismaClient !== "function") return;
+        prismaProto = PrismaClient.prototype;
+        origConnect = prismaProto.$connect;
+        if (typeof origConnect !== "function") return;
+        const saved = origConnect;
+        prismaProto.$connect = async function(...args) {
+          if (!this._brakitPatched) {
+            this._brakitPatched = true;
+            const extended = this.$extends({
+              query: {
+                $allModels: {
+                  async $allOperations({
+                    model,
+                    operation,
+                    args: opArgs,
+                    query
+                  }) {
+                    const requestId = captureRequestId();
+                    const start = performance.now();
+                    const result = await query(opArgs);
+                    emit({
+                      type: "query",
+                      data: {
+                        driver: "prisma",
+                        source: "prisma",
+                        model,
+                        operation,
+                        normalizedOp: normalizePrismaOp(operation),
+                        table: model,
+                        durationMs: Math.round(performance.now() - start),
+                        parentRequestId: requestId,
+                        timestamp: Date.now()
+                      }
+                    });
+                    return result;
+                  }
+                }
+              }
+            });
+            Object.setPrototypeOf(this, Object.getPrototypeOf(extended));
+          }
+          return saved.apply(this, args);
+        };
+      },
+      unpatch() {
+        if (prismaProto && origConnect) {
+          prismaProto.$connect = origConnect;
+          origConnect = null;
+          prismaProto = null;
+        }
+      }
+    };
+  }
+});
+
+// src/instrument/adapters/index.ts
+var adapters_exports = {};
+__export(adapters_exports, {
+  createDefaultRegistry: () => createDefaultRegistry,
+  mysql2Adapter: () => mysql2Adapter,
+  pgAdapter: () => pgAdapter,
+  prismaAdapter: () => prismaAdapter
+});
+function createDefaultRegistry() {
+  const registry = new AdapterRegistry();
+  registry.register(pgAdapter);
+  registry.register(mysql2Adapter);
+  registry.register(prismaAdapter);
+  return registry;
+}
+var init_adapters = __esm({
+  "src/instrument/adapters/index.ts"() {
+    "use strict";
+    init_adapter_registry();
+    init_pg();
+    init_mysql2();
+    init_prisma();
+    init_pg();
+    init_mysql2();
+    init_prisma();
+  }
+});
+
+// src/instrument/preload.ts
+if (process.env.BRAKIT_PORT && process.env.BRAKIT_INSTRUMENT !== "0") {
+  const { setupFetchHook: setupFetchHook2 } = await Promise.resolve().then(() => (init_fetch(), fetch_exports));
+  const { setupConsoleHook: setupConsoleHook2 } = await Promise.resolve().then(() => (init_console(), console_exports));
+  const { setupErrorHook: setupErrorHook2 } = await Promise.resolve().then(() => (init_errors(), errors_exports));
+  const { setupHttpContextHook: setupHttpContextHook2 } = await Promise.resolve().then(() => (init_http_context(), http_context_exports));
+  const { createDefaultRegistry: createDefaultRegistry2 } = await Promise.resolve().then(() => (init_adapters(), adapters_exports));
+  const { send: send2 } = await Promise.resolve().then(() => (init_transport2(), transport_exports));
+  setupHttpContextHook2();
+  setupFetchHook2();
+  setupConsoleHook2();
+  setupErrorHook2();
+  const registry = createDefaultRegistry2();
+  registry.patchAll((event) => send2(event));
+}