@replit/river 0.19.3 → 0.20.0

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

@@ -26,6 +26,7 @@ module.exports = __toCommonJS(client_exports);
 
 // transport/transport.ts
 var import_value = require("@sinclair/typebox/value");
+var import_api2 = require("@opentelemetry/api");
 
 // transport/message.ts
 var import_typebox = require("@sinclair/typebox");
@@ -40,6 +41,12 @@ var TransportMessageSchema = (t) => import_typebox.Type.Object({
   procedureName: import_typebox.Type.Optional(import_typebox.Type.String()),
   streamId: import_typebox.Type.String(),
   controlFlags: import_typebox.Type.Integer(),
+  tracing: import_typebox.Type.Optional(
+    import_typebox.Type.Object({
+      traceparent: import_typebox.Type.String(),
+      tracestate: import_typebox.Type.String()
+    })
+  ),
   payload: t
 });
 var ControlMessageAckSchema = import_typebox.Type.Object({
@@ -77,7 +84,7 @@ var ControlMessagePayloadSchema = import_typebox.Type.Union([
 var OpaqueTransportMessageSchema = TransportMessageSchema(
   import_typebox.Type.Unknown()
 );
-function handshakeRequestMessage(from, to, sessionId, metadata) {
+function handshakeRequestMessage(from, to, sessionId, metadata, tracing) {
   return {
     id: (0, import_nanoid.nanoid)(),
     from,
@@ -86,6 +93,7 @@ function handshakeRequestMessage(from, to, sessionId, metadata) {
     ack: 0,
     streamId: (0, import_nanoid.nanoid)(),
     controlFlags: 0,
+    tracing,
     payload: {
       type: "HANDSHAKE_REQ",
       protocolVersion: PROTOCOL_VERSION,
@@ -373,6 +381,11 @@ var Session = class {
   }
 };
 
+// tracing/index.ts
+var import_api = require("@opentelemetry/api");
+var tracer = import_api.trace.getTracer("river");
+var tracing_default = tracer;
+
 // util/stringify.ts
 function coerceErrorString(err) {
   if (err instanceof Error) {
@@ -932,82 +945,142 @@ var ClientTransport = class extends Transport {
    * @param to The client ID of the node to connect to.
    */
   async connect(to) {
-    const canProceedWithConnection = () => this.state === "open";
-    if (!canProceedWithConnection()) {
-      log?.info(
-        `transport state is no longer open, cancelling attempt to connect to ${to}`,
-        { clientId: this.clientId, connectedTo: to }
-      );
-      return;
-    }
-    let reconnectPromise = this.inflightConnectionPromises.get(to);
-    if (!reconnectPromise) {
-      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(errMsg, { clientId: this.clientId, connectedTo: to });
-        this.protocolError(ProtocolError.RetriesExceeded, errMsg);
-        return;
-      }
-      let sleep = Promise.resolve();
-      const backoffMs = this.retryBudget.getBackoffMs(to);
-      if (backoffMs > 0) {
-        sleep = new Promise((resolve) => setTimeout(resolve, backoffMs));
-      }
-      log?.info(`attempting connection to ${to} (${backoffMs}ms backoff)`, {
-        clientId: this.clientId,
-        connectedTo: to
-      });
-      this.retryBudget.consumeBudget(to);
-      reconnectPromise = sleep.then(() => {
-        if (!canProceedWithConnection()) {
-          throw new Error("transport state is no longer open");
+    return tracing_default.startActiveSpan(
+      "connect",
+      {
+        attributes: {
+          component: "river",
+          "span.kind": "client"
+        },
+        kind: import_api2.SpanKind.CLIENT
+      },
+      async (span) => {
+        try {
+          await this.connectAttempt(to);
+        } catch (e) {
+          if (e instanceof Error) {
+            span.recordException(e);
+          } else {
+            span.recordException(coerceErrorString(e));
+          }
+          span.setStatus({ code: import_api2.SpanStatusCode.ERROR });
+        } finally {
+          span.end();
         }
-      }).then(() => this.createNewOutgoingConnection(to)).then((conn) => {
-        if (!canProceedWithConnection()) {
-          log?.info(
-            `transport state is no longer open, closing pre-handshake connection to ${to}`,
-            {
-              clientId: this.clientId,
-              connectedTo: to,
-              connId: conn.debugId
+      }
+    );
+  }
+  async connectAttempt(to, attempt = 0) {
+    const retry = await tracing_default.startActiveSpan(
+      "connect",
+      {
+        attributes: {
+          component: "river",
+          "river.attempt": attempt,
+          "span.kind": "client"
+        },
+        kind: import_api2.SpanKind.CLIENT
+      },
+      async (span) => {
+        try {
+          const canProceedWithConnection = () => this.state === "open";
+          if (!canProceedWithConnection()) {
+            log?.info(
+              `transport state is no longer open, cancelling attempt to connect to ${to}`,
+              { clientId: this.clientId, connectedTo: to }
+            );
+            return false;
+          }
+          let reconnectPromise = this.inflightConnectionPromises.get(to);
+          if (!reconnectPromise) {
+            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(errMsg, { clientId: this.clientId, connectedTo: to });
+              this.protocolError(ProtocolError.RetriesExceeded, errMsg);
+              return false;
             }
-          );
-          conn.close();
-          throw new Error("transport state is no longer open");
-        }
-        return this.sendHandshake(to, conn).then((ok) => {
-          if (!ok) {
-            conn.close();
-            throw new Error("failed to send handshake");
+            let sleep = Promise.resolve();
+            const backoffMs = this.retryBudget.getBackoffMs(to);
+            if (backoffMs > 0) {
+              sleep = new Promise((resolve) => setTimeout(resolve, backoffMs));
+            }
+            log?.info(
+              `attempting connection to ${to} (${backoffMs}ms backoff)`,
+              {
+                clientId: this.clientId,
+                connectedTo: to
+              }
+            );
+            this.retryBudget.consumeBudget(to);
+            reconnectPromise = sleep.then(() => {
+              if (!canProceedWithConnection()) {
+                throw new Error("transport state is no longer open");
+              }
+            }).then(() => this.createNewOutgoingConnection(to)).then((conn) => {
+              if (!canProceedWithConnection()) {
+                log?.info(
+                  `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");
+              }
+              return this.sendHandshake(to, conn).then((ok) => {
+                if (!ok) {
+                  conn.close();
+                  throw new Error("failed to send handshake");
+                }
+                return conn;
+              });
+            });
+            this.inflightConnectionPromises.set(to, reconnectPromise);
+          } else {
+            log?.info(
+              `attempting connection to ${to} (reusing previous attempt)`,
+              {
+                clientId: this.clientId,
+                connectedTo: to
+              }
+            );
           }
-          return conn;
-        });
-      });
-      this.inflightConnectionPromises.set(to, reconnectPromise);
-    } else {
-      log?.info(`attempting connection to ${to} (reusing previous attempt)`, {
-        clientId: this.clientId,
-        connectedTo: to
-      });
-    }
-    try {
-      await reconnectPromise;
-    } catch (error) {
-      this.inflightConnectionPromises.delete(to);
-      const errStr = coerceErrorString(error);
-      if (!this.reconnectOnConnectionDrop || !canProceedWithConnection()) {
-        log?.warn(`connection to ${to} failed (${errStr})`, {
-          clientId: this.clientId,
-          connectedTo: to
-        });
-      } else {
-        log?.warn(`connection to ${to} failed (${errStr}), retrying`, {
-          clientId: this.clientId,
-          connectedTo: to
-        });
-        return this.connect(to);
+          try {
+            await reconnectPromise;
+          } catch (error) {
+            this.inflightConnectionPromises.delete(to);
+            const errStr = coerceErrorString(error);
+            if (!this.reconnectOnConnectionDrop || !canProceedWithConnection()) {
+              log?.warn(`connection to ${to} failed (${errStr})`, {
+                clientId: this.clientId,
+                connectedTo: to
+              });
+            } else {
+              log?.warn(`connection to ${to} failed (${errStr}), retrying`, {
+                clientId: this.clientId,
+                connectedTo: to
+              });
+              return true;
+            }
+          }
+        } catch (e) {
+          if (e instanceof Error) {
+            span.recordException(e);
+          } else {
+            span.recordException(coerceErrorString(e));
+          }
+          span.setStatus({ code: import_api2.SpanStatusCode.ERROR });
+        } finally {
+          span.end();
+        }
+        return false;
       }
+    );
+    if (retry) {
+      return this.connectAttempt(to, attempt + 1);
     }
   }
   deleteSession(session) {
@@ -1015,6 +1088,8 @@ var ClientTransport = class extends Transport {
     super.deleteSession(session);
   }
   async sendHandshake(to, conn) {
+    const tracing = { traceparent: "", tracestate: "" };
+    import_api2.propagation.inject(import_api2.context.active(), tracing);
     let metadata;
     if (this.options.handshake) {
       metadata = await this.options.handshake.get();
@@ -1035,7 +1110,8 @@ var ClientTransport = class extends Transport {
       this.clientId,
       to,
       session.id,
-      metadata
+      metadata,
+      tracing
     );
     log?.debug(`sending handshake request to ${to}`, {
       clientId: this.clientId,