Preserve computed metrics when the JSON-RPC message backlog overflows

Author: ZelAnton

CHANGELOG.md

@@ -109,6 +109,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - `FirstLineAsync` now preserves cancellation that arrives after a matching line, including while the child is being reaped, and no longer masks a `FinishAsync` error.
 - Linux cgroup legacy hard kills now verify that the reusable cgroup thawed and surface a typed `ProcessError.Io` through `ProcessGroup.KillAll()` and `Signal.Kill` instead of reporting success for a group still frozen; final disposal remains best-effort.
 - `JsonRpcSession` now gives an already-claimed response priority over a concurrent timeout or cancellation, so a successful answer cannot be replaced by a typed deadline error during pending-request completion.
+- `JsonRpcSession` no longer fabricates total message or byte counts when a peer request is evicted from its decoded-message backlog: the terminal `ProcessError.OutputTooLarge` reports zero for both uncounted totals, while notification drops remain counted by `DroppedMessages` and session termination is unchanged.
 - POSIX `LaunchDetached` now transfers each direct child to a private background reaper, preventing zombies in long-lived parents while preserving the pid-and-start-time-only detached API.
 - Ending a POSIX `Pty` run's stdin now actually reaches the child: a drained `Command.Stdin` source, `ProcessStdin.FinishAsync`, and `PtySession.CloseStdinAsync` deliver the terminal's configured end-of-input character (`termios.c_cc[VEOF]`, read from the pty rather than assumed to be Ctrl-D) twice — terminating an unterminated line and then ending input — so a child reading to EOF such as `cat` or a shell `read` loop finishes instead of hanging; the shared pty master stays open and owned by the merged output stream, writes through a finished stdin handle are refused, and a delivery that genuinely fails is now reported (`IOException`, or a typed `ProcessError.Io`/`ProcessError.Stdin`) instead of silently dropped.
 - `WaitForPortAsync`, `WaitForSocketAsync`, `WaitForHttpAsync`, and `WaitForAsync` now check their condition exactly one more time — bounded by the remaining timeout, a brief grace, and the caller's token — after observing the child's exit, so readiness published immediately before that exit reports `Ok` instead of being lost as `NotReady`; a `WaitForAsync` predicate is therefore invoked once more after the child exits, unless the token is already cancelled or the deadline already spent.

README.md

@@ -870,7 +870,10 @@ waits, and disposal release the parked writer before waiting for the process out
 For conversational language-server, build-server, or MCP-style children, use the
 [JSON-RPC 2.0 session layer](docs/streaming.md#json-rpc-sessions-lsp--bsp--mcp). It rejects every
 incoming frame whose `jsonrpc` member is missing, non-string, or not exactly `"2.0"` with a typed
-`ProcessError.Parse` before request, notification, or response routing.
+`ProcessError.Parse` before request, notification, or response routing. Its decoded-message backlog
+may drop old notifications, counted by `DroppedMessages`; evicting a peer request ends the session
+with `ProcessError.OutputTooLarge`, whose totals are zero because this backlog does not count total
+messages or bytes.
 
 ### Interactive stdin — write requests, read responses
 

src/ProcessKit/JsonRpcSession.fs

@@ -198,7 +198,9 @@ type private DropCounter() =
 /// **Two backlogs, two knobs.** `messageBacklog` (the third constructor argument, 1024 by default)
 /// bounds the DECODED incoming messages waiting for `MessagesAsync`. Old notifications may be dropped
 /// and are counted in `DroppedMessages`; a peer request is never silently dropped — if it would be
-/// evicted, the conversation ends with `ProcessError.OutputTooLarge`. `Command.StreamBuffer` bounds the
+/// evicted, the conversation ends with `ProcessError.OutputTooLarge`. The decoded-message backlog does
+/// not count a total message or byte volume, so that error carries zero totals (the `ProcessError`
+/// convention for an unreported metric). `Command.StreamBuffer` bounds the
 /// raw frame backlog underneath it, through the `ContentLengthSession` this session owns, and only its
 /// two LOSSLESS full modes apply there: `Backpressure` paces the peer against the router, and `Error`
 /// ends the conversation with `ProcessError.OutputTooLarge` at the cap. The two DROP modes are refused
@@ -271,13 +273,9 @@ type JsonRpcSession
         )
 
     let messageBacklogOverflow () =
