@lunora/runtime 1.0.0-alpha.35 → 1.0.0-alpha.36

package/dist/packem_shared/{analyticsEngineSink-DgL64WVC.mjs → analyticsEngineSink-yLFNjHDt.mjs}

@@ -1,4 +1,4 @@
-import { m as mergeHeaders, w as wrapResourceSpans, o as otlpRandomHex, a as wrapResourceMetrics, c as wrapResourceLogs, e as encodeAttribute, O as OTLP_SEVERITY, d as otlpUnixNano } from './otlp-DKZJCkdD.mjs';
+import { w as wrapResourceSpans, o as otlpRandomHex, c as wrapResourceMetrics, e as wrapResourceLogs, f as encodeAttribute, g as otlpUnixNano, O as OTLP_SEVERITY, h as mergeHeaders, m as mergeResourceAttributes } from './otlp-resource-Dow6-F_u.mjs';
 
 const stringifyFieldValue = (value) => {
   if (typeof value === "string") {
@@ -12,12 +12,31 @@ const stringifyFieldValue = (value) => {
 };
 const coerceFieldValue = (value) => typeof value === "boolean" || typeof value === "number" || typeof value === "string" ? value : stringifyFieldValue(value);
 
-const shouldSkip = (event, onlyErrors) => onlyErrors === true && event.ok;
-const otlpTraceBody = (event, serviceName, endMs) => {
+const otlpTraceBody = (event, serviceName, endMs, resourceAttributes) => {
   const attributes = [encodeAttribute("lunora.function_path", event.functionPath), encodeAttribute("lunora.ok", event.ok)];
+  if (event.method !== void 0) {
+    attributes.push(encodeAttribute("http.request.method", event.method));
+  }
+  if (event.path !== void 0) {
+    attributes.push(encodeAttribute("url.path", event.path));
+  }
+  attributes.push(encodeAttribute("http.route", event.functionPath));
+  if (event.scheme !== void 0) {
+    attributes.push(encodeAttribute("url.scheme", event.scheme));
+  }
+  if (event.host !== void 0) {
+    attributes.push(encodeAttribute("server.address", event.host));
+  }
+  if (event.port !== void 0) {
+    attributes.push(encodeAttribute("server.port", event.port));
+  }
+  if (event.userAgent !== void 0) {
+    attributes.push(encodeAttribute("user_agent.original", event.userAgent));
+  }
   if (event.shardKey !== void 0) {
     attributes.push(encodeAttribute("lunora.shard_key", event.shardKey));
   }
+  attributes.push(encodeAttribute("http.response.status_code", event.error?.status ?? 200));
   if (event.error) {
     attributes.push(encodeAttribute("error.type", event.error.code), encodeAttribute("lunora.error_status", event.error.status));
   }
@@ -42,7 +61,22 @@ const otlpTraceBody = (event, serviceName, endMs) => {
     status: event.ok ? { code: 1 } : { code: 2, message: event.error?.message ?? "" },
     traceId: event.traceId ?? otlpRandomHex(16)
   };
-  return wrapResourceSpans(span, "@lunora/runtime", serviceName);
+  if (event.parentSpanId !== void 0) {
+    span.parentSpanId = event.parentSpanId;
+  }
+  if (event.traceFlags !== void 0) {
+    span.flags = event.traceFlags;
+  }
+  if (event.error) {
+    span.events = [
+      {
+        attributes: [encodeAttribute("exception.type", event.error.code), encodeAttribute("exception.message", event.error.message)],
+        name: "exception",
+        timeUnixNano: otlpUnixNano(endMs)
+      }
+    ];
+  }
+  return wrapResourceSpans(span, "@lunora/runtime", serviceName, resourceAttributes);
 };
 const encodeSignalAttributes = (reserved, caller) => {
   const byKey = /* @__PURE__ */ new Map([["lunora.function_path", encodeAttribute("lunora.function_path", reserved.functionPath)]]);
@@ -60,7 +94,7 @@ const encodeSignalAttributes = (reserved, caller) => {
   }
   return [...byKey.values()];
 };
-const otlpSpanBody = (event, serviceName) => {
+const otlpSpanBody = (event, serviceName, resourceAttributes) => {
   const span = {
     attributes: encodeSignalAttributes(
       { errorType: event.error?.type, functionPath: event.functionPath, shardKey: event.shardKey, userId: event.userId },
@@ -80,14 +114,14 @@ const otlpSpanBody = (event, serviceName) => {
     status: event.ok ? { code: 1 } : { code: 2, message: event.error?.message ?? "" },
     traceId: event.traceId
   };
-  return wrapResourceSpans(span, "@lunora/runtime", serviceName);
+  return wrapResourceSpans(span, "@lunora/runtime", serviceName, resourceAttributes);
 };
-const otlpMetricBody = (event, serviceName) => {
+const otlpMetricBody = (event, serviceName, resourceAttributes) => {
   const timeUnixNano = otlpUnixNano(event.ts);
   const attributes = encodeSignalAttributes({ functionPath: event.functionPath, shardKey: event.shardKey }, event.attributes);
   const dataPoint = { asDouble: event.value, attributes, timeUnixNano };
   if (event.kind === "gauge") {
-    return wrapResourceMetrics({ gauge: { dataPoints: [dataPoint] }, name: event.name }, "@lunora/runtime", serviceName);
+    return wrapResourceMetrics({ gauge: { dataPoints: [dataPoint] }, name: event.name }, "@lunora/runtime", serviceName, resourceAttributes);
   }
   if (event.kind === "histogram") {
     return wrapResourceMetrics(
@@ -112,16 +146,18 @@ const otlpMetricBody = (event, serviceName) => {
         name: event.name
       },
       "@lunora/runtime",
-      serviceName
+      serviceName,
+      resourceAttributes
     );
   }
   return wrapResourceMetrics(
     { name: event.name, sum: { aggregationTemporality: 1, dataPoints: [dataPoint], isMonotonic: true } },
     "@lunora/runtime",
-    serviceName
+    serviceName,
+    resourceAttributes
   );
 };
-const otlpLogBody = (event, serviceName) => {
+const otlpLogBody = (event, serviceName, resourceAttributes) => {
   const logRecord = {
     // Caller-supplied structured fields become log-record attributes so a
     // pipeline can filter/index on them; precedence per `encodeSignalAttributes`.
@@ -137,7 +173,7 @@ const otlpLogBody = (event, serviceName) => {
   if (event.spanId !== void 0) {
     logRecord.spanId = event.spanId;
   }
-  return wrapResourceLogs(logRecord, "@lunora/runtime", serviceName);
+  return wrapResourceLogs(logRecord, "@lunora/runtime", serviceName, resourceAttributes);
 };
 const OTLP_GZIP_THRESHOLD = 1024;
 const gzipEncode = async (text) => {
@@ -155,6 +191,8 @@ const otlpPost = (url, body, headers, context) => {
   } catch {
   }
 };
+
+const shouldSkip = (event, onlyErrors) => onlyErrors === true && event.ok;
 const consoleSink = (options = {}) => {
   const { onlyErrors } = options;
   return {
@@ -312,8 +350,27 @@ const pipelineLogSink = (options) => {
   };
 };
 const otlpSink = (options) => {
-  const { endpoint, headers, onlyErrors, token } = options;
+  const { deploymentEnvironment, detectResources, endpoint, headers, onlyErrors, resourceAttributes, serviceNamespace, serviceVersion, token } = options;
   const serviceName = options.serviceName ?? "lunora";
+  const staticAttributes = {
+    ...serviceVersion === void 0 ? {} : { "service.version": serviceVersion },
+    ...serviceNamespace === void 0 ? {} : { "service.namespace": serviceNamespace },
+    ...deploymentEnvironment === void 0 ? {} : { "deployment.environment": deploymentEnvironment },
+    ...resourceAttributes
+  };
+  const mergedByContext = /* @__PURE__ */ new WeakMap();
+  const resourceAttributesFor = (context) => {
+    if (detectResources !== true || context?.resourceAttributes === void 0) {
+      return staticAttributes;
+    }
+    const memoized = mergedByContext.get(context);
+    if (memoized !== void 0) {
+      return memoized;
+    }
+    const merged = mergeResourceAttributes(context.resourceAttributes(), staticAttributes);
+    mergedByContext.set(context, merged);
+    return merged;
+  };
   let base = endpoint;
   while (base.endsWith("/")) {
     base = base.slice(0, -1);
@@ -324,19 +381,19 @@ const otlpSink = (options) => {
   const mergedHeaders = mergeHeaders({ "content-type": "application/json" }, headers, token);
   return {
     onLog: (event, context) => {
-      otlpPost(logsUrl, otlpLogBody(event, serviceName), mergedHeaders, context);
+      otlpPost(logsUrl, otlpLogBody(event, serviceName, resourceAttributesFor(context)), mergedHeaders, context);
     },
     onMetric: (event, context) => {
-      otlpPost(metricsUrl, otlpMetricBody(event, serviceName), mergedHeaders, context);
+      otlpPost(metricsUrl, otlpMetricBody(event, serviceName, resourceAttributesFor(context)), mergedHeaders, context);
     },
     onRpc: (event, context) => {
       if (shouldSkip(event, onlyErrors)) {
         return;
       }
-      otlpPost(tracesUrl, otlpTraceBody(event, serviceName, Date.now()), mergedHeaders, context);
+      otlpPost(tracesUrl, otlpTraceBody(event, serviceName, Date.now(), resourceAttributesFor(context)), mergedHeaders, context);
     },
     onSpan: (event, context) => {
-      otlpPost(tracesUrl, otlpSpanBody(event, serviceName), mergedHeaders, context);
+      otlpPost(tracesUrl, otlpSpanBody(event, serviceName, resourceAttributesFor(context)), mergedHeaders, context);
     }
   };
 };

package/dist/packem_shared/{argsFromQuery-BqPiQTPc.mjs → argsFromQuery-c-U1WRy-.mjs}

@@ -71,7 +71,7 @@ const buildRestRoutes = (deps) => {
   const routes = {};
   for (const entry of restSurfaceFromRegistry(functions)) {
     const allowed = entry.kind === "query" ? ["GET", "POST"] : ["POST"];
-    routes[entry.path] = async (request, env) => {
+    routes[entry.path] = async (request, env, _url, context) => {
       const wrongMethod = methodGuard(request, allowed);
       if (wrongMethod) {
         return wrongMethod;
@@ -90,7 +90,14 @@ const buildRestRoutes = (deps) => {
         args = request.body === null ? {} : await readJsonBody(request);
       }
       const shardKey = readShardKey(url, request);
-      return invoke({ args, env, functionPath: entry.functionPath, request, ...shardKey === void 0 ? {} : { shardKey } });
+      return invoke({
+        args,
+        env,
+        functionPath: entry.functionPath,
+        request,
+        ...shardKey === void 0 ? {} : { shardKey },
+        ...context?.waitUntil === void 0 ? {} : { waitUntil: (promise) => context.waitUntil?.(promise) }
+      });
     };
   }
   return routes;

package/dist/packem_shared/{composeWorker-UwHY2r8O.mjs → composeWorker-DiWwOXXt.mjs}

@@ -1,7 +1,5 @@
 import { isLunoraError, toErrorBody } from '@lunora/errors';
 import { NOOP_EXECUTION_CONTEXT } from './NOOP_EXECUTION_CONTEXT-CCTu0Bf1.mjs';
-import { o as otlpRandomHex, b as buildTraceparent } from './otlp-DKZJCkdD.mjs';
-import { r as resolveTraceSampling, a as emitRpcEvent } from './observability--NOFYBFc.mjs';
 import { LunoraError, toErrorResponse } from './LunoraError-Bpb9EFJ3.mjs';
 import { runExportTap } from './createKvCursorStore-g8aA6B4L.mjs';
 import { m as methodGuard } from './method-guard-Qzw99aCj.mjs';
@@ -9,8 +7,10 @@ import { buildHealthRoutes, durableObjectProbe, d1Probe, presenceProbe } from '.
 import { wrapResolverWithContract } from './composeIdentityResolvers-XGjO7V1J.mjs';
 export { composeIdentityResolvers, routeIdentityResolvers } from './composeIdentityResolvers-XGjO7V1J.mjs';
 import { buildLogArchiveAdminRoutes } from './LOG_ARCHIVE_PATH-CNs0bznX.mjs';
+import { r as resolveTraceSampling, a as emitRpcEvent } from './observability--NOFYBFc.mjs';
+import { o as otlpRandomHex, b as buildTraceparent, p as parseTraceparent, m as mergeResourceAttributes, d as detectCloudflareResource, a as detectServiceResource, r as readerFromRecord } from './otlp-resource-Dow6-F_u.mjs';
 import { resolveShard, applyJurisdiction } from './applyJurisdiction-BkZtTkct.mjs';
-import { buildRestRoutes } from './argsFromQuery-BqPiQTPc.mjs';
+import { buildRestRoutes } from './argsFromQuery-c-U1WRy-.mjs';
 import { resolveSecurity, handleCorsPreflight, enforceOrigin, decorateResponse, enforceWebSocketOrigin } from './decorateResponse-DRWQFNhF.mjs';
 
 const evictOldestEntry = (map, capacity) => {
@@ -1753,6 +1753,83 @@ const buildOrchestrationAdminRoutes = (deps) => {
   };
 };
 
+const SAMPLED_FLAG = 1;
+const UNSAMPLED_FLAG = 0;
+const MAX_TRACE_STATE_MEMBERS = 32;
+const MAX_TRACE_STATE_LENGTH = 512;
+const TRACE_STATE_MEMBER = /^[a-z][\d_a-z*/-]{0,255}(?:@[a-z][\d_a-z*/-]{0,13})?=[\u0020-\u002B\u002D-\u003C\u003E-\u007E]{1,256}$/;
+const sanitizeTraceState = (header) => {
+  if (header === null || header === void 0) {
+    return void 0;
+  }
+  const trimmed = header.trim();
+  if (trimmed.length === 0 || trimmed.length > MAX_TRACE_STATE_LENGTH) {
+    return void 0;
+  }
+  const members = trimmed.split(",");
+  if (members.length > MAX_TRACE_STATE_MEMBERS) {
+    return void 0;
+  }
+  for (const member of members) {
+    if (!TRACE_STATE_MEMBER.test(member.trim())) {
+      return void 0;
+    }
+  }
+  return trimmed;
+};
+const extractTraceContext = (request) => {
+  const parsed = parseTraceparent(request.headers.get("traceparent"));
+  if (parsed === void 0) {
+    return void 0;
+  }
+  const traceState = sanitizeTraceState(request.headers.get("tracestate"));
+  return {
+    parentSpanId: parsed.parentSpanId,
+    sampled: parsed.sampled,
+    traceId: parsed.traceId,
+    ...traceState === void 0 ? {} : { traceState }
+  };
+};
+const beginDispatchTrace = (request, options = {}) => {
+  const upstream = extractTraceContext(request);
+  const trusted = options.trustInbound === true ? upstream : void 0;
+  const spanId = otlpRandomHex(8);
+  const traceId = trusted?.traceId ?? otlpRandomHex(16);
+  const decision = resolveTraceSampling(options.sampling, trusted === void 0 ? spanId : traceId);
+  const sampled = decision.isTraced && (trusted === void 0 || trusted.sampled);
+  return {
+    decision,
+    // A parseable upstream trace existed, and we chose not to join it.
+    ignoredUpstream: upstream !== void 0 && trusted === void 0,
+    trace: {
+      sampled,
+      spanId,
+      traceFlags: sampled ? SAMPLED_FLAG : UNSAMPLED_FLAG,
+      traceId,
+      ...trusted?.parentSpanId === void 0 ? {} : { parentSpanId: trusted.parentSpanId },
+      ...trusted?.traceState === void 0 ? {} : { traceState: trusted.traceState }
+    }
+  };
+};
+const injectTraceContext = (trace, headers) => {
+  headers.traceparent = buildTraceparent(trace.traceId, trace.spanId, trace.sampled);
+  if (trace.traceState !== void 0) {
+    headers.tracestate = trace.traceState;
+  }
+};
+
+const createResourceAttributeResolver = (environment, request) => {
+  let resolved;
+  return () => {
+    if (resolved === void 0) {
+      const read = readerFromRecord(environment);
+      const cf = request === void 0 ? void 0 : request.cf;
+      resolved = mergeResourceAttributes(detectServiceResource(read), detectCloudflareResource(read, cf));
+    }
+    return resolved;
+  };
+};
+
 const SCHEDULED_PATH = "/_lunora/admin/scheduled";
 const SCHEDULED_STATUS_PATH = "/_lunora/admin/scheduled/status";
 const SCHEDULED_WS_PATH = "/_lunora/admin/scheduled/ws";
@@ -1934,6 +2011,51 @@ const buildStorageAdminRoutes = (deps) => {
   };
 };
 
+const cfString = (request, ...path) => {
+  let current = request.cf;
+  for (const key of path) {
+    if (typeof current !== "object" || current === null) {
+      return void 0;
+    }
+    current = current[key];
+  }
+  return typeof current === "string" ? current : void 0;
+};
+const SIGNAL_CHECKS = {
+  // Edge-verified client certificate — the platform sets `certVerified`, so
+  // unlike a header this cannot be spoofed by the caller.
+  mtls: (request) => cfString(request, "tlsClientAuth", "certVerified") === "SUCCESS"
+};
+const resolveTraceTrust = (option) => {
+  if (option === void 0 || option === false) {
+    return () => false;
+  }
+  if (option === true) {
+    return () => true;
+  }
+  if (typeof option === "function") {
+    return option;
+  }
+  const check = Object.entries(SIGNAL_CHECKS).find(([signal]) => signal === option)?.[1];
+  return check ?? (() => false);
+};
+const createDroppedTraceNotice = (option) => {
+  if (option !== void 0) {
+    return () => {
+    };
+  }
+  let notified = false;
+  return () => {
+    if (notified) {
+      return;
+    }
+    notified = true;
+    console.warn(
+      '[lunora] Ignored an inbound `traceparent`, so this request starts a new trace instead of joining the caller\'s. That is the safe default: the header is caller-supplied, and trusting it lets any client choose which trace its spans and logs join. If this worker sits behind a gateway, service mesh, or Cloudflare Access that sets `traceparent` itself, set `trustInboundTraceContext: true` on createWorker() (or `"mtls"` to trust only edge-verified client certificates). Set it to `false` to keep this behaviour and silence this message.'
+    );
+  };
+};
+
 const VECTOR_INDEXES_PATH = "/_lunora/admin/vector/indexes";
 const VECTOR_QUERY_PATH = "/_lunora/admin/vector/query";
 const buildVectorAdminRoutes = (deps) => {
@@ -2078,6 +2200,39 @@ const NDJSON_ENCODER = new TextEncoder();
 const RPC_PATH = "/_lunora/rpc";
 const RPC_BATCH_PATH = "/_lunora/rpc-batch";
 const WS_PATH = "/_lunora/ws";
+const buildSinkContext = (environment, request, waitUntil) => {
+  return {
+    resourceAttributes: createResourceAttributeResolver(environment, request),
+    ...waitUntil === void 0 ? {} : { waitUntil }
+  };
+};
+const traceEventFields = (trace) => {
+  return {
+    spanId: trace.spanId,
+    traceFlags: trace.traceFlags,
+    traceId: trace.traceId,
+    ...trace.parentSpanId === void 0 ? {} : { parentSpanId: trace.parentSpanId }
+  };
+};
+const requestTelemetryMeta = (request) => {
+  const { method } = request;
+  const userAgent = request.headers.get("user-agent") ?? void 0;
+  let url;
+  try {
+    url = new URL(request.url);
+  } catch {
+    return { method, userAgent };
+  }
+  const port = url.port === "" ? void 0 : Number(url.port);
+  return {
+    host: url.hostname,
+    method,
+    path: url.pathname,
+    port: Number.isNaN(port) ? void 0 : port,
+    scheme: url.protocol.replace(":", ""),
+    userAgent
+  };
+};
 const VOICE_PATH_PREFIX = "/_lunora/voice/";
 const SCHEDULER_DISPATCH_PATH = "/_lunora/scheduler/dispatch";
 const CRON_JOBS_RUN_PATH = "/_lunora/admin/cron-jobs/run";
@@ -2388,6 +2543,8 @@ const detectBindingProbe = (key, value) => {
   return void 0;
 };
 const createWorker = (options) => {
+  const isTrustedUpstream = resolveTraceTrust(options.trustInboundTraceContext);
+  const noticeDroppedTrace = createDroppedTraceNotice(options.trustInboundTraceContext);
   const defaultShard = options.defaultShardKey ?? "__root__";
   const publicResolveIdentity = wrapResolverWithContract(options.resolveIdentity, options.identity);
   const shardDO = applyJurisdiction(options.shardDO, options.jurisdiction);
@@ -2944,19 +3101,25 @@ const createWorker = (options) => {
       guardUnauthenticatedShardAccess("shard");
     }
   };
-  const dispatchSingleShard = async (functionPath, args, shardKey, forwardedHeaders, sinkContext) => {
+  const dispatchSingleShard = async (request, functionPath, args, shardKey, forwardedHeaders, sinkContext) => {
     const rpcStartedAt = Date.now();
     const { observability, sampling } = options;
-    const traceId = otlpRandomHex(16);
-    const spanId = otlpRandomHex(8);
-    const decision = resolveTraceSampling(sampling, traceId);
+    const requestMeta = requestTelemetryMeta(request);
+    const { decision, ignoredUpstream, trace } = beginDispatchTrace(request, {
+      ...sampling === void 0 ? {} : { sampling },
+      trustInbound: isTrustedUpstream(request)
+    });
+    if (ignoredUpstream) {
+      noticeDroppedTrace();
+    }
+    const outgoingHeaders = {
+      ...forwardedHeaders,
+      "x-lunora-sample-errors": decision.keepErrors ? "1" : "0"
+    };
+    injectTraceContext(trace, outgoingHeaders);
     const forwarded = new Request(`https://shard.internal/rpc`, {
       body: JSON.stringify({ args, functionPath }),
-      headers: {
-        ...forwardedHeaders,
-        traceparent: buildTraceparent(traceId, spanId, decision.isTraced),
-        "x-lunora-sample-errors": decision.keepErrors ? "1" : "0"
-      },
+      headers: outgoingHeaders,
       method: "POST"
     });
     try {
@@ -2964,12 +3127,12 @@ const createWorker = (options) => {
       emitRpcEvent(
         observability,
         {
+          ...requestMeta,
+          ...traceEventFields(trace),
           durationMs: Date.now() - rpcStartedAt,
           functionPath,
           ok: response.ok,
           shardKey,
-          spanId,
-          traceId,
           ...response.ok ? {} : { error: { code: "SHARD_ERROR", message: `shard returned ${String(response.status)}`, status: response.status } }
         },
         sinkContext,
@@ -2979,7 +3142,11 @@ const createWorker = (options) => {
     } catch (error) {
       emitRpcEvent(
         observability,
-        { ...buildErrorEvent(functionPath, Date.now() - rpcStartedAt, error, { shardKey }), spanId, traceId },
+        {
+          ...requestMeta,
+          ...traceEventFields(trace),
+          ...buildErrorEvent(functionPath, Date.now() - rpcStartedAt, error, { shardKey })
+        },
         sinkContext,
         sampling
       );
@@ -3020,11 +3187,8 @@ const createWorker = (options) => {
     {
       const rpcStartedAt = Date.now();
       const { observability } = options;
-      const sinkContext = context ? {
-        waitUntil: (promise) => {
-          context.waitUntil?.(promise);
-        }
-      } : void 0;
+      const requestMeta = requestTelemetryMeta(request);
+      const sinkContext = buildSinkContext(env, request, context && ((promise) => context.waitUntil?.(promise)));
       if (envelope.fanOut) {
         const coordinator = options.queryCoordinator;
         if (!coordinator) {
@@ -3050,6 +3214,7 @@ const createWorker = (options) => {
                 table: envelope.fanOut.table
               },
               functionPath: envelope.functionPath,
+              ...requestMeta,
               ok: true
             },
             sinkContext
@@ -3061,14 +3226,17 @@ const createWorker = (options) => {
         } catch (error) {
           emitRpcEvent(
             observability,
-            buildErrorEvent(envelope.functionPath, Date.now() - rpcStartedAt, error, { fanOut: { table: envelope.fanOut.table } }),
+            {
+              ...buildErrorEvent(envelope.functionPath, Date.now() - rpcStartedAt, error, { fanOut: { table: envelope.fanOut.table } }),
+              ...requestMeta
+            },
             sinkContext
           );
           throw error;
         }
       }
       const shardKey = envelope.shardKey ?? defaultShard;
-      const dispatch = () => dispatchSingleShard(envelope.functionPath, envelope.args ?? {}, shardKey, forwardedHeaders, sinkContext);
+      const dispatch = () => dispatchSingleShard(request, envelope.functionPath, envelope.args ?? {}, shardKey, forwardedHeaders, sinkContext);
       if (x402Tag && options.x402Charge) {
         return options.x402Charge(request, { functionPath: envelope.functionPath, price: x402Tag.price }, dispatch);
       }
@@ -3114,11 +3282,8 @@ const createWorker = (options) => {
       )
     );
     const { observability } = options;
-    const sinkContext = context ? {
-      waitUntil: (promise) => {
-        context.waitUntil?.(promise);
-      }
-    } : void 0;
+    const sinkContext = buildSinkContext(env, request, context && ((promise) => context.waitUntil?.(promise)));
+    const requestMeta = requestTelemetryMeta(request);
     const results = [];
     const bookmarks = [];
     const slotError = (entry, status, code, message) => {
@@ -3139,6 +3304,7 @@ const createWorker = (options) => {
           {
             durationMs,
             functionPath: entry.functionPath,
+            ...requestMeta,
             ok,
             shardKey,
             ...ok ? {} : { error: { code: "SHARD_ERROR", message: `batched call returned ${String(status)}`, status } }
@@ -3159,13 +3325,12 @@ const createWorker = (options) => {
         } catch (error) {
           const durationMs2 = Date.now() - subStartedAt;
           const { body: errorBody } = toErrorBody(error, { fallbackCode: "SHARD_UNAVAILABLE", redactedMessage: "shard unavailable" });
-          failSubBatch(
-            entries,
-            502,
-            errorBody.code,
-            errorBody.message,
-            (entry) => buildErrorEvent(entry.functionPath, durationMs2, error, { shardKey })
-          );
+          failSubBatch(entries, 502, errorBody.code, errorBody.message, (entry) => {
+            return {
+              ...buildErrorEvent(entry.functionPath, durationMs2, error, { shardKey }),
+              ...requestMeta
+            };
+          });
           return;
         }
         const durationMs = Date.now() - subStartedAt;
@@ -3183,6 +3348,7 @@ const createWorker = (options) => {
               durationMs,
               error: { code: "SHARD_ERROR", message, status: response.status },
               functionPath: entry.functionPath,
+              ...requestMeta,
               ok: false,
               shardKey
             };
@@ -3217,7 +3383,8 @@ const createWorker = (options) => {
       const { headers: forwardedHeaders, identity } = await resolveForwardContext(request, env, publicResolveIdentity);
       await authorizeRpcEnvelope({ functionPath, shardKey: callOptions.shardKey }, identity);
       const shardKey = callOptions.shardKey ?? defaultShard;
-      return await dispatchSingleShard(functionPath, args, shardKey, forwardedHeaders);
+      const serverSinkContext = buildSinkContext(env, request, callOptions.waitUntil);
+      return await dispatchSingleShard(request, functionPath, args, shardKey, forwardedHeaders, serverSinkContext);
     } catch (error) {
       return toErrorResponse(error);
     }
@@ -3358,12 +3525,13 @@ const createWorker = (options) => {
     }
     return authResponse;
   };
-  const invokeExposed = async ({ args, env, functionPath, request, shardKey }) => {
+  const invokeExposed = async ({ args, env, functionPath, request, shardKey, waitUntil }) => {
     const envelope = { functionPath, ...shardKey === void 0 ? {} : { shardKey } };
     const { headers: forwardedHeaders, identity } = await resolveForwardContext(request, env, publicResolveIdentity);
     await authorizeRpcEnvelope(envelope, identity);
     const resolvedShardKey = shardKey ?? defaultShard;
-    const dispatch = () => dispatchSingleShard(functionPath, args, resolvedShardKey, forwardedHeaders);
+    const restSinkContext = buildSinkContext(env, request, waitUntil);
+    const dispatch = () => dispatchSingleShard(request, functionPath, args, resolvedShardKey, forwardedHeaders, restSinkContext);
     const x402Tag = resolveX402Charge(envelope, options);
     if (x402Tag && options.x402Charge) {
       return options.x402Charge(request, { functionPath, price: x402Tag.price }, dispatch);