implemented ping-pong heartbeats. adjusted logs and defaults.

outbound/worker.go

@@ -208,11 +208,15 @@ func (s *Session) Start(
 
 		// start session
 		var wg sync.WaitGroup
-		wg.Add(2)
+		wg.Add(3)
 		go func() {
 			defer wg.Done()
 			RunReader(sctx, onStop, conn, s.messages, s.heartbeat, s.logger)
 		}()
+		go func() {
+			defer wg.Done()
+			RunHeartbeatForwarder(sctx, conn, s.heartbeat, s.logger)
+		}()
 		go func() {
 			defer wg.Done()
 			RunStopMonitor(sctx, onStop, conn, s.keepalive, s.logger)
@@ -289,6 +293,29 @@ func RunReader(
 	}
 }
 
+func RunHeartbeatForwarder(
+	ctx context.Context,
+	conn *transport.Connection,
+	heartbeat chan<- struct{},
+	logger *slog.Logger,
+) {
+	for {
+		select {
+		case <-ctx.Done():
+			return
+		case <-conn.Heartbeat():
+			select {
+			case heartbeat <- struct{}{}:
+				if logger != nil {
+					logger.Debug("ping-pong heartbeat")
+				}
+			case <-ctx.Done():
+				return
+			}
+		}
+	}
+}
+
 func RunStopMonitor(
 	ctx context.Context,
 	onStop func(),

outbound/worker_session_inner_test.go

@@ -144,6 +144,39 @@ func TestRunReader(t *testing.T) {
 	})
 }
 
+func TestHeartbeatForwarder(t *testing.T) {
+	t.Run("connection level heartbeat propagates", func(t *testing.T) {
+		socket, _, _ := honeybeetest.SetupTestSocket(t)
+		var pongHandler func(string) error
+		socket.SetPongHandlerFunc = func(h func(string) error) { pongHandler = h }
+
+		conn, err := transport.NewConnectionFromSocket(socket, nil, nil)
+		assert.NoError(t, err)
+
+		heartbeat := make(chan struct{}, 1)
+		ctx, cancel := context.WithCancel(context.Background())
+		defer cancel()
+
+		go RunHeartbeatForwarder(ctx, conn, heartbeat, nil)
+
+		honeybeetest.Eventually(t, func() bool {
+			return pongHandler != nil
+		}, "expected Connection to register PongHandler")
+
+		if pongHandler == nil {
+			t.Fatal("pong handler was never set")
+		}
+
+		pongHandler("") // Trigger pong
+
+		select {
+		case <-heartbeat:
+		case <-time.After(time.Second):
+			t.Fatal("pong did not propagate to worker heartbeat")
+		}
+	})
+}
+
 func TestRunStopMonitor(t *testing.T) {
 	t.Run("keepalive signal calls conn.Close and cancel", func(t *testing.T) {
 		conn, _, _, _ := setupTestConnection(t)