@replit/river 0.17.4 → 0.18.1

package/README.md

@@ -168,12 +168,13 @@ if (result.ok) {
 To add logging,
 
 ```ts
-import { bindLogger, setLevel } from '@replit/river/logging';
+import { bindLogger, stringLogger } from '@replit/river/logging';
 
-bindLogger(console.log);
-setLevel('info');
+bindLogger(stringLogger, 'info');
 ```
 
+You can define your own logging functions that satisfy the `LogFn` type.
+
 ### Connection status
 
 River defines two types of reconnects:

package/dist/{chunk-F3LFO3GU.js → chunk-5YDJDYVB.js}

@@ -1,6 +1,6 @@
 import {
   Connection
-} from "./chunk-7WY3Z5ZN.js";
+} from "./chunk-UNTGVPI6.js";
 
 // transport/impls/ws/connection.ts
 var WebSocketConnection = class extends Connection {

package/dist/{chunk-Q7OSVPZ5.js → chunk-O36533OC.js}

@@ -1,6 +1,6 @@
 import {
   Connection
-} from "./chunk-7WY3Z5ZN.js";
+} from "./chunk-UNTGVPI6.js";
 
 // transport/transforms/messageFraming.ts
 import { Transform } from "node:stream";

package/dist/{chunk-4C2OXQJB.js → chunk-QBGGJSQM.js}

@@ -6,7 +6,7 @@ import {
 } from "./chunk-VH3NGOXQ.js";
 import {
   log
-} from "./chunk-H4BYJELI.js";
+} from "./chunk-XCQF55SQ.js";
 
 // router/services.ts
 import { Type } from "@sinclair/typebox";
@@ -637,46 +637,25 @@ var createClient = (transport, serverId, providedClientOptions = {}) => {
       );
     }
     const [input] = opts.args;
-    log?.info(
-      `${transport.clientId} -- invoked ${procType}: ${serviceName}.${procName} with args: ${JSON.stringify(
-        input
-      )}`
-    );
+    log?.info(`invoked ${procType} ${serviceName}.${procName}`, {
+      clientId: transport.clientId,
+      partialTransportMessage: {
+        procedureName: procName,
+        serviceName,
+        payload: input
+      }
+    });
     if (options.connectOnInvoke && !transport.connections.has(serverId)) {
       void transport.connect(serverId);
     }
     if (procType === "rpc") {
-      return handleRpc(
-        transport,
-        serverId,
-        input,
-        serviceName,
-        procName
-      );
+      return handleRpc(transport, serverId, input, serviceName, procName);
     } else if (procType === "stream") {
-      return handleStream(
-        transport,
-        serverId,
-        input,
-        serviceName,
-        procName
-      );
+      return handleStream(transport, serverId, input, serviceName, procName);
     } else if (procType === "subscribe") {
-      return handleSubscribe(
-        transport,
-        serverId,
-        input,
-        serviceName,
-        procName
-      );
+      return handleSubscribe(transport, serverId, input, serviceName, procName);
     } else if (procType === "upload") {
-      return handleUpload(
-        transport,
-        serverId,
-        input,
-        serviceName,
-        procName
-      );
+      return handleUpload(transport, serverId, input, serviceName, procName);
     } else {
       throw new Error(`invalid river call, unknown procedure type ${procType}`);
     }
