@runtimescope/server-sdk 0.6.0 → 0.6.1

package/dist/index.cjs

@@ -0,0 +1,1635 @@
+"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, {
+  RuntimeScope: () => RuntimeScope,
+  Sampler: () => Sampler,
+  _log: () => _log,
+  generateId: () => generateId,
+  generateSessionId: () => generateSessionId,
+  getRequestContext: () => getRequestContext,
+  getSessionId: () => getSessionId,
+  normalizeQuery: () => normalizeQuery,
+  parseOperation: () => parseOperation,
+  parseTablesAccessed: () => parseTablesAccessed,
+  redactParams: () => redactParams,
+  runWithContext: () => runWithContext,
+  runtimeScopeMiddleware: () => runtimeScopeMiddleware
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/transport.ts
+var import_ws = __toESM(require("ws"), 1);
+var ServerTransport = class {
+  ws = null;
+  url;
+  sessionId;
+  appName;
+  sdkVersion;
+  queue = [];
+  maxQueueSize;
+  _droppedCount = 0;
+  reconnectTimer = null;
+  connected = false;
+  flushTimer = null;
+  authToken;
+  authFailed = false;
+  constructor(options) {
+    this.url = options.url;
+    this.sessionId = options.sessionId;
+    this.appName = options.appName;
+    this.sdkVersion = options.sdkVersion;
+    this.authToken = options.authToken;
+    this.maxQueueSize = options.maxQueueSize ?? 1e4;
+  }
+  get droppedCount() {
+    return this._droppedCount;
+  }
+  connect() {
+    if (this.authFailed) return;
+    try {
+      this.ws = new import_ws.default(this.url);
+      this.ws.on("open", () => {
+        this.connected = true;
+        this.sendHandshake();
+        this.flushQueue();
+        this.flushTimer = setInterval(() => this.flushQueue(), 100);
+      });
+      this.ws.on("message", (data) => {
+        try {
+          const msg = JSON.parse(data.toString());
+          if (msg.type === "error" && msg.payload?.code === "AUTH_FAILED") {
+            console.error("[RuntimeScope] Authentication failed \u2014 stopping reconnection");
+            this.authFailed = true;
+          }
+        } catch {
+        }
+      });
+      this.ws.on("close", () => {
+        this.connected = false;
+        this.cleanup();
+        if (!this.authFailed) this.scheduleReconnect();
+      });
+      this.ws.on("error", () => {
+        this.connected = false;
+        this.cleanup();
+        if (!this.authFailed) this.scheduleReconnect();
+      });
+    } catch {
+      this.scheduleReconnect();
+    }
+  }
+  cleanup() {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+  }
+  scheduleReconnect() {
+    if (this.reconnectTimer) return;
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      this.connect();
+    }, 3e3);
+  }
+  sendHandshake() {
+    this.send({
+      type: "handshake",
+      payload: {
+        appName: this.appName,
+        sdkVersion: this.sdkVersion,
+        sessionId: this.sessionId,
+        ...this.authToken ? { authToken: this.authToken } : {}
+      },
+      timestamp: Date.now(),
+      sessionId: this.sessionId
+    });
+  }
+  sendEvent(event) {
+    if (this.queue.length >= this.maxQueueSize) {
+      this.queue.shift();
+      this._droppedCount++;
+    }
+    this.queue.push(event);
+    if (this.connected && this.queue.length >= 10) {
+      this.flushQueue();
+    }
+  }
+  flushQueue() {
+    if (!this.connected || this.queue.length === 0) return;
+    const batch = this.queue.splice(0);
+    this.send({
+      type: "event",
+      payload: { events: batch },
+      timestamp: Date.now(),
+      sessionId: this.sessionId
+    });
+  }
+  send(msg) {
+    if (this.ws?.readyState === import_ws.default.OPEN) {
+      try {
+        this.ws.send(JSON.stringify(msg));
+      } catch {
+      }
+    }
+  }
+  disconnect() {
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    this.cleanup();
+    this.flushQueue();
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+    this.connected = false;
+  }
+};
+
+// src/utils/id.ts
+var import_node_crypto = require("crypto");
+function generateId() {
+  return (0, import_node_crypto.randomBytes)(16).toString("hex");
+}
+function generateSessionId() {
+  return `srv-${(0, import_node_crypto.randomBytes)(8).toString("hex")}`;
+}
+
+// src/utils/stack.ts
+var INTERNAL_FRAMES = [
+  "RuntimeScope",
+  "server-sdk",
+  "captureQuery",
+  "instrumentPrisma",
+  "instrumentDrizzle",
+  "instrumentKnex",
+  "instrumentPg",
+  "instrumentMysql2",
+  "instrumentBetterSqlite3"
+];
+function captureStack(skipFrames = 3) {
+  const err = new Error();
+  const stack = err.stack ?? "";
+  const lines = stack.split("\n").slice(skipFrames);
+  const filtered = lines.filter(
+    (line) => !INTERNAL_FRAMES.some((frame) => line.includes(frame))
+  );
+  return filtered.slice(0, 10).join("\n");
+}
+
+// src/sampler.ts
+var Sampler = class {
+  constructor(config) {
+    this.config = config;
+  }
+  windowCount = 0;
+  windowStart = Date.now();
+  _droppedCount = 0;
+  get droppedCount() {
+    return this._droppedCount;
+  }
+  shouldSample(_event) {
+    const rate = this.config.sampleRate;
+    if (rate !== void 0 && rate < 1) {
+      if (Math.random() > rate) {
+        this._droppedCount++;
+        return false;
+      }
+    }
+    const maxPerSec = this.config.maxEventsPerSecond;
+    if (maxPerSec !== void 0) {
+      const now = Date.now();
+      if (now - this.windowStart >= 1e3) {
+        this.windowCount = 0;
+        this.windowStart = now;
+      }
+      if (this.windowCount >= maxPerSec) {
+        this._droppedCount++;
+        return false;
+      }
+      this.windowCount++;
+    }
+    return true;
+  }
+  reset() {
+    this.windowCount = 0;
+    this.windowStart = Date.now();
+    this._droppedCount = 0;
+  }
+};
+
+// src/utils/sql-parser.ts
+var OPERATION_RE = /^\s*(SELECT|INSERT|UPDATE|DELETE|CREATE|DROP|ALTER|TRUNCATE|WITH)\b/i;
+var TABLE_RE = /\b(?:FROM|JOIN|INTO|UPDATE|TABLE)\s+["'`]?(\w+)["'`]?/gi;
+var PARAM_RE = /\$\d+|\?|:\w+/g;
+var STRING_LITERAL_RE = /'[^']*'/g;
+var NUMBER_LITERAL_RE = /\b\d+\.?\d*\b/g;
+function parseOperation(query) {
+  const match = query.match(OPERATION_RE);
+  if (!match) return "OTHER";
+  const op = match[1].toUpperCase();
+  if (op === "SELECT" || op === "WITH") return "SELECT";
+  if (op === "INSERT") return "INSERT";
+  if (op === "UPDATE") return "UPDATE";
+  if (op === "DELETE") return "DELETE";
+  return "OTHER";
+}
+function parseTablesAccessed(query) {
+  const tables = /* @__PURE__ */ new Set();
+  let match;
+  const re = new RegExp(TABLE_RE.source, TABLE_RE.flags);
+  while ((match = re.exec(query)) !== null) {
+    const table = match[1].toLowerCase();
+    if (!["select", "where", "and", "or", "not", "null", "set", "values"].includes(table)) {
+      tables.add(table);
+    }
+  }
+  return [...tables];
+}
+function normalizeQuery(query) {
+  return query.replace(STRING_LITERAL_RE, "?").replace(NUMBER_LITERAL_RE, "?").replace(PARAM_RE, "?").replace(/\s+/g, " ").trim();
+}
+function redactParams(params) {
+  return JSON.stringify(
+    params.map((p) => {
+      if (p === null) return "NULL";
+      if (typeof p === "string") return "<string>";
+      if (typeof p === "number") return "<number>";
+      if (typeof p === "boolean") return "<boolean>";
+      if (p instanceof Date) return "<date>";
+      if (Buffer.isBuffer(p)) return "<buffer>";
+      return "<object>";
+    })
+  );
+}
+
+// src/utils/log.ts
+var _log = {
+  log: console.log.bind(console),
+  warn: console.warn.bind(console),
+  error: console.error.bind(console),
+  debug: console.debug.bind(console)
+};
+
+// src/integrations/prisma.ts
+function instrumentPrisma(client, options) {
+  const prisma = client;
+  const source = "prisma";
+  if (typeof prisma.$extends === "function") {
+    try {
+      const extended = prisma.$extends({
+        query: {
+          $allOperations({ operation, model, args, query }) {
+            const start = performance.now();
+            return query(args).then((result) => {
+              const duration = performance.now() - start;
+              const queryStr = `prisma.${model}.${operation}(${JSON.stringify(args).slice(0, 200)})`;
+              options.onEvent({
+                eventId: generateId(),
+                sessionId: options.sessionId,
+                timestamp: Date.now(),
+                eventType: "database",
+                query: queryStr,
+                normalizedQuery: `prisma.${model}.${operation}(?)`,
+                duration,
+                tablesAccessed: model ? [model.toLowerCase()] : [],
+                operation: mapPrismaOperation(operation),
+                source,
+                stackTrace: options.captureStackTraces ? captureStack() : void 0,
+                rowsReturned: Array.isArray(result) ? result.length : void 0
+              });
+              return result;
+            }).catch((err) => {
+              const duration = performance.now() - start;
+              const queryStr = `prisma.${model}.${operation}(${JSON.stringify(args).slice(0, 200)})`;
+              options.onEvent({
+                eventId: generateId(),
+                sessionId: options.sessionId,
+                timestamp: Date.now(),
+                eventType: "database",
+                query: queryStr,
+                normalizedQuery: `prisma.${model}.${operation}(?)`,
+                duration,
+                tablesAccessed: model ? [model.toLowerCase()] : [],
+                operation: mapPrismaOperation(operation),
+                source,
+                error: err.message,
+                stackTrace: options.captureStackTraces ? captureStack() : void 0
+              });
+              throw err;
+            });
+          }
+        }
+      });
+      Object.assign(prisma, extended);
+      return () => {
+      };
+    } catch {
+    }
+  }
+  if (typeof prisma.$on === "function") {
+    prisma.$on("query", (e) => {
+      options.onEvent({
+        eventId: generateId(),
+        sessionId: options.sessionId,
+        timestamp: Date.now(),
+        eventType: "database",
+        query: e.query,
+        normalizedQuery: normalizeQuery(e.query),
+        duration: e.duration,
+        tablesAccessed: parseTablesAccessed(e.query),
+        operation: parseOperation(e.query),
+        source,
+        params: options.redact !== false ? redactParams(JSON.parse(e.params || "[]")) : e.params,
+        stackTrace: options.captureStackTraces ? captureStack() : void 0
+      });
+    });
+    return () => {
+    };
+  }
+  _log.warn("[RuntimeScope] Prisma client does not support $on or $extends");
+  return () => {
+  };
+}
+function mapPrismaOperation(op) {
+  const lower = op.toLowerCase();
+  if (lower.includes("find") || lower === "aggregate" || lower === "count" || lower === "groupby") return "SELECT";
+  if (lower.includes("create") || lower === "createMany") return "INSERT";
+  if (lower.includes("update") || lower === "upsert") return "UPDATE";
+  if (lower.includes("delete")) return "DELETE";
+  return "OTHER";
+}
+
+// src/integrations/pg.ts
+function instrumentPg(pool, options) {
+  const client = pool;
+  const originalQuery = client.query;
+  if (typeof originalQuery !== "function") {
+    _log.warn("[RuntimeScope] pg client does not have a query method");
+    return () => {
+    };
+  }
+  client.query = function(...args) {
+    const start = performance.now();
+    let queryText = "";
+    let params;
+    if (typeof args[0] === "string") {
+      queryText = args[0];
+      if (Array.isArray(args[1])) params = args[1];
+    } else if (typeof args[0] === "object" && args[0] !== null) {
+      const config = args[0];
+      queryText = config.text ?? "";
+      params = config.values;
+    }
+    const result = originalQuery.apply(this, args);
+    if (result && typeof result.then === "function") {
+      return result.then((res) => {
+        const duration = performance.now() - start;
+        const pgResult = res;
+        options.onEvent({
+          eventId: generateId(),
+          sessionId: options.sessionId,
+          timestamp: Date.now(),
+          eventType: "database",
+          query: queryText,
+          normalizedQuery: normalizeQuery(queryText),
+          duration,
+          rowsReturned: pgResult.rows?.length,
+          rowsAffected: pgResult.rowCount ?? void 0,
+          tablesAccessed: parseTablesAccessed(queryText),
+          operation: parseOperation(queryText),
+          source: "pg",
+          params: params && options.redact !== false ? redactParams(params) : void 0,
+          stackTrace: options.captureStackTraces ? captureStack() : void 0
+        });
+        return res;
+      }).catch((err) => {
+        const duration = performance.now() - start;
+        options.onEvent({
+          eventId: generateId(),
+          sessionId: options.sessionId,
+          timestamp: Date.now(),
+          eventType: "database",
+          query: queryText,
+          normalizedQuery: normalizeQuery(queryText),
+          duration,
+          tablesAccessed: parseTablesAccessed(queryText),
+          operation: parseOperation(queryText),
+          source: "pg",
+          error: err.message,
+          params: params && options.redact !== false ? redactParams(params) : void 0,
+          stackTrace: options.captureStackTraces ? captureStack() : void 0
+        });
+        throw err;
+      });
+    }
+    return result;
+  };
+  return () => {
+    client.query = originalQuery;
+  };
+}
+
+// src/integrations/knex.ts
+function instrumentKnex(knex, options) {
+  const instance = knex;
+  const pendingQueries = /* @__PURE__ */ new Map();
+  const onQuery = (data) => {
+    pendingQueries.set(data.__knexQueryUid, {
+      query: data.sql,
+      params: data.bindings ?? [],
+      start: performance.now()
+    });
+  };
+  const onQueryResponse = (_response, data, _builder) => {
+    const pending = pendingQueries.get(data.__knexQueryUid);
+    pendingQueries.delete(data.__knexQueryUid);
+    const duration = pending ? performance.now() - pending.start : 0;
+    const queryText = pending?.query ?? data.sql;
+    const params = pending?.params ?? data.bindings;
+    const rows = Array.isArray(_response) ? _response.length : void 0;
+    options.onEvent({
+      eventId: generateId(),
+      sessionId: options.sessionId,
+      timestamp: Date.now(),
+      eventType: "database",
+      query: queryText,
+      normalizedQuery: normalizeQuery(queryText),
+      duration,
+      rowsReturned: rows,
+      tablesAccessed: parseTablesAccessed(queryText),
+      operation: parseOperation(queryText),
+      source: "knex",
+      params: params.length > 0 && options.redact !== false ? redactParams(params) : void 0,
+      stackTrace: options.captureStackTraces ? captureStack() : void 0
+    });
+  };
+  const onQueryError = (error, data) => {
+    const pending = pendingQueries.get(data.__knexQueryUid);
+    pendingQueries.delete(data.__knexQueryUid);
+    const duration = pending ? performance.now() - pending.start : 0;
+    const queryText = pending?.query ?? data.sql;
+    const params = pending?.params ?? data.bindings;
+    options.onEvent({
+      eventId: generateId(),
+      sessionId: options.sessionId,
+      timestamp: Date.now(),
+      eventType: "database",
+      query: queryText,
+      normalizedQuery: normalizeQuery(queryText),
+      duration,
+      tablesAccessed: parseTablesAccessed(queryText),
+      operation: parseOperation(queryText),
+      source: "knex",
+      error: error.message,
+      params: params.length > 0 && options.redact !== false ? redactParams(params) : void 0,
+      stackTrace: options.captureStackTraces ? captureStack() : void 0
+    });
+  };
+  instance.on("query", onQuery);
+  instance.on("query-response", onQueryResponse);
+  instance.on("query-error", onQueryError);
+  return () => {
+    instance.removeListener("query", onQuery);
+    instance.removeListener("query-response", onQueryResponse);
+    instance.removeListener("query-error", onQueryError);
+    pendingQueries.clear();
+  };
+}
+
+// src/integrations/drizzle.ts
+function instrumentDrizzle(db, options) {
+  const drizzleDb = db;
+  const internals = drizzleDb._;
+  if (!internals) {
+    _log.warn("[RuntimeScope] Drizzle db does not have internals (_). Cannot instrument.");
+    return () => {
+    };
+  }
+  const session = internals.session;
+  if (!session) {
+    _log.warn("[RuntimeScope] Drizzle db does not have a session. Cannot instrument.");
+    return () => {
+    };
+  }
+  const originalExecute = session.execute;
+  if (typeof originalExecute === "function") {
+    session.execute = function(queryOrSql) {
+      const start = performance.now();
+      let queryText = "";
+      let params;
+      if (queryOrSql && typeof queryOrSql === "object") {
+        const q = queryOrSql;
+        queryText = q.sql ?? q.query ?? String(queryOrSql);
+        params = q.params;
+      } else if (typeof queryOrSql === "string") {
+        queryText = queryOrSql;
+      }
+      const stack = options.captureStackTraces ? captureStack() : void 0;
+      const result = originalExecute.apply(this, arguments);
+      if (result && typeof result.then === "function") {
+        return result.then((res) => {
+          const duration = performance.now() - start;
+          const rows = Array.isArray(res) ? res.length : void 0;
+          options.onEvent({
+            eventId: generateId(),
+            sessionId: options.sessionId,
+            timestamp: Date.now(),
+            eventType: "database",
+            query: queryText,
+            normalizedQuery: normalizeQuery(queryText),
+            duration,
+            rowsReturned: rows,
+            tablesAccessed: parseTablesAccessed(queryText),
+            operation: parseOperation(queryText),
+            source: "drizzle",
+            params: params && options.redact !== false ? redactParams(params) : void 0,
+            stackTrace: stack
+          });
+          return res;
+        }).catch((err) => {
+          const duration = performance.now() - start;
+          options.onEvent({
+            eventId: generateId(),
+            sessionId: options.sessionId,
+            timestamp: Date.now(),
+            eventType: "database",
+            query: queryText,
+            normalizedQuery: normalizeQuery(queryText),
+            duration,
+            tablesAccessed: parseTablesAccessed(queryText),
+            operation: parseOperation(queryText),
+            source: "drizzle",
+            error: err.message,
+            params: params && options.redact !== false ? redactParams(params) : void 0,
+            stackTrace: stack
+          });
+          throw err;
+        });
+      }
+      return result;
+    };
+    return () => {
+      session.execute = originalExecute;
+    };
+  }
+  const client = session.client;
+  const originalQuery = client?.query;
+  if (client && typeof originalQuery === "function") {
+    client.query = function(...args) {
+      const start = performance.now();
+      const queryText = typeof args[0] === "string" ? args[0] : "";
+      const params = Array.isArray(args[1]) ? args[1] : void 0;
+      const stack = options.captureStackTraces ? captureStack() : void 0;
+      const result = originalQuery.apply(this, args);
+      if (result && typeof result.then === "function") {
+        return result.then((res) => {
+          const duration = performance.now() - start;
+          options.onEvent({
+            eventId: generateId(),
+            sessionId: options.sessionId,
+            timestamp: Date.now(),
+            eventType: "database",
+            query: queryText,
+            normalizedQuery: normalizeQuery(queryText),
+            duration,
+            rowsReturned: Array.isArray(res) ? res.length : void 0,
+            tablesAccessed: parseTablesAccessed(queryText),
+            operation: parseOperation(queryText),
+            source: "drizzle",
+            params: params && options.redact !== false ? redactParams(params) : void 0,
+            stackTrace: stack
+          });
+          return res;
+        }).catch((err) => {
+          const duration = performance.now() - start;
+          options.onEvent({
+            eventId: generateId(),
+            sessionId: options.sessionId,
+            timestamp: Date.now(),
+            eventType: "database",
+            query: queryText,
+            normalizedQuery: normalizeQuery(queryText),
+            duration,
+            tablesAccessed: parseTablesAccessed(queryText),
+            operation: parseOperation(queryText),
+            source: "drizzle",
+            error: err.message,
+            params: params && options.redact !== false ? redactParams(params) : void 0,
+            stackTrace: stack
+          });
+          throw err;
+        });
+      }
+      return result;
+    };
+    return () => {
+      client.query = originalQuery;
+    };
+  }
+  _log.warn("[RuntimeScope] Drizzle db has no instrumentable execute or query method.");
+  return () => {
+  };
+}
+
+// src/integrations/mysql2.ts
+function instrumentMysql2(pool, options) {
+  const client = pool;
+  const originalQuery = client.query;
+  const originalExecute = client.execute;
+  if (typeof originalQuery !== "function") {
+    _log.warn("[RuntimeScope] mysql2 client does not have a query method");
+    return () => {
+    };
+  }
+  function wrapMethod(original, methodName) {
+    return function(...args) {
+      const start = performance.now();
+      let queryText = "";
+      let params;
+      if (typeof args[0] === "string") {
+        queryText = args[0];
+        if (Array.isArray(args[1])) params = args[1];
+      } else if (typeof args[0] === "object" && args[0] !== null) {
+        const config = args[0];
+        queryText = config.sql ?? "";
+        params = config.values;
+        if (!params && Array.isArray(args[1])) params = args[1];
+      }
+      const lastArg = args[args.length - 1];
+      const hasCallback = typeof lastArg === "function";
+      if (hasCallback) {
+        const cb = lastArg;
+        args[args.length - 1] = function(err, results, fields) {
+          const duration = performance.now() - start;
+          const rows = Array.isArray(results) ? results.length : void 0;
+          const affectedRows = results && typeof results === "object" ? results.affectedRows : void 0;
+          options.onEvent({
+            eventId: generateId(),
+            sessionId: options.sessionId,
+            timestamp: Date.now(),
+            eventType: "database",
+            query: queryText,
+            normalizedQuery: normalizeQuery(queryText),
+            duration,
+            rowsReturned: rows,
+            rowsAffected: affectedRows,
+            tablesAccessed: parseTablesAccessed(queryText),
+            operation: parseOperation(queryText),
+            source: "mysql2",
+            error: err?.message,
+            params: params && options.redact !== false ? redactParams(params) : void 0,
+            stackTrace: options.captureStackTraces ? captureStack() : void 0
+          });
+          cb(err, results, fields);
+        };
+        return original.apply(this, args);
+      }
+      const result = original.apply(this, args);
+      if (result && typeof result.then === "function") {
+        return result.then((res) => {
+          const duration = performance.now() - start;
+          const resultArr = Array.isArray(res) ? res : [res];
+          const rows = Array.isArray(resultArr[0]) ? resultArr[0].length : void 0;
+          const affectedRows = resultArr[0] && typeof resultArr[0] === "object" ? resultArr[0].affectedRows : void 0;
+          options.onEvent({
+            eventId: generateId(),
+            sessionId: options.sessionId,
+            timestamp: Date.now(),
+            eventType: "database",
+            query: queryText,
+            normalizedQuery: normalizeQuery(queryText),
+            duration,
+            rowsReturned: rows,
+            rowsAffected: affectedRows,
+            tablesAccessed: parseTablesAccessed(queryText),
+            operation: parseOperation(queryText),
+            source: "mysql2",
+            params: params && options.redact !== false ? redactParams(params) : void 0,
+            stackTrace: options.captureStackTraces ? captureStack() : void 0
+          });
+          return res;
+        }).catch((err) => {
+          const duration = performance.now() - start;
+          options.onEvent({
+            eventId: generateId(),
+            sessionId: options.sessionId,
+            timestamp: Date.now(),
+            eventType: "database",
+            query: queryText,
+            normalizedQuery: normalizeQuery(queryText),
+            duration,
+            tablesAccessed: parseTablesAccessed(queryText),
+            operation: parseOperation(queryText),
+            source: "mysql2",
+            error: err.message,
+            params: params && options.redact !== false ? redactParams(params) : void 0,
+            stackTrace: options.captureStackTraces ? captureStack() : void 0
+          });
+          throw err;
+        });
+      }
+      return result;
+    };
+  }
+  client.query = wrapMethod(originalQuery, "query");
+  if (typeof originalExecute === "function") {
+    client.execute = wrapMethod(originalExecute, "execute");
+  }
+  return () => {
+    client.query = originalQuery;
+    if (originalExecute) client.execute = originalExecute;
+  };
+}
+
+// src/integrations/better-sqlite3.ts
+function instrumentBetterSqlite3(db, options) {
+  const database = db;
+  const originalPrepare = database.prepare;
+  const originalExec = database.exec;
+  if (typeof originalPrepare !== "function") {
+    _log.warn("[RuntimeScope] better-sqlite3 db does not have a prepare method");
+    return () => {
+    };
+  }
+  function emitQuery(queryText, start, result, error, params) {
+    const duration = performance.now() - start;
+    const rows = Array.isArray(result) ? result.length : void 0;
+    const changes = result && typeof result === "object" ? result.changes : void 0;
+    options.onEvent({
+      eventId: generateId(),
+      sessionId: options.sessionId,
+      timestamp: Date.now(),
+      eventType: "database",
+      query: queryText,
+      normalizedQuery: normalizeQuery(queryText),
+      duration,
+      rowsReturned: rows,
+      rowsAffected: changes,
+      tablesAccessed: parseTablesAccessed(queryText),
+      operation: parseOperation(queryText),
+      source: "better-sqlite3",
+      error,
+      params: params && options.redact !== false ? redactParams(params) : void 0,
+      stackTrace: options.captureStackTraces ? captureStack() : void 0
+    });
+  }
+  database.prepare = function(sql) {
+    const stmt = originalPrepare.call(this, sql);
+    const stmtObj = stmt;
+    const methods = ["run", "get", "all"];
+    for (const method of methods) {
+      const original = stmtObj[method];
+      if (typeof original !== "function") continue;
+      stmtObj[method] = function(...args) {
+        const start = performance.now();
+        try {
+          const result = original.apply(this, args);
+          emitQuery(sql, start, result, void 0, args);
+          return result;
+        } catch (err) {
+          emitQuery(sql, start, void 0, err.message, args);
+          throw err;
+        }
+      };
+    }
+    const originalIterate = stmtObj.iterate;
+    if (typeof originalIterate === "function") {
+      stmtObj.iterate = function(...args) {
+        const start = performance.now();
+        const iter = originalIterate.apply(this, args);
+        let rowCount = 0;
+        const originalNext = iter.next.bind(iter);
+        let emitted = false;
+        iter.next = function() {
+          const result = originalNext();
+          if (!result.done) rowCount++;
+          if (result.done && !emitted) {
+            emitted = true;
+            emitQuery(sql, start, { length: rowCount }, void 0, args);
+          }
+          return result;
+        };
+        return iter;
+      };
+    }
+    return stmt;
+  };
+  if (typeof originalExec === "function") {
+    database.exec = function(sql) {
+      const start = performance.now();
+      try {
+        const result = originalExec.call(this, sql);
+        emitQuery(sql, start);
+        return result;
+      } catch (err) {
+        emitQuery(sql, start, void 0, err.message);
+        throw err;
+      }
+    };
+  }
+  return () => {
+    database.prepare = originalPrepare;
+    if (originalExec) database.exec = originalExec;
+  };
+}
+
+// src/utils/serialize.ts
+function safeSerialize(value, maxDepth = 5) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  function walk(val, depth) {
+    if (depth > maxDepth) return "[max depth]";
+    if (val === null || val === void 0) return val;
+    if (typeof val === "function") return `[Function: ${val.name || "anonymous"}]`;
+    if (typeof val === "symbol") return val.toString();
+    if (typeof val === "bigint") return val.toString();
+    if (typeof val !== "object") return val;
+    if (val instanceof Error) {
+      return { name: val.name, message: val.message, stack: val.stack };
+    }
+    if (val instanceof Date) {
+      return val.toISOString();
+    }
+    if (val instanceof RegExp) {
+      return val.toString();
+    }
+    if (seen.has(val)) return "[Circular]";
+    seen.add(val);
+    if (Array.isArray(val)) {
+      return val.map((v) => walk(v, depth + 1));
+    }
+    const result = {};
+    for (const key of Object.keys(val)) {
+      result[key] = walk(val[key], depth + 1);
+    }
+    return result;
+  }
+  return walk(value, 0);
+}
+
+// src/context.ts
+var import_node_async_hooks = require("async_hooks");
+var storage = new import_node_async_hooks.AsyncLocalStorage();
+function runWithContext(ctx, fn) {
+  return storage.run(ctx, fn);
+}
+function getRequestContext() {
+  return storage.getStore();
+}
+function getSessionId(fallback) {
+  return storage.getStore()?.sessionId ?? fallback;
+}
+
+// src/interceptors/console.ts
+var LEVELS = ["log", "warn", "error", "info", "debug", "trace"];
+function interceptConsole(emit, sessionId, options) {
+  const levels = options?.levels ?? LEVELS;
+  const captureStack2 = options?.captureStackTraces ?? true;
+  const originals = {};
+  for (const level of levels) {
+    originals[level] = console[level].bind(console);
+    console[level] = (...args) => {
+      const message = args.map((a) => typeof a === "string" ? a : stringifyArg(a)).join(" ");
+      const event = {
+        eventId: generateId(),
+        sessionId: getSessionId(sessionId),
+        timestamp: Date.now(),
+        eventType: "console",
+        level,
+        message,
+        args: args.map((a) => safeSerialize(a, 3)),
+        stackTrace: captureStack2 && (level === "error" || level === "trace") ? new Error().stack?.split("\n").slice(2).join("\n") : void 0,
+        sourceFile: void 0
+      };
+      if (options?.beforeSend) {
+        const filtered = options.beforeSend(event);
+        if (filtered) emit(filtered);
+      } else {
+        emit(event);
+      }
+      originals[level](...args);
+    };
+  }
+  return () => {
+    for (const level of levels) {
+      console[level] = originals[level];
+    }
+  };
+}
+function stringifyArg(arg) {
+  try {
+    return JSON.stringify(arg);
+  } catch {
+    return String(arg);
+  }
+}
+
+// src/interceptors/errors.ts
+function interceptErrors(emit, sessionId, options) {
+  const onUncaughtException = (error) => {
+    const event = {
+      eventId: generateId(),
+      sessionId: getSessionId(sessionId),
+      timestamp: Date.now(),
+      eventType: "console",
+      level: "error",
+      message: `[Uncaught] ${error.message}`,
+      args: [safeSerialize(error, 3)],
+      stackTrace: error.stack,
+      sourceFile: extractSourceFile(error.stack)
+    };
+    if (options?.beforeSend) {
+      const filtered = options.beforeSend(event);
+      if (filtered) emit(filtered);
+    } else {
+      emit(event);
+    }
+    process.exitCode = 1;
+  };
+  const onUnhandledRejection = (reason) => {
+    let message;
+    let stackTrace;
+    if (reason instanceof Error) {
+      message = reason.message;
+      stackTrace = reason.stack;
+    } else if (typeof reason === "string") {
+      message = reason;
+    } else {
+      try {
+        message = JSON.stringify(reason);
+      } catch {
+        message = String(reason);
+      }
+    }
+    const event = {
+      eventId: generateId(),
+      sessionId: getSessionId(sessionId),
+      timestamp: Date.now(),
+      eventType: "console",
+      level: "error",
+      message: `[Unhandled Rejection] ${message}`,
+      args: [safeSerialize(reason, 3)],
+      stackTrace,
+      sourceFile: void 0
+    };
+    if (options?.beforeSend) {
+      const filtered = options.beforeSend(event);
+      if (filtered) emit(filtered);
+    } else {
+      emit(event);
+    }
+  };
+  process.on("uncaughtException", onUncaughtException);
+  process.on("unhandledRejection", onUnhandledRejection);
+  return () => {
+    process.removeListener("uncaughtException", onUncaughtException);
+    process.removeListener("unhandledRejection", onUnhandledRejection);
+  };
+}
+function extractSourceFile(stack) {
+  if (!stack) return void 0;
+  const lines = stack.split("\n");
+  for (const line of lines.slice(1)) {
+    const match = line.match(/at\s+.*?\((.+?):(\d+):(\d+)\)/);
+    if (match && !match[1].includes("node_modules") && !match[1].includes("node:")) {
+      return `${match[1]}:${match[2]}:${match[3]}`;
+    }
+  }
+  return void 0;
+}
+
+// src/interceptors/http.ts
+var import_node_http = __toESM(require("http"), 1);
+var import_node_https = __toESM(require("https"), 1);
+var DEFAULT_REDACT_HEADERS = ["authorization", "cookie", "set-cookie", "x-api-key"];
+function interceptHttp(emit, sessionId, options) {
+  const maxBodySize = options?.maxBodySize ?? 65536;
+  const redactSet = new Set(
+    (options?.redactHeaders ?? DEFAULT_REDACT_HEADERS).map((h) => h.toLowerCase())
+  );
+  const ignorePatterns = options?.ignoreUrls ?? [];
+  const originalHttpRequest = import_node_http.default.request;
+  const originalHttpsRequest = import_node_https.default.request;
+  function shouldIgnore(url) {
+    for (const pattern of ignorePatterns) {
+      if (typeof pattern === "string") {
+        if (url.includes(pattern)) return true;
+      } else if (pattern.test(url)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  function redactHeaders(headers) {
+    const result = {};
+    for (const [key, val] of Object.entries(headers)) {
+      if (val === void 0) continue;
+      const lk = key.toLowerCase();
+      result[lk] = redactSet.has(lk) ? "[REDACTED]" : String(val);
+    }
+    return result;
+  }
+  function buildUrl(input, protocol) {
+    if (typeof input === "string") return input;
+    if (input instanceof URL) return input.toString();
+    const host = input.hostname ?? input.host ?? "localhost";
+    const port = input.port ? `:${input.port}` : "";
+    const path = input.path ?? "/";
+    return `${protocol}://${host}${port}${path}`;
+  }
+  function wrapRequest(original, protocol) {
+    return function wrappedRequest(...args) {
+      const url = buildUrl(args[0], protocol);
+      if (shouldIgnore(url)) {
+        return original.apply(this, args);
+      }
+      const startTime = performance.now();
+      let method = "GET";
+      if (typeof args[0] !== "string" && !(args[0] instanceof URL)) {
+        method = args[0].method?.toUpperCase() ?? "GET";
+      } else if (args[1] && typeof args[1] === "object" && !("on" in args[1])) {
+        method = args[1].method?.toUpperCase() ?? "GET";
+      }
+      let reqHeaders = {};
+      if (typeof args[0] !== "string" && !(args[0] instanceof URL)) {
+        reqHeaders = args[0].headers ?? {};
+      } else if (args[1] && typeof args[1] === "object" && !("on" in args[1])) {
+        reqHeaders = args[1].headers ?? {};
+      }
+      const req = original.apply(this, args);
+      let requestBodySize = 0;
+      let requestBody;
+      const requestChunks = [];
+      const origWrite = req.write;
+      req.write = function(chunk, ...rest) {
+        if (chunk) {
+          const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk));
+          requestBodySize += buf.length;
+          if (options?.captureBody) requestChunks.push(buf);
+        }
+        return origWrite.apply(req, [chunk, ...rest]);
+      };
+      const origEnd = req.end;
+      req.end = function(chunk, ...rest) {
+        if (chunk && typeof chunk !== "function") {
+          const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk));
+          requestBodySize += buf.length;
+          if (options?.captureBody) requestChunks.push(buf);
+        }
+        return origEnd.apply(req, [chunk, ...rest]);
+      };
+      req.on("response", (res) => {
+        const responseChunks = [];
+        let responseBodySize = 0;
+        if (options?.captureBody) {
+          const origPush = res.push;
+          res.push = function(chunk, ...rest) {
+            if (chunk) {
+              responseBodySize += chunk.length;
+              if (responseBodySize <= maxBodySize) responseChunks.push(chunk);
+            }
+            return origPush.apply(res, [chunk, ...rest]);
+          };
+        }
+        res.on("end", () => {
+          const duration = performance.now() - startTime;
+          if (options?.captureBody) {
+            requestBody = joinChunks(requestChunks, maxBodySize);
+          }
+          const contentLength = parseInt(
+            res.headers["content-length"] ?? "0",
+            10
+          );
+          const event = {
+            eventId: generateId(),
+            sessionId: getSessionId(sessionId),
+            timestamp: Date.now(),
+            eventType: "network",
+            url,
+            method,
+            status: res.statusCode ?? 0,
+            requestHeaders: redactHeaders(reqHeaders),
+            responseHeaders: redactHeaders(
+              res.headers
+            ),
+            requestBodySize,
+            responseBodySize: contentLength || responseBodySize,
+            duration: Math.round(duration * 100) / 100,
+            ttfb: Math.round(duration * 100) / 100,
+            requestBody,
+            responseBody: options?.captureBody ? joinChunks(responseChunks, maxBodySize) : void 0,
+            source: protocol === "https" ? "node-https" : "node-http"
+          };
+          if (options?.beforeSend) {
+            const filtered = options.beforeSend(event);
+            if (filtered) emit(filtered);
+          } else {
+            emit(event);
+          }
+        });
+      });
+      req.on("error", (err) => {
+        const duration = performance.now() - startTime;
+        const event = {
+          eventId: generateId(),
+          sessionId: getSessionId(sessionId),
+          timestamp: Date.now(),
+          eventType: "network",
+          url,
+          method,
+          status: 0,
+          requestHeaders: redactHeaders(reqHeaders),
+          responseHeaders: {},
+          requestBodySize,
+          responseBodySize: 0,
+          duration: Math.round(duration * 100) / 100,
+          ttfb: 0,
+          errorPhase: "error",
+          errorMessage: err.message,
+          source: protocol === "https" ? "node-https" : "node-http"
+        };
+        if (options?.beforeSend) {
+          const filtered = options.beforeSend(event);
+          if (filtered) emit(filtered);
+        } else {
+          emit(event);
+        }
+      });
+      return req;
+    };
+  }
+  import_node_http.default.request = wrapRequest(originalHttpRequest, "http");
+  import_node_https.default.request = wrapRequest(originalHttpsRequest, "https");
+  return () => {
+    import_node_http.default.request = originalHttpRequest;
+    import_node_https.default.request = originalHttpsRequest;
+  };
+}
+function joinChunks(chunks, maxSize) {
+  if (chunks.length === 0) return void 0;
+  const combined = Buffer.concat(chunks);
+  if (combined.length === 0) return void 0;
+  return combined.toString("utf8", 0, Math.min(combined.length, maxSize));
+}
+
+// src/interceptors/perf-metrics.ts
+var import_node_perf_hooks = require("perf_hooks");
+var import_node_perf_hooks2 = require("perf_hooks");
+var ALL_METRICS = [
+  "memory.rss",
+  "memory.heapUsed",
+  "memory.heapTotal",
+  "memory.external",
+  "eventloop.lag.mean",
+  "eventloop.lag.p99",
+  "eventloop.lag.max",
+  "gc.pause.major",
+  "gc.pause.minor",
+  "cpu.user",
+  "cpu.system",
+  "handles.active",
+  "requests.active"
+];
+function shouldCollect(metric, enabled) {
+  return enabled.includes(metric);
+}
+function emitMetric(emit, sessionId, metricName, value, unit) {
+  emit({
+    eventId: generateId(),
+    sessionId: getSessionId(sessionId),
+    timestamp: Date.now(),
+    eventType: "performance",
+    metricName,
+    value: Math.round(value * 100) / 100,
+    unit
+  });
+}
+function startPerfMetrics(emit, sessionId, options) {
+  const intervalMs = options?.intervalMs ?? 5e3;
+  const enabled = options?.metrics ?? ALL_METRICS;
+  let lastCpuUsage = process.cpuUsage();
+  let lastCpuTime = Date.now();
+  let histogram = null;
+  const needsEventLoop = enabled.some((m) => m.startsWith("eventloop."));
+  if (needsEventLoop) {
+    histogram = (0, import_node_perf_hooks.monitorEventLoopDelay)({ resolution: 20 });
+    histogram.enable();
+  }
+  let gcObserver = null;
+  let lastMajorGcMs = 0;
+  let lastMinorGcMs = 0;
+  const needsGc = enabled.some((m) => m.startsWith("gc."));
+  if (needsGc) {
+    gcObserver = new import_node_perf_hooks2.PerformanceObserver((list) => {
+      for (const entry of list.getEntries()) {
+        const gcEntry = entry;
+        const durationMs = entry.duration;
+        const kind = gcEntry.detail?.kind ?? 0;
+        if (kind === 2) {
+          lastMajorGcMs += durationMs;
+        } else if (kind === 1 || kind === 4 || kind === 8) {
+          lastMinorGcMs += durationMs;
+        }
+      }
+    });
+    gcObserver.observe({ entryTypes: ["gc"] });
+  }
+  const timer = setInterval(() => {
+    if (enabled.some((m) => m.startsWith("memory."))) {
+      const mem = process.memoryUsage();
+      if (shouldCollect("memory.rss", enabled)) emitMetric(emit, sessionId, "memory.rss", mem.rss, "bytes");
+      if (shouldCollect("memory.heapUsed", enabled)) emitMetric(emit, sessionId, "memory.heapUsed", mem.heapUsed, "bytes");
+      if (shouldCollect("memory.heapTotal", enabled)) emitMetric(emit, sessionId, "memory.heapTotal", mem.heapTotal, "bytes");
+      if (shouldCollect("memory.external", enabled)) emitMetric(emit, sessionId, "memory.external", mem.external, "bytes");
+    }
+    if (histogram) {
+      if (shouldCollect("eventloop.lag.mean", enabled)) emitMetric(emit, sessionId, "eventloop.lag.mean", histogram.mean / 1e6, "ms");
+      if (shouldCollect("eventloop.lag.p99", enabled)) emitMetric(emit, sessionId, "eventloop.lag.p99", histogram.percentile(99) / 1e6, "ms");
+      if (shouldCollect("eventloop.lag.max", enabled)) emitMetric(emit, sessionId, "eventloop.lag.max", histogram.max / 1e6, "ms");
+      histogram.reset();
+    }
+    if (needsGc) {
+      if (shouldCollect("gc.pause.major", enabled)) emitMetric(emit, sessionId, "gc.pause.major", lastMajorGcMs, "ms");
+      if (shouldCollect("gc.pause.minor", enabled)) emitMetric(emit, sessionId, "gc.pause.minor", lastMinorGcMs, "ms");
+      lastMajorGcMs = 0;
+      lastMinorGcMs = 0;
+    }
+    if (enabled.some((m) => m.startsWith("cpu."))) {
+      const now = Date.now();
+      const elapsed = (now - lastCpuTime) * 1e3;
+      const cpu = process.cpuUsage(lastCpuUsage);
+      lastCpuUsage = process.cpuUsage();
+      lastCpuTime = now;
+      if (elapsed > 0) {
+        if (shouldCollect("cpu.user", enabled)) emitMetric(emit, sessionId, "cpu.user", cpu.user / elapsed * 100, "percent");
+        if (shouldCollect("cpu.system", enabled)) emitMetric(emit, sessionId, "cpu.system", cpu.system / elapsed * 100, "percent");
+      }
+    }
+    if (shouldCollect("handles.active", enabled)) {
+      const handles = process._getActiveHandles?.()?.length ?? 0;
+      emitMetric(emit, sessionId, "handles.active", handles, "count");
+    }
+    if (shouldCollect("requests.active", enabled)) {
+      const requests = process._getActiveRequests?.()?.length ?? 0;
+      emitMetric(emit, sessionId, "requests.active", requests, "count");
+    }
+  }, intervalMs);
+  timer.unref();
+  return () => {
+    clearInterval(timer);
+    if (histogram) {
+      histogram.disable();
+    }
+    if (gcObserver) {
+      gcObserver.disconnect();
+    }
+  };
+}
+
+// src/interceptors/middleware.ts
+var DEFAULT_REDACT_HEADERS2 = ["authorization", "cookie", "set-cookie", "x-api-key"];
+function runtimeScopeMiddleware(emit, sessionId, options) {
+  const maxBodySize = options?.maxBodySize ?? 65536;
+  const redactSet = new Set(
+    (options?.redactHeaders ?? DEFAULT_REDACT_HEADERS2).map((h) => h.toLowerCase())
+  );
+  const ignorePatterns = options?.ignoreRoutes ?? [];
+  function shouldIgnore(path) {
+    for (const pattern of ignorePatterns) {
+      if (typeof pattern === "string") {
+        if (path === pattern || path.startsWith(pattern)) return true;
+      } else if (pattern.test(path)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  function redactHeaders(headers) {
+    const result = {};
+    for (const [key, val] of Object.entries(headers)) {
+      if (val === void 0) continue;
+      const lk = key.toLowerCase();
+      result[lk] = redactSet.has(lk) ? "[REDACTED]" : String(val);
+    }
+    return result;
+  }
+  return (req, res, next) => {
+    const path = req.originalUrl ?? req.url ?? "/";
+    if (shouldIgnore(path)) {
+      return next();
+    }
+    const startTime = performance.now();
+    const originalEnd = res.end.bind(res);
+    let responseBody;
+    res.end = function(chunk, ...rest) {
+      const duration = performance.now() - startTime;
+      if (options?.captureBody && chunk) {
+        if (Buffer.isBuffer(chunk)) {
+          responseBody = chunk.toString("utf8", 0, Math.min(chunk.length, maxBodySize));
+        } else if (typeof chunk === "string") {
+          responseBody = chunk.slice(0, maxBodySize);
+        }
+      }
+      const proto = req.protocol ?? (req.socket?.encrypted ? "https" : "http");
+      const host = req.get?.("host") ?? req.headers?.host ?? "localhost";
+      const url = `${proto}://${host}${path}`;
+      const event = {
+        eventId: generateId(),
+        sessionId,
+        timestamp: Date.now(),
+        eventType: "network",
+        url,
+        method: (req.method ?? "GET").toUpperCase(),
+        status: res.statusCode ?? 200,
+        requestHeaders: redactHeaders(req.headers ?? {}),
+        responseHeaders: redactHeaders(
+          typeof res.getHeaders === "function" ? res.getHeaders() : {}
+        ),
+        requestBodySize: parseInt(req.headers?.["content-length"] ?? "0", 10),
+        responseBodySize: parseInt(
+          (typeof res.getHeader === "function" ? res.getHeader("content-length") : void 0)?.toString() ?? "0",
+          10
+        ),
+        duration: Math.round(duration * 100) / 100,
+        ttfb: Math.round(duration * 100) / 100,
+        responseBody,
+        source: "node-http"
+      };
+      if (options?.beforeSend) {
+        const filtered = options.beforeSend(event);
+        if (filtered) emit(filtered);
+      } else {
+        emit(event);
+      }
+      return originalEnd(chunk, ...rest);
+    };
+    const requestId = generateId();
+    runWithContext({ sessionId, requestId }, () => next());
+  };
+}
+
+// src/index.ts
+var SDK_VERSION = "0.6.1";
+var RuntimeScopeServer = class {
+  transport = null;
+  sessionId = "";
+  config = {};
+  sampler = null;
+  restoreFunctions = [];
+  connect(config = {}) {
+    this.config = config;
+    this.sessionId = config.sessionId ?? generateSessionId();
+    const serverUrl = config.serverUrl ?? "ws://127.0.0.1:9090";
+    this.transport = new ServerTransport({
+      url: serverUrl,
+      sessionId: this.sessionId,
+      appName: config.appName ?? "server-app",
+      sdkVersion: SDK_VERSION,
+      authToken: config.authToken,
+      maxQueueSize: config.maxQueueSize
+    });
+    this.transport.connect();
+    if (config.sampleRate !== void 0 || config.maxEventsPerSecond !== void 0) {
+      this.sampler = new Sampler({
+        sampleRate: config.sampleRate,
+        maxEventsPerSecond: config.maxEventsPerSecond
+      });
+    }
+    const emit = (event) => this.emitEvent(event);
+    if (config.captureConsole !== false) {
+      try {
+        this.restoreFunctions.push(
+          interceptConsole(emit, this.sessionId, {
+            captureStackTraces: config.captureStackTraces,
+            beforeSend: config.beforeSend
+          })
+        );
+      } catch {
+      }
+    }
+    if (config.captureErrors !== false && config.captureConsole !== false) {
+      try {
+        this.restoreFunctions.push(
+          interceptErrors(emit, this.sessionId, {
+            beforeSend: config.beforeSend
+          })
+        );
+      } catch {
+      }
+    }
+    if (config.captureHttp) {
+      try {
+        this.restoreFunctions.push(
+          interceptHttp(emit, this.sessionId, {
+            captureBody: config.captureBody,
+            maxBodySize: config.maxBodySize,
+            redactHeaders: config.redactHeaders,
+            // Auto-ignore the collector URL to prevent recursion
+            ignoreUrls: [serverUrl.replace("ws://", "").replace("wss://", "")],
+            beforeSend: config.beforeSend
+          })
+        );
+      } catch {
+      }
+    }
+    if (config.capturePerformance) {
+      try {
+        this.restoreFunctions.push(
+          startPerfMetrics(emit, this.sessionId, {
+            intervalMs: config.performanceInterval,
+            metrics: config.performanceMetrics
+          })
+        );
+      } catch {
+      }
+    }
+  }
+  disconnect() {
+    for (const restore of this.restoreFunctions) {
+      try {
+        restore();
+      } catch {
+      }
+    }
+    this.restoreFunctions = [];
+    this.sampler = null;
+    this.transport?.disconnect();
+    this.transport = null;
+  }
+  get currentSessionId() {
+    return this.sessionId;
+  }
+  emitEvent(event) {
+    if (this.sampler && !this.sampler.shouldSample(event)) return;
+    if (this.config.beforeSend) {
+      const filtered = this.config.beforeSend(event);
+      if (!filtered) return;
+      this.transport?.sendEvent(filtered);
+    } else {
+      this.transport?.sendEvent(event);
+    }
+  }
+  // --- Express/Connect Middleware ---
+  middleware(options) {
+    return runtimeScopeMiddleware(
+      (event) => this.emitEvent(event),
+      this.sessionId,
+      {
+        ...options,
+        redactHeaders: options?.redactHeaders ?? this.config.redactHeaders,
+        beforeSend: options?.beforeSend ?? this.config.beforeSend
+      }
+    );
+  }
+  // --- ORM Instrumentation ---
+  instrumentPrisma(client) {
+    const restore = instrumentPrisma(client, {
+      sessionId: this.sessionId,
+      captureStackTraces: this.config.captureStackTraces,
+      redact: this.config.redactParams,
+      onEvent: (event) => this.emitEvent(event)
+    });
+    this.restoreFunctions.push(restore);
+    return client;
+  }
+  instrumentPg(pool) {
+    const restore = instrumentPg(pool, {
+      sessionId: this.sessionId,
+      captureStackTraces: this.config.captureStackTraces,
+      redact: this.config.redactParams,
+      onEvent: (event) => this.emitEvent(event)
+    });
+    this.restoreFunctions.push(restore);
+    return pool;
+  }
+  instrumentKnex(knex) {
+    const restore = instrumentKnex(knex, {
+      sessionId: this.sessionId,
+      captureStackTraces: this.config.captureStackTraces,
+      redact: this.config.redactParams,
+      onEvent: (event) => this.emitEvent(event)
+    });
+    this.restoreFunctions.push(restore);
+    return knex;
+  }
+  instrumentDrizzle(db) {
+    const restore = instrumentDrizzle(db, {
+      sessionId: this.sessionId,
+      captureStackTraces: this.config.captureStackTraces,
+      redact: this.config.redactParams,
+      onEvent: (event) => this.emitEvent(event)
+    });
+    this.restoreFunctions.push(restore);
+    return db;
+  }
+  instrumentMysql2(pool) {
+    const restore = instrumentMysql2(pool, {
+      sessionId: this.sessionId,
+      captureStackTraces: this.config.captureStackTraces,
+      redact: this.config.redactParams,
+      onEvent: (event) => this.emitEvent(event)
+    });
+    this.restoreFunctions.push(restore);
+    return pool;
+  }
+  instrumentBetterSqlite3(db) {
+    const restore = instrumentBetterSqlite3(db, {
+      sessionId: this.sessionId,
+      captureStackTraces: this.config.captureStackTraces,
+      redact: this.config.redactParams,
+      onEvent: (event) => this.emitEvent(event)
+    });
+    this.restoreFunctions.push(restore);
+    return db;
+  }
+  // --- Generic query capture ---
+  async captureQuery(fn, options) {
+    const start = performance.now();
+    try {
+      const result = await fn();
+      const duration = performance.now() - start;
+      this.emitEvent({
+        eventId: generateId(),
+        sessionId: this.sessionId,
+        timestamp: Date.now(),
+        eventType: "database",
+        query: options?.label ?? "custom query",
+        normalizedQuery: options?.label ?? "custom query",
+        duration,
+        tablesAccessed: [],
+        operation: "OTHER",
+        source: "generic",
+        label: options?.label,
+        stackTrace: this.config.captureStackTraces ? captureStack() : void 0,
+        rowsReturned: Array.isArray(result) ? result.length : void 0
+      });
+      return result;
+    } catch (err) {
+      const duration = performance.now() - start;
+      this.emitEvent({
+        eventId: generateId(),
+        sessionId: this.sessionId,
+        timestamp: Date.now(),
+        eventType: "database",
+        query: options?.label ?? "custom query",
+        normalizedQuery: options?.label ?? "custom query",
+        duration,
+        tablesAccessed: [],
+        operation: "OTHER",
+        source: "generic",
+        label: options?.label,
+        error: err.message,
+        stackTrace: this.config.captureStackTraces ? captureStack() : void 0
+      });
+      throw err;
+    }
+  }
+};
+var RuntimeScope = new RuntimeScopeServer();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RuntimeScope,
+  Sampler,
+  _log,
+  generateId,
+  generateSessionId,
+  getRequestContext,
+  getSessionId,
+  normalizeQuery,
+  parseOperation,
+  parseTablesAccessed,
+  redactParams,
+  runWithContext,
+  runtimeScopeMiddleware
+});
+//# sourceMappingURL=index.cjs.map