@lunora/do 1.0.0-alpha.33 → 1.0.0-alpha.34

package/dist/index.mjs

@@ -26,7 +26,7 @@ export { RLS_UNWRAP_SYMBOL, RlsRequiredError, guardWriter } from './packem_share
 export { buildFtsMatch, ftsTableName, scoreDocument, stringifySearchText, tokenizeSearch } from './packem_shared/buildFtsMatch-BLEMawrp.mjs';
 export { M as MIN_ADMIN_TOKEN_LENGTH, a as MIN_AUTH_SECRET_LENGTH, b as buildSecurityAudit } from './packem_shared/security-audit-CucgBice.mjs';
 export { SESSION_DO_TTL_DEFAULT, SessionDO } from './packem_shared/SESSION_DO_TTL_DEFAULT-BnSKgVO4.mjs';
-export { ROOT_DO_SIZE_WARN_BYTES, ROOT_SHARD_NAME, ShardDO } from './packem_shared/ROOT_DO_SIZE_WARN_BYTES-afQHUhyA.mjs';
+export { ROOT_DO_SIZE_WARN_BYTES, ROOT_SHARD_NAME, ShardDO } from './packem_shared/ROOT_DO_SIZE_WARN_BYTES-B5c6kQIN.mjs';
 export { SHARD_REGISTRY_DO_NAME, ShardRegistryDO } from './packem_shared/SHARD_REGISTRY_DO_NAME-D99roc-r.mjs';
 export { MAX_SQL_ROWS, assertReadonly, runReadonlySql } from './packem_shared/MAX_SQL_ROWS-iFAA8FbD.mjs';
 export { createSystemReader } from './packem_shared/createSystemReader-D12eNH13.mjs';

package/dist/packem_shared/{ROOT_DO_SIZE_WARN_BYTES-afQHUhyA.mjs → ROOT_DO_SIZE_WARN_BYTES-B5c6kQIN.mjs}

@@ -27,6 +27,30 @@ import { a as selectShapeMemberIds, s as selectShapeRows } from './ctx-db-shapes
 
 const MAX_BATCH_ENTRIES = 500;
 