@@ -950,9 +929,10 @@ var RiverServer = class {
   }
   onMessage = async (message) => {
     if (message.to !== this.transport.clientId) {
-      log?.info(
-        `${this.transport.clientId} -- got msg with destination that isn't the server, ignoring`
-      );
+      log?.info(`got msg with destination that isn't this server, ignoring`, {
+        clientId: this.transport.clientId,
+        fullTransportMessage: message
+      });
       return;
     }
     let procStream = this.streamMap.get(message.streamId);
@@ -969,7 +949,8 @@ var RiverServer = class {
       return;
     const disconnectedClientId = evt.session.to;
     log?.info(
-      `${this.transport.clientId} -- got session disconnect from ${disconnectedClientId}, cleaning up streams`
+      `got session disconnect from ${disconnectedClientId}, cleaning up streams`,
+      evt.session.loggingMetadata
     );
     const streamsFromThisClient = this.clientStreams.get(disconnectedClientId);
     if (!streamsFromThisClient)
@@ -989,37 +970,43 @@ var RiverServer = class {
   createNewProcStream(message) {
     if (!isStreamOpen(message.controlFlags)) {
       log?.error(
-        `${this.transport.clientId} -- can't create a new procedure stream from a message that doesn't have the stream open bit set`
+        `can't create a new procedure stream from a message that doesn't have the stream open bit set`,
+        { clientId: this.transport.clientId, fullTransportMessage: message }
       );
-      log?.debug(` -> ${JSON.stringify(message)}`);
       return;
     }
     if (!message.procedureName || !message.serviceName) {
-      log?.warn(
-        `${this.transport.clientId} -- missing procedure or service name in stream open message`
-      );
-      log?.debug(` -> ${JSON.stringify(message)}`);
+      log?.warn(`missing procedure or service name in stream open message`, {
+        clientId: this.transport.clientId,
+        fullTransportMessage: message
+      });
       return;
     }
     if (!(message.serviceName in this.services)) {
-      log?.warn(
-        `${this.transport.clientId} -- couldn't find service ${message.serviceName}`
-      );
+      log?.warn(`couldn't find service ${message.serviceName}`, {
+        clientId: this.transport.clientId,
+        fullTransportMessage: message
+      });
       return;
     }
     const service = this.services[message.serviceName];
     const serviceContext = this.getContext(service, message.serviceName);
     if (!(message.procedureName in service.procedures)) {
       log?.warn(
-        `${this.transport.clientId} -- couldn't find a matching procedure for ${message.serviceName}.${message.procedureName}`
+        `couldn't find a matching procedure for ${message.serviceName}.${message.procedureName}`,
+        {
+          clientId: this.transport.clientId,
+          fullTransportMessage: message
+        }
       );
       return;
     }
     const session = this.transport.sessions.get(message.from);
     if (!session) {
-      log?.warn(
-        `${this.transport.clientId} -- couldn't find session for ${message.from}`
-      );
+      log?.warn(`couldn't find session for ${message.from}`, {
+        clientId: this.transport.clientId,
+        fullTransportMessage: message
+      });
       return;
     }
     const procedure = service.procedures[message.procedureName];
@@ -1062,7 +1049,8 @@ var RiverServer = class {
     const errorHandler = (err) => {
       const errorMsg = coerceErrorString(err);
       log?.error(
-        `${this.transport.clientId} -- procedure ${message.serviceName}.${message.procedureName}:${message.streamId} threw an uncaught error: ${errorMsg}`
+        `procedure ${message.serviceName}.${message.procedureName} threw an uncaught error: ${errorMsg}`,
+        session.loggingMetadata
       );
       outgoing.push(
         Err({
@@ -1105,12 +1093,19 @@ var RiverServer = class {
             if (initMessage.done) {
               return;
             }
-            return procedure.handler(
-              serviceContextWithTransportInfo,
-              initMessage.value,
-              incoming,
-              outgoing
-            ).catch(errorHandler);
+            try {
+              const dispose = await procedure.handler(
+                serviceContextWithTransportInfo,
+                initMessage.value,
+                incoming,
+                outgoing
+              );
+              if (dispose) {
+                disposables.push(dispose);
+              }
+            } catch (err) {
+              errorHandler(err);
+            }
           })();
         } else {
           inputHandler = procedure.handler(serviceContextWithTransportInfo, incoming, outgoing).catch(errorHandler);
@@ -1174,7 +1169,8 @@ var RiverServer = class {
         break;
       default:
         log?.warn(
-          `${this.transport.clientId} -- got request for invalid procedure type ${procedure.type} at ${message.serviceName}.${message.procedureName}`
+          `got request for invalid procedure type ${procedure.type} at ${message.serviceName}.${message.procedureName}`,
+          { ...session.loggingMetadata, fullTransportMessage: message }
         );
         return;
     }
@@ -1202,9 +1198,8 @@ var RiverServer = class {
       procStream.incoming.push(message.payload);
     } else if (!Value.Check(ControlMessagePayloadSchema, message.payload)) {
       log?.error(
-        `${this.transport.clientId} -- procedure ${serviceName}.${procedureName} received invalid payload: ${JSON.stringify(
-          message.payload
-        )}`
+        `procedure ${serviceName}.${procedureName} received invalid payload`,
+        { clientId: this.transport.clientId, fullTransportMessage: message }
       );
     }
     if (isStreamClose(message.controlFlags)) {
@@ -1218,11 +1213,13 @@ var RiverServer = class {
       }
     }
   }
-  getContext(service, name) {
+  getContext(service, serviceName) {
     const context = this.contextMap.get(service);
     if (!context) {
-      const err = `${this.transport.clientId} -- no context found for ${name}`;
-      log?.error(err);
+      const err = `no context found for ${serviceName}`;
+      log?.error(err, {
+        clientId: this.transport.clientId
+      });
       throw new Error(err);
     }
     return context;