@replit/river 0.23.6 → 0.23.8

package/dist/router/index.cjs

@@ -705,14 +705,11 @@ function Err(error) {
   };
 }
 
-// logging/log.ts
-var log = void 0;
-
 // tracing/index.ts
 var import_api = require("@opentelemetry/api");
 
 // package.json
-var version = "0.23.6";
+var version = "0.23.8";
 
 // tracing/index.ts
 function getPropagationContext(ctx) {
@@ -723,8 +720,8 @@ function getPropagationContext(ctx) {
   import_api.propagation.inject(ctx, tracing);
   return tracing;
 }
-function createProcTelemetryInfo(kind, serviceName, procedureName, streamId) {
-  const ctx = import_api.context.active();
+function createProcTelemetryInfo(transport, kind, serviceName, procedureName, streamId) {
+  const baseCtx = import_api.context.active();
   const span = tracer.startSpan(
     `procedure call ${serviceName}.${procedureName}`,
     {
@@ -738,8 +735,20 @@ function createProcTelemetryInfo(kind, serviceName, procedureName, streamId) {
       },
       kind: import_api.SpanKind.CLIENT
     },
-    ctx
+    baseCtx
   );
+  const ctx = import_api.trace.setSpan(baseCtx, span);
+  transport.log?.info(`invoked ${serviceName}.${procedureName}`, {
+    clientId: transport.clientId,
+    transportMessage: {
+      procedureName,
+      serviceName
+    },
+    telemetry: {
+      traceId: span.spanContext().traceId,
+      spanId: span.spanContext().spanId
+    }
+  });
   return { span, ctx };
 }
 function createHandlerSpan(kind, message, fn) {
@@ -804,13 +813,6 @@ function createClient(transport, serverId, providedClientOptions = {}) {
       );
     }
     const [input] = opts.args;
-    log?.info(`invoked ${procType} ${serviceName}.${procName}`, {
-      clientId: transport.clientId,
-      transportMessage: {
-        procedureName: procName,
-        serviceName
-      }
-    });
     if (options.connectOnInvoke && !transport.connections.has(serverId)) {
       void transport.connect(serverId);
     }
@@ -837,6 +839,7 @@ function createSessionDisconnectHandler(from, cb) {
 function handleRpc(transport, serverId, input, serviceName, procedureName) {
   const streamId = (0, import_nanoid2.nanoid)();
   const { span, ctx } = createProcTelemetryInfo(
+    transport,
     "rpc",
     serviceName,
     procedureName,
@@ -881,6 +884,7 @@ function handleRpc(transport, serverId, input, serviceName, procedureName) {
 function handleStream(transport, serverId, init, serviceName, procedureName) {
   const streamId = (0, import_nanoid2.nanoid)();
   const { span, ctx } = createProcTelemetryInfo(
+    transport,
     "stream",
     serviceName,
     procedureName,
@@ -957,6 +961,7 @@ function handleStream(transport, serverId, init, serviceName, procedureName) {
 function handleSubscribe(transport, serverId, input, serviceName, procedureName) {
   const streamId = (0, import_nanoid2.nanoid)();
   const { span, ctx } = createProcTelemetryInfo(
+    transport,
     "subscription",
     serviceName,
     procedureName,
@@ -1012,6 +1017,7 @@ function handleSubscribe(transport, serverId, input, serviceName, procedureName)
 function handleUpload(transport, serverId, init, serviceName, procedureName) {
   const streamId = (0, import_nanoid2.nanoid)();
   const { span, ctx } = createProcTelemetryInfo(
+    transport,
     "upload",
     serviceName,
     procedureName,
@@ -1105,6 +1111,7 @@ var RiverServer = class {
   // map of client to their open streams by streamId
   clientStreams;
   disconnectedSessions;
+  log;
   constructor(transport, services, handshakeOptions, extendedContext) {
     const instances = {};
     this.services = instances;
@@ -1126,16 +1133,20 @@ var RiverServer = class {
     this.clientStreams = /* @__PURE__ */ new Map();
     this.transport.addEventListener("message", this.onMessage);
     this.transport.addEventListener("sessionStatus", this.onSessionStatus);
+    this.log = transport.log;
   }
   get streams() {
     return this.streamMap;
   }
   onMessage = async (message) => {
     if (message.to !== this.transport.clientId) {
-      log?.info(`got msg with destination that isn't this server, ignoring`, {
-        clientId: this.transport.clientId,
-        transportMessage: message
-      });
+      this.log?.info(
+        `got msg with destination that isn't this server, ignoring`,
+        {
+          clientId: this.transport.clientId,
+          transportMessage: message
+        }
+      );
       return;
     }
     let procStream = this.streamMap.get(message.streamId);
@@ -1151,7 +1162,7 @@ var RiverServer = class {
     if (evt.status !== "disconnect")
       return;
     const disconnectedClientId = evt.session.to;
-    log?.info(
+    this.log?.info(
       `got session disconnect from ${disconnectedClientId}, cleaning up streams`,
       evt.session.loggingMetadata
     );
@@ -1180,7 +1191,7 @@ var RiverServer = class {
   }
   createNewProcStream(message) {
     if (!isStreamOpen(message.controlFlags)) {
-      log?.error(
+      this.log?.error(
         `can't create a new procedure stream from a message that doesn't have the stream open bit set`,
         {
           clientId: this.transport.clientId,
@@ -1191,14 +1202,17 @@ var RiverServer = class {
       return;
     }
     if (!message.procedureName || !message.serviceName) {
-      log?.warn(`missing procedure or service name in stream open message`, {
-        clientId: this.transport.clientId,
-        transportMessage: message
-      });
+      this.log?.warn(
+        `missing procedure or service name in stream open message`,
+        {
+          clientId: this.transport.clientId,
+          transportMessage: message
+        }
+      );
       return;
     }
     if (!(message.serviceName in this.services)) {
-      log?.warn(`couldn't find service ${message.serviceName}`, {
+      this.log?.warn(`couldn't find service ${message.serviceName}`, {
         clientId: this.transport.clientId,
         transportMessage: message
       });
@@ -1207,7 +1221,7 @@ var RiverServer = class {
     const service = this.services[message.serviceName];
     const serviceContext = this.getContext(service, message.serviceName);
     if (!(message.procedureName in service.procedures)) {
-      log?.warn(
+      this.log?.warn(
         `couldn't find a matching procedure for ${message.serviceName}.${message.procedureName}`,
         {
           clientId: this.transport.clientId,
@@ -1218,7 +1232,7 @@ var RiverServer = class {
     }
     const session = this.transport.sessions.get(message.from);
     if (!session) {
-      log?.warn(`couldn't find session for ${message.from}`, {
+      this.log?.warn(`couldn't find session for ${message.from}`, {
         clientId: this.transport.clientId,
         transportMessage: message
       });
@@ -1263,7 +1277,7 @@ var RiverServer = class {
     );
     const errorHandler = (err, span) => {
       const errorMsg = coerceErrorString(err);
-      log?.error(
+      this.log?.error(
         `procedure ${message.serviceName}.${message.procedureName} threw an uncaught error: ${errorMsg}`,
         session.loggingMetadata
       );
@@ -1278,7 +1292,7 @@ var RiverServer = class {
     };
     const sessionMeta = this.transport.sessionHandshakeMetadata.get(session);
     if (!sessionMeta) {
-      log?.error(`session doesn't have handshake metadata`, {
+      this.log?.error(`session doesn't have handshake metadata`, {
         ...session.loggingMetadata,
         tags: ["invariant-violation"]
       });
@@ -1443,7 +1457,7 @@ var RiverServer = class {
         }
         break;
       default:
-        log?.warn(
+        this.log?.warn(
           `got request for invalid procedure type ${procedure.type} at ${message.serviceName}.${message.procedureName}`,
           { ...session.loggingMetadata, transportMessage: message }
         );
@@ -1471,7 +1485,7 @@ var RiverServer = class {
       if (import_value.Value.Check(procedure.init, message.payload)) {
         procStream.incoming.push(message.payload);
       } else {
-        log?.error(
+        this.log?.error(
           `procedure ${serviceName}.${procedureName} received invalid init payload`,
           {
             clientId: this.transport.clientId,
@@ -1485,7 +1499,7 @@ var RiverServer = class {
     } else if (import_value.Value.Check(procedure.input, message.payload)) {
       procStream.incoming.push(message.payload);
     } else if (!import_value.Value.Check(ControlMessagePayloadSchema, message.payload)) {
-      log?.error(
+      this.log?.error(
         `procedure ${serviceName}.${procedureName} received invalid payload`,
         {
           clientId: this.transport.clientId,
@@ -1509,7 +1523,7 @@ var RiverServer = class {
     const context2 = this.contextMap.get(service);
     if (!context2) {
       const err = `no context found for ${serviceName}`;
-      log?.error(err, {
+      this.log?.error(err, {
         clientId: this.transport.clientId,
         tags: ["invariant-violation"]
       });