@dvmkit/sdk 0.3.0-rc.9 → 0.3.2-rc.10

package/dist/{chunk-MD3H3BF7.js → chunk-2A33VHYM.js}

@@ -1,7 +1,7 @@
 import {
   StepCache,
   loggers
-} from "./chunk-YO56VCTQ.js";
+} from "./chunk-BWGRKGKG.js";
 import {
   redactUrl
 } from "./chunk-FUJ36YDV.js";

package/dist/{chunk-AJNFXR7J.js → chunk-3KYLYVY4.js}

@@ -1,6 +1,9 @@
 import {
   withSdkInitLock
 } from "./chunk-COYKJRMM.js";
+import {
+  diagnosticConsole
+} from "./chunk-D42FMCLJ.js";
 
 // src/sdk/server/postgres-replay-store.ts
 var DEFAULT_TABLE_NAME = "signed_request_replays";
@@ -57,7 +60,7 @@ var PostgresReplayStore = class {
   gcSweep(now) {
     const cutoff = now - this.windowSeconds;
     this.pool.query(`DELETE FROM ${this.tableName} WHERE recorded_at < $1`, [cutoff]).catch((err) => {
-      console.error("PostgresReplayStore GC sweep failed:", err);
+      diagnosticConsole.error("PostgresReplayStore GC sweep failed:", err);
     });
   }
 };

package/dist/{chunk-YO56VCTQ.js → chunk-BWGRKGKG.js}

@@ -1,6 +1,14 @@
 import {
   initCallerLoggers
 } from "./chunk-66HGCPBU.js";