-        let totalMessages =
-            if messageBacklog = Int32.MaxValue then
-                Int32.MaxValue
-            else
-                messageBacklog + 1
-
-        ProcessError.OutputTooLarge(program, None, None, totalMessages, 0)
+        // This backlog counts dropped notifications, but not total messages or bytes. Zero is the
+        // ProcessError convention for a metric this producer did not measure.
+        ProcessError.OutputTooLarge(program, None, None, 0, 0)
 
     let parseFailure (detail: string) = ProcessError.Parse(program, detail)
 

tests/ProcessKit.Tests/JsonRpcSessionTests.fs

@@ -1705,7 +1705,7 @@ type JsonRpcSessionTests() =
         :> Task
 
     [<Test>]
-    member _.``evicting a peer request faults a mixed inbound backlog instead of losing it silently``() : Task =
+    member _.``evicting a peer request after notification drops reports no fabricated totals``() : Task =
         task {
             let peer = peerHandle ()
             use running = peer.Running
@@ -1716,30 +1716,36 @@ type JsonRpcSessionTests() =
 
             peer.Stdout.Emit(framed "{\"jsonrpc\":\"2.0\",\"method\":\"note/1\"}")
 
-            peer.Stdout.Emit(framed "{\"jsonrpc\":\"2.0\",\"id\":7,\"method\":\"workspace/configuration\"}")
-
             peer.Stdout.Emit(framed "{\"jsonrpc\":\"2.0\",\"method\":\"note/2\"}")
             peer.Stdout.Emit(framed "{\"jsonrpc\":\"2.0\",\"method\":\"note/3\"}")
+            peer.Stdout.Emit(framed "{\"jsonrpc\":\"2.0\",\"method\":\"note/4\"}")
+
+            peer.Stdout.Emit(framed "{\"jsonrpc\":\"2.0\",\"id\":7,\"method\":\"workspace/configuration\"}")
+
+            peer.Stdout.Emit(framed "{\"jsonrpc\":\"2.0\",\"method\":\"note/5\"}")
+            peer.Stdout.Emit(framed "{\"jsonrpc\":\"2.0\",\"method\":\"note/6\"}")
 
             // The pending local request is completed by endSession, so this is a deterministic fence
             // for the overflow without a delay or a response frame the faulted router could not read.
             match! call with
             | Error(ProcessError.OutputTooLarge(program, None, None, totalMessages, totalBytes)) ->
                 Assert.That(program, Is.EqualTo "language-server")
-                Assert.That(totalMessages, Is.EqualTo 3)
+                Assert.That(totalMessages, Is.EqualTo 0)
                 Assert.That(totalBytes, Is.EqualTo 0)
             | other -> Assert.Fail $"expected a typed decoded-backlog overflow, got {other}"
 
-            let droppedMessage = "only the admissibly lossy notification is counted as dropped"
-            Assert.That(session.DroppedMessages, Is.EqualTo 1L, droppedMessage)
+            let droppedMessage =
+                "only notifications are counted as dropped; the evicted request is not"
+
+            Assert.That(session.DroppedMessages, Is.EqualTo 4L, droppedMessage)
 
             match! session.RequestRawAsync("shutdown", null) with
             | Error(ProcessError.OutputTooLarge _) -> ()
             | other -> Assert.Fail $"expected the overflow to remain the session's terminal error, got {other}"
 
             let messages = session.MessagesAsync().GetAsyncEnumerator()
 
-            for expected in [ "note/2"; "note/3" ] do
+            for expected in [ "note/5"; "note/6" ] do
                 let! received = messages.MoveNextAsync()
                 Assert.That(received, Is.True)
                 Assert.That(messages.Current.Method, Is.EqualTo expected)
@@ -1751,7 +1757,7 @@ type JsonRpcSessionTests() =
             | null -> Assert.Fail "expected the decoded-message stream to fault after draining retained notifications"
             | error ->
                 match error.Error with
-                | ProcessError.OutputTooLarge(_, None, None, 3, 0) -> ()
+                | ProcessError.OutputTooLarge(_, None, None, 0, 0) -> ()
                 | other -> Assert.Fail $"expected the same OutputTooLarge terminal error, got {other}"
 
             do! messages.DisposeAsync()