@replit/river 0.19.2 → 0.20.0

package/dist/router/index.cjs

@@ -322,6 +322,9 @@ var Procedure = {
   stream
 };
 
+// router/client.ts
+var import_api2 = require("@opentelemetry/api");
+
 // node_modules/p-defer/index.js
 function pDefer() {
   const deferred = {};
@@ -617,6 +620,12 @@ var TransportMessageSchema = (t) => import_typebox3.Type.Object({
   procedureName: import_typebox3.Type.Optional(import_typebox3.Type.String()),
   streamId: import_typebox3.Type.String(),
   controlFlags: import_typebox3.Type.Integer(),
+  tracing: import_typebox3.Type.Optional(
+    import_typebox3.Type.Object({
+      traceparent: import_typebox3.Type.String(),
+      tracestate: import_typebox3.Type.String()
+    })
+  ),
   payload: t
 });
 var ControlMessageAckSchema = import_typebox3.Type.Object({
@@ -696,6 +705,11 @@ function Err(error) {
 // logging/log.ts
 var log = void 0;
 
+// tracing/index.ts
+var import_api = require("@opentelemetry/api");
+var tracer = import_api.trace.getTracer("river");
+var tracing_default = tracer;
+
 // router/client.ts
 var noop = () => {
 };
@@ -767,220 +781,318 @@ function createSessionDisconnectHandler(from, cb) {
 }
 function handleRpc(transport, serverId, input, serviceName, procedureName) {
   const streamId = (0, import_nanoid2.nanoid)();
-  transport.send(serverId, {
-    streamId,
-    serviceName,
-    procedureName,
-    payload: input,
-    controlFlags: 2 /* StreamOpenBit */ | 4 /* StreamClosedBit */
-  });
-  const responsePromise = new Promise((resolve) => {
-    const onSessionStatus = createSessionDisconnectHandler(serverId, () => {
-      cleanup();
-      resolve(
-        Err({
-          code: UNEXPECTED_DISCONNECT,
-          message: `${serverId} unexpectedly disconnected`
-        })
-      );
-    });
-    function cleanup() {
-      transport.removeEventListener("message", onMessage);
-      transport.removeEventListener("sessionStatus", onSessionStatus);
-    }
-    function onMessage(msg) {
-      if (msg.streamId !== streamId)
-        return;
-      if (msg.to !== transport.clientId)
-        return;
-      cleanup();
-      resolve(msg.payload);
+  return tracing_default.startActiveSpan(
+    `${serviceName}.${procedureName}`,
+    {
+      attributes: {
+        component: "river",
+        "river.method.kind": "rpc",
+        "river.method.service": serviceName,
+        "river.method.name": procedureName,
+        "river.streamId": streamId,
+        "span.kind": "client"
+      },
+      kind: import_api2.SpanKind.CLIENT
+    },
+    (span) => {
+      const tracing = { traceparent: "", tracestate: "" };
+      import_api2.propagation.inject(import_api2.context.active(), tracing);
+      transport.send(serverId, {
+        streamId,
+        serviceName,
+        procedureName,
+        tracing,
+        payload: input,
+        controlFlags: 2 /* StreamOpenBit */ | 4 /* StreamClosedBit */
+      });
+      const responsePromise = new Promise((resolve) => {
+        const onSessionStatus = createSessionDisconnectHandler(serverId, () => {
+          span.setStatus({ code: import_api2.SpanStatusCode.ERROR });
+          cleanup();
+          resolve(
+            Err({
+              code: UNEXPECTED_DISCONNECT,
+              message: `${serverId} unexpectedly disconnected`
+            })
+          );
+        });
+        function cleanup() {
+          transport.removeEventListener("message", onMessage);
+          transport.removeEventListener("sessionStatus", onSessionStatus);
+          span.end();
+        }
+        function onMessage(msg) {
+          if (msg.streamId !== streamId)
+            return;
+          if (msg.to !== transport.clientId)
+            return;
+          if (msg.payload && typeof msg.payload === "object" && "ok" in msg.payload) {
+            span.setStatus({
+              code: msg.payload.ok ? import_api2.SpanStatusCode.OK : import_api2.SpanStatusCode.ERROR
+            });
+          }
+          cleanup();
+          resolve(msg.payload);
+        }
+        transport.addEventListener("message", onMessage);
+        transport.addEventListener("sessionStatus", onSessionStatus);
+      });
+      return responsePromise;
     }
-    transport.addEventListener("message", onMessage);
-    transport.addEventListener("sessionStatus", onSessionStatus);
-  });
-  return responsePromise;
+  );
 }
 function handleStream(transport, serverId, init, serviceName, procedureName) {
   const streamId = (0, import_nanoid2.nanoid)();
-  const inputStream = pushable({ objectMode: true });
-  const outputStream = pushable({ objectMode: true });
-  let firstMessage = true;
-  let healthyClose = true;
-  if (init) {
-    transport.send(serverId, {
-      streamId,
-      serviceName,
-      procedureName,
-      payload: init,
-      controlFlags: 2 /* StreamOpenBit */
-    });
-    firstMessage = false;
-  }
-  const pipeInputToTransport = async () => {
-    for await (const rawIn of inputStream) {
-      const m = {
-        streamId,
-        payload: rawIn,
-        controlFlags: 0
-      };
-      if (firstMessage) {
-        m.serviceName = serviceName;
-        m.procedureName = procedureName;
-        m.controlFlags |= 2 /* StreamOpenBit */;
+  return tracing_default.startActiveSpan(
+    `${serviceName}.${procedureName}`,
+    {
+      attributes: {
+        component: "river",
+        "river.method.kind": init ? "stream-with-init" : "stream",
+        "river.method.service": serviceName,
+        "river.method.name": procedureName,
+        "river.streamId": streamId,
+        "span.kind": "client"
+      },
+      kind: import_api2.SpanKind.CLIENT
+    },
+    (span) => {
+      const tracing = { traceparent: "", tracestate: "" };
+      import_api2.propagation.inject(import_api2.context.active(), tracing);
+      const inputStream = pushable({ objectMode: true });
+      const outputStream = pushable({ objectMode: true });
+      let firstMessage = true;
+      let healthyClose = true;
+      if (init) {
+        transport.send(serverId, {
+          streamId,
+          serviceName,
+          procedureName,
+          tracing,
+          payload: init,
+          controlFlags: 2 /* StreamOpenBit */
+        });
         firstMessage = false;
       }
-      transport.send(serverId, m);
-    }
-    if (!healthyClose)
-      return;
-    transport.sendCloseStream(serverId, streamId);
-  };
-  void pipeInputToTransport();
-  function onMessage(msg) {
-    if (msg.streamId !== streamId)
-      return;
-    if (msg.to !== transport.clientId)
-      return;
-    if (isStreamClose(msg.controlFlags)) {
-      cleanup();
-    } else {
-      outputStream.push(msg.payload);
+      const pipeInputToTransport = async () => {
+        for await (const rawIn of inputStream) {
+          const m = {
+            streamId,
+            payload: rawIn,
+            controlFlags: 0
+          };
+          if (firstMessage) {
+            m.serviceName = serviceName;
+            m.procedureName = procedureName;
+            m.tracing = tracing;
+            m.controlFlags |= 2 /* StreamOpenBit */;
+            firstMessage = false;
+          }
+          transport.send(serverId, m);
+        }
+        if (!healthyClose)
+          return;
+        transport.sendCloseStream(serverId, streamId);
+        span.setStatus({ code: import_api2.SpanStatusCode.OK });
+      };
+      void pipeInputToTransport();
+      function onMessage(msg) {
+        if (msg.streamId !== streamId)
+          return;
+        if (msg.to !== transport.clientId)
+          return;
+        if (isStreamClose(msg.controlFlags)) {
+          cleanup();
+        } else {
+          outputStream.push(msg.payload);
+        }
+      }
+      function cleanup() {
+        inputStream.end();
+        outputStream.end();
+        transport.removeEventListener("message", onMessage);
+        transport.removeEventListener("sessionStatus", onSessionStatus);
+        span.end();
+      }
+      const onSessionStatus = createSessionDisconnectHandler(serverId, () => {
+        outputStream.push(
+          Err({
+            code: UNEXPECTED_DISCONNECT,
+            message: `${serverId} unexpectedly disconnected`
+          })
+        );
+        healthyClose = false;
+        span.setStatus({ code: import_api2.SpanStatusCode.ERROR });
+        cleanup();
+      });
+      transport.addEventListener("message", onMessage);
+      transport.addEventListener("sessionStatus", onSessionStatus);
+      return [inputStream, outputStream, cleanup];
     }
-  }
-  function cleanup() {
-    inputStream.end();
-    outputStream.end();
-    transport.removeEventListener("message", onMessage);
-    transport.removeEventListener("sessionStatus", onSessionStatus);
-  }
-  const onSessionStatus = createSessionDisconnectHandler(serverId, () => {
-    outputStream.push(
-      Err({
-        code: UNEXPECTED_DISCONNECT,
-        message: `${serverId} unexpectedly disconnected`
-      })
-    );
-    healthyClose = false;
-    cleanup();
-  });
-  transport.addEventListener("message", onMessage);
-  transport.addEventListener("sessionStatus", onSessionStatus);
-  return [inputStream, outputStream, cleanup];
+  );
 }
 function handleSubscribe(transport, serverId, input, serviceName, procedureName) {
   const streamId = (0, import_nanoid2.nanoid)();
-  transport.send(serverId, {
-    streamId,
-    serviceName,
-    procedureName,
-    payload: input,
-    controlFlags: 2 /* StreamOpenBit */
-  });
-  let healthyClose = true;
-  const outputStream = pushable({ objectMode: true });
-  function onMessage(msg) {
-    if (msg.streamId !== streamId)
-      return;
-    if (msg.to !== transport.clientId)
-      return;
-    if (isStreamClose(msg.controlFlags)) {
-      cleanup();
-    } else {
-      outputStream.push(msg.payload);
+  return tracing_default.startActiveSpan(
+    `${serviceName}.${procedureName}`,
+    {
+      attributes: {
+        component: "river",
+        "river.method.kind": "subscribe",
+        "river.method.service": serviceName,
+        "river.method.name": procedureName,
+        "river.streamId": streamId,
+        "span.kind": "client"
+      },
+      kind: import_api2.SpanKind.CLIENT
+    },
+    (span) => {
+      const tracing = { traceparent: "", tracestate: "" };
+      import_api2.propagation.inject(import_api2.context.active(), tracing);
+      transport.send(serverId, {
+        streamId,
+        serviceName,
+        procedureName,
+        tracing,
+        payload: input,
+        controlFlags: 2 /* StreamOpenBit */
+      });
+      let healthyClose = true;
+      const outputStream = pushable({ objectMode: true });
+      function onMessage(msg) {
+        if (msg.streamId !== streamId)
+          return;
+        if (msg.to !== transport.clientId)
+          return;
+        if (isStreamClose(msg.controlFlags)) {
+          cleanup();
+        } else {
+          outputStream.push(msg.payload);
+        }
+      }
+      function cleanup() {
+        outputStream.end();
+        transport.removeEventListener("message", onMessage);
+        transport.removeEventListener("sessionStatus", onSessionStatus);
+        span.end();
+      }
+      const closeHandler = () => {
+        cleanup();
+        if (!healthyClose)
+          return;
+        transport.sendCloseStream(serverId, streamId);
+      };
+      const onSessionStatus = createSessionDisconnectHandler(serverId, () => {
+        outputStream.push(
+          Err({
+            code: UNEXPECTED_DISCONNECT,
+            message: `${serverId} unexpectedly disconnected`
+          })
+        );
+        healthyClose = false;
+        span.setStatus({ code: import_api2.SpanStatusCode.ERROR });
+        cleanup();
+      });
+      transport.addEventListener("message", onMessage);
+      transport.addEventListener("sessionStatus", onSessionStatus);
+      return [outputStream, closeHandler];
     }
-  }
-  function cleanup() {
-    outputStream.end();
-    transport.removeEventListener("message", onMessage);
-    transport.removeEventListener("sessionStatus", onSessionStatus);
-  }
-  const closeHandler = () => {
-    cleanup();
-    if (!healthyClose)
-      return;
-    transport.sendCloseStream(serverId, streamId);
-  };
-  const onSessionStatus = createSessionDisconnectHandler(serverId, () => {
-    outputStream.push(
-      Err({
-        code: UNEXPECTED_DISCONNECT,
-        message: `${serverId} unexpectedly disconnected`
-      })
-    );
-    healthyClose = false;
-    cleanup();
-  });
-  transport.addEventListener("message", onMessage);
-  transport.addEventListener("sessionStatus", onSessionStatus);
-  return [outputStream, closeHandler];
+  );
 }
 function handleUpload(transport, serverId, init, serviceName, procedureName) {
   const streamId = (0, import_nanoid2.nanoid)();
-  const inputStream = pushable({ objectMode: true });
-  let firstMessage = true;
-  let healthyClose = true;
-  if (init) {
-    transport.send(serverId, {
-      streamId,
-      serviceName,
-      procedureName,
-      payload: init,
-      controlFlags: 2 /* StreamOpenBit */
-    });
-    firstMessage = false;
-  }
-  const pipeInputToTransport = async () => {
-    for await (const rawIn of inputStream) {
-      const m = {
-        streamId,
-        payload: rawIn,
-        controlFlags: 0
-      };
-      if (firstMessage) {
-        m.serviceName = serviceName;
-        m.procedureName = procedureName;
-        m.controlFlags |= 2 /* StreamOpenBit */;
+  return tracing_default.startActiveSpan(
+    `${serviceName}.${procedureName}`,
+    {
+      attributes: {
+        component: "river",
+        "river.method.kind": init ? "upload-with-init" : "upload",
+        "river.method.service": serviceName,
+        "river.method.name": procedureName,
+        "river.streamId": streamId,
+        "span.kind": "client"
+      },
+      kind: import_api2.SpanKind.CLIENT
+    },
+    (span) => {
+      const tracing = { traceparent: "", tracestate: "" };
+      import_api2.propagation.inject(import_api2.context.active(), tracing);
+      const inputStream = pushable({ objectMode: true });
+      let firstMessage = true;
+      let healthyClose = true;
+      if (init) {
+        transport.send(serverId, {
+          streamId,
+          serviceName,
+          procedureName,
+          tracing,
+          payload: init,
+          controlFlags: 2 /* StreamOpenBit */
+        });
         firstMessage = false;
       }
-      transport.send(serverId, m);
-    }
-    if (!healthyClose)
-      return;
-    transport.sendCloseStream(serverId, streamId);
-  };
-  void pipeInputToTransport();
-  const responsePromise = new Promise((resolve) => {
-    const onSessionStatus = createSessionDisconnectHandler(serverId, () => {
-      healthyClose = false;
-      cleanup();
-      resolve(
-        Err({
-          code: UNEXPECTED_DISCONNECT,
-          message: `${serverId} unexpectedly disconnected`
-        })
-      );
-    });
-    function cleanup() {
-      inputStream.end();
-      transport.removeEventListener("message", onMessage);
-      transport.removeEventListener("sessionStatus", onSessionStatus);
-    }
-    function onMessage(msg) {
-      if (msg.streamId !== streamId)
-        return;
-      if (msg.to !== transport.clientId)
-        return;
-      cleanup();
-      resolve(msg.payload);
+      const pipeInputToTransport = async () => {
+        for await (const rawIn of inputStream) {
+          const m = {
+            streamId,
+            payload: rawIn,
+            controlFlags: 0
+          };
+          if (firstMessage) {
+            m.serviceName = serviceName;
+            m.procedureName = procedureName;
+            m.tracing = tracing;
+            m.controlFlags |= 2 /* StreamOpenBit */;
+            firstMessage = false;
+          }
+          transport.send(serverId, m);
+        }
+        if (!healthyClose)
+          return;
+        transport.sendCloseStream(serverId, streamId);
+      };
+      void pipeInputToTransport();
+      const responsePromise = new Promise((resolve) => {
+        const onSessionStatus = createSessionDisconnectHandler(serverId, () => {
+          healthyClose = false;
+          span.setStatus({ code: import_api2.SpanStatusCode.ERROR });
+          cleanup();
+          resolve(
+            Err({
+              code: UNEXPECTED_DISCONNECT,
+              message: `${serverId} unexpectedly disconnected`
+            })
+          );
+        });
+        function cleanup() {
+          inputStream.end();
+          transport.removeEventListener("message", onMessage);
+          transport.removeEventListener("sessionStatus", onSessionStatus);
+          span.end();
+        }
+        function onMessage(msg) {
+          if (msg.streamId !== streamId)
+            return;
+          if (msg.to !== transport.clientId)
+            return;
+          if (msg.payload && typeof msg.payload === "object" && "ok" in msg.payload) {
+            span.setStatus({
+              code: msg.payload.ok ? import_api2.SpanStatusCode.OK : import_api2.SpanStatusCode.ERROR
+            });
+          }
+          cleanup();
+          resolve(msg.payload);
+        }
+        transport.addEventListener("message", onMessage);
+        transport.addEventListener("sessionStatus", onSessionStatus);
+      });
+      return [inputStream, responsePromise];
     }
-    transport.addEventListener("message", onMessage);
-    transport.addEventListener("sessionStatus", onSessionStatus);
-  });
-  return [inputStream, responsePromise];
+  );
 }
 
 // router/server.ts
+var import_api3 = require("@opentelemetry/api");
 var import_value = require("@sinclair/typebox/value");
 
 // util/stringify.ts
@@ -1062,9 +1174,9 @@ var RiverServer = class {
     this.transport.removeEventListener("message", this.onMessage);
     this.transport.removeEventListener("sessionStatus", this.onSessionStatus);
     await Promise.all([...this.streamMap.keys()].map(this.cleanupStream));
-    for (const context of this.contextMap.values()) {
-      if (Symbol.dispose in context.state) {
-        const dispose = context.state[Symbol.dispose];
+    for (const context3 of this.contextMap.values()) {
+      if (Symbol.dispose in context3.state) {
+        const dispose = context3.state[Symbol.dispose];
         if (typeof dispose === "function") {
           dispose();
         }
@@ -1093,6 +1205,10 @@ var RiverServer = class {
       });
       return;
     }
+    let activeContext = import_api3.context.active();
+    if (message.tracing) {
+      activeContext = import_api3.propagation.extract(activeContext, message.tracing);
+    }
     const service = this.services[message.serviceName];
     const serviceContext = this.getContext(service, message.serviceName);
     if (!(message.procedureName in service.procedures)) {
@@ -1150,12 +1266,18 @@ var RiverServer = class {
         })()
       )
     );
-    const errorHandler = (err) => {
+    const errorHandler = (err, span) => {
       const errorMsg = coerceErrorString(err);
       log?.error(
         `procedure ${message.serviceName}.${message.procedureName} threw an uncaught error: ${errorMsg}`,
         session.loggingMetadata
       );
+      if (err instanceof Error) {
+        span.recordException(err);
+      } else {
+        span.recordException(errorMsg);
+      }
+      span.setStatus({ code: import_api3.SpanStatusCode.ERROR });
       outgoing.push(
         Err({
           code: UNCAUGHT_ERROR,
@@ -1187,15 +1309,34 @@ var RiverServer = class {
           if (inputMessage.done) {
             return;
           }
-          try {
-            const outputMessage = await procedure.handler(
-              serviceContextWithTransportInfo,
-              inputMessage.value
-            );
-            outgoing.push(outputMessage);
-          } catch (err) {
-            errorHandler(err);
-          }
+          await tracing_default.startActiveSpan(
+            `${message.serviceName}.${message.procedureName}`,
+            {
+              attributes: {
+                component: "river",
+                "river.method.kind": "rpc",
+                "river.method.service": message.serviceName,
+                "river.method.name": message.procedureName,
+                "river.streamId": message.streamId,
+                "span.kind": "server"
+              },
+              kind: import_api3.SpanKind.SERVER
+            },
+            activeContext,
+            async (span) => {
+              try {
+                const outputMessage = await procedure.handler(
+                  serviceContextWithTransportInfo,
+                  inputMessage.value
+                );
+                outgoing.push(outputMessage);
+              } catch (err) {
+                errorHandler(err, span);
+              } finally {
+                span.end();
+              }
+            }
+          );
         })();
         break;
       case "stream":
@@ -1205,22 +1346,79 @@ var RiverServer = class {
             if (initMessage.done) {
               return;
             }
-            try {
-              const dispose = await procedure.handler(
-                serviceContextWithTransportInfo,
-                initMessage.value,
-                incoming,
-                outgoing
-              );
-              if (dispose) {
-                disposables.push(dispose);
+            await tracing_default.startActiveSpan(
+              `${message.serviceName}.${message.procedureName}`,
+              {
+                attributes: {
+                  component: "river",
+                  "river.method.kind": "stream-with-init",
+                  "river.method.service": message.serviceName,
+                  "river.method.name": message.procedureName,
+                  "river.streamId": message.streamId,
+                  "span.kind": "server"
+                },
+                kind: import_api3.SpanKind.SERVER
+              },
+              activeContext,
+              async (span) => {
+                try {
+                  const dispose = await procedure.handler(
+                    serviceContextWithTransportInfo,
+                    initMessage.value,
+                    incoming,
+                    outgoing
+                  );
+                  if (dispose) {
+                    disposables.push(() => {
+                      dispose();
+                      span.end();
+                    });
+                  } else {
+                    span.end();
+                  }
+                } catch (err) {
+                  errorHandler(err, span);
+                  span.end();
+                }
               }
-            } catch (err) {
-              errorHandler(err);
-            }
+            );
           })();
         } else {
-          inputHandler = procedure.handler(serviceContextWithTransportInfo, incoming, outgoing).catch(errorHandler);
+          inputHandler = tracing_default.startActiveSpan(
+            `${message.serviceName}.${message.procedureName}`,
+            {
+              attributes: {
+                component: "river",
+                "river.method.kind": "stream",
+                "river.method.service": message.serviceName,
+                "river.method.name": message.procedureName,
+                "river.streamId": message.streamId,
+                "span.kind": "server"
+              },
+              kind: import_api3.SpanKind.SERVER
+            },
+            activeContext,
+            async (span) => {
+              try {
+                const dispose = await procedure.handler(
+                  serviceContextWithTransportInfo,
+                  incoming,
+                  outgoing
+                );
+                if (dispose) {
+                  disposables.push(() => {
+                    dispose();
+                    span.end();
+                  });
+                } else {
+                  span.end();
+                }
+              } catch (err) {
+                errorHandler(err, span);
+                span.end();
+              }
+            }
+          );
         }
         break;
       case "subscription":
@@ -1229,18 +1427,41 @@ var RiverServer = class {
           if (inputMessage.done) {
             return;
           }
-          try {
-            const dispose = await procedure.handler(
-              serviceContextWithTransportInfo,
-              inputMessage.value,
-              outgoing
-            );
-            if (dispose) {
-              disposables.push(dispose);
+          await tracing_default.startActiveSpan(
+            `${message.serviceName}.${message.procedureName}`,
+            {
+              attributes: {
+                component: "river",
+                "river.method.kind": "subscription",
+                "river.method.service": message.serviceName,
+                "river.method.name": message.procedureName,
+                "river.streamId": message.streamId,
+                "span.kind": "server"
+              },
+              kind: import_api3.SpanKind.SERVER
+            },
+            activeContext,
+            async (span) => {
+              try {
+                const dispose = await procedure.handler(
+                  serviceContextWithTransportInfo,
+                  inputMessage.value,
+                  outgoing
+                );
+                if (dispose) {
+                  disposables.push(() => {
+                    dispose();
+                    span.end();
+                  });
+                } else {
+                  span.end();
+                }
+              } catch (err) {
+                errorHandler(err, span);
+                span.end();
+              }
             }
-          } catch (err) {
-            errorHandler(err);
-          }
+          );
         })();
         break;
       case "upload":
@@ -1250,33 +1471,69 @@ var RiverServer = class {
             if (initMessage.done) {
               return;
             }
-            try {
-              const outputMessage = await procedure.handler(
-                serviceContextWithTransportInfo,
-                initMessage.value,
-                incoming
-              );
-              if (!this.disconnectedSessions.has(message.from)) {
-                outgoing.push(outputMessage);
+            await tracing_default.startActiveSpan(
+              `${message.serviceName}.${message.procedureName}`,
+              {
+                attributes: {
+                  component: "river",
+                  "river.method.kind": "upload-with-init",
+                  "river.method.service": message.serviceName,
+                  "river.method.name": message.procedureName,
+                  "river.streamId": message.streamId,
+                  "span.kind": "server"
+                },
+                kind: import_api3.SpanKind.SERVER
+              },
+              activeContext,
+              async (span) => {
+                try {
+                  const outputMessage = await procedure.handler(
+                    serviceContextWithTransportInfo,
+                    initMessage.value,
+                    incoming
+                  );
+                  if (!this.disconnectedSessions.has(message.from)) {
+                    outgoing.push(outputMessage);
+                  }
+                } catch (err) {
+                  errorHandler(err, span);
+                } finally {
+                  span.end();
+                }
               }
-            } catch (err) {
-              errorHandler(err);
-            }
+            );
           })();
         } else {
-          inputHandler = (async () => {
-            try {
-              const outputMessage = await procedure.handler(
-                serviceContextWithTransportInfo,
-                incoming
-              );
-              if (!this.disconnectedSessions.has(message.from)) {
-                outgoing.push(outputMessage);
+          inputHandler = tracing_default.startActiveSpan(
+            `${message.serviceName}.${message.procedureName}`,
+            {
+              attributes: {
+                component: "river",
+                "river.method.kind": "upload",
+                "river.method.service": message.serviceName,
+                "river.method.name": message.procedureName,
+                "river.streamId": message.streamId,
+                "span.kind": "server"
+              },
+              kind: import_api3.SpanKind.SERVER
+            },
+            activeContext,
+            async (span) => {
+              try {
+                const outputMessage = await procedure.handler(
+                  serviceContextWithTransportInfo,
+                  incoming
+                );
+                if (!this.disconnectedSessions.has(message.from)) {
+                  outgoing.push(outputMessage);
+                }
+              } catch (err) {
+                errorHandler(err, span);
+              } finally {
+                span.end();
               }
-            } catch (err) {
-              errorHandler(err);
             }
-          })();
+          );
         }
         break;
       default:
@@ -1326,15 +1583,15 @@ var RiverServer = class {
     }
   }
   getContext(service, serviceName) {
-    const context = this.contextMap.get(service);
-    if (!context) {
+    const context3 = this.contextMap.get(service);
+    if (!context3) {
       const err = `no context found for ${serviceName}`;
       log?.error(err, {
         clientId: this.transport.clientId
       });
       throw new Error(err);
     }
-    return context;
+    return context3;
   }
   cleanupStream = async (id) => {
     const stream2 = this.streamMap.get(id);
@@ -1353,7 +1610,7 @@ function createServer(transport, services, extendedContext) {
 }
 
 // package.json
-var version = "0.19.2";
+var version = "0.20.0";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Err,
@@ -1367,3 +1624,4 @@ var version = "0.19.2";
   createServer,
   serializeSchema
 });
+//# sourceMappingURL=index.cjs.map