+import {
+  bindDiagnosticCapabilityAuthority,
+  bindDiagnosticIdentityAuthority,
+  emitDiagnostic,
+  extendDiagnosticIdentityAuthority,
+  projectDiagnosticFields,
+  projectSpanRow
+} from "./chunk-D42FMCLJ.js";
 
 // src/sdk/step-cache.ts
 var StepCache = class _StepCache {
@@ -36,36 +44,34 @@ var StepCache = class _StepCache {
 };
 
 // src/sdk/logger.ts
-function createConsoleLogger(jobId) {
-  const fmt = (message, data) => {
-    const parts = [`[${jobId}] ${message}`];
-    if (data) parts.push(data);
-    return parts;
-  };
+function createConsoleLogger(_jobId) {
   return {
-    debug(message, data) {
-      console.debug(...fmt(message, data));
+    debug(_message, data) {
+      emitDiagnostic("debug", "diagnostic.message", data);
     },
-    info(message, data) {
-      console.info(...fmt(message, data));
+    info(_message, data) {
+      emitDiagnostic("info", "diagnostic.message", data);
     },
-    warn(message, data) {
-      console.warn(...fmt(message, data));
+    warn(_message, data) {
+      emitDiagnostic("warn", "diagnostic.message", data);
     },
-    error(message, data) {
-      console.error(...fmt(message, data));
+    error(_message, data) {
+      emitDiagnostic("error", "diagnostic.message", data);
     }
   };
 }
 function createStdoutLogger(context) {
-  const emit = (sink, level) => (message, data) => {
-    sink(JSON.stringify({ level, msg: message, ...context, ...data }));
+  const emit = (level) => (_message, data) => {
+    emitDiagnostic(level, "diagnostic.message", {
+      ...projectDiagnosticFields(context),
+      ...projectDiagnosticFields(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")
+    debug: emit("debug"),
+    info: emit("info"),
+    warn: emit("warn"),
+    error: emit("error")
   };
 }
 function createNoopLogger() {
@@ -108,6 +114,17 @@ function currentContext(service) {
   };
 }
 function pinDimension(key, value) {
+  const ctx = storage.getStore();
+  if (ctx) {
+    ctx.dimensions = { ...ctx.dimensions, [key]: value };
+    ctx.diagnosticIdentityAuthority = extendDiagnosticIdentityAuthority(
+      ctx.diagnosticIdentityAuthority,
+      key,
+      value
+    );
+  }
+}
+function setDimension(key, value) {
   const ctx = storage.getStore();
   if (ctx) {
     ctx.dimensions = { ...ctx.dimensions, [key]: value };
@@ -121,36 +138,35 @@ function rawContext() {
 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}`);
+  const result = projectSpanRow(span);
+  if (!result.ok) return "";
+  const safeSpan = result.row;
+  const ts = new Date(safeSpan.started_at_ms).toISOString();
+  const levelStr = colorLevel(safeSpan.level);
+  const parts = [`[${ts}]`, safeSpan.dataset, `${levelStr}:`, safeSpan.name];
+  if (safeSpan.trace_id) {
+    parts.push(`trace=${safeSpan.trace_id}`);
   }
-  for (const [k, v] of Object.entries(span.dimensions)) {
+  for (const [k, v] of Object.entries(safeSpan.dimensions)) {
     parts.push(formatKV(k, v));
   }
-  for (const [k, v] of Object.entries(span.attributes)) {
+  for (const [k, v] of Object.entries(safeSpan.attributes)) {
     parts.push(formatKV(k, v));
   }
-  const durationMs = span.ended_at_ms - span.started_at_ms;
+  const durationMs = safeSpan.ended_at_ms - safeSpan.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");
+  if (line) process.stdout.write(line + "\n");
 }
 function colorLevel(level) {
   if (level === "error") return `${RED}error${RESET}`;
@@ -158,7 +174,6 @@ function colorLevel(level) {
   return level;
 }
 function formatKV(key, value) {
-  if (SENSITIVE_KEY_RE.test(key)) return `${key}=[REDACTED]`;
   return `${key}=${truncate(stringify(value), 80)}`;
 }
 function stringify(value) {
@@ -182,28 +197,88 @@ function setEmitter(fn) {
 }
 var cachedHost = hostname();
 var serviceVersion = process.env.GIT_SHA ?? process.env.FLY_IMAGE_REF ?? "dev";
+function ownDataValue(input, key) {
+  if ((typeof input !== "object" || input === null) && typeof input !== "function") {
+    return void 0;
+  }
+  const descriptor = Object.getOwnPropertyDescriptor(input, key);
+  if (!descriptor) return void 0;
+  if (!("value" in descriptor)) throw new TypeError("accessor override");
+  return descriptor.value;
+}
+function ownIdentityKeys(input) {
+  try {
+    return ["dvm_id", "dvm_slug", "builder_id"].filter((key) => {
+      const descriptor = (typeof input === "object" && input !== null || typeof input === "function") && Object.getOwnPropertyDescriptor(input, key);
+      return descriptor && "value" in descriptor;
+    });
+  } catch {
+    return [];
+  }
+}
 async function withSpan(opts, fn) {
   const spanId = randomSpanId();
   const existingCtx = rawContext();
   const ctx = existingCtx ?? currentContext();
+  const authority = ctx.diagnosticCapabilityAuthority;
+  const identityAuthority = ctx.diagnosticIdentityAuthority;
   const startMs = opts.startMs ?? Date.now();
+  const attributeInput = opts.attrs;
+  const attributeIdentityKeys = ownIdentityKeys(attributeInput);
   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;
   }
+  let attributes = projectDiagnosticFields(
+    attributeInput,
+    opts.dataset,
+    authority,
+    identityAuthority
+  );
+  const childDimensions = bindDiagnosticIdentityAuthority(
+    bindDiagnosticCapabilityAuthority(
+      {
+        ...projectDiagnosticFields(
+          ctx.dimensions,
+          opts.dataset,
+          authority,
+          identityAuthority
+        ),
+        ...projectDiagnosticFields(
+          opts.dims,
+          opts.dataset,
+          authority,
+          identityAuthority
+        )
+      },
+      authority
+    ),
+    identityAuthority
+  );
   const childCtx = {
     traceId: ctx.traceId,
     spanId,
-    dimensions: { ...ctx.dimensions, ...opts.dims },
+    dimensions: childDimensions,
     service: ctx.service,
-    tracestate: ctx.tracestate
+    tracestate: ctx.tracestate,
+    diagnosticCapabilityAuthority: authority,
+    diagnosticIdentityAuthority: identityAuthority
+  };
+  const latestIdentityAuthority = () => childCtx.diagnosticIdentityAuthority;
+  const refreshAttributes = () => {
+    const identityCandidates = Object.fromEntries(
+      attributeIdentityKeys.map((key) => [key, null])
+    );
+    attributes = projectDiagnosticFields(
+      { ...attributes, ...identityCandidates },
+      opts.dataset,
+      authority,
+      latestIdentityAuthority()
+    );
   };
   const emitRow = () => {
+    const activeIdentityAuthority = latestIdentityAuthority();
     const endMs = opts.endMs ?? Date.now();
     const row = {
       span_id: spanId,
@@ -219,43 +294,81 @@ async function withSpan(opts, fn) {
       service_version: serviceVersion,
       host: cachedHost,
       pid: process.pid,
-      dimensions: childCtx.dimensions,
-      attributes: opts.attrs ?? {},
-      error_message: errorMessage,
-      error_stack: errorStack,
+      dimensions: projectDiagnosticFields(
+        childCtx.dimensions,
+        opts.dataset,
+        authority,
+        activeIdentityAuthority
+      ),
+      attributes,
+      error_message: null,
+      error_stack: null,
       sample_rate: 1
     };
-    writeSpanLine(row);
-    if (emitter) emitter(row);
+    bindDiagnosticCapabilityAuthority(row, authority);
+    bindDiagnosticIdentityAuthority(row, activeIdentityAuthority);
+    const projected = projectSpanRow(row);
+    if (!projected.ok) return;
+    try {
+      writeSpanLine(projected.row);
+    } catch {
+    }
+    try {
+      if (emitter) emitter(projected.row);
+    } catch {
+    }
   };
+  let result;
   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;
+    result = await withTraceContext(childCtx, () => fn());
   } 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);
+    refreshAttributes();
+    try {
+      const onError = opts.onError;
+      if (onError) {
+        const overrides = onError(err);
+        attributes = {
+          ...attributes,
+          ...projectDiagnosticFields(
+            overrides,
+            opts.dataset,
+            authority,
+            latestIdentityAuthority()
+          )
+        };
+      }
+    } catch {
     }
     emitRow();
     throw err;
   }
+  refreshAttributes();
+  try {
+    const inspect = opts.inspect;
+    if (inspect) {
+      const overrides = inspect(result);
+      const nextStatus = ownDataValue(overrides, "status");
+      const nextLevel = ownDataValue(overrides, "level");
+      const nextAttributes = ownDataValue(overrides, "attrs");
+      const projectedAttributes = nextAttributes === void 0 ? void 0 : projectDiagnosticFields(
+        nextAttributes,
+        opts.dataset,
+        authority,
+        latestIdentityAuthority()
+      );
+      if (nextStatus === "ok" || nextStatus === "error") status = nextStatus;
+      if (nextLevel === "info" || nextLevel === "warn" || nextLevel === "error") {
+        level = nextLevel;
+      }
+      if (projectedAttributes) {
+        attributes = { ...attributes, ...projectedAttributes };
+      }
+    }
+  } catch {
+  }
+  emitRow();
+  return result;
 }
 
 // src/observability/datasets.ts
@@ -298,11 +411,15 @@ function createLogger(dataset, bakedDims) {
       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 },
+        {
+          dataset,
+          name,
+          level: "error",
+          attrs,
+          dims: bakedDims,
+          err: new Error()
+        },
         noop
       ).catch(noop);
     },
@@ -314,15 +431,13 @@ function createLogger(dataset, bakedDims) {
       return {
         [Symbol.dispose]() {
           const endMs = Date.now();
-          void withSpan({ dataset, name, attrs, dims: bakedDims, startMs, endMs }, noop).catch(
-            noop
-          );
+          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);
+        setDimension(k, v);
       }
     },
     extend(dims) {

package/dist/{chunk-MMCE7XSR.js → chunk-C2AGARLM.js}

@@ -765,7 +765,7 @@ function recordPendingDrain(endpoint, callerPubkey, drain, identity) {
     );
     if (index === -1) drains.push(drain);
     else drains[index] = drain;
-    record.pendingDrains = capPendingDrains(drains, record.creditId);
+    record.pendingDrains = drains;
     return void 0;
   });
 }
@@ -879,7 +879,6 @@ function adoptCreditId(record, creditId) {
   delete record.discrepancy;
   delete record.lastReceiptJobId;
 }
-var MAX_PENDING_DRAINS = 8;
 var MAX_SETTLED_DRAIN_EVIDENCE = 8;
 var MAX_LOST_IMPLICIT_CREDITS = 8;
 var MAX_DATE_MS = 864e13;
@@ -1285,17 +1284,6 @@ function isEvidenceish(value) {
 function isDrainish(value) {
   return typeof value === "object" && value !== null && typeof value.drainId === "string";
 }
-function capPendingDrains(drains, creditId) {
-  if (drains.length <= MAX_PENDING_DRAINS) return drains;
-  const evictable = drains.filter((d) => d.creditId !== creditId).sort((a, b) => a.requestedAt - b.requestedAt);
-  const dropped = new Set(evictable.slice(0, drains.length - MAX_PENDING_DRAINS));
-  for (const d of dropped) {
-    info(
-      `Dropping the oldest unclaimed drain record (${d.drainId}${d.creditId ? ` on credit ${d.creditId}` : ""}) \u2014 ${String(MAX_PENDING_DRAINS)} is the most this DVM's record keeps.`
-    );
-  }
-  return drains.filter((d) => !dropped.has(d));
-}
 function capDrainEvidence(evidence, endpoint) {
   const settled = evidence.filter((e) => e.settledAt !== void 0).sort((a, b) => (a.settledAt ?? 0) - (b.settledAt ?? 0));
   if (settled.length <= MAX_SETTLED_DRAIN_EVIDENCE) return evidence;