Argus RPC

Overview

Argus RPC v2 is a compact TypeScript RPC runtime and wire protocol built from first principles over persistent TCP. It uses a 14-byte binary frame header and uint32 message IDs to multiplex independent calls without imposing HTTP semantics on the transport, with explicit failure behaviour for deadlines, cancellation, overload, retries, backpressure, and unhealthy connections.

Platform proof

The v2 rewrite focuses on the failure cases that make network runtimes difficult in practice: hostile declared frame lengths, arbitrary TCP fragmentation, write backpressure, out-of-order completion, message-ID wraparound, deadline and cancellation races, overloaded servers, transient retry classification, failed pooled connections, circuit breaking, and bounded observability. The result remains deliberately small and unary-RPC focused rather than hiding incomplete streaming or cross-language features behind a broad feature list.

Key capabilities

Protocol and resource limits

Argus validates declared lengths before waiting for frame bodies, separates practical configurable ceilings from wider wire-field maxima, reserves message ID zero, and safely wraps uint32 IDs while avoiding collisions with live calls.

Reliability model

Calls can complete out of order on a shared connection. Retries are opt-in and status-aware rather than applied to every application failure, while transport failures retire unhealthy pooled channels so capacity can be recreated instead of leaving dead connections occupying pool slots.

Technical profile

Architecture signal

Observability and extensibility

The metrics model keeps bounded aggregate state rather than retaining per-call latency samples. Interceptors provide a composable policy boundary for authentication, authorization, tracing, tenant context, and application-specific measurements without coupling those concerns to the wire decoder.

Verification and release

The v2 release checkpoint is verified by CI across Node 20, 22, and 24 with clean install, strict TypeScript typechecking, the full test suite, and package build; Node 22 additionally runs npm pack --dry-run. The suite covers malformed and oversized frames, random fragmentation, backpressure races, out-of-order concurrency, deadline/cancellation races, retry behaviour, multiplexed pooling, circuit breaking, keepalive, interceptors, metrics, and benchmark execution.

Benchmark discipline

The benchmark harness now records error rate, average latency, p50/p90/p95/p99/max latency, requests per second, warmup configuration, and machine/runtime metadata, with optional machine-readable JSON output. Argus intentionally does not publish a made-up throughput multiplier: performance results are only meaningful with the commit, machine, Node version, concurrency, payload shape, request count, and methodology attached.

Engineering focus

Skills

Technical note

Argus v2 keeps the network mechanics explicit: bytes belong to the protocol layer, sockets and backpressure belong to transport, deadlines and cancellation belong to RPC semantics, retry/pool/health behaviour belongs to policy, and observability measures the runtime without changing correctness. The project is intentionally scoped to robust unary request/response RPC over raw TCP; it does not claim integrated TLS, streaming, negotiated compression, service discovery, or cross-language code generation as completed v2 features.