@rasputin-ai/node 0.2.0 → 0.3.0

package/dist/index.js

@@ -1,3 +1,1131 @@
+// src/auto-instrumentation/schedule-instrumentation-manifest-upload.ts
+import {
+  detectRelease,
+  resolveEndpointUrls,
+  uploadInstrumentationManifest
+} from "@rasputin-ai/core";
+
+// src/auto-instrumentation/instrumentation-manifest-registry.ts
+import { isAbsolute as isAbsolute2, relative as relative2, resolve as resolve2, sep as sep2 } from "node:path";
+
+// src/execution-recorder/automatic-runtime.ts
+import { isAbsolute, relative, resolve, sep } from "node:path";
+var AUTOMATIC_RUNTIME_SYMBOL = "rasputin.execution.runtime.v1";
+var AUTOMATIC_SOURCE_SEPARATOR = "\0";
+var runtimeSymbol = Symbol.for(AUTOMATIC_RUNTIME_SYMBOL);
+var normalizeAutomaticFunctionId = (sourceToken, repoRoot) => {
+  if (!sourceToken.includes(AUTOMATIC_SOURCE_SEPARATOR)) return sourceToken;
+  const [filePath, name, line, column] = sourceToken.split(AUTOMATIC_SOURCE_SEPARATOR);
+  if (!filePath || !name || !line || !column) return void 0;
+  const fromRoot = relative(repoRoot, resolve(filePath));
+  if (!fromRoot || fromRoot === ".." || fromRoot.startsWith(`..${sep}`) || isAbsolute(fromRoot)) {
+    return void 0;
+  }
+  return `${fromRoot.replaceAll("\\", "/")}:${name}@${line}:${column}`;
+};
+var getRegistry = () => {
+  const existing = Reflect.get(globalThis, runtimeSymbol);
+  if (existing?.__rasputinRuntimeRegistry && Array.isArray(existing.runtimes)) {
+    return existing;
+  }
+  const runtimes = [];
+  const registry = {
+    __rasputinRuntimeRegistry: true,
+    runtimes,
+    run: (functionId, args, callback) => {
+      const runtime = runtimes.at(-1);
+      return runtime ? runtime.run(functionId, args, callback) : callback();
+    }
+  };
+  Reflect.set(globalThis, runtimeSymbol, registry);
+  return registry;
+};
+var installAutomaticExecutionRuntime = (execution, options = {}) => {
+  const registry = getRegistry();
+  const repoRoot = options.repoRoot ? resolve(options.repoRoot) : void 0;
+  const normalizedIds = /* @__PURE__ */ new Map();
+  const runtime = {
+    run: (sourceToken, args, callback) => {
+      if (!sourceToken.includes(AUTOMATIC_SOURCE_SEPARATOR)) {
+        return execution.runFunction(sourceToken, args, callback);
+      }
+      if (!repoRoot) return callback();
+      let functionId = normalizedIds.get(sourceToken);
+      if (!normalizedIds.has(sourceToken)) {
+        functionId = normalizeAutomaticFunctionId(sourceToken, repoRoot);
+        normalizedIds.set(sourceToken, functionId);
+      }
+      return functionId ? execution.runFunction(functionId, args, callback) : callback();
+    }
+  };
+  registry.runtimes.push(runtime);
+  return () => {
+    const index = registry.runtimes.lastIndexOf(runtime);
+    if (index >= 0) registry.runtimes.splice(index, 1);
+  };
+};
+
+// src/auto-instrumentation/instrumentation-manifest-registry.ts
+var INSTRUMENTATION_MANIFEST_SYMBOL = "rasputin.instrumentation.manifest.v1";
+var registrySymbol = Symbol.for(INSTRUMENTATION_MANIFEST_SYMBOL);
+var getRegistry2 = () => {
+  const existing = Reflect.get(globalThis, registrySymbol);
+  if (existing?.__rasputinManifestRegistry && existing.files instanceof Map && typeof existing.generation === "number" && typeof existing.uploadedGeneration === "number") {
+    return existing;
+  }
+  const registry = {
+    __rasputinManifestRegistry: true,
+    files: /* @__PURE__ */ new Map(),
+    generation: 0,
+    uploadedGeneration: 0
+  };
+  Reflect.set(globalThis, registrySymbol, registry);
+  return registry;
+};
+var repoRelativePath = (filePath, repoRoot) => {
+  const fromRoot = relative2(repoRoot, resolve2(filePath));
+  if (!fromRoot || fromRoot === ".." || fromRoot.startsWith(`..${sep2}`) || isAbsolute2(fromRoot)) {
+    return void 0;
+  }
+  return fromRoot.replaceAll("\\", "/");
+};
+var isInstrumentationManifestDirty = () => {
+  const registry = getRegistry2();
+  return registry.generation !== registry.uploadedGeneration && registry.files.size > 0;
+};
+var instrumentationManifestGeneration = () => getRegistry2().generation;
+var snapshotInstrumentationManifest = (repoRoot) => {
+  const functions = [];
+  const callSites = [];
+  const destructures = [];
+  const root = resolve2(repoRoot);
+  for (const delta of getRegistry2().files.values()) {
+    for (const fn of delta.functions) {
+      const functionId = normalizeAutomaticFunctionId(fn.sourceToken, root);
+      const path = repoRelativePath(fn.filePath, root);
+      if (!functionId || !path) continue;
+      functions.push({
+        functionId,
+        path,
+        name: fn.name,
+        startLine: fn.startLine,
+        startColumn: fn.startColumn,
+        endLine: fn.endLine,
+        endColumn: fn.endColumn,
+        params: fn.params
+      });
+    }
+    for (const site of delta.callSites) {
+      const callerFunctionId = normalizeAutomaticFunctionId(site.callerSourceToken, root);
+      const path = repoRelativePath(site.filePath, root);
+      if (!callerFunctionId || !path) continue;
+      callSites.push({
+        id: `${path}:${site.line}:${site.column}`,
+        callerFunctionId,
+        calleeName: site.calleeName,
+        calleeText: site.calleeText,
+        path,
+        line: site.line,
+        column: site.column,
+        endLine: site.endLine,
+        endColumn: site.endColumn,
+        resultBinding: site.resultBinding,
+        argIdentifiers: site.argIdentifiers
+      });
+    }
+    for (const destructure of delta.destructures) {
+      const callerFunctionId = normalizeAutomaticFunctionId(destructure.callerSourceToken, root);
+      const path = repoRelativePath(destructure.filePath, root);
+      if (!callerFunctionId || !path) continue;
+      destructures.push({
+        callerFunctionId,
+        sourceParam: destructure.sourceParam,
+        path,
+        line: destructure.line,
+        column: destructure.column,
+        binding: destructure.binding
+      });
+    }
+  }
+  if (functions.length === 0 && callSites.length === 0 && destructures.length === 0) {
+    return void 0;
+  }
+  return {
+    schema_version: 1,
+    functions,
+    callSites,
+    destructures
+  };
+};
+var markInstrumentationManifestUploaded = (generation) => {
+  const registry = getRegistry2();
+  if (registry.generation === generation) {
+    registry.uploadedGeneration = generation;
+  }
+};
+var setInstrumentationManifestOnDirty = (onDirty) => {
+  getRegistry2().onDirty = onDirty;
+};
+
+// src/auto-instrumentation/schedule-instrumentation-manifest-upload.ts
+var noopHandle = {
+  flushSoon() {
+  },
+  async wait() {
+  },
+  disconnect() {
+  }
+};
+var scheduleInstrumentationManifestUpload = (options) => {
+  const release = detectRelease({ release: options.release });
+  const repoRoot = options.repoRoot;
+  if (!options.enabled || !release || !repoRoot || !options.projectApiKey.trim()) {
+    return noopHandle;
+  }
+  const { instrumentationManifestUrl } = resolveEndpointUrls(options.apiUrl);
+  let inflight;
+  const flushSoon = () => {
+    if (!isInstrumentationManifestDirty()) return;
+    const generation = instrumentationManifestGeneration();
+    const manifest = snapshotInstrumentationManifest(repoRoot);
+    if (!manifest) {
+      markInstrumentationManifestUploaded(generation);
+      return;
+    }
+    const work = uploadInstrumentationManifest({
+      url: instrumentationManifestUrl,
+      projectApiKey: options.projectApiKey,
+      release,
+      manifest,
+      fetch: options.fetch
+    }).then((result) => {
+      if (result === "ok") markInstrumentationManifestUploaded(generation);
+    });
+    inflight = inflight ? inflight.then(() => work) : work;
+  };
+  setInstrumentationManifestOnDirty(flushSoon);
+  flushSoon();
+  return {
+    flushSoon,
+    wait: async () => {
+      await inflight;
+    },
+    disconnect: () => {
+      setInstrumentationManifestOnDirty(void 0);
+    }
+  };
+};
+
+// src/execution-recorder/execution-recorder.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+
+// src/execution-recorder/call-aware-event-buffer.ts
+var CallAwareEventBuffer = class {
+  constructor(capacity) {
+    this.capacity = capacity;
+  }
+  items = [];
+  openCallIds = /* @__PURE__ */ new Set();
+  dropped = 0;
+  canStartCall() {
+    return this.items.length + this.openCallIds.size + 2 <= this.capacity;
+  }
+  startCall(event) {
+    this.items.push(event);
+    this.openCallIds.add(event.callId);
+  }
+  finishCall(event) {
+    if (event.type !== "function_exit" && event.type !== "function_throw") return;
+    if (!this.openCallIds.delete(event.callId)) return;
+    this.items.push(event);
+  }
+  dropCall() {
+    this.dropped += 2;
+  }
+  append(event) {
+    if (this.items.length + this.openCallIds.size + 1 > this.capacity) {
+      this.dropped++;
+      return false;
+    }
+    this.items.push(event);
+    return true;
+  }
+  forceCompletedCall(enter, terminal) {
+    while (this.items.length + this.openCallIds.size + 2 > this.capacity) {
+      if (!this.evictCompletedLeafOrSummary()) {
+        this.dropCall();
+        return false;
+      }
+    }
+    this.items.push(enter, terminal);
+    return true;
+  }
+  values() {
+    return [...this.items];
+  }
+  contains(target) {
+    return this.items.includes(target);
+  }
+  evictCompletedLeafOrSummary() {
+    const summaryIndex = this.items.findIndex(
+      (event) => event.type === "function_calls_suppressed"
+    );
+    if (summaryIndex >= 0) {
+      this.items.splice(summaryIndex, 1);
+      this.dropped++;
+      return true;
+    }
+    const parentCallIds = /* @__PURE__ */ new Set();
+    for (const event of this.items) {
+      if ((event.type === "function_enter" || event.type === "function_calls_suppressed") && event.parentCallId !== void 0) {
+        parentCallIds.add(event.parentCallId);
+      }
+    }
+    for (let index = 0; index < this.items.length; index++) {
+      const event = this.items[index];
+      if (event?.type !== "function_enter" || this.openCallIds.has(event.callId) || parentCallIds.has(event.callId)) {
+        continue;
+      }
+      const terminalIndex = this.items.findIndex(
+        (candidate) => (candidate.type === "function_exit" || candidate.type === "function_throw") && candidate.callId === event.callId
+      );
+      if (terminalIndex < 0) continue;
+      this.items.splice(Math.max(index, terminalIndex), 1);
+      this.items.splice(Math.min(index, terminalIndex), 1);
+      this.dropped += 2;
+      return true;
+    }
+    return false;
+  }
+};
+
+// src/execution-recorder/recorder-memory-budget.ts
+import { Buffer } from "node:buffer";
+var EXECUTION_BASE_ESTIMATED_BYTES = 1024;
+var EVENT_PAIR_BASE_ESTIMATED_BYTES = 512;
+var SUMMARY_EVENT_BASE_ESTIMATED_BYTES = 256;
+var VALUE_HEAP_ESTIMATE_MULTIPLIER = 2;
+var MEMORY_BUDGET_VALUE_MARKER = {
+  __rasputin_type: "omitted",
+  __reason: "process_memory_budget"
+};
+var RecorderMemoryBudget = class {
+  constructor(maximumBytes, maximumSerializedValueBytes) {
+    this.maximumBytes = maximumBytes;
+    this.maximumSerializedValueBytes = maximumSerializedValueBytes;
+  }
+  activeEstimatedBytes = 0;
+  stats = {
+    activeEstimatedBytes: 0,
+    peakActiveEstimatedBytes: 0,
+    memoryPressureExecutions: 0,
+    memoryPressureDegradations: 0,
+    valuesDroppedByMemoryBudget: 0,
+    eventsDroppedByMemoryBudget: 0
+  };
+  startExecution() {
+    const allocation = {
+      mode: "full",
+      estimatedBytes: 0,
+      released: false,
+      underPressure: false,
+      valuesDropped: 0,
+      eventsDropped: 0
+    };
+    if (!this.reserve(allocation, EXECUTION_BASE_ESTIMATED_BYTES)) {
+      this.markPressure(allocation, "metadata-only");
+    }
+    return allocation;
+  }
+  captureValue(allocation, serialize) {
+    if (allocation.mode !== "full") {
+      this.dropValues(allocation, 1);
+      return MEMORY_BUDGET_VALUE_MARKER;
+    }
+    const maximumEstimate = this.maximumSerializedValueBytes * VALUE_HEAP_ESTIMATE_MULTIPLIER;
+    if (this.activeEstimatedBytes + maximumEstimate > this.maximumBytes) {
+      this.markPressure(allocation, "structure-only");
+      this.dropValues(allocation, 1);
+      return MEMORY_BUDGET_VALUE_MARKER;
+    }
+    const serialized = serialize();
+    if (!this.reserve(allocation, serialized.bytes * VALUE_HEAP_ESTIMATE_MULTIPLIER)) {
+      this.markPressure(allocation, "structure-only");
+      this.dropValues(allocation, 1);
+      return MEMORY_BUDGET_VALUE_MARKER;
+    }
+    return serialized.value;
+  }
+  reserveCall(allocation, functionId) {
+    if (allocation.mode === "metadata-only") {
+      this.dropEvents(allocation, 2);
+      return false;
+    }
+    const estimatedBytes = EVENT_PAIR_BASE_ESTIMATED_BYTES + Buffer.byteLength(functionId, "utf8") * 2;
+    if (this.reserve(allocation, estimatedBytes)) return true;
+    this.markPressure(allocation, "metadata-only");
+    this.dropEvents(allocation, 2);
+    return false;
+  }
+  reserveStandaloneEvent(allocation) {
+    if (allocation.mode === "metadata-only") {
+      this.dropEvents(allocation, 1);
+      return false;
+    }
+    if (this.reserve(allocation, SUMMARY_EVENT_BASE_ESTIMATED_BYTES)) return true;
+    this.markPressure(allocation, "metadata-only");
+    this.dropEvents(allocation, 1);
+    return false;
+  }
+  release(allocation) {
+    if (allocation.released) return;
+    allocation.released = true;
+    this.activeEstimatedBytes = Math.max(0, this.activeEstimatedBytes - allocation.estimatedBytes);
+    this.stats.activeEstimatedBytes = this.activeEstimatedBytes;
+  }
+  getStats() {
+    return { ...this.stats };
+  }
+  reserve(allocation, bytes) {
+    const boundedBytes = Math.max(0, Math.ceil(bytes));
+    if (this.activeEstimatedBytes + boundedBytes > this.maximumBytes) return false;
+    this.activeEstimatedBytes += boundedBytes;
+    allocation.estimatedBytes += boundedBytes;
+    this.stats.activeEstimatedBytes = this.activeEstimatedBytes;
+    this.stats.peakActiveEstimatedBytes = Math.max(
+      this.stats.peakActiveEstimatedBytes,
+      this.activeEstimatedBytes
+    );
+    return true;
+  }
+  markPressure(allocation, mode) {
+    if (!allocation.underPressure) {
+      allocation.underPressure = true;
+      this.stats.memoryPressureExecutions++;
+    }
+    if (allocation.mode === mode || allocation.mode === "metadata-only" && mode === "structure-only") {
+      return;
+    }
+    allocation.mode = mode;
+    this.stats.memoryPressureDegradations++;
+  }
+  dropValues(allocation, count) {
+    allocation.valuesDropped += count;
+    this.stats.valuesDroppedByMemoryBudget += count;
+  }
+  dropEvents(allocation, count) {
+    allocation.eventsDropped += count;
+    this.stats.eventsDroppedByMemoryBudget += count;
+  }
+};
+
+// src/execution-recorder/safe-serialize.ts
+import { Buffer as Buffer2 } from "node:buffer";
+var DEFAULT_REDACT_KEYS = /* @__PURE__ */ new Set([
+  "password",
+  "token",
+  "authorization",
+  "cookie",
+  "secret",
+  "apikey",
+  "creditcard"
+]);
+var defaults = {
+  maxDepth: 3,
+  maxObjectKeys: 30,
+  maxArrayElements: 20,
+  maxStringLength: 500,
+  maxSerializedValueBytes: 8 * 1024
+};
+var truncation = (reason, extra = {}) => ({
+  __rasputin_truncated: true,
+  __reason: reason,
+  ...extra
+});
+var typeMarker = (type, value) => ({
+  __rasputin_type: type,
+  ...value === void 0 ? {} : { value }
+});
+var redact = (item, redactKeys, seen) => {
+  if (!item || typeof item !== "object") return item;
+  if (seen.has(item)) return item;
+  seen.add(item);
+  if (Array.isArray(item)) {
+    return item.map((entry) => redact(entry, redactKeys, seen));
+  }
+  for (const [key, child] of Object.entries(item)) {
+    item[key] = redactKeys.has(key.toLowerCase()) ? "[RASPUTIN_REDACTED]" : redact(child, redactKeys, seen);
+  }
+  return item;
+};
+var errorValue = (error, depth, seen, limits) => ({
+  __rasputin_type: "Error",
+  name: error.name,
+  message: serializeInner(error.message, depth + 1, seen, limits),
+  ...error.stack ? { stack: serializeInner(error.stack, depth + 1, seen, limits) } : {}
+});
+var serializeInner = (value, depth, seen, limits) => {
+  if (value === null || typeof value === "boolean" || typeof value === "number") return value;
+  if (typeof value === "string") {
+    if (value.length <= limits.maxStringLength) return value;
+    return truncation("max_string_length", {
+      __original_length: value.length,
+      value: value.slice(0, limits.maxStringLength)
+    });
+  }
+  if (typeof value === "undefined") return typeMarker("undefined");
+  if (typeof value === "bigint") return typeMarker("bigint", value.toString());
+  if (typeof value === "symbol") return typeMarker("symbol", String(value));
+  if (typeof value === "function") return typeMarker("function", value.name || "anonymous");
+  if (depth >= limits.maxDepth) return truncation("max_depth");
+  if (typeof value !== "object") return typeMarker(typeof value);
+  if (seen.has(value)) return typeMarker("circular");
+  seen.add(value);
+  try {
+    if (value instanceof Error) return errorValue(value, depth, seen, limits);
+    if (value instanceof Date) return typeMarker("Date", value.toISOString());
+    if (Buffer2.isBuffer(value)) {
+      return typeMarker("Buffer", {
+        byteLength: value.byteLength,
+        base64: value.subarray(0, limits.maxStringLength).toString("base64"),
+        ...value.byteLength > limits.maxStringLength ? { __rasputin_truncated: true } : {}
+      });
+    }
+    if (value instanceof Promise) return typeMarker("Promise");
+    if (value instanceof Map) {
+      const entries = [];
+      for (const entry of value.entries()) {
+        if (entries.length >= limits.maxArrayElements) break;
+        entries.push([
+          serializeInner(entry[0], depth + 1, seen, limits),
+          serializeInner(entry[1], depth + 1, seen, limits)
+        ]);
+      }
+      return {
+        __rasputin_type: "Map",
+        entries,
+        ...value.size > limits.maxArrayElements ? truncation("max_array_elements", { __original_length: value.size }) : {}
+      };
+    }
+    if (value instanceof Set) {
+      const items = [];
+      for (const item of value.values()) {
+        if (items.length >= limits.maxArrayElements) break;
+        items.push(serializeInner(item, depth + 1, seen, limits));
+      }
+      return {
+        __rasputin_type: "Set",
+        values: items,
+        ...value.size > limits.maxArrayElements ? truncation("max_array_elements", { __original_length: value.size }) : {}
+      };
+    }
+    if (Array.isArray(value)) {
+      const maxItems = value.length > limits.maxArrayElements ? limits.maxArrayElements - 1 : value.length;
+      const items = value.slice(0, maxItems).map((item) => serializeInner(item, depth + 1, seen, limits));
+      if (value.length > limits.maxArrayElements) {
+        items.push(truncation("max_array_elements", { __original_length: value.length }));
+      }
+      return items;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    const serialized = {};
+    if (prototype && prototype !== Object.prototype) {
+      serialized.__rasputin_type = prototype.constructor?.name ?? "instance";
+    }
+    const keys = Object.keys(value);
+    const maxKeys = keys.length > limits.maxObjectKeys ? limits.maxObjectKeys - 1 : keys.length;
+    for (const key of keys.slice(0, maxKeys)) {
+      const descriptor = Object.getOwnPropertyDescriptor(value, key);
+      serialized[key] = descriptor && "value" in descriptor ? serializeInner(descriptor.value, depth + 1, seen, limits) : typeMarker("accessor");
+    }
+    if (keys.length > limits.maxObjectKeys) {
+      Object.assign(serialized, truncation("max_object_keys", { __original_length: keys.length }));
+    }
+    return serialized;
+  } catch (error) {
+    return typeMarker("unserializable", error instanceof Error ? error.message : void 0);
+  } finally {
+    seen.delete(value);
+  }
+};
+var safeSerializeWithBytes = (value, options = {}) => {
+  const limits = {
+    maxDepth: options.maxDepth ?? defaults.maxDepth,
+    maxObjectKeys: options.maxObjectKeys ?? defaults.maxObjectKeys,
+    maxArrayElements: options.maxArrayElements ?? defaults.maxArrayElements,
+    maxStringLength: options.maxStringLength ?? defaults.maxStringLength,
+    maxSerializedValueBytes: options.maxSerializedValueBytes ?? defaults.maxSerializedValueBytes
+  };
+  try {
+    const redactKeys = /* @__PURE__ */ new Set([
+      ...DEFAULT_REDACT_KEYS,
+      ...(options.redactKeys ?? []).map((key) => key.toLowerCase())
+    ]);
+    const serialized = serializeInner(value, 0, /* @__PURE__ */ new WeakSet(), limits);
+    const redacted = redact(serialized, redactKeys, /* @__PURE__ */ new WeakSet());
+    const bytes = Buffer2.byteLength(JSON.stringify(redacted), "utf8");
+    const bounded = bytes <= limits.maxSerializedValueBytes ? redacted : truncation("max_serialized_value_bytes", { __serialized_bytes: bytes });
+    return {
+      value: bounded,
+      bytes: bounded === redacted ? bytes : Buffer2.byteLength(JSON.stringify(bounded), "utf8")
+    };
+  } catch {
+    const value2 = typeMarker("unserializable");
+    return { value: value2, bytes: Buffer2.byteLength(JSON.stringify(value2), "utf8") };
+  }
+};
+var safeSerialize = (value, options = {}) => safeSerializeWithBytes(value, options).value;
+
+// src/execution-recorder/source-exclusions.ts
+var sourcePathFrom = (functionId) => {
+  const separator = functionId.indexOf(":");
+  return (separator < 0 ? functionId : functionId.slice(0, separator)).replaceAll("\\", "/");
+};
+var normalizePattern = (pattern) => pattern.trim().replaceAll("\\", "/").replace(/^\.\//, "").replace(/\/$/, "");
+var globRegex = (pattern) => {
+  let expression = "";
+  for (let index = 0; index < pattern.length; index++) {
+    const character = pattern[index];
+    const next = pattern[index + 1];
+    if (character === "*" && next === "*") {
+      if (pattern[index + 2] === "/") {
+        expression += "(?:.*/)?";
+        index += 2;
+      } else {
+        expression += ".*";
+        index++;
+      }
+      continue;
+    }
+    if (character === "*") {
+      expression += "[^/]*";
+      continue;
+    }
+    if (character === "?") {
+      expression += "[^/]";
+      continue;
+    }
+    expression += character?.replace(/[.*+?^${}()|[\]\\]/g, "\\$&") ?? "";
+  }
+  return new RegExp(`^${expression}$`);
+};
+var createSourceExclusionMatcher = (exclusions) => {
+  const matchers = (exclusions ?? []).flatMap((exclusion) => {
+    if (exclusion instanceof RegExp) {
+      return [
+        (functionId) => {
+          exclusion.lastIndex = 0;
+          const matched = exclusion.test(functionId);
+          exclusion.lastIndex = 0;
+          return matched;
+        }
+      ];
+    }
+    const pattern = normalizePattern(exclusion);
+    if (!pattern) return [];
+    if (pattern.includes("*") || pattern.includes("?")) {
+      const regex = globRegex(pattern);
+      return [(functionId) => regex.test(sourcePathFrom(functionId))];
+    }
+    return [
+      (functionId) => {
+        const sourcePath = sourcePathFrom(functionId);
+        return sourcePath === pattern || sourcePath.startsWith(`${pattern}/`);
+      }
+    ];
+  });
+  return matchers.length === 0 ? () => false : (functionId) => matchers.some((matcher) => matcher(functionId));
+};
+
+// src/execution-recorder/execution-recorder.ts
+var DEFAULT_MAX_ACTIVE_MEMORY_BYTES = 64 * 1024 * 1024;
+var elapsedMs = (startedAtNs, endedAtNs = process.hrtime.bigint()) => Number(endedAtNs - startedAtNs) / 1e6;
+var roundedMilliseconds = (nanoseconds) => Math.round(Number(nanoseconds) / 1e6 * 1e4) / 1e4;
+var addRecorderTime = (recording, nanoseconds) => {
+  if (nanoseconds > 0n) recording.inlineRecorderTimeNs += nanoseconds;
+};
+var isPromiseLike = (value) => Boolean(value) && typeof value.then === "function";
+var notifyObserver = (observer, value) => {
+  try {
+    observer(value);
+  } catch {
+  }
+};
+var observeCallback = (callback, onReturn, onThrow) => {
+  let result;
+  try {
+    result = callback();
+  } catch (error) {
+    notifyObserver(onThrow, error);
+    throw error;
+  }
+  if (isPromiseLike(result)) {
+    return result.then(
+      (value) => {
+        notifyObserver(onReturn, value);
+        return value;
+      },
+      (error) => {
+        notifyObserver(onThrow, error);
+        throw error;
+      }
+    );
+  }
+  notifyObserver(onReturn, result);
+  return result;
+};
+var observeRecordedCallback = (recording, recorderStartedAtNs, callback, onReturn, onThrow) => {
+  const callbackStartedAtNs = process.hrtime.bigint();
+  const recordExitWork = (callbackEndedAtNs2) => {
+    addRecorderTime(recording, callbackStartedAtNs - recorderStartedAtNs);
+    addRecorderTime(recording, process.hrtime.bigint() - callbackEndedAtNs2);
+  };
+  let result;
+  try {
+    result = callback();
+  } catch (error) {
+    const callbackEndedAtNs2 = process.hrtime.bigint();
+    notifyObserver(onThrow, error);
+    recordExitWork(callbackEndedAtNs2);
+    throw error;
+  }
+  if (isPromiseLike(result)) {
+    return result.then(
+      (value) => {
+        const callbackEndedAtNs2 = process.hrtime.bigint();
+        notifyObserver(onReturn, value);
+        recordExitWork(callbackEndedAtNs2);
+        return value;
+      },
+      (error) => {
+        const callbackEndedAtNs2 = process.hrtime.bigint();
+        notifyObserver(onThrow, error);
+        recordExitWork(callbackEndedAtNs2);
+        throw error;
+      }
+    );
+  }
+  const callbackEndedAtNs = process.hrtime.bigint();
+  notifyObserver(onReturn, result);
+  recordExitWork(callbackEndedAtNs);
+  return result;
+};
+var noOpExecution = {
+  createScope: () => ({
+    run: (callback) => callback(),
+    getErrorState: () => void 0,
+    finish: () => {
+    }
+  }),
+  run: (_metadata, callback) => callback(),
+  getErrorState: () => void 0,
+  runFunction: (_functionId, _args, callback) => callback(),
+  trace: (_functionId, fn) => fn,
+  getStats: () => ({
+    errorSnapshots: 0,
+    successfulExecutionsDiscarded: 0,
+    truncatedEvents: 0,
+    repeatedCallsSuppressed: 0,
+    activeExecutions: 0,
+    peakActiveExecutions: 0,
+    activeEstimatedBytes: 0,
+    peakActiveEstimatedBytes: 0,
+    memoryPressureExecutions: 0,
+    memoryPressureDegradations: 0,
+    valuesDroppedByMemoryBudget: 0,
+    eventsDroppedByMemoryBudget: 0,
+    partialErrorSnapshots: 0
+  })
+};
+var mergeExecutionMetadata = (target, metadata) => {
+  if (metadata.kind) target.kind = metadata.kind;
+  if (metadata.name !== void 0) target.name = metadata.name;
+  if (metadata.request) target.request = { ...target.request, ...metadata.request };
+};
+var createExecutionRecorder = (options) => {
+  if (!options?.enabled) return noOpExecution;
+  const storage = new AsyncLocalStorage();
+  const maxEventsPerExecution = Math.max(2, Math.floor(options.maxEventsPerExecution ?? 500));
+  const maxCapturedCallsPerFunction = Math.max(
+    1,
+    Math.floor(options.maxCapturedCallsPerFunction ?? 3)
+  );
+  const maxActiveMemoryBytes = Math.max(
+    0,
+    Math.floor(options.maxActiveMemoryBytes ?? DEFAULT_MAX_ACTIVE_MEMORY_BYTES)
+  );
+  const memoryBudget = new RecorderMemoryBudget(
+    maxActiveMemoryBytes,
+    options.maxSerializedValueBytes ?? 8 * 1024
+  );
+  const excludesSource = createSourceExclusionMatcher(options.excludeSources);
+  let executionCounter = 0;
+  const errorExecutions = /* @__PURE__ */ new WeakMap();
+  const stats = {
+    errorSnapshots: 0,
+    successfulExecutionsDiscarded: 0,
+    truncatedEvents: 0,
+    repeatedCallsSuppressed: 0,
+    activeExecutions: 0,
+    peakActiveExecutions: 0,
+    partialErrorSnapshots: 0
+  };
+  const captureValue = (recording, value) => memoryBudget.captureValue(recording.memory, () => safeSerializeWithBytes(value, options));
+  const stateFrom = (recording, endedAtNs = process.hrtime.bigint()) => {
+    const recorderStartedAtNs = process.hrtime.bigint();
+    const state = {
+      version: 1,
+      executionId: recording.executionId,
+      startedAt: recording.startedAt,
+      durationMs: elapsedMs(recording.startedAtNs, endedAtNs),
+      recorder: { inlineWallTimeMs: 0 },
+      execution: {
+        ...recording.execution,
+        ...recording.execution.request ? { request: { ...recording.execution.request } } : {}
+      },
+      events: recording.events.values().map((event) => event.type === "function_calls_suppressed" ? { ...event } : event),
+      ...recording.events.dropped > 0 ? { truncated: { eventsDropped: recording.events.dropped } } : {},
+      ...recording.memory.underPressure ? {
+        capture: {
+          completeness: "partial",
+          reason: "process_memory_budget",
+          valuesDropped: recording.memory.valuesDropped,
+          eventsDropped: recording.memory.eventsDropped
+        }
+      } : {}
+    };
+    addRecorderTime(recording, process.hrtime.bigint() - recorderStartedAtNs);
+    state.recorder = { inlineWallTimeMs: roundedMilliseconds(recording.inlineRecorderTimeNs) };
+    return state;
+  };
+  const rememberError = (error, recording) => {
+    recording.hasError = true;
+    if (typeof error !== "object" && typeof error !== "function" || error === null) return;
+    if (!errorExecutions.has(error)) {
+      stats.errorSnapshots++;
+      if (recording.memory.underPressure && !recording.partialSnapshotCounted) {
+        recording.partialSnapshotCounted = true;
+        stats.partialErrorSnapshots++;
+      }
+    }
+    errorExecutions.set(error, recording);
+  };
+  const countDroppedEvents = (recording, droppedBefore) => {
+    stats.truncatedEvents += recording.events.dropped - droppedBefore;
+  };
+  const appendStandaloneEvent = (recording, event) => {
+    if (!memoryBudget.reserveStandaloneEvent(recording.memory)) return;
+    const droppedBefore = recording.events.dropped;
+    recording.events.append(event);
+    countDroppedEvents(recording, droppedBefore);
+  };
+  const repeatedCallGroup = (recording, functionId, parentCallId) => {
+    let byParent = recording.repeatedCalls.get(functionId);
+    if (!byParent) {
+      byParent = /* @__PURE__ */ new Map();
+      recording.repeatedCalls.set(functionId, byParent);
+    }
+    let group = byParent.get(parentCallId);
+    if (!group) {
+      group = { observedCalls: 0 };
+      byParent.set(parentCallId, group);
+    }
+    return group;
+  };
+  const serializedError = (recording, error, callId) => {
+    const key = (typeof error === "object" || typeof error === "function") && error !== null ? error : void 0;
+    const referencedCallId = key ? recording.capturedErrors.get(key) : void 0;
+    if (referencedCallId !== void 0) {
+      return {
+        value: { __rasputin_type: "ErrorReference", callId: referencedCallId },
+        commit: () => {
+        }
+      };
+    }
+    return {
+      // Keep the bounded thrown value even after surrounding capture degrades. A partial
+      // snapshot without the exception itself would not be useful for investigation.
+      value: safeSerialize(error, options),
+      commit: () => {
+        if (key) recording.capturedErrors.set(key, callId);
+      }
+    };
+  };
+  const captureCompletedThrow = (recording, functionId, args, parentCallId, startedAtNs, startedAtMs, error) => {
+    if (!memoryBudget.reserveCall(recording.memory, functionId)) {
+      rememberError(error, recording);
+      return;
+    }
+    const callId = ++recording.nextCallId;
+    const capturedError = serializedError(recording, error, callId);
+    const enter = {
+      type: "function_enter",
+      callId,
+      functionId,
+      timestampMs: startedAtMs,
+      args: Array.from(args, (argument) => captureValue(recording, argument)),
+      ...parentCallId === void 0 ? {} : { parentCallId }
+    };
+    const terminal = {
+      type: "function_throw",
+      callId,
+      timestampMs: elapsedMs(recording.startedAtNs),
+      durationMs: elapsedMs(startedAtNs),
+      error: capturedError.value
+    };
+    const droppedBefore = recording.events.dropped;
+    const retained = recording.events.forceCompletedCall(enter, terminal);
+    if (retained) capturedError.commit();
+    countDroppedEvents(recording, droppedBefore);
+    rememberError(error, recording);
+  };
+  const recordSuppressedCall = (recording, group, functionId, parentCallId, startedAtMs, durationMs) => {
+    stats.repeatedCallsSuppressed++;
+    const endedAtMs = startedAtMs + durationMs;
+    if (!group.summary) {
+      group.summary = {
+        type: "function_calls_suppressed",
+        functionId,
+        timestampMs: startedAtMs,
+        lastTimestampMs: endedAtMs,
+        suppressedCallCount: 1,
+        totalDurationMs: durationMs,
+        ...parentCallId === void 0 ? {} : { parentCallId }
+      };
+      appendStandaloneEvent(recording, group.summary);
+      return;
+    }
+    group.summary.lastTimestampMs = endedAtMs;
+    group.summary.suppressedCallCount++;
+    group.summary.totalDurationMs = Math.round((group.summary.totalDurationMs + durationMs) * 1e4) / 1e4;
+    if (!recording.events.contains(group.summary)) appendStandaloneEvent(recording, group.summary);
+  };
+  const finish = (store, metadata) => {
+    const { recording } = store;
+    if (recording.finished) return;
+    const recorderStartedAtNs = process.hrtime.bigint();
+    recording.finished = true;
+    if (metadata) mergeExecutionMetadata(recording.execution, metadata);
+    memoryBudget.release(recording.memory);
+    stats.activeExecutions = Math.max(0, stats.activeExecutions - 1);
+    if (!recording.hasError) stats.successfulExecutionsDiscarded++;
+    recording.finishedAtNs = process.hrtime.bigint();
+    addRecorderTime(recording, recording.finishedAtNs - recorderStartedAtNs);
+  };
+  const createScope = (metadata) => {
+    const recorderStartedAtNs = process.hrtime.bigint();
+    try {
+      const recording = {
+        executionId: `${Date.now()}-${process.pid}-${++executionCounter}`,
+        startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        startedAtNs: recorderStartedAtNs,
+        inlineRecorderTimeNs: 0n,
+        execution: {
+          ...metadata,
+          ...metadata.request ? { request: { ...metadata.request } } : {}
+        },
+        events: new CallAwareEventBuffer(maxEventsPerExecution),
+        repeatedCalls: /* @__PURE__ */ new Map(),
+        capturedErrors: /* @__PURE__ */ new WeakMap(),
+        nextCallId: 0,
+        finished: false,
+        hasError: false,
+        memory: memoryBudget.startExecution(),
+        partialSnapshotCounted: false
+      };
+      stats.activeExecutions++;
+      stats.peakActiveExecutions = Math.max(stats.peakActiveExecutions, stats.activeExecutions);
+      addRecorderTime(recording, process.hrtime.bigint() - recorderStartedAtNs);
+      const store = { recording };
+      return {
+        run: (callback) => {
+          const runStartedAtNs = process.hrtime.bigint();
+          return storage.run(store, () => {
+            addRecorderTime(recording, process.hrtime.bigint() - runStartedAtNs);
+            return callback();
+          });
+        },
+        getErrorState: (error, errorMetadata) => {
+          const getStateStartedAtNs = process.hrtime.bigint();
+          if (errorMetadata) mergeExecutionMetadata(recording.execution, errorMetadata);
+          rememberError(error, recording);
+          addRecorderTime(recording, process.hrtime.bigint() - getStateStartedAtNs);
+          return stateFrom(recording, recording.finishedAtNs);
+        },
+        finish: (finishMetadata) => finish(store, finishMetadata)
+      };
+    } catch {
+      return noOpExecution.createScope(metadata);
+    }
+  };
+  const run = (metadata, callback) => {
+    const scope = createScope(metadata);
+    return scope.run(
+      () => observeCallback(
+        callback,
+        () => scope.finish(),
+        (error) => {
+          try {
+            const store = storage.getStore();
+            if (store) {
+              const recorderStartedAtNs = process.hrtime.bigint();
+              rememberError(error, store.recording);
+              addRecorderTime(store.recording, process.hrtime.bigint() - recorderStartedAtNs);
+            }
+          } finally {
+            scope.finish();
+          }
+        }
+      )
+    );
+  };
+  const getErrorState = (error, metadata) => {
+    const getStateStartedAtNs = process.hrtime.bigint();
+    try {
+      const weakKey = (typeof error === "object" || typeof error === "function") && error !== null ? error : void 0;
+      const recording = (weakKey ? errorExecutions.get(weakKey) : void 0) ?? storage.getStore()?.recording;
+      if (!recording) return void 0;
+      if (metadata) mergeExecutionMetadata(recording.execution, metadata);
+      rememberError(error, recording);
+      addRecorderTime(recording, process.hrtime.bigint() - getStateStartedAtNs);
+      return stateFrom(recording, recording.finishedAtNs);
+    } catch {
+      return void 0;
+    }
+  };
+  const runFunction = (functionId, args, callback) => {
+    const store = storage.getStore();
+    if (!store || store.recording.finished) return callback();
+    const recorderStartedAtNs = process.hrtime.bigint();
+    if (store.suppressCapture || excludesSource(functionId)) {
+      return storage.run({ ...store, suppressCapture: true }, () => {
+        addRecorderTime(store.recording, process.hrtime.bigint() - recorderStartedAtNs);
+        return callback();
+      });
+    }
+    const parentCallId = store.currentCallId;
+    const group = repeatedCallGroup(store.recording, functionId, parentCallId);
+    group.observedCalls++;
+    if (group.observedCalls > maxCapturedCallsPerFunction) {
+      const startedAtNs2 = process.hrtime.bigint();
+      const startedAtMs = elapsedMs(store.recording.startedAtNs, startedAtNs2);
+      const captureSuccess = () => recordSuppressedCall(
+        store.recording,
+        group,
+        functionId,
+        parentCallId,
+        startedAtMs,
+        elapsedMs(startedAtNs2)
+      );
+      return observeRecordedCallback(
+        store.recording,
+        recorderStartedAtNs,
+        callback,
+        captureSuccess,
+        (error) => captureCompletedThrow(
+          store.recording,
+          functionId,
+          args,
+          parentCallId,
+          startedAtNs2,
+          startedAtMs,
+          error
+        )
+      );
+    }
+    const startedAtNs = process.hrtime.bigint();
+    if (!store.recording.events.canStartCall()) {
+      const startedAtMs = elapsedMs(store.recording.startedAtNs, startedAtNs);
+      const captureSuccess = () => {
+        const droppedBefore = store.recording.events.dropped;
+        store.recording.events.dropCall();
+        countDroppedEvents(store.recording, droppedBefore);
+      };
+      return storage.run(
+        store,
+        () => observeRecordedCallback(
+          store.recording,
+          recorderStartedAtNs,
+          callback,
+          captureSuccess,
+          (error) => captureCompletedThrow(
+            store.recording,
+            functionId,
+            args,
+            parentCallId,
+            startedAtNs,
+            startedAtMs,
+            error
+          )
+        )
+      );
+    }
+    if (!memoryBudget.reserveCall(store.recording.memory, functionId)) {
+      return observeRecordedCallback(
+        store.recording,
+        recorderStartedAtNs,
+        callback,
+        () => {
+        },
+        (error) => rememberError(error, store.recording)
+      );
+    }
+    const callId = ++store.recording.nextCallId;
+    const enter = {
+      type: "function_enter",
+      callId,
+      functionId,
+      timestampMs: elapsedMs(store.recording.startedAtNs),
+      args: Array.from(args, (argument) => captureValue(store.recording, argument)),
+      ...parentCallId === void 0 ? {} : { parentCallId }
+    };
+    store.recording.events.startCall(enter);
+    const callStore = { recording: store.recording, currentCallId: callId };
+    return storage.run(
+      callStore,
+      () => observeRecordedCallback(
+        store.recording,
+        recorderStartedAtNs,
+        callback,
+        (value) => {
+          store.recording.events.finishCall({
+            type: "function_exit",
+            callId,
+            timestampMs: elapsedMs(store.recording.startedAtNs),
+            durationMs: elapsedMs(startedAtNs),
+            returnValue: captureValue(store.recording, value)
+          });
+        },
+        (error) => {
+          const capturedError = serializedError(store.recording, error, callId);
+          store.recording.events.finishCall({
+            type: "function_throw",
+            callId,
+            timestampMs: elapsedMs(store.recording.startedAtNs),
+            durationMs: elapsedMs(startedAtNs),
+            error: capturedError.value
+          });
+          capturedError.commit();
+          rememberError(error, store.recording);
+        }
+      )
+    );
+  };
+  function trace(functionId, fn) {
+    return function traced(...args) {
+      return runFunction(functionId, args, () => fn.apply(this, args));
+    };
+  }
+  return {
+    createScope,
+    run,
+    getErrorState,
+    runFunction,
+    trace,
+    getStats: () => ({ ...stats, ...memoryBudget.getStats() })
+  };
+};
+
 // src/install-global-handlers.ts
 var removeProcessListener = process.off.bind(process);
 var installGlobalHandlers = (client, options = {}) => {
@@ -49,26 +1177,90 @@ var installGlobalHandlers = (client, options = {}) => {
 // src/rasputin-init.ts
 import {
   createClient,
-  isClientEnabled
+  isClientEnabled,
+  resolveRepoRoot
 } from "@rasputin-ai/core";
 
 // src/sdk-meta.ts
 var SDK_NAME = "@rasputin-ai/node";
-var SDK_VERSION = "0.2.0";
+var SDK_VERSION = "0.3.0";
 
 // src/rasputin-init.ts
+var withExecution = (client, execution, installRuntime, repoRoot, manifest) => {
+  const uninstallRuntime = installRuntime ? installAutomaticExecutionRuntime(execution, { repoRoot }) : () => {
+  };
+  const manifestUpload = scheduleInstrumentationManifestUpload({
+    ...manifest,
+    repoRoot
+  });
+  return {
+    ...client,
+    execution,
+    getStats: () => ({ ...client.getStats(), recorder: execution.getStats() }),
+    captureException: (error, context) => {
+      const runtimeState = context?.runtimeState ?? execution.getErrorState(
+        error,
+        context?.request ? { kind: "http", request: context.request } : void 0
+      );
+      const result = client.captureException(error, { ...context, runtimeState });
+      manifestUpload.flushSoon();
+      return result;
+    },
+    flush: async (timeoutMs) => {
+      await client.flush(timeoutMs);
+      await manifestUpload.wait();
+    },
+    close: async () => {
+      uninstallRuntime();
+      manifestUpload.disconnect();
+      await client.close();
+      await manifestUpload.wait();
+    }
+  };
+};
 var RasputinInit = (options) => {
   try {
     const client = createClient(options, { sdkVersion: SDK_VERSION, sdkName: SDK_NAME });
+    const recorderEnabled = isClientEnabled(options) && options.executionRecorder?.enabled !== false;
+    const execution = createExecutionRecorder({
+      ...options.executionRecorder,
+      enabled: recorderEnabled
+    });
+    const wrappedClient = withExecution(
+      client,
+      execution,
+      recorderEnabled,
+      resolveRepoRoot(options),
+      {
+        projectApiKey: options.projectApiKey,
+        release: options.release,
+        apiUrl: options.apiUrl,
+        enabled: isClientEnabled(options)
+      }
+    );
     if (isClientEnabled(options)) {
-      installGlobalHandlers(client);
+      installGlobalHandlers(wrappedClient);
     }
-    return client;
+    return wrappedClient;
   } catch {
-    return createClient({ ...options, enabled: false });
+    return withExecution(
+      createClient({ ...options, enabled: false }),
+      createExecutionRecorder({ enabled: false }),
+      false,
+      void 0,
+      {
+        projectApiKey: options.projectApiKey,
+        release: options.release,
+        apiUrl: options.apiUrl,
+        enabled: false
+      }
+    );
   }
 };
 export {
   RasputinInit,
-  installGlobalHandlers
+  createExecutionRecorder,
+  installAutomaticExecutionRuntime,
+  installGlobalHandlers,
+  scheduleInstrumentationManifestUpload
 };