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

package/dist/packem_shared/context-telemetry-DWfYDxCS.mjs

@@ -0,0 +1,165 @@
+import { isLunoraError } from '@lunora/errors';
+
+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 otlpRandomHex = (bytes) => {
+  const buffer = new Uint8Array(bytes);
+  crypto.getRandomValues(buffer);
+  let hex = "";
+  for (const byte of buffer) {
+    hex += byte.toString(16).padStart(2, "0");
+  }
+  return hex;
+};
+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 resolveTraceAnchor = (traceparent) => {
+  const inbound = parseTraceparent(traceparent);
+  return { rootSpanId: inbound?.parentSpanId ?? otlpRandomHex(8), traceId: inbound?.traceId ?? otlpRandomHex(16) };
+};
+const toErrorType = (error) => {
+  if (isLunoraError(error)) {
+    return error.code;
+  }
+  return error instanceof Error ? error.constructor.name : "Error";
+};
+
+const createTracer = (deps) => {
+  const { anchor, functionPath, record, shardKey, userId } = deps;
+  const tracerFor = (parentSpanId) => async (name, function_, attributes) => {
+    const spanId = otlpRandomHex(8);
+    const startTs = Date.now();
+    const normalized = normalizeLogFields(attributes);
+    let ok = true;
+    let error;
+    try {
+      return await function_(tracerFor(spanId));
+    } catch (error_) {
+      ok = false;
+      error = {
+        message: error_ instanceof Error ? error_.message : String(error_),
+        // Prefer a LunoraError's stable `code` over the class name so
+        // spans group by the same taxonomy the RPC spans use.
+        type: toErrorType(error_)
+      };
+      throw error_;
+    } finally {
+      try {
+        record({
+          ...normalized === void 0 ? {} : { attributes: normalized },
+          durationMs: Date.now() - startTs,
+          ...error === void 0 ? {} : { error },
+          functionPath,
+          name,
+          ok,
+          parentSpanId,
+          shardKey,
+          spanId,
+          startTs,
+          traceId: anchor.traceId,
+          userId: userId()
+        });
+      } catch {
+      }
+    }
+  };
+  return tracerFor(anchor.rootSpanId);
+};
+const createMetrics = (deps) => {
+  const { functionPath, record, shardKey } = deps;
+  const emit = (kind, name, value, attributes) => {
+    if (!Number.isFinite(value)) {
+      return;
+    }
+    const normalized = normalizeLogFields(attributes);
+    try {
+      record({
+        ...normalized === void 0 ? {} : { attributes: normalized },
+        functionPath,
+        kind,
+        name,
+        shardKey,
+        ts: Date.now(),
+        value
+      });
+    } catch {
+    }
+  };
+  return {
+    count: (name, value = 1, attributes) => {
+      emit("counter", name, value, attributes);
+    },
+    gauge: (name, value, attributes) => {
+      emit("gauge", name, value, attributes);
+    },
+    record: (name, value, attributes) => {
+      emit("histogram", name, value, attributes);
+    }
+  };
+};
+const dispatchRootSpan = (input) => {
+  const { anchor, durationMs, failure, functionPath, shardKey, startTs, userId } = input;
+  return {
+    dispatch: true,
+    durationMs,
+    ...failure === void 0 ? {} : {
+      error: {
+        message: failure.thrown instanceof Error ? failure.thrown.message : String(failure.thrown),
+        type: toErrorType(failure.thrown)
+      }
+    },
+    functionPath,
+    name: functionPath,
+    ok: failure === void 0,
+    // Empty: this span IS the trace's root locally. The worker's own RPC span
+    // sits above it in a full collector-side trace, but it is not in this
+    // buffer, so naming it here would dangle.
+    parentSpanId: "",
+    shardKey,
+    spanId: anchor.rootSpanId,
+    startTs,
+    traceId: anchor.traceId,
+    userId
+  };
+};
+
+export { createTracer as a, createMetrics as c, dispatchRootSpan as d, normalizeLogFields as n, resolveTraceAnchor as r };

package/dist/packem_shared/createMetrics-BIL8Cl8X.mjs

@@ -0,0 +1 @@
+export { c as createMetrics, a as createTracer, d as dispatchRootSpan } from './context-telemetry-DWfYDxCS.mjs';

package/dist/packem_shared/{serveRelationFanout-BgaNg3Hu.mjs → serveRelationFanout-Yiyx2OQB.mjs}

@@ -1,5 +1,5 @@
 import { LunoraError } from '@lunora/errors';
-import { RELATION_FUNCTION_PREFIX } from './ADMIN_FUNCTIONS-CAHLZMj8.mjs';
+import { RELATION_FUNCTION_PREFIX } from './ADMIN_FUNCTIONS-CqVmUVNs.mjs';
 
 const serveRelationFanout = async (schema, database, functionPath, args) => {
   const table = typeof args["table"] === "string" ? args["table"] : "";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lunora/do",
-  "version": "1.0.0-alpha.34",
+  "version": "1.0.0-alpha.35",
   "description": "Lunora Durable Objects: ShardDO (SQLite, OCC, hibernated WebSocket subscriptions) and SessionDO",
   "keywords": [
     "cloudflare",