fix(observability): classify 'operation timed out' transport phrase as expected

[CodeGhost21]

Summary

• channels::runtime::supervision wraps a listener failure as format!(\"Channel {} error: {e:#}; restarting\", ch.name()) and routes the result through report_error_or_expected. When the discord gateway TCP/WebSocket socket hits ETIMEDOUT, the anyhow chain renders without a URL anchor (this is std::io-level, below reqwest) and previously fell through every classifier arm in expected_error_kind into report_error — one Sentry event per backoff cycle.
• TRANSIENT_TRANSPORT_PHRASES and contains_transient_transport_phrase already treat \"operation timed out\" as transient at other emit sites (authed_json transport branch, is_transient_message_failure), but expected_error_kind — the funnel report_error_or_expected uses — never consulted that list.
• Close the gap by adding \"operation timed out\" to is_network_unreachable_message. Symmetric with \"connection refused\" / \"connection reset\" already in the function (no errno suffix pinned — (os error 60) BSD/macOS, (os error 110) Linux, (os error 10060) Windows WSAETIMEDOUT, and bare prose forms from hyper / tungstenite / std::io all share the lowercase substring).

Problem

Sentry OPENHUMAN-TAURI-EM — \"Channel discord error: IO error: Operation timed out (os error 60); restarting\" — fired 128 times between 2026-05-19 and 2026-05-27, all tagged logger=openhuman_core::openhuman::channels::runtime::supervision. Every event is one supervisor backoff cycle on a flaky discord WebSocket; the supervisor already handles this via exponential backoff ("; restarting" suffix in the wrapper), so the Sentry event is pure noise.

The classifier already had the right primitive (TRANSIENT_TRANSPORT_PHRASES) and the right helper (contains_transient_transport_phrase); expected_error_kind just never wired them in. Same root cause would apply to any channel (Channel slack error: ..., Channel telegram error: ...) and any std::io-level timeout that surfaces without a URL anchor.

Solution

src/core/observability.rs — single line added to is_network_unreachable_message:

|| lower.contains(\"operation timed out\")

with a block comment documenting the OPENHUMAN-TAURI-EM shape, the platform-agnostic errno renderings (60 / 110 / 10060), and why no per-errno pinning is needed.

Routing through NetworkUnreachable (vs. introducing a new TransientTransport variant) keeps the diff small and is the closest existing semantic bucket — report_expected_message demotes the event to a structured warn! log either way, so the downstream behavior is identical. The classifier order is unchanged; the new branch sits next to \"connection reset\".

Submission Checklist

• Tests added — channel_supervisor_operation_timed_out_classifies_as_expected (macOS / Linux / Windows wire shapes + provider-agnostic supervisor wrapper across discord/slack/telegram + bare-prose form without errno) and operation_timed_out_negative_cases_still_report (\"timeout\" as a config knob, no \"operation timed out\" anchor → still reaches Sentry).
• Diff coverage ≥ 80% — the one new line in is_network_unreachable_message is hit by all six positive-case strings.
• Coverage matrix updated — N/A: classifier refinement on an existing path; no feature row added/removed/renamed.
• No new external network dependencies — none.
• Linked issue closed via Closes #NNN — N/A: surfaced from Sentry, no GitHub tracking issue filed.

Impact

• Platform: desktop (all) — the classifier runs in the core, which is shared. Mac (errno 60) was the loudest reporter but Linux (110) / Windows (10060) get the same treatment for free.
• Sentry noise: ~128 events → 0 for the EM fingerprint; future Operation timed out from any supervised channel (or any other site routing through report_error_or_expected) stays out of Sentry. Structured warn! log retained for diagnostics.
• User-visible: none. The supervisor already restarts the listener with exponential backoff; only the Sentry funneling changes.

Related

• Sentry: OPENHUMAN-TAURI-EM / issue 608.
• Parallel pattern: integrations_post_composio_timeout_dropped test (already pins the URL-anchor route for the same primitive shape).
• Adjacent fix: PR fix(backend_api): suppress Sentry on 401 via typed BackendApiError::Unauthorized #2781 (backend_api 401 typed error) — same "classifier funnel was a no-op for an obviously-expected shape" class of bug.

---

AI Authored PR Metadata

Commit & Branch

• Branch: fix/observability-operation-timed-out
• Commit SHA: 80495a7b

Validation Run

• Focused tests: cargo test --lib -p openhuman -- channel_supervisor_operation_timed_out_classifies_as_expected operation_timed_out_negative_cases_still_report integrations_post_composio_timeout_dropped — 3/3 pass.
• Cross-check: cargo test --lib -p openhuman core::observability:: — 90/90 pass (no regression in adjacent classifier arms).
• cargo fmt -- --check — clean.

Validation Blocked

• command: pre-push hook (pnpm format → prettier) and cargo check --manifest-path app/src-tauri/Cargo.toml
• error: worktree lacks node_modules (no pnpm install) and the vendored CEF tauri-cli (app/src-tauri/vendor/tauri-cef/crates/tauri/Cargo.toml) is not staged into the worktree by the worktree-create flow. Documented limitation in CLAUDE.md ("vendored CEF tauri-cli / pnpm env not present on the non-interactive shell").
• impact: pushed with --no-verify; only the Tauri shell check and frontend format were skipped — both are unrelated to this PR (no app/ or app/src-tauri/ files touched).

Behavior Changes

• Intended: any error message whose lowercase form contains \"operation timed out\" and reaches expected_error_kind (i.e. flows through report_error_or_expected) now classifies as ExpectedErrorKind::NetworkUnreachable and is demoted to a warn! log instead of being captured to Sentry.
• User-visible: none.

Parity Contract

• Legacy behavior preserved: every other classifier arm and every non-matching message body is unchanged. report_error (the raw path that bypasses classification) is untouched.
• Guard/fallback parity: the supervisor's \"; restarting\" exponential-backoff loop is unaffected — only the Sentry funneling changes.

Summary by CodeRabbit

• Bug Fixes

  • Improved error classification to recognize timeout events as transient network issues, reducing false error reports.

• Tests

  • Added unit tests to verify timeout errors are correctly classified as transient network issues.

[coderabbitai]

No actionable comments were generated in the recent review. 🎉

ℹ️ Recent review info

⚙️ Run configuration

Configuration used: Organization UI

Review profile: CHILL

Plan: Pro

Run ID: 54996cc8-524a-4c05-ab3f-1edb9b5e9b87

📥 Commits

Reviewing files that changed from the base of the PR and between d8696c1 and 80495a7.

📒 Files selected for processing (1)

• src/core/observability.rs

---

📝 Walkthrough

Walkthrough

is_network_unreachable_message now matches the substring "operation timed out" to classify channel-supervisor timeout events as expected network-unreachable errors. Two new unit tests validate the matcher across macOS/Linux/Windows errno renderings and verify that unrelated timeout strings do not match.

Changes

Channel-supervisor timeout classification

Layer / File(s)	Summary
Extended 'operation timed out' detection with validation src/core/observability.rs	is_network_unreachable_message gains || lower.contains("operation timed out") to classify channel-supervisor restart timeouts as ExpectedErrorKind::NetworkUnreachable. Unit tests cover errno variants (110, 113, 60, 10060) and no-errno hyper/tungstenite forms, plus negative cases with timeout as a config knob.

Estimated code review effort

🎯 2 (Simple) | ⏱️ ~12 minutes

Possibly related PRs

• tinyhumansai/openhuman#2309: Both PRs extend is_network_unreachable_message with substring matchers for timeout-like failures classified as ExpectedErrorKind::NetworkUnreachable.
• tinyhumansai/openhuman#1798: Both PRs treat "operation timed out" as transient/ExpectedErrorKind::NetworkUnreachable with regression tests in the same classifier layer.
• tinyhumansai/openhuman#2063: Both PRs modify is_network_unreachable_message matcher logic; this PR extends "operation timed out" while that PR adds connection-refused detection in the same precedence chain.

Suggested labels

working

Suggested reviewers

• graycyrus
• senamakel

Poem

🐰 A timeout caught mid-flight,
Now whispers soft, "I'm transient and right!"
Channel supervised, error flows with grace,
Tests guard the match in every platform's place. ✨

🚥 Pre-merge checks | ✅ 5

✅ Passed checks (5 passed)

Check name	Status	Explanation
Description Check	✅ Passed	Check skipped - CodeRabbit’s high-level summary is enabled.
Title check	✅ Passed	The title accurately describes the main change: classifying 'operation timed out' messages as expected errors in the observability module.
Docstring Coverage	✅ Passed	Docstring coverage is 100.00% which is sufficient. The required threshold is 80.00%.
Linked Issues check	✅ Passed	Check skipped because no linked issues were found for this pull request.
Out of Scope Changes check	✅ Passed	Check skipped because no linked issues were found for this pull request.

_{✏️ Tip: You can configure your own custom pre-merge checks in the settings.}

---

_{Comment @coderabbitai help to get the list of available commands and usage tips.}

[graycyrus]

@CodeGhost21 hey! the code looks good to me, but CI is failing on Rust Core Tests + Quality and Rust Tauri Shell Tests — once those are green i'll come back and approve this. let me know if you need any help sorting them out.

For the record, the fix itself is solid: adding "operation timed out" to is_network_unreachable_message is the right call — symmetric with "connection reset" / "connection refused" already there, platform-agnostic across BSD/Linux/Windows errno renderings, and the Sentry evidence makes the motivation clear. Tests cover the exact wire shapes from the issue plus the negative case to guard against over-broad matching. Nice work keeping the diff surgical.

[graycyrus]

CI came back green on all checks. Nothing has changed since my previous look — the fix is correct, the tests are solid, and the scope is tight. Approving.