@autter/runtime-node 1.3.4 → 1.4.0

package/dist/index.js

@@ -17,8 +17,8 @@ var IpWindow = class {
     return entry.count <= this.limitPerMinute;
   }
 };
-function firstForwardedFor(value) {
-  const raw = Array.isArray(value) ? value[0] : value;
+function firstForwardedFor(value2) {
+  const raw = Array.isArray(value2) ? value2[0] : value2;
   return raw ? (raw.split(",")[0] ?? "").trim() : "";
 }
 var DEFAULT_ENDPOINT = "https://otlp.autter.dev";
@@ -204,10 +204,10 @@ function createBrowserRelayHandler(opts) {
 
 // src/server.ts
 import { ServerResponse } from "http";
-import { randomUUID } from "crypto";
+import { randomUUID as randomUUID2 } from "crypto";
 import {
   context,
-  trace,
+  trace as trace2,
   SpanKind,
   SpanStatusCode,
   TraceFlags
@@ -310,13 +310,13 @@ function installAutterAutoFlush(options = {}) {
   const signals = options.signals ?? DEFAULT_SIGNALS;
   const flushOnUncaughtException = options.flushOnUncaughtException !== false;
   let disposed = false;
-  let inFlight = null;
+  let inFlight2 = null;
   const doFlush = async () => {
     const targets = options.targets ?? activeFlushTargets();
     if (targets.length === 0) return true;
-    let timer;
+    let timer2;
     const timedOut = new Promise((resolve) => {
-      timer = setTimeout(() => resolve(false), timeoutMs);
+      timer2 = setTimeout(() => resolve(false), timeoutMs);
     });
     const drained = Promise.allSettled(
       targets.map(
@@ -329,7 +329,7 @@ function installAutterAutoFlush(options = {}) {
     try {
       ok = await Promise.race([drained, timedOut]);
     } finally {
-      clearTimeout(timer);
+      clearTimeout(timer2);
     }
     if (ok) {
       telemetryStats.markAllFlushed();
@@ -345,13 +345,13 @@ function installAutterAutoFlush(options = {}) {
   };
   const flush = (reason = "exit") => {
     if (disposed) return Promise.resolve(false);
-    if (!inFlight) {
-      inFlight = doFlush().finally(() => {
-        inFlight = null;
+    if (!inFlight2) {
+      inFlight2 = doFlush().finally(() => {
+        inFlight2 = null;
       });
     }
     if (isDebugEnabled()) debugLog(`auto-flush requested on ${reason}`);
-    return inFlight;
+    return inFlight2;
   };
   const signalCounts = /* @__PURE__ */ new Map();
   let handlingUncaughtException = false;
@@ -490,8 +490,8 @@ function compile(options) {
     scrubEmailValues: options?.scrubEmailValues !== false
   };
 }
-function redactString(value, r) {
-  let out = value.replace(r.privateKeyBlock, r.mask);
+function redactString(value2, r) {
+  let out = value2.replace(r.privateKeyBlock, r.mask);
   for (const re of r.valuePatterns) {
     out = out.replace(re, r.mask);
   }
@@ -509,40 +509,40 @@ function canTraverse(depth, state) {
   state.remainingWork -= 1;
   return true;
 }
-function redactValue(value, r, state, depth) {
-  if (typeof value === "string") return redactString(value, r);
+function redactValue(value2, r, state, depth) {
+  if (typeof value2 === "string") return redactString(value2, r);
   let isArray = false;
   try {
-    isArray = Array.isArray(value);
+    isArray = Array.isArray(value2);
   } catch {
     return r.mask;
   }
   if (isArray) {
-    return redactArray(value, r, state, depth);
+    return redactArray(value2, r, state, depth);
   }
-  if (typeof value === "object" && value !== null) {
-    return redactObject(value, r, state, depth);
+  if (typeof value2 === "object" && value2 !== null) {
+    return redactObject(value2, r, state, depth);
   }
-  return value;
+  return value2;
 }
-function redactArray(value, r, state, depth) {
-  const existing = state.ancestors.get(value);
+function redactArray(value2, r, state, depth) {
+  const existing = state.ancestors.get(value2);
   if (existing) return r.mask;
   if (!canTraverse(depth, state)) return r.mask;
   const out = [];
-  state.ancestors.set(value, out);
+  state.ancestors.set(value2, out);
   let length;
   try {
-    length = value.length;
+    length = value2.length;
   } catch {
-    state.ancestors.delete(value);
+    state.ancestors.delete(value2);
     return r.mask;
   }
   const limit = Math.min(length, MAX_COLLECTION_ENTRIES);
   for (let i = 0; i < limit; i += 1) {
     let item;
     try {
-      item = value[i];
+      item = value2[i];
     } catch {
       out.push(r.mask);
       continue;
@@ -552,21 +552,21 @@ function redactArray(value, r, state, depth) {
   if (length > limit) {
     out.push(r.mask);
   }
-  state.ancestors.delete(value);
+  state.ancestors.delete(value2);
   return out;
 }
-function redactObject(value, r, state, depth) {
-  const existing = state.ancestors.get(value);
+function redactObject(value2, r, state, depth) {
+  const existing = state.ancestors.get(value2);
   if (existing) return r.mask;
   if (!canTraverse(depth, state)) return r.mask;
   const out = {};
-  state.ancestors.set(value, out);
+  state.ancestors.set(value2, out);
   let count = 0;
   let truncated = false;
   try {
-    for (const key in value) {
+    for (const key in value2) {
       if (!Object.prototype.propertyIsEnumerable.call(
-        value,
+        value2,
         key
       )) {
         continue;
@@ -577,7 +577,7 @@ function redactObject(value, r, state, depth) {
       }
       let nestedValue;
       try {
-        nestedValue = value[key];
+        nestedValue = value2[key];
       } catch {
         out[key] = r.mask;
         count += 1;
@@ -597,7 +597,7 @@ function redactObject(value, r, state, depth) {
   if (truncated) {
     out.__redaction_truncated__ = r.mask;
   }
-  state.ancestors.delete(value);
+  state.ancestors.delete(value2);
   return out;
 }
 var USAGE_TOKEN_KEYS = /* @__PURE__ */ new Set([
@@ -614,10 +614,10 @@ var USAGE_TOKEN_KEYS = /* @__PURE__ */ new Set([
   "gen_ai.usage.total_tokens",
   "gen_ai.usage.token_count"
 ]);
-function isSensitiveKey(key, value, r) {
+function isSensitiveKey(key, value2, r) {
   const lowered = key.toLowerCase();
   if (USAGE_TOKEN_KEYS.has(lowered)) {
-    return !(typeof value === "number" && Number.isFinite(value) && value >= 0);
+    return !(typeof value2 === "number" && Number.isFinite(value2) && value2 >= 0);
   }
   return r.keyPatterns.some((re) => re.test(lowered));
 }
@@ -646,9 +646,9 @@ function redactWith(attributes, r) {
         truncated = true;
         break;
       }
-      let value;
+      let value2;
       try {
-        value = attributes[key];
+        value2 = attributes[key];
       } catch {
         out[key] = r.mask;
         count += 1;
@@ -657,8 +657,8 @@ function redactWith(attributes, r) {
       }
       count += 1;
       state.remainingWork -= 1;
-      if (value === void 0) continue;
-      out[key] = isSensitiveKey(key, value, r) ? r.mask : redactValue(value, r, state, 0);
+      if (value2 === void 0) continue;
+      out[key] = isSensitiveKey(key, value2, r) ? r.mask : redactValue(value2, r, state, 0);
     }
   } catch {
     truncated = true;
@@ -721,6 +721,390 @@ function startMemoryMetrics() {
   };
 }
 
+// src/logger.ts
+import { AsyncLocalStorage } from "async_hooks";
+import { randomUUID } from "crypto";
+import { trace } from "@opentelemetry/api";
+var local = new AsyncLocalStorage();
+var config = null;
+var queue = [];
+var queueBytes = 0;
+var inFlightBytes = 0;
+var timer;
+var flushing = null;
+var dropped = 0;
+var inFlight = 0;
+var stopping = false;
+var failureStreak = 0;
+var severity = { debug: 5, info: 9, warning: 13, error: 17 };
+function safe(attributes = {}) {
+  const redacted = config?.redact(attributes) ?? redactAttributes(attributes);
+  let budget = 512;
+  let characters = 16384;
+  let truncated = false;
+  const visit = (input, depth) => {
+    if (--budget < 0 || depth > 6) {
+      truncated = true;
+      return "[truncated]";
+    }
+    if (typeof input === "string") {
+      const text = input.replace(/(https?:\/\/[^\s?#]+)[?#][^\s]*/gi, "$1");
+      const kept = text.slice(0, Math.max(0, characters));
+      truncated ||= kept.length < text.length;
+      characters -= kept.length;
+      return kept;
+    }
+    if (typeof input === "number")
+      return Number.isFinite(input) ? input : void 0;
+    if (typeof input === "boolean" || input === null) return input;
+    if (Array.isArray(input)) {
+      truncated ||= input.length > 64;
+      return input.slice(0, 64).map((item) => visit(item, depth + 1));
+    }
+    if (input && typeof input === "object") {
+      const entries = Object.entries(input);
+      if (depth === 0) {
+        const priority = (key) => /^autter\.(?:operation|event)\./.test(key) ? 2 : /^exception\./.test(key) ? 1 : 0;
+        entries.sort(([a], [b]) => priority(b) - priority(a));
+      }
+      truncated ||= entries.length > 100;
+      return Object.fromEntries(
+        entries.slice(0, 100).filter(([key]) => !/^(?:__proto__|constructor|prototype)$/.test(key)).map(([key, item]) => [key.slice(0, 200), visit(item, depth + 1)])
+      );
+    }
+    return void 0;
+  };
+  const result = visit(redacted, 0);
+  if (truncated) result["autter.context.truncated"] = true;
+  return result;
+}
+function operationAttributes(state) {
+  return state ? {
+    "autter.operation.id": state.id,
+    "autter.operation.name": state.name,
+    ...state.parentId ? { "autter.operation.parent_id": state.parentId } : {},
+    ...state.attributes
+  } : {};
+}
+function userAttributes(attributes = {}) {
+  return Object.fromEntries(
+    Object.entries(safe(attributes)).filter(
+      ([key]) => !/^autter\.(?:operation|event)\./.test(key)
+    )
+  );
+}
+function mergeContext(current, next = {}) {
+  const merge = (left, right, depth) => {
+    const result = { ...left };
+    for (const [key, value2] of Object.entries(right)) {
+      const prior = result[key];
+      result[key] = depth < 6 && value2 && typeof value2 === "object" && !Array.isArray(value2) && prior && typeof prior === "object" && !Array.isArray(prior) ? merge(prior, value2, depth + 1) : value2;
+    }
+    return result;
+  };
+  return userAttributes(merge(current, userAttributes(next), 0));
+}
+function traceAttributes(state) {
+  return Object.fromEntries(
+    Object.entries(operationAttributes(state)).filter(([, item]) => item !== null && item !== void 0).map(([key, item]) => [
+      key,
+      typeof item === "object" ? JSON.stringify(item) : item
+    ])
+  );
+}
+function scheduleFlush() {
+  if (!timer && config && !stopping && queue.length) {
+    timer = setTimeout(
+      () => {
+        timer = void 0;
+        void flushRuntimeLogs().catch(() => {
+        });
+      },
+      Math.min(3e4, 2e3 * 2 ** Math.min(failureStreak, 4))
+    );
+    timer.unref();
+  }
+}
+function value(input) {
+  if (typeof input === "number") return { doubleValue: input };
+  if (typeof input === "boolean") return { boolValue: input };
+  if (Array.isArray(input))
+    return { arrayValue: { values: input.slice(0, 64).map(value) } };
+  if (input && typeof input === "object")
+    return {
+      kvlistValue: {
+        values: Object.entries(input).slice(0, 128).map(([key, item]) => ({ key, value: value(item) }))
+      }
+    };
+  return { stringValue: String(input ?? "").slice(0, 32e3) };
+}
+function emit(level, message, attributes, extra = {}) {
+  const state = local.getStore();
+  if (state?.sealed) return;
+  if (extra["autter.event.type"] !== "operation" && severity[level] < severity[config?.options?.minLevel ?? "debug"])
+    return;
+  const span = trace.getActiveSpan()?.spanContext();
+  const user = mergeContext(state?.attributes ?? {}, attributes);
+  const exceptions = Object.fromEntries(
+    Object.entries(user).filter(([key]) => key.startsWith("exception."))
+  );
+  const attrs = safe({
+    "autter.event.id": randomUUID(),
+    ...extra,
+    ...exceptions,
+    ...operationAttributes(state),
+    ...user
+  });
+  const record = {
+    timeUnixNano: String(BigInt(Date.now()) * 1000000n),
+    severityNumber: severity[level],
+    severityText: level.toUpperCase(),
+    body: value(String(safe({ message }).message ?? "").slice(0, 4e3)),
+    attributes: Object.entries(attrs).map(([key, item]) => ({
+      key,
+      value: value(item)
+    })),
+    ...span && /^[a-f0-9]{32}$/.test(span.traceId) && !/^0+$/.test(span.traceId) ? { traceId: span.traceId, spanId: span.spanId } : {}
+  };
+  if (config?.options?.console !== false)
+    console.log(
+      JSON.stringify({ ...attrs, level, message: record.body.stringValue })
+    );
+  if (!config) return;
+  if (stopping) {
+    dropped++;
+    return;
+  }
+  const bytes = Buffer.byteLength(JSON.stringify(record));
+  if (bytes > 256 * 1024 || queue.length + inFlight >= 1e3 || queueBytes + inFlightBytes + bytes > 4 * 1024 * 1024) {
+    dropped++;
+    console.warn(
+      "[autter-runtime] log buffer or record limit reached; record dropped"
+    );
+    return;
+  }
+  queue.push({ record, bytes });
+  queueBytes += bytes;
+  scheduleFlush();
+}
+function configureRuntimeLogger(next) {
+  config = next;
+  stopping = false;
+  failureStreak = 0;
+}
+function runtimeLogStats() {
+  return { buffered: queue.length + inFlight, dropped };
+}
+async function flushRuntimeLogs() {
+  if (flushing) return flushing;
+  if (!config || !queue.length) return;
+  if (timer) {
+    clearTimeout(timer);
+    timer = void 0;
+  }
+  const activeConfig = config;
+  const deadline = Date.now() + 1e4;
+  flushing = (async () => {
+    const count = queue.length;
+    for (let remaining = count; remaining > 0; ) {
+      const batch = [];
+      inFlightBytes = 0;
+      while (batch.length < Math.min(50, remaining) && queue.length) {
+        const next = queue[0];
+        if (batch.length && inFlightBytes + next.bytes > 512 * 1024) break;
+        batch.push(queue.shift());
+        inFlightBytes += next.bytes;
+        queueBytes -= next.bytes;
+      }
+      remaining -= batch.length;
+      inFlight = batch.length;
+      const body = JSON.stringify({
+        resourceLogs: [
+          {
+            resource: {
+              attributes: Object.entries({
+                "service.name": activeConfig.service,
+                "deployment.environment.name": activeConfig.environment,
+                ...activeConfig.release ? { "service.version": activeConfig.release } : {}
+              }).map(([key, item]) => ({ key, value: value(item) }))
+            },
+            scopeLogs: [
+              {
+                scope: { name: "autter-runtime" },
+                logRecords: batch.map((entry) => entry.record)
+              }
+            ]
+          }
+        ]
+      });
+      let failure;
+      for (let attempt = 0; attempt < 3; attempt++) {
+        try {
+          if (Date.now() >= deadline)
+            throw new Error("Runtime log flush exceeded 10 seconds");
+          const response = await fetch(`${activeConfig.endpoint}/v1/logs`, {
+            method: "POST",
+            headers: {
+              "content-type": "application/json",
+              authorization: `Bearer ${activeConfig.apiKey}`
+            },
+            body,
+            signal: AbortSignal.timeout(
+              Math.max(1, Math.min(3e3, deadline - Date.now()))
+            )
+          });
+          if (!response.ok)
+            throw new Error(`Runtime log export failed (${response.status})`);
+          failure = void 0;
+          break;
+        } catch (error) {
+          failure = error;
+        }
+      }
+      inFlight = 0;
+      if (failure) {
+        failureStreak++;
+        queue = [...batch, ...queue];
+        queueBytes += inFlightBytes;
+        inFlightBytes = 0;
+        throw failure;
+      }
+      inFlightBytes = 0;
+      failureStreak = 0;
+    }
+  })().finally(() => {
+    flushing = null;
+    scheduleFlush();
+  });
+  return flushing;
+}
+async function shutdownRuntimeLogger() {
+  stopping = true;
+  try {
+    await flushRuntimeLogs();
+  } finally {
+    if (queue.length) {
+      dropped += queue.length;
+      console.warn(
+        `[autter-runtime] ${queue.length} log records could not be delivered before shutdown`
+      );
+    }
+    queue = [];
+    queueBytes = 0;
+    config = null;
+    if (timer) clearTimeout(timer);
+    timer = void 0;
+  }
+}
+function createRuntimeLogger(attributes = {}) {
+  const attrs = userAttributes(attributes);
+  return {
+    debug: (message, extra) => emit("debug", message, mergeContext(attrs, extra)),
+    info: (message, extra) => emit("info", message, mergeContext(attrs, extra)),
+    warn: (message, extra) => emit("warning", message, mergeContext(attrs, extra)),
+    error: (error, extra) => emit("error", error instanceof Error ? error.message : String(error), {
+      ...attrs,
+      ...extra,
+      ...error instanceof Error ? {
+        "exception.type": error.name,
+        "exception.stacktrace": error.stack ?? ""
+      } : {}
+    })
+  };
+}
+var runtimeLogger = createRuntimeLogger();
+function withRuntimeOperation(name, fn, attributes = {}) {
+  const parent = local.getStore();
+  const state = {
+    id: randomUUID(),
+    name: String(safe({ name }).name).slice(0, 200),
+    parentId: parent?.sealed ? void 0 : parent?.id,
+    attributes: mergeContext(
+      parent?.sealed ? {} : parent?.attributes ?? {},
+      attributes
+    ),
+    startedAt: Date.now(),
+    outcome: "succeeded",
+    steps: []
+  };
+  const operation = {
+    id: state.id,
+    setContext: (attrs) => {
+      if (!state.sealed) {
+        state.attributes = mergeContext(state.attributes, attrs);
+        trace.getActiveSpan()?.setAttributes(traceAttributes(state));
+      }
+    },
+    outcome: (status, message) => {
+      if (state.sealed) return;
+      state.outcome = status;
+      state.message = message;
+      if (status === "failed")
+        state.reportingStack = new Error("Operation outcome reported here").stack ?? "";
+    },
+    step: async (stepName, stepFn) => {
+      const started = Date.now();
+      let status = "succeeded";
+      try {
+        return await stepFn();
+      } catch (error) {
+        status = "failed";
+        throw error;
+      } finally {
+        if (!state.sealed && state.steps.length < 64)
+          state.steps.push({
+            name: String(safe({ name: stepName }).name).slice(0, 200),
+            status,
+            durationMs: Date.now() - started
+          });
+      }
+    }
+  };
+  const run = () => local.run(state, async () => {
+    let thrown;
+    try {
+      return await fn(operation);
+    } catch (error) {
+      state.outcome = "failed";
+      thrown = error;
+      throw error;
+    } finally {
+      trace.getActiveSpan()?.setAttributes({
+        ...traceAttributes(state),
+        "autter.operation.outcome": state.outcome
+      });
+      if (state.outcome === "failed" && !thrown)
+        config?.reportOutcome(
+          state.name,
+          state.message ?? "Operation failed",
+          {
+            ...traceAttributes(state),
+            "autter.outcome.stack": state.reportingStack ?? ""
+          }
+        );
+      emit(
+        state.outcome === "failed" ? "error" : "info",
+        state.message ?? `${state.name}: ${state.outcome}`,
+        {
+          ...operationAttributes(state),
+          ...thrown instanceof Error ? {
+            "exception.type": thrown.name,
+            "exception.stacktrace": thrown.stack ?? ""
+          } : {}
+        },
+        {
+          "autter.event.type": "operation",
+          "autter.operation.outcome": state.outcome,
+          "autter.operation.duration_ms": Date.now() - state.startedAt,
+          "autter.operation.steps": state.steps
+        }
+      );
+      state.sealed = true;
+    }
+  });
+  return config ? config.run(state.name, run, traceAttributes(state)) : run();
+}
+
 // src/server.ts
 var LLM_MARKER_ATTRIBUTES = [
   "gen_ai.operation.name",
@@ -849,7 +1233,7 @@ var ErrorTraceRetentionProcessor = class {
   }
   /** Promote the active trace, if any — called on captured errors. */
   retainActiveTrace() {
-    const active2 = trace.getActiveSpan()?.spanContext();
+    const active2 = trace2.getActiveSpan()?.spanContext();
     if (!active2 || (active2.traceFlags & TraceFlags.SAMPLED) !== 0) return;
     const entry = this.entryFor(active2.traceId);
     if (entry.retained) return;
@@ -952,7 +1336,7 @@ async function runLlmSpan(tracer, info, fn) {
   };
   try {
     const result = await context.with(
-      trace.setSpan(context.active(), span),
+      trace2.setSpan(context.active(), span),
       () => fn(handle)
     );
     span.setStatus({ code: SpanStatusCode.OK });
@@ -1001,7 +1385,7 @@ async function runWithSpan(tracer, name, fn, attributes) {
   const span = tracer.startSpan(name, { attributes });
   try {
     const result = await context.with(
-      trace.setSpan(context.active(), span),
+      trace2.setSpan(context.active(), span),
       fn
     );
     span.setStatus({ code: SpanStatusCode.OK });
@@ -1053,7 +1437,7 @@ function initAutterServer(options) {
   activeRedactor = makeRedactor(options.redactAttributes ?? true);
   const resource = new Resource({
     [ATTR_SERVICE_NAME]: options.service,
-    "service.instance.id": (options.instanceId || process.env.AUTTER_RUNTIME_INSTANCE_ID || randomUUID()).slice(0, 128),
+    "service.instance.id": (options.instanceId || process.env.AUTTER_RUNTIME_INSTANCE_ID || randomUUID2()).slice(0, 128),
     ...options.release ? { [ATTR_SERVICE_VERSION]: options.release } : {},
     "deployment.environment": environment,
     // Tells the ingester request metrics arrive on the metrics pipe, so
@@ -1140,7 +1524,7 @@ function initAutterServer(options) {
     const isError = error instanceof Error;
     const message = isError ? error.message : String(error);
     const redacted = activeRedactor(attributes);
-    const activeSpan = trace.getActiveSpan();
+    const activeSpan = trace2.getActiveSpan();
     const reuseActive = activeSpan?.isRecording() === true;
     const span = reuseActive ? activeSpan : errorTracer.startSpan(isError ? error.name : "Error");
     span.setAttributes({ "autter.severity": "error", ...redacted });
@@ -1168,20 +1552,20 @@ function initAutterServer(options) {
     span.setStatus({ code: SpanStatusCode.ERROR, message });
     if (!reuseActive) span.end();
   }
-  function captureMessage2(message, severity = "warning", attributes) {
-    if (severity === "error" || severity === "fatal") {
+  function captureMessage2(message, severity2 = "warning", attributes) {
+    if (severity2 === "error" || severity2 === "fatal") {
       errorTraceBuffer?.retainActiveTrace();
     }
     telemetryStats.markCaptured();
     const stack = new Error().stack?.split("\n").filter((line, i) => i === 0 || !line.includes("captureMessage")).join("\n");
     const span = errorTracer.startSpan("Message", {
-      attributes: { "autter.severity": severity, ...activeRedactor(attributes) }
+      attributes: { "autter.severity": severity2, ...activeRedactor(attributes) }
     });
     span.addEvent("exception", {
       "exception.type": "Message",
       "exception.message": message,
       ...stack ? { "exception.stacktrace": stack } : {},
-      "autter.severity": severity
+      "autter.severity": severity2
     });
     span.setStatus({ code: SpanStatusCode.ERROR, message });
     span.end();
@@ -1189,7 +1573,7 @@ function initAutterServer(options) {
   function reportOutcome2(name, message, attributes) {
     errorTraceBuffer?.retainActiveTrace();
     telemetryStats.markCaptured();
-    const activeSpan = trace.getActiveSpan();
+    const activeSpan = trace2.getActiveSpan();
     const reuseActive = activeSpan?.isRecording() === true;
     const span = reuseActive ? activeSpan : errorTracer.startSpan("OutcomeFailure");
     const safeOutcome = activeRedactor({ "autter.outcome.name": name.slice(0, 200), "autter.outcome.message": message.slice(0, 1e3) });
@@ -1204,6 +1588,17 @@ function initAutterServer(options) {
     span.setStatus({ code: SpanStatusCode.ERROR, message: safeMessage });
     if (!reuseActive) span.end();
   }
+  configureRuntimeLogger({
+    endpoint,
+    apiKey: options.apiKey,
+    service: options.service,
+    environment,
+    release: options.release,
+    options: options.logging,
+    redact: activeRedactor,
+    run: (name, fn, attributes) => runWithSpan(processTracer, name, fn, activeRedactor(attributes)),
+    reportOutcome: reportOutcome2
+  });
   if (options.captureGlobalErrors !== false) {
     process.on("uncaughtExceptionMonitor", (err) => {
       captureException2(err, { "autter.unhandled": true });
@@ -1214,6 +1609,7 @@ function initAutterServer(options) {
   const flushTarget = {
     forceFlush: async () => {
       const results = await Promise.allSettled([
+        flushRuntimeLogs(),
         Promise.resolve().then(() => alwaysOnProvider.forceFlush()),
         Promise.resolve().then(() => mainSpanProcessor.forceFlush()),
         ...errorTraceBuffer ? [Promise.resolve().then(() => errorTraceBuffer.forceFlush())] : [],
@@ -1240,6 +1636,7 @@ function initAutterServer(options) {
     withLlmCall: (info, fn) => runLlmSpan(llmTracer, info, fn),
     trackLlmCall: (call) => recordLlmCall(llmTracer, call),
     shutdown: async () => {
+      const logShutdown = await Promise.allSettled([shutdownRuntimeLogger()]);
       stopMemoryMetrics?.();
       active = null;
       activeAlwaysOnProvider = null;
@@ -1248,6 +1645,7 @@ function initAutterServer(options) {
       unregisterFlushTargets();
       telemetryStats.markAllFlushed();
       await Promise.allSettled([alwaysOnProvider.shutdown(), sdk.shutdown()]);
+      if (logShutdown[0]?.status === "rejected") throw logShutdown[0].reason;
     }
   };
   active = server;
@@ -1259,7 +1657,7 @@ function captureException(error, attributes) {
     active.captureException(error, attributes);
     return;
   }
-  const span = trace.getTracer("autter-errors").startSpan(error instanceof Error ? error.name : "Error", { attributes });
+  const span = trace2.getTracer("autter-errors").startSpan(error instanceof Error ? error.name : "Error", { attributes });
   if (error instanceof Error) span.recordException(error);
   span.setStatus({
     code: SpanStatusCode.ERROR,
@@ -1269,38 +1667,38 @@ function captureException(error, attributes) {
 }
 function withProcessSpan(name, fn, attributes) {
   if (active) return active.withProcessSpan(name, fn, attributes);
-  return runWithSpan(trace.getTracer("autter-processes"), name, fn, attributes);
+  return runWithSpan(trace2.getTracer("autter-processes"), name, fn, attributes);
 }
 function withLlmCall(info, fn) {
   if (active) return active.withLlmCall(info, fn);
-  return runLlmSpan(trace.getTracer("autter-llm"), info, fn);
+  return runLlmSpan(trace2.getTracer("autter-llm"), info, fn);
 }
 function trackLlmCall(call) {
   if (active) {
     active.trackLlmCall(call);
     return;
   }
-  recordLlmCall(trace.getTracer("autter-llm"), call);
+  recordLlmCall(trace2.getTracer("autter-llm"), call);
 }
-function captureMessage(message, severity = "warning", attributes) {
+function captureMessage(message, severity2 = "warning", attributes) {
   if (active) {
-    active.captureMessage(message, severity, attributes);
+    active.captureMessage(message, severity2, attributes);
     return;
   }
-  const span = trace.getTracer("autter-errors").startSpan("Message", {
-    attributes: { "autter.severity": severity, ...attributes }
+  const span = trace2.getTracer("autter-errors").startSpan("Message", {
+    attributes: { "autter.severity": severity2, ...attributes }
   });
   span.addEvent("exception", {
     "exception.type": "Message",
     "exception.message": message,
-    "autter.severity": severity
+    "autter.severity": severity2
   });
   span.setStatus({ code: SpanStatusCode.ERROR, message });
   span.end();
 }
 function reportOutcome(name, message, attributes) {
   if (active) return active.reportOutcome(name, message, attributes);
-  const span = trace.getTracer("autter-outcomes").startSpan("OutcomeFailure");
+  const span = trace2.getTracer("autter-outcomes").startSpan("OutcomeFailure");
   const safeOutcome = redactAttributes({ "autter.outcome.name": name.slice(0, 200), "autter.outcome.message": message.slice(0, 1e3) });
   const safeName = String(safeOutcome["autter.outcome.name"] ?? "operation");
   const safeMessage = String(safeOutcome["autter.outcome.message"] ?? "failed");
@@ -1317,11 +1715,11 @@ function makeSafeCapture(options) {
   const clean = (attributes) => attributes ? { ...redactAttributes(attributes, options) } : void 0;
   return {
     captureException: (error, attributes) => captureException(error, clean(attributes)),
-    captureMessage: (message, severity, attributes) => captureMessage(message, severity ?? "warning", clean(attributes))
+    captureMessage: (message, severity2, attributes) => captureMessage(message, severity2 ?? "warning", clean(attributes))
   };
 }
 function alwaysOnTracer(name) {
-  return activeAlwaysOnProvider ? activeAlwaysOnProvider.getTracer(name) : trace.getTracer(name);
+  return activeAlwaysOnProvider ? activeAlwaysOnProvider.getTracer(name) : trace2.getTracer(name);
 }
 function autterLlmTracer() {
   return alwaysOnTracer("autter-llm");
@@ -1341,7 +1739,7 @@ async function emitLlmSelftestTrace() {
       attributes: { "autter.selftest": true }
     },
     (llm) => {
-      traceId = trace.getActiveSpan()?.spanContext().traceId ?? "";
+      traceId = trace2.getActiveSpan()?.spanContext().traceId ?? "";
       llm.setUsage({ inputTokens: 1, outputTokens: 1 });
       llm.setCost(0);
     }
@@ -1459,9 +1857,9 @@ function wrapStream(stream, span) {
                 throw err;
               }
             },
-            async return(value2) {
+            async return(value3) {
               finish();
-              return inner.return ? inner.return(value2) : { done: true, value: void 0 };
+              return inner.return ? inner.return(value3) : { done: true, value: void 0 };
             },
             async throw(err) {
               finish(err);
@@ -1471,8 +1869,8 @@ function wrapStream(stream, span) {
           };
         };
       }
-      const value = Reflect.get(target, prop, receiver);
-      return typeof value === "function" ? value.bind(target) : value;
+      const value2 = Reflect.get(target, prop, receiver);
+      return typeof value2 === "function" ? value2.bind(target) : value2;
     }
   });
 }
@@ -1534,30 +1932,30 @@ function instrumentLlmClient(client, options) {
     if (cached) return cached;
     const proxy = new Proxy(target, {
       get(t, prop, receiver) {
-        const value = Reflect.get(t, prop, receiver);
-        if (typeof prop === "symbol") return value;
+        const value2 = Reflect.get(t, prop, receiver);
+        if (typeof prop === "symbol") return value2;
         const propPath = path ? `${path}.${prop}` : prop;
-        if (typeof value === "function") {
+        if (typeof value2 === "function") {
           if (CALL_METHODS.has(prop)) {
             return (...args) => {
               const first = args[0];
               if (first && typeof first === "object" && typeof first.model === "string") {
                 return traceCall(
-                  value,
+                  value2,
                   t,
                   propPath,
                   args
                 );
               }
-              return value.apply(t, args);
+              return value2.apply(t, args);
             };
           }
-          return value.bind(t);
+          return value2.bind(t);
         }
-        if (value !== null && typeof value === "object" && !(value instanceof Promise)) {
-          return deepProxy(value, propPath);
+        if (value2 !== null && typeof value2 === "object" && !(value2 instanceof Promise)) {
+          return deepProxy(value2, propPath);
         }
-        return value;
+        return value2;
       }
     });
     proxied.set(target, proxy);
@@ -1614,16 +2012,21 @@ export {
   captureMessage,
   createBrowserRelayFetchHandler,
   createBrowserRelayHandler,
+  createRuntimeLogger,
   emitLlmSelftestTrace,
+  flushRuntimeLogs,
   initAutterServer,
   installAutterAutoFlush,
   instrumentLlmClient,
   makeSafeCapture,
   redactAttributes,
   reportOutcome,
+  runtimeLogStats,
+  runtimeLogger,
   sanitizeBrowserPayload,
   startCaughtExceptionSampler,
   trackLlmCall,
   withLlmCall,
-  withProcessSpan
+  withProcessSpan,
+  withRuntimeOperation
 };