@replit/river 0.19.2 → 0.20.0

package/dist/{chunk-SR4DBLJ6.js → chunk-YB5LRYL6.js}

@@ -2,11 +2,12 @@ import {
   ControlMessagePayloadSchema,
   coerceErrorString,
   isStreamClose,
-  isStreamOpen
-} from "./chunk-D5PVGZPQ.js";
+  isStreamOpen,
+  tracing_default
+} from "./chunk-5WFL722S.js";
 import {
   log
-} from "./chunk-NBE3D667.js";
+} from "./chunk-DT5JS6TM.js";
 
 // router/services.ts
 import { Type } from "@sinclair/typebox";
@@ -297,6 +298,14 @@ var Procedure = {
   stream
 };
 
+// router/client.ts
+import {
+  context,
+  propagation,
+  SpanKind,
+  SpanStatusCode
+} from "@opentelemetry/api";
+
 // node_modules/p-defer/index.js
 function pDefer() {
   const deferred = {};
@@ -679,220 +688,323 @@ function createSessionDisconnectHandler(from, cb) {
 }
 function handleRpc(transport, serverId, input, serviceName, procedureName) {
   const streamId = 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: SpanKind.CLIENT
+    },
+    (span) => {
+      const tracing = { traceparent: "", tracestate: "" };
+      propagation.inject(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: 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 ? SpanStatusCode.OK : 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 = 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: SpanKind.CLIENT
+    },
+    (span) => {
+      const tracing = { traceparent: "", tracestate: "" };
+      propagation.inject(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: 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: 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 = 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: SpanKind.CLIENT
+    },
+    (span) => {
+      const tracing = { traceparent: "", tracestate: "" };
+      propagation.inject(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: 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 = 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: SpanKind.CLIENT
+    },
+    (span) => {
+      const tracing = { traceparent: "", tracestate: "" };
+      propagation.inject(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: 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 ? SpanStatusCode.OK : 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
+import {
+  context as context2,
+  propagation as propagation2,
+  SpanKind as SpanKind2,
+  SpanStatusCode as SpanStatusCode2
+} from "@opentelemetry/api";
 import { Value } from "@sinclair/typebox/value";
 var RiverServer = class {
   transport;
@@ -964,9 +1076,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();
         }
@@ -995,6 +1107,10 @@ var RiverServer = class {
       });
       return;
     }
+    let activeContext = context2.active();
+    if (message.tracing) {
+      activeContext = propagation2.extract(activeContext, message.tracing);
+    }
     const service = this.services[message.serviceName];
     const serviceContext = this.getContext(service, message.serviceName);
     if (!(message.procedureName in service.procedures)) {
@@ -1052,12 +1168,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: SpanStatusCode2.ERROR });
       outgoing.push(
         Err({
           code: UNCAUGHT_ERROR,
@@ -1089,15 +1211,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: SpanKind2.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":
@@ -1107,22 +1248,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: SpanKind2.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: SpanKind2.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":
@@ -1131,18 +1329,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: SpanKind2.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":
@@ -1152,33 +1373,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: SpanKind2.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: SpanKind2.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:
@@ -1228,15 +1485,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);
@@ -1255,7 +1512,7 @@ function createServer(transport, services, extendedContext) {
 }
 
 // package.json
-var version = "0.19.2";
+var version = "0.20.0";
 
 export {
   serializeSchema,
@@ -1270,3 +1527,4 @@ export {
   createServer,
   version
 };
+//# sourceMappingURL=chunk-YB5LRYL6.js.map