rivetkit 2.3.18-rc.4 → 2.3.19

package/dist/browser/client.js

@@ -9,6 +9,7 @@ import { z as z2 } from "zod/v4";
 var INTERNAL_ERROR_CODE = "internal_error";
 var INTERNAL_ERROR_DESCRIPTION = "An internal error occurred";
 var USER_ERROR_CODE = "user_error";
+var BRIDGE_RIVET_ERROR_PREFIX = "__RIVET_ERROR_JSON__:";
 function looksLikeRivetErrorOptions(value) {
   return typeof value === "object" && value !== null && ("public" in value || "metadata" in value || "rayId" in value || "statusCode" in value || "actor" in value || "cause" in value);
 }
@@ -64,6 +65,27 @@ var UserError = class extends RivetError {
     });
   }
 };
+function encodeBridgeRivetError(error) {
+  return `${BRIDGE_RIVET_ERROR_PREFIX}${JSON.stringify({
+    group: error.group,
+    code: error.code,
+    message: error.message,
+    metadata: error.metadata,
+    rayId: error.rayId,
+    public: error.public,
+    statusCode: error.statusCode,
+    actor: error.actor
+  })}`;
+}
+function encodeErrorForBridge(error) {
+  if (isCanonicalStructuredRivetError(error)) {
+    return encodeBridgeRivetError(error);
+  }
+  return String(error);
+}
+function isCanonicalStructuredRivetError(error) {
+  return error instanceof RivetError || typeof error === "object" && error !== null && "__type" in error && error.__type === "RivetError" && "group" in error && typeof error.group === "string" && "code" in error && typeof error.code === "string" && "message" in error && typeof error.message === "string";
+}
 function invalidRequest(error) {
   return new RivetError(
     "request",
@@ -88,9 +110,6 @@ function actorNotFound(identifier) {
 function assertUnreachable(x) {
   throw new Error(`Unreachable case: ${x}`);
 }
-function isCanonicalStructuredRivetError(error) {
-  return error instanceof RivetError || typeof error === "object" && error !== null && "__type" in error && error.__type === "RivetError" && "group" in error && typeof error.group === "string" && "code" in error && typeof error.code === "string" && "message" in error && typeof error.message === "string";
-}
 function deconstructError(error, exposeInternalError = false) {
   let statusCode;
   let public_;
@@ -201,7 +220,7 @@ function noopNext() {
 // package.json
 var package_default = {
   name: "rivetkit",
-  version: "2.3.18-rc.4",
+  version: "2.3.19",
   description: "Lightweight libraries for building stateful actors on edge platforms",
   license: "Apache-2.0",
   keywords: [
@@ -410,6 +429,7 @@ var package_default = {
   },
   dependencies: {
     "@hono/zod-openapi": "^1.1.5",
+    "@opentelemetry/api": "^1.1.0",
     "@rivet-dev/agent-os-core": "^0.1.1",
     "@rivet-dev/services": "^0.1.5",
     "@rivetkit/bare-ts": "^0.6.2",
@@ -436,6 +456,7 @@ var package_default = {
     "@copilotkit/llmock": "^1.6.0",
     "@hono/node-server": "^1.18.2",
     "@hono/node-ws": "^1.1.1",
+    "@opentelemetry/sdk-trace-node": "2.11.0",
     "@rivet-dev/agent-os-common": "*",
     "@rivet-dev/agent-os-pi": "^0.1.1",
     "@standard-schema/spec": "^1.0.0",
@@ -1132,6 +1153,9 @@ var HEADER_ENCODING = "x-rivet-encoding";
 var HEADER_CONN_PARAMS = "x-rivet-conn-params";
 var HEADER_ORIGINAL_REQUEST_URL = "x-rivet-internal-original-request-url";
 var HEADER_RIVET_TOKEN = "x-rivet-token";
+var HEADER_RIVET_RAY_ID = "x-rivet-ray-id";
+var HEADER_TRACEPARENT = "traceparent";
+var HEADER_TRACESTATE = "tracestate";
 var HEADER_RIVET_TARGET = "x-rivet-target";
 var HEADER_RIVET_ACTOR = "x-rivet-actor";
 var HEADER_RIVET_SKIP_READY_WAIT = "x-rivet-skip-ready-wait";
@@ -1179,6 +1203,17 @@ function buildGuardHeaders(runConfig, actorRequest, options) {
   for (const [key, value] of Object.entries(runConfig.headers)) {
     headers.set(key, value);
   }
+  for (const name of [HEADER_TRACEPARENT, HEADER_TRACESTATE]) {
+    headers.delete(name);
+    const value = actorRequest.headers.get(name);
+    if (value !== null) {
+      headers.set(name, value);
+    }
+  }
+  const requestRayId = actorRequest.headers.get(HEADER_RIVET_RAY_ID);
+  if (requestRayId !== null) {
+    headers.set(HEADER_RIVET_RAY_ID, requestRayId);
+  }
   if (runConfig.token) {
     headers.set(HEADER_RIVET_TOKEN, runConfig.token);
   }
@@ -4742,6 +4777,81 @@ async function retryOnLifecycleBoundary(run, opts) {
   throw lastError;
 }
 
+// src/common/otel-context.ts
+import {
+  context,
+  createTraceState,
+  isSpanContextValid,
+  propagation,
+  trace
+} from "@opentelemetry/api";
+function readActiveTraceHeaders() {
+  return traceHeaders(trace.getSpanContext(context.active()));
+}
+var RAY_BAGGAGE_KEY = "rivet.ray.id";
+function readActiveRayId() {
+  const value = propagation.getBaggage(context.active())?.getEntry(RAY_BAGGAGE_KEY)?.value;
+  if (value && value.length <= 30 && /^[A-Za-z0-9_-]+$/.test(value)) {
+    return value;
+  }
+  return void 0;
+}
+function actorInvocationTraceHeaders(invocation) {
+  const spanContext = invocationSpanContext(invocation);
+  if (!spanContext) return void 0;
+  return traceHeaders(spanContext);
+}
+function traceHeaders(spanContext) {
+  if (!spanContext || !isSpanContextValid(spanContext)) return void 0;
+  const tracestate = spanContext.traceState?.serialize();
+  return {
+    traceparent: `00-${spanContext.traceId}-${spanContext.spanId}-${spanContext.traceFlags.toString(16).padStart(2, "0")}`,
+    ...tracestate ? { tracestate } : {}
+  };
+}
+function invocationSpanContext(invocation) {
+  if (!invocation) return void 0;
+  try {
+    const spanContext = {
+      traceId: invocation.traceId,
+      spanId: invocation.spanId,
+      traceFlags: invocation.traceFlags,
+      traceState: invocation.tracestate ? createTraceState(invocation.tracestate) : void 0,
+      isRemote: false
+    };
+    return isSpanContextValid(spanContext) ? spanContext : void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/client/outbound-telemetry.ts
+function outboundTelemetryHeaders(invocation, callSpan) {
+  const headers = {};
+  const rayId = invocation?.rayId ?? readActiveRayId();
+  if (rayId) {
+    headers[HEADER_RIVET_RAY_ID] = rayId;
+  }
+  const traceHeaders2 = actorInvocationTraceHeaders(callSpan) ?? readActiveTraceHeaders() ?? actorInvocationTraceHeaders(invocation?.span);
+  if (traceHeaders2) {
+    headers[HEADER_TRACEPARENT] = traceHeaders2.traceparent;
+    if (traceHeaders2.tracestate) {
+      headers[HEADER_TRACESTATE] = traceHeaders2.tracestate;
+    }
+  }
+  return headers;
+}
+function addOutboundTelemetryHeaders(headers, telemetry) {
+  const callerSetTraceContext = headers.has(HEADER_TRACEPARENT) || headers.has(HEADER_TRACESTATE);
+  for (const [name, value] of Object.entries(telemetry)) {
+    const isTraceContext = name === HEADER_TRACEPARENT || name === HEADER_TRACESTATE;
+    if (isTraceContext ? callerSetTraceContext : headers.has(name)) {
+      continue;
+    }
+    headers.set(name, value);
+  }
+}
+
 // src/client/queue.ts
 function createQueueSender(senderOptions) {
   async function send(name, body, options) {
@@ -4752,6 +4862,7 @@ function createQueueSender(senderOptions) {
       method: "POST",
       headers: {
         [HEADER_ENCODING]: senderOptions.encoding,
+        ...senderOptions.telemetryHeaders(),
         ...senderOptions.params !== void 0 ? {
           [HEADER_CONN_PARAMS]: JSON.stringify(
             senderOptions.params
@@ -4840,6 +4951,7 @@ var ActorConnRaw = class {
   #websocket;
   #client;
   #driver;
+  #currentActorInvocation;
   #params;
   #getParams;
   #encoding;
@@ -4853,8 +4965,9 @@ var ActorConnRaw = class {
    *
    * @protected
    */
-  constructor(client, driver, params, getParams, encoding, actorResolutionState, gatewayOptions = {}) {
+  constructor(client, driver, params, getParams, encoding, actorResolutionState, gatewayOptions = {}, currentActorInvocation) {
     this.#client = client;
+    this.#currentActorInvocation = currentActorInvocation;
     this.#driver = driver;
     this.#params = params;
     this.#getParams = getParams;
@@ -4873,6 +4986,7 @@ var ActorConnRaw = class {
     this.#queueSender = createQueueSender({
       encoding: this.#encoding,
       params: this.#params,
+      telemetryHeaders: () => outboundTelemetryHeaders(this.#currentActorInvocation?.()),
       customFetch: async (request) => {
         return await this.#driver.sendRequest(
           getGatewayTarget(this.#actorResolutionState),
@@ -5930,7 +6044,7 @@ async function prepareRetryableInit(init) {
   }
   return init;
 }
-async function rawHttpFetch(driver, target, params, input, init, options = {}) {
+async function rawHttpFetch(driver, target, params, input, init, options = {}, telemetryHeaders = {}) {
   let path;
   let originalUrl;
   let mergedInit = init || {};
@@ -5991,6 +6105,7 @@ async function rawHttpFetch(driver, target, params, input, init, options = {}) {
     if (params) {
       proxyRequestHeaders.set(HEADER_CONN_PARAMS, JSON.stringify(params));
     }
+    addOutboundTelemetryHeaders(proxyRequestHeaders, telemetryHeaders);
     const proxyRequest = new Request(url, {
       ...mergedInit,
       headers: proxyRequestHeaders
@@ -6090,6 +6205,8 @@ var ActorHandleRaw = class {
   #resolvedActorId;
   #resolvingActorId;
   #queueSendMutex = new AsyncMutex();
+  #currentActorInvocation;
+  #startCallSpan;
   /**
    * Do not call this directly.
    *
@@ -6097,7 +6214,7 @@ var ActorHandleRaw = class {
    *
    * @protected
    */
-  constructor(client, driver, params, getParams, encoding, actorResolutionState, gatewayOptions = {}, signal) {
+  constructor(client, driver, params, getParams, encoding, actorResolutionState, gatewayOptions = {}, signal, currentActorInvocation, startCallSpan) {
     this.#client = client;
     this.#driver = driver;
     this.#encoding = encoding;
@@ -6106,6 +6223,8 @@ var ActorHandleRaw = class {
     this.#params = params;
     this.#getParams = getParams;
     this.#signal = signal;
+    this.#currentActorInvocation = currentActorInvocation;
+    this.#startCallSpan = startCallSpan;
   }
   async #resolveConnectionParams() {
     if (this.#getParams) {
@@ -6136,6 +6255,9 @@ var ActorHandleRaw = class {
           return await createQueueSender({
             encoding: this.#encoding,
             params: this.#params,
+            telemetryHeaders: () => outboundTelemetryHeaders(
+              this.#currentActorInvocation?.()
+            ),
             customFetch: async (request) => {
               return await this.#driver.sendRequest(
                 target,
@@ -6216,13 +6338,33 @@ var ActorHandleRaw = class {
     }
     const signal = opts.signal ?? this.#signal;
     const optsWithSignal = { ...opts, signal };
-    const run = async () => await this.#sendActionNow(optsWithSignal);
-    if (opts.name === "destroy") {
-      return await run();
+    const call = this.#startCallSpan?.(
+      getActorNameFromQuery(this.#actorResolutionState),
+      opts.name
+    );
+    const run = async () => await this.#sendActionAttempts(
+      optsWithSignal,
+      call?.span
+    );
+    const send = async () => {
+      if (opts.name === "destroy") {
+        return await run();
+      }
+      return await retryOnLifecycleBoundary(run, { signal });
+    };
+    if (!call) {
+      return await send();
+    }
+    try {
+      const output = await send();
+      call.finish();
+      return output;
+    } catch (error) {
+      call.finish(encodeErrorForBridge(error));
+      throw error;
     }
-    return await retryOnLifecycleBoundary(run, { signal });
   }
-  async #sendActionNow(opts) {
+  async #sendActionAttempts(opts, callSpan) {
     const maxAttempts = this.#getDynamicQueryMaxAttempts();
     let useQueryTarget = isDynamicActorQuery(this.#actorResolutionState);
     const gatewayOptions = resolveActorGatewayOptions(
@@ -6248,17 +6390,20 @@ var ActorHandleRaw = class {
           name: opts.name,
           encoding: this.#encoding
         });
+        const headers = {
+          [HEADER_ENCODING]: this.#encoding,
+          ...outboundTelemetryHeaders(
+            this.#currentActorInvocation?.(),
+            callSpan
+          )
+        };
+        if (this.#params !== void 0) {
+          headers[HEADER_CONN_PARAMS] = JSON.stringify(this.#params);
+        }
         const output = await sendHttpRequest({
           url: `http://actor/action/${encodeURIComponent(opts.name)}`,
           method: "POST",
-          headers: {
-            [HEADER_ENCODING]: this.#encoding,
-            ...this.#params !== void 0 ? {
-              [HEADER_CONN_PARAMS]: JSON.stringify(
-                this.#params
-              )
-            } : {}
-          },
+          headers,
           body: opts.args,
           encoding: this.#encoding,
           customFetch: async (request) => await this.#driver.sendRequest(
@@ -6458,7 +6603,8 @@ var ActorHandleRaw = class {
       getParams,
       this.#encoding,
       this.#actorResolutionState,
-      resolveActorGatewayOptions(this.#gatewayOptions, options)
+      resolveActorGatewayOptions(this.#gatewayOptions, options),
+      this.#currentActorInvocation
     );
     return this.#client[CREATE_ACTOR_CONN_PROXY](
       conn
@@ -6483,6 +6629,9 @@ var ActorHandleRaw = class {
         skipReadyWait
       }
     );
+    const telemetryHeaders = outboundTelemetryHeaders(
+      this.#currentActorInvocation?.()
+    );
     for (let attempt = 0; attempt < maxAttempts; attempt++) {
       let actorId;
       try {
@@ -6499,7 +6648,8 @@ var ActorHandleRaw = class {
           // NOTE: This holds the body in memory until GC (unavoidable).
           clonesInputBody ? input.clone() : input,
           requestInit,
-          gatewayOptions
+          gatewayOptions,
+          telemetryHeaders
         );
         const retry = await this.#shouldRetryRawFetchResponse(
           response,
@@ -6720,13 +6870,17 @@ var ClientRaw = class {
   #driver;
   #encodingKind;
   #gatewayOptions;
+  #currentActorInvocation;
+  #startCallSpan;
   /**
    * Creates an instance of Client.
    */
-  constructor(driver, encoding, gatewayOptions = {}) {
+  constructor(driver, options = {}) {
     this.#driver = driver;
-    this.#encodingKind = encoding ?? "bare";
-    this.#gatewayOptions = gatewayOptions;
+    this.#encodingKind = options.encoding ?? "bare";
+    this.#gatewayOptions = options.gateway ?? {};
+    this.#currentActorInvocation = options.currentActorInvocation;
+    this.#startCallSpan = options.startCallSpan;
   }
   /**
    * Gets a stateless handle to a actor by its ID.
@@ -6882,7 +7036,9 @@ var ClientRaw = class {
       this.#encodingKind,
       actorQuery,
       this.#gatewayOptions,
-      signal
+      signal,
+      this.#currentActorInvocation,
+      this.#startCallSpan
     );
   }
   [CREATE_ACTOR_CONN_PROXY](conn) {
@@ -6909,8 +7065,8 @@ var ClientRaw = class {
     await Promise.all(disposePromises);
   }
 };
-function createClientWithDriver(driver, config = {}) {
-  const client = new ClientRaw(driver, config.encoding, config.gateway);
+function createClientWithDriver(driver, options = {}) {
+  const client = new ClientRaw(driver, options);
   return new Proxy(client, {
     get: (target, prop, receiver) => {
       if (typeof prop === "symbol" || prop in target) {