APP-14871: Report WebRTC client connection metadata

[Daniel Botros (danielbotros)]

Port of goutils#583 to rust-utils. After a WebRTC dial finishes — success or failure — the client best-effort reports to the app signaling server it dialed through: the furthest dial stage reached, the gRPC failure code, the dial duration, how the dial was signaled, and the selected ICE candidate pair per side (host / stun / relay, plus the relay address).

Changes

• New src/rpc/dial_report.rs — the reporting subsystem: StageTracker (monotonic atomic dial stage), classify_signaling_path, classify_connection / classify_candidate (reads peer.get_stats() and maps the nominated + succeeded ICE candidate pair to host/stun/relay + relay address), failure_code (extracts a tonic::Status code, else UNKNOWN), should_deliver (report-selection semantics), and send_dial_report (best-effort delivery, 5s timeout). Includes unit tests.
• src/rpc/dial.rs — maybe_connect_via_webrtc is split into a reporting wrapper and an _inner; stage advance() calls are threaded through the dial, the spawned call-response task, and the ICE callback. Both connect_inner variants classify the signaling path and pass it down. The report is built and delivered on a detached tokio::spawn over the same already-authenticated, rpc-host-stamped signaling channel, so reporting adds no latency to the dial.
• src/rpc/webrtc.rs — new_peer_connection_for_client takes the stage tracker and advances DTLS_CONNECTED on peer-connection Connected.

The proto types are already vendored on main (Automated Protos Update #187), so no src/gen changes are needed.

This PR is three commits: (1) cloud-signaled reporting; (2) the local-signaled case (Go's fixUpReportDialOpts); (3) refinements to failure suppression, stage tracking, and test gating.

Design notes / divergences from Go

• Cloud-signaled dials (routed through app.viam.com / app.viam.dev) report over their own authenticated channel.
• Locally-signaled WebRTC dials — dialing a .local.viam.cloud name or a LAN address directly, i.e. WebRTC signaled through the robot's own signaling server — report to prod app, reconstructing an authenticated connection reusing the dial's credentials and stamping the robot's rpc-host (only app implements ReportConnectionMetadata; a robot's local signaling server doesn't aggregate these metrics). A locally-signaled dial with no credentials is dropped, matching Go. Like Go, the app address is hard-coded to prod, so a staging robot dialed locally isn't routed to app.viam.dev.
• mDNS-discovered dials are direct gRPC, not WebRTC, so they have no report (WebRTC-over-mDNS is a future feature, RSDK-14026).
• should_deliver: on success only a READY report is delivered. Failures are reported only for cloud-signaled dials — rust-utils falls back to direct gRPC on any WebRTC failure, and for a local dial that fallback to the robot generally succeeds, so the WebRTC failure did not fail the dial and is suppressed (a cloud robot isn't directly reachable, so a cloud WebRTC failure is terminal and is reported). This mirrors Go suppressing non-READY reports when the logical dial nonetheless succeeded.
• SIGNALING_CONNECTED is set at the start of the WebRTC dial (the channel is already eagerly connected by create_channel), so a config-RPC failure against a reachable signaler reports SIGNALING_CONNECTED rather than UNSPECIFIED, matching Go.
• Reporting runs entirely on a detached task (with timeouts) and never adds latency to or fails the dial. It is disabled under cfg(test) and whenever VIAM_DISABLE_DIAL_REPORTING is set — the latter so integration-test / CI harnesses (which cfg(test) doesn't cover) can opt out; the echo integration tests set it.
• The public C ABI / viam_rust_utils.h is unchanged (only internal functions changed).

Downstream SDKs

No code changes are required in the C++ or Python SDKs. Both dial through the rust-utils FFI (dial → DialBuilder::connect(), the instrumented path) and download libviam_rust_utils from rust-utils/releases/latest at build time, so they pick this up automatically once it merges, a new rust-utils release is cut, and each SDK is rebuilt. Receiver-side requirement: the app signaling server must implement ReportConnectionMetadata (otherwise the client gets Unimplemented, logged at debug — harmless).

Testing

• cargo build clean; cargo clippy clean on the new/changed code.
• cargo test --lib — all pass (4 new dial_report tests).

🤖 Generated with Claude Code