@replit/river 0.17.4 → 0.18.1

package/dist/transport/impls/ws/client.cjs

@@ -96,8 +96,8 @@ function isAck(controlFlag) {
   return (controlFlag & 1 /* AckBit */) === 1 /* AckBit */;
 }
 
-// logging/index.ts
-var log;
+// logging/log.ts
+var log = void 0;
 
 // transport/events.ts
 var ProtocolError = {
@@ -199,6 +199,14 @@ var Session = class {
       options.heartbeatIntervalMs
     );
   }
+  get loggingMetadata() {
+    return {
+      clientId: this.from,
+      connectedTo: this.to,
+      sessionId: this.id,
+      connId: this.connection?.debugId
+    };
+  }
   /**
    * Sends a message over the session's connection.
    * If the connection is not ready or the message fails to send, the message can be buffered for retry unless skipped.
@@ -209,26 +217,37 @@ var Session = class {
    */
   send(msg) {
     const fullMsg = this.constructMsg(msg);
-    log?.debug(`${this.from} -- sending ${JSON.stringify(fullMsg)}`);
+    log?.debug(`sending msg`, {
+      ...this.loggingMetadata,
+      fullTransportMessage: fullMsg
+    });
     if (this.connection) {
       const ok = this.connection.send(this.codec.toBuffer(fullMsg));
       if (ok)
         return fullMsg.id;
       log?.info(
-        `${this.from} -- failed to send ${fullMsg.id} (seq: ${fullMsg.seq}) to ${fullMsg.to}, connection (id: ${this.connection.debugId}) is probably dead`
+        `failed to send msg to ${fullMsg.to}, connection is probably dead`,
+        {
+          ...this.loggingMetadata,
+          fullTransportMessage: fullMsg
+        }
       );
     } else {
       log?.info(
-        `${this.from} -- failed to send ${fullMsg.id} (seq: ${fullMsg.seq}) to ${fullMsg.to}, connection not ready yet`
+        `failed to send msg to ${fullMsg.to}, connection not ready yet`,
+        { ...this.loggingMetadata, fullTransportMessage: fullMsg }
       );
     }
     return fullMsg.id;
   }
   sendHeartbeat() {
-    if (this.heartbeatMisses >= this.options.heartbeatsUntilDead) {
+    const misses = this.heartbeatMisses;
+    const missDuration = misses * this.options.heartbeatIntervalMs;
+    if (misses > this.options.heartbeatsUntilDead) {
       if (this.connection) {
         log?.info(
-          `${this.from} -- closing connection (id: ${this.connection.debugId}) to ${this.to} due to inactivity`
+          `closing connection to ${this.to} due to inactivity (missed ${misses} heartbeats which is ${missDuration}ms)`,
+          this.loggingMetadata
         );
         this.closeStaleConnection();
       }
@@ -250,26 +269,36 @@ var Session = class {
   }
   sendBufferedMessages() {
     if (!this.connection) {
-      const msg = `${this.from} -- tried sending buffered messages without a connection (if you hit this code path something is seriously wrong)`;
-      log?.error(msg);
+      const msg = `tried sending buffered messages without a connection (if you hit this code path something is seriously wrong)`;
+      log?.error(msg, this.loggingMetadata);
       throw new Error(msg);
     }
     log?.info(
-      `${this.from} -- resending ${this.sendBuffer.length} buffered messages`
+      `resending ${this.sendBuffer.length} buffered messages`,
+      this.loggingMetadata
     );
     for (const msg of this.sendBuffer) {
-      log?.debug(`${this.from} -- resending ${msg.id} (seq: ${msg.seq})`);
+      log?.debug(`resending msg`, {
+        ...this.loggingMetadata,
+        fullTransportMessage: msg
+      });
       const ok = this.connection.send(this.codec.toBuffer(msg));
       if (!ok) {
-        const msg2 = `${this.from} -- failed to send buffered message to ${this.to} in session (id: ${this.id}) (if you hit this code path something is seriously wrong)`;
-        log?.error(msg2);
-        throw new Error(msg2);
+        const errMsg = `failed to send buffered message to ${this.to} (if you hit this code path something is seriously wrong)`;
+        log?.error(errMsg, {
+          ...this.loggingMetadata,
+          fullTransportMessage: msg
+        });
+        throw new Error(errMsg);
       }
     }
   }
   updateBookkeeping(ack, seq) {
     if (seq + 1 < this.ack) {
-      log?.error(`${this.from} -- received stale seq ${seq} + 1 < ${this.ack}`);
+      log?.error(
+        `received stale seq ${seq} + 1 < ${this.ack}`,
+        this.loggingMetadata
+      );
       return;
     }
     this.sendBuffer = this.sendBuffer.filter((unacked) => unacked.seq >= ack);
@@ -279,7 +308,8 @@ var Session = class {
     if (this.connection === void 0 || this.connection === conn)
       return;
     log?.info(
-      `${this.from} -- closing old inner connection (id: ${this.connection.debugId}) from session (id: ${this.id}) to ${this.to}`
+      `closing old inner connection from session to ${this.to}`,
+      this.loggingMetadata
     );
     this.connection.close();
     this.connection = void 0;
@@ -291,7 +321,8 @@ var Session = class {
   }
   beginGrace(cb) {
     log?.info(
-      `${this.from} -- starting ${this.options.sessionDisconnectGraceMs}ms grace period until session (id: ${this.id}) to ${this.to} is closed`
+      `starting ${this.options.sessionDisconnectGraceMs}ms grace period until session to ${this.to} is closed`,
+      this.loggingMetadata
     );
     this.disconnectionGrace = setTimeout(() => {
       this.close();
@@ -546,7 +577,8 @@ var Transport = class {
     let oldSession = this.sessions.get(connectedTo);
     if (oldSession?.advertisedSessionId && oldSession.advertisedSessionId !== advertisedSessionId) {
       log?.warn(
-        `${this.clientId} -- connection from ${connectedTo} is a different session (id: ${advertisedSessionId}, last connected to: ${oldSession.advertisedSessionId}), starting a new session`
+        `connection from ${connectedTo} is a different session (id: ${advertisedSessionId}, last connected to: ${oldSession.advertisedSessionId}), killing old session and starting a new one`,
+        oldSession.loggingMetadata
       );
       this.deleteSession(oldSession);
       oldSession = void 0;
@@ -555,16 +587,18 @@ var Transport = class {
       const newSession = this.createSession(connectedTo, conn);
       newSession.advertisedSessionId = advertisedSessionId;
       log?.info(
-        `${this.clientId} -- new connection (id: ${conn.debugId}) for new session (id: ${newSession.id}) to ${connectedTo}`
+        `new connection for new session to ${connectedTo}`,
+        newSession.loggingMetadata
       );
       return newSession;
     }
-    log?.info(
-      `${this.clientId} -- new connection (id: ${conn.debugId}) for existing session (id: ${oldSession.id}) to ${connectedTo}`
-    );
     oldSession.replaceWithNewConnection(conn);
     oldSession.sendBufferedMessages();
     oldSession.advertisedSessionId = advertisedSessionId;
+    log?.info(
+      `new connection for existing session to ${connectedTo}`,
+      oldSession.loggingMetadata
+    );
     return oldSession;
   }
   createSession(to, conn) {
@@ -586,7 +620,8 @@ var Transport = class {
     if (!session) {
       session = this.createSession(to, conn);
       log?.info(
-        `${this.clientId} -- no session for ${to}, created a new one (id: ${session.id})`
+        `no session for ${to}, created a new one`,
+        session.loggingMetadata
       );
     }
     return session;
@@ -595,7 +630,8 @@ var Transport = class {
     session.close();
     this.sessions.delete(session.to);
     log?.info(
-      `${this.clientId} -- session ${session.id} disconnect from ${session.to}`
+      `session ${session.id} disconnect from ${session.to}`,
+      session.loggingMetadata
     );
     this.eventDispatcher.dispatchEvent("sessionStatus", {
       status: "disconnect",
@@ -624,17 +660,15 @@ var Transport = class {
     const parsedMsg = this.codec.fromBuffer(msg);
     if (parsedMsg === null) {
       const decodedBuffer = new TextDecoder().decode(Buffer.from(msg));
-      log?.error(
-        `${this.clientId} -- received malformed msg, killing conn: ${decodedBuffer}`
-      );
+      log?.error(`received malformed msg, killing conn: ${decodedBuffer}`, {
+        clientId: this.clientId
+      });
       return null;
     }
     if (!import_value.Value.Check(OpaqueTransportMessageSchema, parsedMsg)) {
-      log?.error(
-        `${this.clientId} -- received invalid msg: ${JSON.stringify(
-          parsedMsg
-        )}`
-      );
+      log?.error(`received invalid msg: ${JSON.stringify(parsedMsg)}`, {
+        clientId: this.clientId
+      });
       return null;
     }
     return parsedMsg;
@@ -649,26 +683,29 @@ var Transport = class {
       return;
     const session = this.sessions.get(msg.from);
     if (!session) {
-      const err = `${this.clientId} -- (invariant violation) no existing session for ${msg.from}`;
-      log?.error(err);
+      log?.error(`(invariant violation) no existing session for ${msg.from}`, {
+        clientId: this.clientId,
+        fullTransportMessage: msg
+      });
       return;
     }
     session.cancelGrace();
-    log?.debug(`${this.clientId} -- received msg: ${JSON.stringify(msg)}`);
+    log?.debug(`received msg`, {
+      clientId: this.clientId,
+      fullTransportMessage: msg
+    });
     if (msg.seq !== session.nextExpectedSeq) {
       if (msg.seq < session.nextExpectedSeq) {
         log?.debug(
-          `${this.clientId} -- received duplicate msg (got: ${msg.seq}, wanted: ${session.nextExpectedSeq}), discarding: ${JSON.stringify(
-            msg
-          )}`
+          `received duplicate msg (got seq: ${msg.seq}, wanted seq: ${session.nextExpectedSeq}), discarding`,
+          { clientId: this.clientId, fullTransportMessage: msg }
         );
       } else {
         const errMsg = `received out-of-order msg (got seq: ${msg.seq}, wanted seq: ${session.nextExpectedSeq})`;
-        log?.error(
-          `${this.clientId} -- fatal: ${errMsg}, marking connection as dead: ${JSON.stringify(
-            msg
-          )}`
-        );
+        log?.error(`${errMsg}, marking connection as dead`, {
+          clientId: this.clientId,
+          fullTransportMessage: msg
+        });
         this.protocolError(ProtocolError.MessageOrderingViolated, errMsg);
         session.close();
       }
@@ -678,7 +715,10 @@ var Transport = class {
     if (!isAck(msg.controlFlags)) {
       this.eventDispatcher.dispatchEvent("message", msg);
     } else {
-      log?.debug(`${this.clientId} -- discarding msg ${msg.id} (ack bit set)`);
+      log?.debug(`discarding msg (ack bit set)`, {
+        clientId: this.clientId,
+        fullTransportMessage: msg
+      });
     }
   }
   /**
@@ -706,15 +746,17 @@ var Transport = class {
   send(to, msg) {
     if (this.state === "destroyed") {
       const err = "transport is destroyed, cant send";
-      log?.error(`${this.clientId} -- ` + err + `: ${JSON.stringify(msg)}`);
+      log?.error(err, {
+        clientId: this.clientId,
+        partialTransportMessage: msg
+      });
       this.protocolError(ProtocolError.UseAfterDestroy, err);
       return void 0;
     } else if (this.state === "closed") {
-      log?.info(
-        `${this.clientId} -- transport closed when sending, discarding : ${JSON.stringify(
-          msg
-        )}`
-      );
+      log?.info(`transport closed when sending, discarding`, {
+        clientId: this.clientId,
+        partialTransportMessage: msg
+      });
       return void 0;
     }
     return this.getOrCreateSession(to).send(msg);
@@ -742,7 +784,7 @@ var Transport = class {
     for (const session of this.sessions.values()) {
       this.deleteSession(session);
     }
-    log?.info(`${this.clientId} -- manually closed transport`);
+    log?.info(`manually closed transport`, { clientId: this.clientId });
   }
   /**
    * Default destroy implementation for transports. You should override this in the downstream
@@ -754,7 +796,7 @@ var Transport = class {
     for (const session of this.sessions.values()) {
       this.deleteSession(session);
     }
-    log?.info(`${this.clientId} -- manually destroyed transport`);
+    log?.info(`manually destroyed transport`, { clientId: this.clientId });
   }
 };
 var ClientTransport = class extends Transport {
@@ -787,6 +829,15 @@ var ClientTransport = class extends Transport {
     if (this.state !== "open")
       return;
     let session = void 0;
+    const handshakeTimeout = setTimeout(() => {
+      if (!session) {
+        log?.warn(
+          `connection to ${to} timed out waiting for handshake, closing`,
+          { clientId: this.clientId, connectedTo: to, connId: conn.debugId }
+        );
+        conn.close();
+      }
+    }, this.options.sessionDisconnectGraceMs);
     const handshakeHandler = (data) => {
       const maybeSession = this.receiveHandshakeResponseMessage(data, conn);
       if (!maybeSession) {
@@ -794,6 +845,7 @@ var ClientTransport = class extends Transport {
         return;
       } else {
         session = maybeSession;
+        clearTimeout(handshakeTimeout);
       }
       conn.removeDataListener(handshakeHandler);
       conn.addDataListener((data2) => {
@@ -810,18 +862,22 @@ var ClientTransport = class extends Transport {
       if (session) {
         this.onDisconnect(conn, session);
       }
-      log?.info(
-        `${this.clientId} -- connection (id: ${conn.debugId}) to ${to} disconnected`
-      );
+      log?.info(`connection to ${to} disconnected`, {
+        ...session?.loggingMetadata,
+        clientId: this.clientId,
+        connectedTo: to
+      });
       this.inflightConnectionPromises.delete(to);
       if (this.reconnectOnConnectionDrop) {
         void this.connect(to);
       }
     });
     conn.addErrorListener((err) => {
-      log?.warn(
-        `${this.clientId} -- error in connection (id: ${conn.debugId}) to ${to}: ${coerceErrorString(err)}`
-      );
+      log?.warn(`error in connection to ${to}: ${coerceErrorString(err)}`, {
+        ...session?.loggingMetadata,
+        clientId: this.clientId,
+        connectedTo: to
+      });
     });
   }
   receiveHandshakeResponseMessage(data, conn) {
@@ -834,11 +890,11 @@ var ClientTransport = class extends Transport {
       return false;
     }
     if (!import_value.Value.Check(ControlMessageHandshakeResponseSchema, parsed.payload)) {
-      log?.warn(
-        `${this.clientId} -- received invalid handshake resp: ${JSON.stringify(
-          parsed
-        )}`
-      );
+      log?.warn(`received invalid handshake resp`, {
+        clientId: this.clientId,
+        connectedTo: parsed.from,
+        fullTransportMessage: parsed
+      });
       this.protocolError(
         ProtocolError.HandshakeFailed,
         "invalid handshake resp"
@@ -846,18 +902,22 @@ var ClientTransport = class extends Transport {
       return false;
     }
     if (!parsed.payload.status.ok) {
-      log?.warn(
-        `${this.clientId} -- received failed handshake resp: ${JSON.stringify(
-          parsed
-        )}`
-      );
+      log?.warn(`received invalid handshake resp`, {
+        clientId: this.clientId,
+        connectedTo: parsed.from,
+        fullTransportMessage: parsed
+      });
       this.protocolError(
         ProtocolError.HandshakeFailed,
         parsed.payload.status.reason
       );
       return false;
     }
-    log?.debug(`${this.clientId} -- handshake from ${parsed.from} ok`);
+    log?.debug(`handshake from ${parsed.from} ok`, {
+      clientId: this.clientId,
+      connectedTo: parsed.from,
+      fullTransportMessage: parsed
+    });
     const session = this.onConnect(
       conn,
       parsed.from,
@@ -874,7 +934,8 @@ var ClientTransport = class extends Transport {
     const canProceedWithConnection = () => this.state === "open";
     if (!canProceedWithConnection()) {
       log?.info(
-        `${this.clientId} -- transport state is no longer open, cancelling attempt to connect to ${to}`
+        `transport state is no longer open, cancelling attempt to connect to ${to}`,
+        { clientId: this.clientId, connectedTo: to }
       );
       return;
     }
@@ -883,7 +944,7 @@ var ClientTransport = class extends Transport {
       const budgetConsumed = this.retryBudget.getBudgetConsumed(to);
       if (!this.retryBudget.hasBudget(to)) {
         const errMsg = `tried to connect to ${to} but retry budget exceeded (more than ${budgetConsumed} attempts in the last ${this.retryBudget.totalBudgetRestoreTime}ms)`;
-        log?.warn(`${this.clientId} -- ${errMsg}`);
+        log?.warn(errMsg, { clientId: this.clientId, connectedTo: to });
         this.protocolError(ProtocolError.RetriesExceeded, errMsg);
         return;
       }
@@ -892,9 +953,10 @@ var ClientTransport = class extends Transport {
       if (backoffMs > 0) {
         sleep = new Promise((resolve) => setTimeout(resolve, backoffMs));
       }
-      log?.info(
-        `${this.clientId} -- attempting connection to ${to} (${backoffMs}ms backoff)`
-      );
+      log?.info(`attempting connection to ${to} (${backoffMs}ms backoff)`, {
+        clientId: this.clientId,
+        connectedTo: to
+      });
       this.retryBudget.consumeBudget(to);
       reconnectPromise = sleep.then(() => {
         if (!canProceedWithConnection()) {
@@ -903,7 +965,12 @@ var ClientTransport = class extends Transport {
       }).then(() => this.createNewOutgoingConnection(to)).then((conn) => {
         if (!canProceedWithConnection()) {
           log?.info(
-            `${this.clientId} -- transport state is no longer open, closing pre-handshake connection (id: ${conn.debugId}) to ${to}`
+            `transport state is no longer open, closing pre-handshake connection to ${to}`,
+            {
+              clientId: this.clientId,
+              connectedTo: to,
+              connId: conn.debugId
+            }
           );
           conn.close();
           throw new Error("transport state is no longer open");
@@ -913,9 +980,10 @@ var ClientTransport = class extends Transport {
       });
       this.inflightConnectionPromises.set(to, reconnectPromise);
     } else {
-      log?.info(
-        `${this.clientId} -- attempting connection to ${to} (reusing previous attempt)`
-      );
+      log?.info(`attempting connection to ${to} (reusing previous attempt)`, {
+        clientId: this.clientId,
+        connectedTo: to
+      });
     }
     try {
       await reconnectPromise;
@@ -923,11 +991,15 @@ var ClientTransport = class extends Transport {
       this.inflightConnectionPromises.delete(to);
       const errStr = coerceErrorString(error);
       if (!this.reconnectOnConnectionDrop || !canProceedWithConnection()) {
-        log?.warn(`${this.clientId} -- connection to ${to} failed (${errStr})`);
+        log?.warn(`connection to ${to} failed (${errStr})`, {
+          clientId: this.clientId,
+          connectedTo: to
+        });
       } else {
-        log?.warn(
-          `${this.clientId} -- connection to ${to} failed (${errStr}), retrying`
-        );
+        log?.warn(`connection to ${to} failed (${errStr}), retrying`, {
+          clientId: this.clientId,
+          connectedTo: to
+        });
         return this.connect(to);
       }
     }
@@ -939,7 +1011,10 @@ var ClientTransport = class extends Transport {
   sendHandshake(to, conn) {
     const session = this.getOrCreateSession(to, conn);
     const requestMsg = handshakeRequestMessage(this.clientId, to, session.id);
-    log?.debug(`${this.clientId} -- sending handshake request to ${to}`);
+    log?.debug(`sending handshake request to ${to}`, {
+      clientId: this.clientId,
+      connectedTo: to
+    });
     conn.send(this.codec.toBuffer(requestMsg));
   }
   close() {
@@ -1000,7 +1075,10 @@ var WebSocketClientTransport = class extends ClientTransport {
   }
   async createNewOutgoingConnection(to) {
     const wsRes = await new Promise((resolve) => {
-      log?.info(`${this.clientId} -- establishing a new websocket to ${to}`);
+      log?.info(`establishing a new websocket to ${to}`, {
+        clientId: this.clientId,
+        connectedTo: to
+      });
       this.wsGetter(to).then((ws) => {
         if (ws.readyState === ws.OPEN) {
           resolve({ ws });
@@ -1029,9 +1107,10 @@ var WebSocketClientTransport = class extends ClientTransport {
     });
     if ("ws" in wsRes) {
       const conn = new WebSocketConnection(wsRes.ws);
-      log?.info(
-        `${this.clientId} -- websocket (id: ${conn.debugId}) to ${to} ok`
-      );
+      log?.info(`raw websocket to ${to} ok, starting handshake`, {
+        clientId: this.clientId,
+        connectedTo: to
+      });
       this.handleConnection(conn, to);
       return conn;
     } else {

package/dist/transport/impls/ws/client.d.cts

@@ -1,6 +1,7 @@
 import WebSocket from 'isomorphic-ws';
-import { b as ClientTransport, c as TransportClientId, d as ProvidedClientTransportOptions } from '../../../index-9e300e8a.js';
-import { W as WebSocketConnection } from '../../../connection-c4a17403.js';
+import { b as ClientTransport, P as ProvidedClientTransportOptions } from '../../../index-d412ca83.js';
+import { T as TransportClientId } from '../../../index-46ed19d8.js';
+import { W as WebSocketConnection } from '../../../connection-893bd769.js';
 import '../../../types-3e5768ec.js';
 import '@sinclair/typebox';
 

package/dist/transport/impls/ws/client.d.ts

@@ -1,6 +1,7 @@
 import WebSocket from 'isomorphic-ws';
-import { b as ClientTransport, c as TransportClientId, d as ProvidedClientTransportOptions } from '../../../index-9e300e8a.js';
-import { W as WebSocketConnection } from '../../../connection-c4a17403.js';
+import { b as ClientTransport, P as ProvidedClientTransportOptions } from '../../../index-d412ca83.js';
+import { T as TransportClientId } from '../../../index-46ed19d8.js';
+import { W as WebSocketConnection } from '../../../connection-893bd769.js';
 import '../../../types-3e5768ec.js';
 import '@sinclair/typebox';
 

package/dist/transport/impls/ws/client.js

@@ -1,13 +1,13 @@
 import {
   WebSocketConnection
-} from "../../../chunk-F3LFO3GU.js";
+} from "../../../chunk-5YDJDYVB.js";
 import {
   ClientTransport
-} from "../../../chunk-7WY3Z5ZN.js";
+} from "../../../chunk-UNTGVPI6.js";
 import "../../../chunk-VH3NGOXQ.js";
 import {
   log
-} from "../../../chunk-H4BYJELI.js";
+} from "../../../chunk-XCQF55SQ.js";
 import "../../../chunk-GZ7HCLLM.js";
 
 // transport/impls/ws/client.ts
@@ -29,7 +29,10 @@ var WebSocketClientTransport = class extends ClientTransport {
   }
   async createNewOutgoingConnection(to) {
     const wsRes = await new Promise((resolve) => {
-      log?.info(`${this.clientId} -- establishing a new websocket to ${to}`);
+      log?.info(`establishing a new websocket to ${to}`, {
+        clientId: this.clientId,
+        connectedTo: to
+      });
       this.wsGetter(to).then((ws) => {
         if (ws.readyState === ws.OPEN) {
           resolve({ ws });
@@ -58,9 +61,10 @@ var WebSocketClientTransport = class extends ClientTransport {
     });
     if ("ws" in wsRes) {
       const conn = new WebSocketConnection(wsRes.ws);
-      log?.info(
-        `${this.clientId} -- websocket (id: ${conn.debugId}) to ${to} ok`
-      );
+      log?.info(`raw websocket to ${to} ok, starting handshake`, {
+        clientId: this.clientId,
+        connectedTo: to
+      });
       this.handleConnection(conn, to);
       return conn;
     } else {