+const BUFFER_LEVEL = {
+  debug: "debug",
+  error: "error",
+  fatal: "error",
+  info: "info",
+  log: "info",
+  trace: "debug",
+  warn: "warn"
+};
+
+const HEX_ONLY = /^[0-9a-f]+$/;
+const parseTraceparent = (header) => {
+  if (header === null || header === void 0) {
+    return void 0;
+  }
+  const parts = header.trim().toLowerCase().split("-");
+  const [version, traceId, parentSpanId, flags] = parts;
+  if (parts.length < 4 || version === void 0 || version.length !== 2 || !HEX_ONLY.test(version) || version === "ff" || // Version 00 forbids trailing fields; only a future version may carry them.
+  version === "00" && parts.length !== 4 || traceId === void 0 || parentSpanId === void 0 || flags === void 0 || flags.length !== 2 || !HEX_ONLY.test(flags) || traceId.length !== 32 || parentSpanId.length !== 16 || !HEX_ONLY.test(traceId) || !HEX_ONLY.test(parentSpanId) || traceId === "00000000000000000000000000000000" || parentSpanId === "0000000000000000") {
+    return void 0;
+  }
+  return { parentSpanId, traceId };
+};
+
 const evictOldestEntry = (map, capacity) => {
   if (map.size < capacity) {
     return;
@@ -1158,6 +1182,35 @@ const createRelayLink = (host) => {
   return parsed === void 0 ? new OwnerRelay(host, name) : new RelayMember(host, parsed.ownerKey, parsed.relayIndex);
 };
 
+const stringifyFieldValue = (value) => {
+  if (typeof value === "string") {
+    return value;
+  }
+  try {
+    return JSON.stringify(value) ?? String(value);
+  } catch {
+    return String(value);
+  }
+};
+const coerceFieldValue = (value) => typeof value === "boolean" || typeof value === "number" || typeof value === "string" ? value : stringifyFieldValue(value);
+const normalizeLogFields = (perCall, bound) => {
+  if (perCall === void 0 && bound === void 0) {
+    return void 0;
+  }
+  const merged = {};
+  if (bound !== void 0) {
+    for (const [key, value] of Object.entries(bound)) {
+      merged[key] = coerceFieldValue(value);
+    }
+  }
+  if (perCall !== void 0) {
+    for (const [key, value] of Object.entries(perCall)) {
+      merged[key] = coerceFieldValue(value);
+    }
+  }
+  return Object.keys(merged).length === 0 ? void 0 : merged;
+};
+
 const REQUEST_LOG_TABLE = "__lunora_reqlog__";
 const REQUEST_LOG_RETENTION = 1e3;
 const REQUEST_LOG_EVENT_SOURCE = "lunora";
@@ -1271,18 +1324,40 @@ const renderLogMessage = (args) => args.map((value) => {
     return String(value);
   }
 }).join(" ");
+const isLogFields = (value) => {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+};
+const parseLogArgs = (args, boundFields) => {
+  if (args.length === 2 && typeof args[0] === "string" && isLogFields(args[1])) {
+    return { fields: normalizeLogFields(args[1], boundFields), message: args[0] };
+  }
+  return { fields: normalizeLogFields(void 0, boundFields), message: renderLogMessage(args) };
+};
 const emitLogEvent = (input) => {
-  const line = JSON.stringify({
+  const payload = {
+    fields: input.fields,
     function: input.functionPath,
     level: input.level,
     message: input.message,
     shard: input.shardKey,
     source: REQUEST_LOG_EVENT_SOURCE,
+    spanId: input.spanId,
+    traceId: input.traceId,
     ts: input.ts,
     type: LOG_EVENT_TYPE,
     userId: input.userId
-  });
-  if (input.level === "error") {
+  };
+  let line;
+  try {
+    line = JSON.stringify(payload);
+  } catch {
+    line = JSON.stringify({ ...payload, fields: void 0 });
+  }
+  if (input.level === "error" || input.level === "fatal") {
     console.error(line);
   } else if (input.level === "warn") {
     console.warn(line);
@@ -4082,28 +4157,55 @@ class ShardDO {
    * Unlike request-log args, `ctx.log` args are NOT redacted: the developer
    * chose to log them, exactly like a raw `console.log`.
    */
-  recordUserLog(functionPath, level, args, sink) {
+  recordUserLog(functionPath, level, args, message, fields, sink) {
+    const trace = parseTraceparent(this.getCurrentTraceparent());
     const event = {
       args,
+      fields,
       functionPath,
       level,
-      message: renderLogMessage(args),
+      message,
       shardKey: this.state.id?.name,
+      spanId: trace?.parentSpanId,
+      traceId: trace?.traceId,
       ts: Date.now(),
       userId: this.getCurrentUserId()
     };
-    this.logs.push({ functionPath, level: level === "log" ? "info" : level, message: event.message, timestamp: event.ts });
+    this.logs.push({ fields, functionPath, level: BUFFER_LEVEL[level], message, timestamp: event.ts });
     try {
       emitLogEvent(event);
     } catch {
     }
     if (sink?.onLog) {
       try {
-        sink.onLog(event);
+        sink.onLog(event, { waitUntil: this.state.waitUntil?.bind(this.state) });
       } catch {
       }
     }
   }
+  /**
+   * Build the `ctx.log` logger for one dispatched function. Each severity method
+   * accepts either the structured form (`(message, fields)`) or console-style
+   * varargs (see {@link parseLogArgs}); `with(fields)` returns a child that
+   * stamps `fields` onto every line. The generated `buildCtx` calls this once
+   * per dispatch and assigns the result to `ctx.log`.
+   */
+  makeLogger(functionPath, sink, boundFields) {
+    const emit = (level, args) => {
+      const { fields, message } = parseLogArgs(args, boundFields);
+      this.recordUserLog(functionPath, level, args, message, fields, sink);
+    };
+    return {
+      debug: (...args) => emit("debug", args),
+      error: (...args) => emit("error", args),
+      fatal: (...args) => emit("fatal", args),
+      info: (...args) => emit("info", args),
+      log: (...args) => emit("log", args),
+      trace: (...args) => emit("trace", args),
+      warn: (...args) => emit("warn", args),
+      with: (fields) => this.makeLogger(functionPath, sink, boundFields ? { ...boundFields, ...fields } : fields)
+    };
+  }
   /**
    * Assemble the per-socket {@link LifecycleDispatchInfo} from its attachment:
    * the verified identity to replay and the {@link LifecycleEvent} the hooks

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lunora/do",
-  "version": "1.0.0-alpha.33",
+  "version": "1.0.0-alpha.34",
   "description": "Lunora Durable Objects: ShardDO (SQLite, OCC, hibernated WebSocket subscriptions) and SessionDO",
   "keywords": [
     "cloudflare",
@@ -46,7 +46,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@lunora/errors": "1.0.0-alpha.5",
+    "@lunora/errors": "1.0.0-alpha.6",
     "@lunora/fingerprint": "1.0.0-alpha.3",
     "@visulima/redact": "3.0.0",
     "drizzle-orm": "^0.45.2"