@dvmkit/sdk 0.1.2-rc.7 → 0.1.4-rc.7

package/dist/chunk-E4EVGPDX.js

@@ -0,0 +1,391 @@
+import {
+  initCallerLoggers
+} from "./chunk-66HGCPBU.js";
+
+// src/sdk/step-cache.ts
+var StepCache = class _StepCache {
+  cache = /* @__PURE__ */ new Map();
+  /** Check if a step result is cached. */
+  has(id) {
+    return this.cache.has(id);
+  }
+  /** Get a cached step result. Throws if not present. */
+  get(id) {
+    return this.getRecord(id).value;
+  }
+  /** Get a cached step record, including replay metadata. Throws if not present. */
+  getRecord(id) {
+    const record = this.cache.get(id);
+    if (record === void 0) throw new Error(`StepCache: no cached result for step "${id}"`);
+    return record;
+  }
+  /** Cache a step result. */
+  set(id, value, costs) {
+    this.cache.set(id, {
+      id,
+      value,
+      ...costs !== void 0 && costs.length > 0 ? { costs: costs.map(({ amount, currency }) => ({ amount, currency })) } : {}
+    });
+  }
+  /** Export all cached steps for persistence. */
+  serialize() {
+    return [...this.cache.values()];
+  }
+  /** Restore a StepCache from persisted records. */
+  static deserialize(records) {
+    const cache = new _StepCache();
+    for (const { id, value, costs } of records) {
+      cache.set(id, value, costs);
+    }
+    return cache;
+  }
+};
+
+// src/sdk/logger.ts
+function createConsoleLogger(jobId) {
+  const fmt = (message, data) => {
+    const parts = [`[${jobId}] ${message}`];
+    if (data) parts.push(data);
+    return parts;
+  };
+  return {
+    debug(message, data) {
+      console.debug(...fmt(message, data));
+    },
+    info(message, data) {
+      console.info(...fmt(message, data));
+    },
+    warn(message, data) {
+      console.warn(...fmt(message, data));
+    },
+    error(message, data) {
+      console.error(...fmt(message, data));
+    }
+  };
+}
+function createStdoutLogger(context) {
+  const emit = (sink, level) => (message, data) => {
+    sink(JSON.stringify({ level, msg: message, ...context, ...data }));
+  };
+  return {
+    debug: emit(console.debug.bind(console), "debug"),
+    info: emit(console.info.bind(console), "info"),
+    warn: emit(console.warn.bind(console), "warn"),
+    error: emit(console.error.bind(console), "error")
+  };
+}
+function createNoopLogger() {
+  const noop2 = () => {
+  };
+  return { debug: noop2, info: noop2, warn: noop2, error: noop2 };
+}
+
+// src/observability/context.ts
+import { AsyncLocalStorage } from "async_hooks";
+import { randomBytes, randomUUID } from "crypto";
+var storage = new AsyncLocalStorage();
+var defaultService = "unknown";
+function setDefaultService(service) {
+  defaultService = service;
+}
+function randomTraceId() {
+  const buf = randomBytes(16);
+  const now = Date.now();
+  buf.writeUInt16BE(Math.floor(now / 4294967296), 0);
+  buf.writeUInt32BE(now % 4294967296, 2);
+  buf[6] = buf[6] & 15 | 112;
+  buf[8] = buf[8] & 63 | 128;
+  return buf.toString("hex");
+}
+function randomSpanId() {
+  return randomUUID().replace(/-/g, "").slice(0, 16);
+}
+function withTraceContext(ctx, fn) {
+  return storage.run(ctx, fn);
+}
+function currentContext(service) {
+  const ctx = storage.getStore();
+  if (ctx) return ctx;
+  return {
+    traceId: randomTraceId(),
+    spanId: null,
+    dimensions: {},
+    service: service ?? defaultService
+  };
+}
+function pinDimension(key, value) {
+  const ctx = storage.getStore();
+  if (ctx) {
+    ctx.dimensions = { ...ctx.dimensions, [key]: value };
+  }
+}
+function rawContext() {
+  return storage.getStore();
+}
+
+// src/observability/with-span.ts
+import { hostname } from "os";
+
+// src/observability/stdout-sink.ts
+var SENSITIVE_KEY_RE = /secret|token|password|private|bearer|seed|preimage|api[_-]?key|signing[_-]?key|priv[_-]?key/i;
+var isTTY = typeof process.stdout.isTTY === "boolean" && process.stdout.isTTY;
+var RED = isTTY ? "\x1B[31m" : "";
+var YELLOW = isTTY ? "\x1B[33m" : "";
+var RESET = isTTY ? "\x1B[0m" : "";
+function formatSpanLine(span) {
+  const ts = new Date(span.started_at_ms).toISOString();
+  const levelStr = colorLevel(span.level);
+  const parts = [`[${ts}]`, span.dataset, `${levelStr}:`, span.name];
+  if (span.trace_id) {
+    parts.push(`trace=${span.trace_id}`);
+  }
+  for (const [k, v] of Object.entries(span.dimensions)) {
+    parts.push(formatKV(k, v));
+  }
+  for (const [k, v] of Object.entries(span.attributes)) {
+    parts.push(formatKV(k, v));
+  }
+  const durationMs = span.ended_at_ms - span.started_at_ms;
+  if (durationMs > 0) {
+    parts.push(`duration=${durationMs}ms`);
+  }
+  if (span.error_message) {
+    parts.push(`error=${truncate(span.error_message, 120)}`);
+  }
+  return parts.join(" ");
+}
+function writeSpanLine(span) {
+  const line = formatSpanLine(span);
+  process.stdout.write(line + "\n");
+}
+function colorLevel(level) {
+  if (level === "error") return `${RED}error${RESET}`;
+  if (level === "warn") return `${YELLOW}warn${RESET}`;
+  return level;
+}
+function formatKV(key, value) {
+  if (SENSITIVE_KEY_RE.test(key)) return `${key}=[REDACTED]`;
+  return `${key}=${truncate(stringify(value), 80)}`;
+}
+function stringify(value) {
+  if (typeof value === "string") return value;
+  if (value === void 0) return "undefined";
+  if (value === null) return "null";
+  if (typeof value === "function") return "[function]";
+  if (typeof value === "symbol") return value.toString();
+  if (typeof value === "bigint") return value.toString();
+  return JSON.stringify(value);
+}
+function truncate(s, max) {
+  if (s.length <= max) return s;
+  return s.slice(0, max - 3) + "...";
+}
+
+// src/observability/with-span.ts
+var emitter = null;
+function setEmitter(fn) {
+  emitter = fn;
+}
+var cachedHost = hostname();
+var serviceVersion = process.env.GIT_SHA ?? process.env.FLY_IMAGE_REF ?? "dev";
+async function withSpan(opts, fn) {
+  const spanId = randomSpanId();
+  const existingCtx = rawContext();
+  const ctx = existingCtx ?? currentContext();
+  const startMs = opts.startMs ?? Date.now();
+  let status = "ok";
+  let level = opts.level;
+  let errorMessage = null;
+  let errorStack = null;
+  if (opts.err) {
+    status = "error";
+    errorMessage = opts.err.message;
+    errorStack = opts.err.stack ?? null;
+  }
+  const childCtx = {
+    traceId: ctx.traceId,
+    spanId,
+    dimensions: { ...ctx.dimensions, ...opts.dims },
+    service: ctx.service,
+    tracestate: ctx.tracestate
+  };
+  const emitRow = () => {
+    const endMs = opts.endMs ?? Date.now();
+    const row = {
+      span_id: spanId,
+      trace_id: ctx.traceId,
+      parent_span_id: ctx.spanId,
+      dataset: opts.dataset,
+      name: opts.name,
+      level: level ?? (status === "error" ? "error" : "info"),
+      status,
+      started_at_ms: startMs,
+      ended_at_ms: endMs,
+      service: ctx.service,
+      service_version: serviceVersion,
+      host: cachedHost,
+      pid: process.pid,
+      dimensions: childCtx.dimensions,
+      attributes: opts.attrs ?? {},
+      error_message: errorMessage,
+      error_stack: errorStack,
+      sample_rate: 1
+    };
+    writeSpanLine(row);
+    if (emitter) emitter(row);
+  };
+  try {
+    const result = await withTraceContext(childCtx, () => fn());
+    if (opts.inspect) {
+      const overrides = opts.inspect(result);
+      if (overrides) {
+        if (overrides.status) status = overrides.status;
+        if (overrides.level) level = overrides.level;
+        if (overrides.errorMessage !== void 0) errorMessage = overrides.errorMessage;
+        if (overrides.attrs) Object.assign(opts.attrs ??= {}, overrides.attrs);
+      }
+    }
+    emitRow();
+    return result;
+  } catch (err) {
+    status = "error";
+    if (err instanceof Error) {
+      errorMessage = err.message;
+      errorStack = err.stack ?? null;
+    } else {
+      errorMessage = String(err);
+    }
+    if (opts.onError) {
+      const overrides = opts.onError(err);
+      if (overrides) Object.assign(opts.attrs ??= {}, overrides);
+    }
+    emitRow();
+    throw err;
+  }
+}
+
+// src/observability/datasets.ts
+var SPANS_DATASETS = [
+  { name: "platform", retentionDays: 90 },
+  { name: "cashu", retentionDays: 90 },
+  { name: "lightning", retentionDays: 90 },
+  { name: "stripe", retentionDays: 90 },
+  { name: "x402", retentionDays: 90 },
+  { name: "tempo", retentionDays: 90 },
+  { name: "isolate", retentionDays: 90 },
+  { name: "audit", retentionDays: 365 },
+  { name: "cron", retentionDays: 30 }
+];
+var DATASET_NAMES = new Set(SPANS_DATASETS.map((d) => d.name));
+
+// src/observability/loggers.ts
+var noop = () => {
+};
+var loggers = buildNoopLoggers();
+function initLoggers(writer, service) {
+  setEmitter((row) => {
+    writer.enqueue(row);
+  });
+  setDefaultService(service);
+  const result = {};
+  for (const ds of SPANS_DATASETS) {
+    result[ds.name] = createLogger(ds.name, {});
+  }
+  loggers = result;
+  initCallerLoggers(result);
+  return result;
+}
+function createLogger(dataset, bakedDims) {
+  const logger = {
+    info(name, attrs) {
+      void withSpan({ dataset, name, level: "info", attrs, dims: bakedDims }, noop).catch(noop);
+    },
+    warn(name, attrs) {
+      void withSpan({ dataset, name, level: "warn", attrs, dims: bakedDims }, noop).catch(noop);
+    },
+    error(name, attrs) {
+      const err = attrs?.err instanceof Error ? attrs.err : void 0;
+      const cleanAttrs = attrs ? { ...attrs } : void 0;
+      if (cleanAttrs) delete cleanAttrs.err;
+      void withSpan(
+        { dataset, name, level: "error", attrs: cleanAttrs, dims: bakedDims, err },
+        noop
+      ).catch(noop);
+    },
+    async span(name, attrs, fn, opts) {
+      return withSpan({ dataset, name, attrs, dims: bakedDims, onError: opts?.onError }, fn);
+    },
+    timer(name, attrs) {
+      const startMs = Date.now();
+      return {
+        [Symbol.dispose]() {
+          const endMs = Date.now();
+          void withSpan({ dataset, name, attrs, dims: bakedDims, startMs, endMs }, noop).catch(
+            noop
+          );
+        }
+      };
+    },
+    set(dims) {
+      for (const [k, v] of Object.entries(dims)) {
+        pinDimension(k, v);
+      }
+    },
+    extend(dims) {
+      return createLogger(dataset, { ...bakedDims, ...dims });
+    },
+    tracked(name, fn) {
+      return ((...args) => logger.span(name, {}, () => fn(...args)));
+    }
+  };
+  return logger;
+}
+function buildNoopLoggers() {
+  const noopLogger = {
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    info() {
+    },
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    warn() {
+    },
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    error() {
+    },
+    async span(_name, _attrs, fn, _opts) {
+      return fn();
+    },
+    timer() {
+      return { [Symbol.dispose]() {
+      } };
+    },
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    set() {
+    },
+    extend() {
+      return noopLogger;
+    },
+    tracked(_name, fn) {
+      return fn;
+    }
+  };
+  const result = {};
+  for (const ds of SPANS_DATASETS) {
+    result[ds.name] = noopLogger;
+  }
+  return result;
+}
+
+export {
+  StepCache,
+  createConsoleLogger,
+  createStdoutLogger,
+  createNoopLogger,
+  randomTraceId,
+  withTraceContext,
+  currentContext,
+  pinDimension,
+  setEmitter,
+  withSpan,
+  loggers,
+  initLoggers
+};