@replit/river 0.21.1 → 0.23.0

package/dist/{chunk-JMXO5L2X.js → chunk-MJUFKPBT.js}

@@ -4,11 +4,14 @@ import {
   OpaqueTransportMessageSchema,
   PROTOCOL_VERSION,
   coerceErrorString,
+  createConnectionTelemetryInfo,
+  createSessionTelemetryInfo,
+  getPropagationContext,
   handshakeRequestMessage,
   handshakeResponseMessage,
   isAck,
   tracing_default
-} from "./chunk-5WFL722S.js";
+} from "./chunk-PCKHBAVP.js";
 import {
   log
 } from "./chunk-OTQNCLFH.js";
@@ -18,17 +21,20 @@ import {
 
 // transport/session.ts
 import { customAlphabet } from "nanoid";
+import { SpanStatusCode } from "@opentelemetry/api";
 var nanoid = customAlphabet("1234567890abcdefghijklmnopqrstuvxyz", 6);
 var unsafeId = () => nanoid();
 var Connection = class {
-  debugId;
+  id;
+  telemetry;
   constructor() {
-    this.debugId = `conn-${unsafeId()}`;
+    this.id = `conn-${nanoid(12)}`;
   }
 };
 var Session = class {
   codec;
   options;
+  telemetry;
   /**
    * The buffer of messages that have been sent but not yet acknowledged.
    */
@@ -48,12 +54,6 @@ var Session = class {
    * for this session.
    */
   advertisedSessionId;
-  /**
-   * The metadata for this session, as parsed from the handshake.
-   *
-   * Will only ever be populated on the server side.
-   */
-  metadata;
   /**
    * Number of messages we've sent along this session (excluding handshake and acks)
    */
@@ -75,7 +75,7 @@ var Session = class {
    * The interval for sending heartbeats.
    */
   heartbeat;
-  constructor(conn, from, to, options) {
+  constructor(conn, from, to, options, propagationCtx) {
     this.id = `session-${nanoid(12)}`;
     this.options = options;
     this.from = from;
@@ -87,13 +87,14 @@ var Session = class {
       () => this.sendHeartbeat(),
       options.heartbeatIntervalMs
     );
+    this.telemetry = createSessionTelemetryInfo(this, propagationCtx);
   }
   get loggingMetadata() {
     return {
       clientId: this.from,
       connectedTo: this.to,
       sessionId: this.id,
-      connId: this.connection?.debugId
+      connId: this.connection?.id
     };
   }
   /**
@@ -138,6 +139,7 @@ var Session = class {
           `closing connection to ${this.to} due to inactivity (missed ${misses} heartbeats which is ${missDuration}ms)`,
           this.loggingMetadata
         );
+        this.telemetry.span.addEvent("closing connection due to inactivity");
         this.closeStaleConnection();
       }
       return;
@@ -159,21 +161,25 @@ var Session = class {
   sendBufferedMessages(conn) {
     log?.info(`resending ${this.sendBuffer.length} buffered messages`, {
       ...this.loggingMetadata,
-      connId: conn.debugId
+      connId: conn.id
     });
     for (const msg of this.sendBuffer) {
       log?.debug(`resending msg`, {
         ...this.loggingMetadata,
         fullTransportMessage: msg,
-        connId: conn.debugId
+        connId: conn.id
       });
       const ok = conn.send(this.codec.toBuffer(msg));
       if (!ok) {
         const errMsg = `failed to send buffered message to ${this.to} (sus, this is a fresh connection)`;
+        conn.telemetry?.span.setStatus({
+          code: SpanStatusCode.ERROR,
+          message: errMsg
+        });
         log?.error(errMsg, {
           ...this.loggingMetadata,
           fullTransportMessage: msg,
-          connId: conn.debugId,
+          connId: conn.id,
           tags: ["invariant-violation"]
         });
         conn.close();
@@ -292,12 +298,6 @@ var EventDispatcher = class {
 
 // transport/transport.ts
 import { Value } from "@sinclair/typebox/value";
-import {
-  context,
-  propagation,
-  SpanKind,
-  SpanStatusCode
-} from "@opentelemetry/api";
 
 // transport/rateLimit.ts
 var LeakyBucketRateLimit = class {
@@ -371,6 +371,7 @@ var LeakyBucketRateLimit = class {
 };
 
 // transport/transport.ts
+import { SpanStatusCode as SpanStatusCode2 } from "@opentelemetry/api";
 var defaultTransportOptions = {
   heartbeatIntervalMs: 1e3,
   heartbeatsUntilDead: 2,
@@ -449,17 +450,22 @@ var Transport = class {
       status: "connect",
       conn
     });
+    conn.telemetry = createConnectionTelemetryInfo(
+      conn,
+      session.telemetry.span
+    );
     if (isReconnect) {
       session.replaceWithNewConnection(conn);
       log?.info(`reconnected to ${connectedTo}`, session.loggingMetadata);
     }
   }
-  createSession(to, conn) {
+  createSession(to, conn, propagationCtx) {
     const session = new Session(
       conn,
       this.clientId,
       to,
-      this.options
+      this.options,
+      propagationCtx
     );
     this.sessions.set(session.to, session);
     this.eventDispatcher.dispatchEvent("sessionStatus", {
@@ -468,11 +474,11 @@ var Transport = class {
     });
     return session;
   }
-  getOrCreateSession(to, conn, sessionId) {
+  getOrCreateSession(to, conn, sessionId, propagationCtx) {
     let session = this.sessions.get(to);
     let isReconnect = session !== void 0;
     if (session?.advertisedSessionId !== void 0 && sessionId !== void 0 && session.advertisedSessionId !== sessionId) {
-      log?.warn(
+      log?.info(
         `session for ${to} already exists but has a different session id (expected: ${session.advertisedSessionId}, got: ${sessionId}), creating a new one`,
         session.loggingMetadata
       );
@@ -481,7 +487,7 @@ var Transport = class {
       session = void 0;
     }
     if (!session) {
-      session = this.createSession(to, conn);
+      session = this.createSession(to, conn, propagationCtx);
       log?.info(
         `no session for ${to}, created a new one`,
         session.loggingMetadata
@@ -494,6 +500,7 @@ var Transport = class {
   }
   deleteSession(session) {
     session.close();
+    session.telemetry.span.end();
     this.sessions.delete(session.to);
     log?.info(
       `session ${session.id} disconnect from ${session.to}`,
@@ -510,12 +517,16 @@ var Transport = class {
    * @param connectedTo The peer we are connected to.
    */
   onDisconnect(conn, session) {
+    conn.telemetry?.span.end();
     this.eventDispatcher.dispatchEvent("connectionStatus", {
       status: "disconnect",
       conn
     });
     session.connection = void 0;
-    session.beginGrace(() => this.deleteSession(session));
+    session.beginGrace(() => {
+      session.telemetry.span.addEvent("session grace period expired");
+      this.deleteSession(session);
+    });
   }
   /**
    * Parses a message from a Uint8Array into a {@link OpaqueTransportMessage}.
@@ -575,6 +586,10 @@ var Transport = class {
           tags: ["invariant-violation"]
         });
         this.protocolError(ProtocolError.MessageOrderingViolated, errMsg);
+        session.telemetry.span.setStatus({
+          code: SpanStatusCode2.ERROR,
+          message: "message order violated"
+        });
         session.close();
       }
       return;
@@ -685,6 +700,10 @@ var ClientTransport = class extends Transport {
    * tests or a special case where you don't want to reconnect.
    */
   reconnectOnConnectionDrop = true;
+  /**
+   * Optional handshake options for this client.
+   */
+  handshakeExtensions;
   constructor(clientId, providedOptions) {
     super(clientId, providedOptions);
     this.options = {
@@ -694,6 +713,9 @@ var ClientTransport = class extends Transport {
     this.inflightConnectionPromises = /* @__PURE__ */ new Map();
     this.retryBudget = new LeakyBucketRateLimit(this.options);
   }
+  extendHandshake(options) {
+    this.handshakeExtensions = options;
+  }
   handleConnection(conn, to) {
     if (this.state !== "open")
       return;
@@ -702,7 +724,7 @@ var ClientTransport = class extends Transport {
       if (!session) {
         log?.warn(
           `connection to ${to} timed out waiting for handshake, closing`,
-          { clientId: this.clientId, connectedTo: to, connId: conn.debugId }
+          { clientId: this.clientId, connectedTo: to, connId: conn.id }
         );
         conn.close();
       }
@@ -720,6 +742,10 @@ var ClientTransport = class extends Transport {
       conn.addDataListener((data2) => {
         const parsed = this.parseMsg(data2);
         if (!parsed) {
+          conn.telemetry?.span.setStatus({
+            code: SpanStatusCode2.ERROR,
+            message: "message parse failure"
+          });
           conn.close();
           return;
         }
@@ -742,6 +768,10 @@ var ClientTransport = class extends Transport {
       }
     });
     conn.addErrorListener((err) => {
+      conn.telemetry?.span.setStatus({
+        code: SpanStatusCode2.ERROR,
+        message: "connection error"
+      });
       log?.warn(`error in connection to ${to}: ${coerceErrorString(err)}`, {
         ...session?.loggingMetadata,
         clientId: this.clientId,
@@ -752,6 +782,10 @@ var ClientTransport = class extends Transport {
   receiveHandshakeResponseMessage(data, conn) {
     const parsed = this.parseMsg(data);
     if (!parsed) {
+      conn.telemetry?.span.setStatus({
+        code: SpanStatusCode2.ERROR,
+        message: "non-transport message"
+      });
       this.protocolError(
         ProtocolError.HandshakeFailed,
         "received non-transport message"
@@ -759,6 +793,10 @@ var ClientTransport = class extends Transport {
       return false;
     }
     if (!Value.Check(ControlMessageHandshakeResponseSchema, parsed.payload)) {
+      conn.telemetry?.span.setStatus({
+        code: SpanStatusCode2.ERROR,
+        message: "invalid handshake response"
+      });
       log?.warn(`received invalid handshake resp`, {
         clientId: this.clientId,
         connectedTo: parsed.from,
@@ -771,7 +809,11 @@ var ClientTransport = class extends Transport {
       return false;
     }
     if (!parsed.payload.status.ok) {
-      log?.warn(`received invalid handshake resp`, {
+      conn.telemetry?.span.setStatus({
+        code: SpanStatusCode2.ERROR,
+        message: "handshake rejected"
+      });
+      log?.warn(`received handshake rejection`, {
         clientId: this.clientId,
         connectedTo: parsed.from,
         fullTransportMessage: parsed
@@ -801,142 +843,94 @@ var ClientTransport = class extends Transport {
    * @param to The client ID of the node to connect to.
    */
   async connect(to) {
-    return tracing_default.startActiveSpan(
-      "connect",
-      {
-        attributes: {
-          component: "river",
-          "span.kind": "client"
-        },
-        kind: 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: SpanStatusCode.ERROR });
-        } finally {
-          span.end();
-        }
+    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;
       }
-    );
-  }
-  async connectAttempt(to, attempt = 0) {
-    const retry = await tracing_default.startActiveSpan(
-      "connect",
-      {
-        attributes: {
-          component: "river",
-          "river.attempt": attempt,
-          "span.kind": "client"
-        },
-        kind: SpanKind.CLIENT
-      },
-      async (span) => {
+      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 = tracing_default.startActiveSpan("connect", async (span) => {
         try {
-          const canProceedWithConnection = () => this.state === "open";
+          span.addEvent("backoff", { backoffMs });
+          await sleep;
           if (!canProceedWithConnection()) {
-            log?.info(
-              `transport state is no longer open, cancelling attempt to connect to ${to}`,
-              { clientId: this.clientId, connectedTo: to }
-            );
-            return false;
+            throw new Error("transport state is no longer open");
           }
-          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;
-            }
-            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 {
+          span.addEvent("connecting");
+          const conn = await this.createNewOutgoingConnection(to);
+          if (!canProceedWithConnection()) {
             log?.info(
-              `attempting connection to ${to} (reusing previous attempt)`,
+              `transport state is no longer open, closing pre-handshake connection to ${to}`,
               {
                 clientId: this.clientId,
-                connectedTo: to
+                connectedTo: to,
+                connId: conn.id
               }
             );
+            conn.close();
+            throw new Error("transport state is no longer open");
           }
-          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.addEvent("sending handshake");
+          const ok = await this.sendHandshake(to, conn);
+          if (!ok) {
+            conn.close();
+            throw new Error("failed to send handshake");
           }
-          span.setStatus({ code: SpanStatusCode.ERROR });
+          return conn;
+        } catch (err) {
+          const errStr = coerceErrorString(err);
+          span.recordException(errStr);
+          span.setStatus({ code: SpanStatusCode2.ERROR });
+          throw err;
         } finally {
           span.end();
         }
-        return false;
+      });
+      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);
       }
-    );
-    if (retry) {
-      return this.connectAttempt(to, attempt + 1);
     }
   }
   deleteSession(session) {
@@ -944,13 +938,11 @@ var ClientTransport = class extends Transport {
     super.deleteSession(session);
   }
   async sendHandshake(to, conn) {
-    const tracing = { traceparent: "", tracestate: "" };
-    propagation.inject(context.active(), tracing);
     let metadata;
-    if (this.options.handshake) {
-      metadata = await this.options.handshake.get();
-      if (!Value.Check(this.options.handshake.schema, metadata)) {
-        log?.error(`handshake metadata did not match schema`, {
+    if (this.handshakeExtensions) {
+      metadata = await this.handshakeExtensions.construct();
+      if (!Value.Check(this.handshakeExtensions.schema, metadata)) {
+        log?.error(`constructed handshake metadata did not match schema`, {
           clientId: this.clientId,
           connectedTo: to,
           tags: ["invariant-violation"]
@@ -959,6 +951,10 @@ var ClientTransport = class extends Transport {
           ProtocolError.HandshakeFailed,
           "handshake metadata did not match schema"
         );
+        conn.telemetry?.span.setStatus({
+          code: SpanStatusCode2.ERROR,
+          message: "handshake meta mismatch"
+        });
         return false;
       }
     }
@@ -968,7 +964,7 @@ var ClientTransport = class extends Transport {
       to,
       session.id,
       metadata,
-      tracing
+      getPropagationContext(session.telemetry.ctx)
     );
     log?.debug(`sending handshake request to ${to}`, {
       clientId: this.clientId,
@@ -987,280 +983,240 @@ var ServerTransport = class extends Transport {
    * The options for this transport.
    */
   options;
+  /**
+   * Optional handshake options for the server.
+   */
+  handshakeExtensions;
+  /**
+   * A map of session handshake data for each session.
+   */
+  sessionHandshakeMetadata;
   constructor(clientId, providedOptions) {
     super(clientId, providedOptions);
     this.options = {
       ...defaultServerTransportOptions,
       ...providedOptions
     };
+    this.sessionHandshakeMetadata = /* @__PURE__ */ new WeakMap();
     log?.info(`initiated server transport`, {
       clientId: this.clientId,
       protocolVersion: PROTOCOL_VERSION
     });
   }
+  extendHandshake(options) {
+    this.handshakeExtensions = options;
+  }
   handleConnection(conn) {
-    tracing_default.startActiveSpan(
-      "handleConnection",
-      {
-        attributes: {
-          component: "river",
-          "span.kind": "server"
-        },
-        kind: SpanKind.SERVER
-      },
-      (span) => {
-        if (this.state !== "open")
-          return;
-        log?.info(`new incoming connection`, {
-          clientId: this.clientId,
-          connId: conn.debugId
+    if (this.state !== "open")
+      return;
+    log?.info(`new incoming connection`, {
+      clientId: this.clientId,
+      connId: conn.id
+    });
+    let session = void 0;
+    const client = () => session?.to ?? "unknown";
+    const handshakeTimeout = setTimeout(() => {
+      if (!session) {
+        log?.warn(
+          `connection to ${client()} timed out waiting for handshake, closing`,
+          {
+            clientId: this.clientId,
+            connectedTo: client(),
+            connId: conn.id
+          }
+        );
+        conn.telemetry?.span.setStatus({
+          code: SpanStatusCode2.ERROR,
+          message: "handshake timeout"
         });
-        let session = void 0;
-        const client = () => session?.to ?? "unknown";
-        const handshakeTimeout = setTimeout(() => {
-          if (!session) {
-            log?.warn(
-              `connection to ${client()} timed out waiting for handshake, closing`,
-              {
-                clientId: this.clientId,
-                connectedTo: client(),
-                connId: conn.debugId
-              }
-            );
-            span.setStatus({ code: SpanStatusCode.ERROR });
-            span.end();
+        conn.close();
+      }
+    }, this.options.sessionDisconnectGraceMs);
+    const buffer = [];
+    let receivedHandshakeMessage = false;
+    const handshakeHandler = (data) => {
+      if (receivedHandshakeMessage) {
+        buffer.push(data);
+        return;
+      }
+      receivedHandshakeMessage = true;
+      clearTimeout(handshakeTimeout);
+      void this.receiveHandshakeRequestMessage(data, conn).then(
+        (maybeSession) => {
+          if (!maybeSession) {
             conn.close();
-          }
-        }, this.options.sessionDisconnectGraceMs);
-        const buffer = [];
-        let receivedHandshakeMessage = false;
-        const handshakeHandler = (data) => {
-          if (receivedHandshakeMessage) {
-            buffer.push(data);
             return;
           }
-          receivedHandshakeMessage = true;
-          clearTimeout(handshakeTimeout);
-          void this.receiveHandshakeRequestMessage(data, conn).then(
-            (maybeSession) => {
-              if (!maybeSession) {
-                span.setStatus({ code: SpanStatusCode.ERROR });
-                span.end();
-                conn.close();
-                return;
-              }
-              session = maybeSession;
-              const dataHandler = (data2) => {
-                const parsed = this.parseMsg(data2);
-                if (!parsed) {
-                  conn.close();
-                  return;
-                }
-                this.handleMsg(parsed);
-              };
-              conn.removeDataListener(handshakeHandler);
-              conn.addDataListener(dataHandler);
-              for (const data2 of buffer) {
-                dataHandler(data2);
-              }
-              buffer.length = 0;
+          session = maybeSession;
+          const dataHandler = (data2) => {
+            const parsed = this.parseMsg(data2);
+            if (!parsed) {
+              conn.close();
+              return;
             }
-          );
-        };
-        conn.addDataListener(handshakeHandler);
-        conn.addCloseListener(() => {
-          if (session) {
-            log?.info(`connection to ${client()} disconnected`, {
-              clientId: this.clientId,
-              connId: conn.debugId
-            });
-            this.onDisconnect(conn, session);
+            this.handleMsg(parsed);
+          };
+          for (const data2 of buffer) {
+            dataHandler(data2);
           }
-          span.setStatus({ code: SpanStatusCode.OK });
-          span.end();
+          conn.removeDataListener(handshakeHandler);
+          conn.addDataListener(dataHandler);
+          buffer.length = 0;
+        }
+      );
+    };
+    conn.addDataListener(handshakeHandler);
+    conn.addCloseListener(() => {
+      if (!session)
+        return;
+      log?.info(`connection to ${client()} disconnected`, {
+        clientId: this.clientId,
+        connId: conn.id
+      });
+      this.onDisconnect(conn, session);
+    });
+    conn.addErrorListener((err) => {
+      conn.telemetry?.span.setStatus({
+        code: SpanStatusCode2.ERROR,
+        message: "connection error"
+      });
+      if (!session)
+        return;
+      log?.warn(
+        `connection to ${client()} got an error: ${coerceErrorString(err)}`,
+        { clientId: this.clientId, connId: conn.id }
+      );
+    });
+  }
+  async validateHandshakeMetadata(conn, session, rawMetadata, from) {
+    let parsedMetadata = {};
+    if (this.handshakeExtensions) {
+      if (!Value.Check(this.handshakeExtensions.schema, rawMetadata)) {
+        conn.telemetry?.span.setStatus({
+          code: SpanStatusCode2.ERROR,
+          message: "malformed handshake meta"
         });
-        conn.addErrorListener((err) => {
-          if (session) {
-            log?.warn(
-              `connection to ${client()} got an error: ${coerceErrorString(
-                err
-              )}`,
-              { clientId: this.clientId, connId: conn.debugId }
-            );
-          }
-          span.setStatus({ code: SpanStatusCode.ERROR });
-          span.end();
+        const reason = "received malformed handshake metadata";
+        const responseMsg = handshakeResponseMessage(this.clientId, from, {
+          ok: false,
+          reason
+        });
+        conn.send(this.codec.toBuffer(responseMsg));
+        log?.warn(`received malformed handshake metadata from ${from}`, {
+          clientId: this.clientId,
+          connId: conn.id
         });
+        this.protocolError(ProtocolError.HandshakeFailed, reason);
+        return false;
       }
-    );
+      parsedMetadata = await this.handshakeExtensions.validate(
+        rawMetadata,
+        session
+      );
+      if (parsedMetadata === false) {
+        const reason = "rejected by handshake handler";
+        conn.telemetry?.span.setStatus({
+          code: SpanStatusCode2.ERROR,
+          message: reason
+        });
+        const responseMsg = handshakeResponseMessage(this.clientId, from, {
+          ok: false,
+          reason
+        });
+        conn.send(this.codec.toBuffer(responseMsg));
+        log?.warn(`rejected handshake from ${from}`, {
+          clientId: this.clientId,
+          connId: conn.id
+        });
+        this.protocolError(ProtocolError.HandshakeFailed, reason);
+        return false;
+      }
+    }
+    return parsedMetadata;
   }
   async receiveHandshakeRequestMessage(data, conn) {
     const parsed = this.parseMsg(data);
     if (!parsed) {
+      conn.telemetry?.span.setStatus({
+        code: SpanStatusCode2.ERROR,
+        message: "non-transport message"
+      });
       this.protocolError(
         ProtocolError.HandshakeFailed,
         "received non-transport message"
       );
       return false;
     }
-    let activeContext = context.active();
-    if (parsed.tracing) {
-      activeContext = propagation.extract(activeContext, parsed.tracing);
+    if (!Value.Check(ControlMessageHandshakeRequestSchema, parsed.payload)) {
+      conn.telemetry?.span.setStatus({
+        code: SpanStatusCode2.ERROR,
+        message: "invalid handshake request"
+      });
+      const reason = "received invalid handshake msg";
+      const responseMsg2 = handshakeResponseMessage(this.clientId, parsed.from, {
+        ok: false,
+        reason
+      });
+      conn.send(this.codec.toBuffer(responseMsg2));
+      const logData = { ...parsed.payload ?? {}, metadata: "redacted" };
+      log?.warn(reason, {
+        clientId: this.clientId,
+        connId: conn.id,
+        partialTransportMessage: { ...parsed, payload: logData }
+      });
+      this.protocolError(
+        ProtocolError.HandshakeFailed,
+        "invalid handshake request"
+      );
+      return false;
     }
-    return tracing_default.startActiveSpan(
-      "receiveHandshakeRequestMessage",
-      {
-        attributes: {
-          component: "river",
-          "span.kind": "server"
-        },
-        kind: SpanKind.SERVER
-      },
-      activeContext,
-      async (span) => {
-        if (!Value.Check(ControlMessageHandshakeRequestSchema, parsed.payload)) {
-          const reason = "received invalid handshake msg";
-          const responseMsg2 = handshakeResponseMessage(
-            this.clientId,
-            parsed.from,
-            {
-              ok: false,
-              reason
-            }
-          );
-          conn.send(this.codec.toBuffer(responseMsg2));
-          const logData = typeof parsed.payload === "object" ? {
-            ...parsed,
-            payload: { ...parsed.payload, metadata: "redacted" }
-          } : { ...parsed };
-          log?.warn(`${reason}: ${JSON.stringify(logData)}`, {
-            clientId: this.clientId,
-            connId: conn.debugId
-          });
-          this.protocolError(
-            ProtocolError.HandshakeFailed,
-            "invalid handshake request"
-          );
-          span.setStatus({ code: SpanStatusCode.ERROR });
-          span.end();
-          return false;
-        }
-        const gotVersion = parsed.payload.protocolVersion;
-        if (gotVersion !== PROTOCOL_VERSION) {
-          const reason = `incorrect version (got: ${gotVersion} wanted ${PROTOCOL_VERSION})`;
-          const responseMsg2 = handshakeResponseMessage(
-            this.clientId,
-            parsed.from,
-            {
-              ok: false,
-              reason
-            }
-          );
-          conn.send(this.codec.toBuffer(responseMsg2));
-          log?.warn(
-            `received handshake msg with incompatible protocol version (got: ${gotVersion}, expected: ${PROTOCOL_VERSION})`,
-            { clientId: this.clientId, connId: conn.debugId }
-          );
-          this.protocolError(ProtocolError.HandshakeFailed, reason);
-          span.setStatus({ code: SpanStatusCode.ERROR });
-          span.end();
-          return false;
-        }
-        const { session, isReconnect } = this.getOrCreateSession(
-          parsed.from,
-          conn,
-          parsed.payload.sessionId
-        );
-        let handshakeMetadata;
-        if (this.options.handshake) {
-          if (!Value.Check(
-            this.options.handshake.requestSchema,
-            parsed.payload.metadata
-          )) {
-            const reason = "received malformed handshake metadata";
-            const responseMsg2 = handshakeResponseMessage(
-              this.clientId,
-              parsed.from,
-              { ok: false, reason }
-            );
-            conn.send(this.codec.toBuffer(responseMsg2));
-            log?.warn(
-              `received malformed handshake metadata from ${parsed.from}`,
-              {
-                clientId: this.clientId,
-                connId: conn.debugId
-              }
-            );
-            this.protocolError(ProtocolError.HandshakeFailed, reason);
-            this.deleteSession(session);
-            span.setStatus({ code: SpanStatusCode.ERROR });
-            span.end();
-            return false;
-          }
-          const parsedMetadata = await this.options.handshake.parse(
-            parsed.payload.metadata,
-            session,
-            isReconnect
-          );
-          if (parsedMetadata === false) {
-            const reason = "rejected by server";
-            const responseMsg2 = handshakeResponseMessage(
-              this.clientId,
-              parsed.from,
-              { ok: false, reason }
-            );
-            conn.send(this.codec.toBuffer(responseMsg2));
-            log?.warn(`rejected handshake from ${parsed.from}`, {
-              clientId: this.clientId,
-              connId: conn.debugId
-            });
-            this.protocolError(ProtocolError.HandshakeFailed, reason);
-            this.deleteSession(session);
-            span.setStatus({ code: SpanStatusCode.ERROR });
-            span.end();
-            return false;
-          }
-          if (!Value.Check(this.options.handshake.parsedSchema, parsedMetadata)) {
-            const reason = "failed to parse handshake metadata";
-            const responseMsg2 = handshakeResponseMessage(
-              this.clientId,
-              parsed.from,
-              { ok: false, reason }
-            );
-            conn.send(this.codec.toBuffer(responseMsg2));
-            log?.error(`failed to parse handshake metadata`, {
-              clientId: this.clientId,
-              connId: conn.debugId,
-              tags: ["invariant-violation"]
-            });
-            this.protocolError(ProtocolError.HandshakeFailed, reason);
-            this.deleteSession(session);
-            span.setStatus({ code: SpanStatusCode.ERROR });
-            span.end();
-            return false;
-          }
-          handshakeMetadata = parsedMetadata;
-        }
-        handshakeMetadata ??= {};
-        session.metadata = handshakeMetadata;
-        log?.debug(
-          `handshake from ${parsed.from} ok, responding with handshake success`,
-          { clientId: this.clientId, connId: conn.debugId }
-        );
-        const responseMsg = handshakeResponseMessage(
-          this.clientId,
-          parsed.from,
-          {
-            ok: true,
-            sessionId: session.id
-          }
-        );
-        conn.send(this.codec.toBuffer(responseMsg));
-        this.onConnect(conn, parsed.from, session, isReconnect);
-        span.end();
-        return session;
-      }
+    const gotVersion = parsed.payload.protocolVersion;
+    if (gotVersion !== PROTOCOL_VERSION) {
+      conn.telemetry?.span.setStatus({
+        code: SpanStatusCode2.ERROR,
+        message: "incorrect protocol version"
+      });
+      const reason = `incorrect version (got: ${gotVersion} wanted ${PROTOCOL_VERSION})`;
+      const responseMsg2 = handshakeResponseMessage(this.clientId, parsed.from, {
+        ok: false,
+        reason
+      });
+      conn.send(this.codec.toBuffer(responseMsg2));
+      log?.warn(
+        `received handshake msg with incompatible protocol version (got: ${gotVersion}, expected: ${PROTOCOL_VERSION})`,
+        { clientId: this.clientId, connId: conn.id }
+      );
+      this.protocolError(ProtocolError.HandshakeFailed, reason);
+      return false;
+    }
+    const oldSession = this.sessions.get(parsed.from);
+    const parsedMetadata = await this.validateHandshakeMetadata(
+      conn,
+      oldSession,
+      parsed.payload.metadata,
+      parsed.from
     );
+    if (parsedMetadata === false) {
+      return false;
+    }
+    const { session, isReconnect } = this.getOrCreateSession(
+      parsed.from,
+      conn,
+      parsed.payload.sessionId,
+      parsed.tracing
+    );
+    this.sessionHandshakeMetadata.set(session, parsedMetadata);
+    log?.debug(
+      `handshake from ${parsed.from} ok, responding with handshake success`,
+      { clientId: this.clientId, connId: conn.id }
+    );
+    const responseMsg = handshakeResponseMessage(this.clientId, parsed.from, {
+      ok: true,
+      sessionId: session.id
+    });
+    conn.send(this.codec.toBuffer(responseMsg));
+    this.onConnect(conn, parsed.from, session, isReconnect);
+    return session;
   }
 };
 
@@ -1273,4 +1229,4 @@ export {
   ClientTransport,
   ServerTransport
 };
-//# sourceMappingURL=chunk-JMXO5L2X.js.map
+//# sourceMappingURL=chunk-MJUFKPBT.js.map