perf: watch the call's context with AfterFunc instead of a goroutine

[costela]

Why

Calls with a cancellable context, which is nearly every request, started a goroutine and a child context per call just to notice a cancellation early. On main such a call costs about 51x a call with context.Background() on one CPU, and about 176x and 258x on 8 and 24 CPUs (table below). No benchmark showed it, since all of them used context.Background(), which skips the watchdog.

What

• Register the watchdog with context.AfterFunc, which only starts a goroutine if the context is actually canceled during the call. Cancellations are still recorded as promptly; the internal cancellation cause and observeCtx go away. The callback is created in a small non-generic method, since a closure created inside the generic Wrap is allocated one size class bigger.
• Add a benchmark with a per-goroutine cancellable context, and a test that the watchdog is unregistered once the call returns, so it can't pile up on long-lived contexts. The test counts registrations through a context's AfterFunc method, the hook context.AfterFunc documents.
• Fix Wrap's comment on unobserved errors: it named a nonexistent ErrConcurrencyLimit and attributed the non-blocking limiter's error to blocking circuits. The sentinels are now doc links.

benchstat, n=10, main and this branch's test binaries run interleaved:

./main.test|./new.test -test.run '^$' -test.bench BenchmarkHoglet_Do_ -test.benchmem -test.benchtime 1s -test.cpu 1,8,24 -test.count 1

Benchmark	main	this PR	change
Hoglet_Do_EWMA (context.Background())	26.63 ns	26.34 ns	~ (p=0.072)
Hoglet_Do_EWMA-8	3.363 ns	3.314 ns	-1.46% (p=0.000)
Hoglet_Do_EWMA-24	1.942 ns	1.972 ns	+1.57% (p=0.001)
Hoglet_Do_EWMA_cancellable	1348.0 ns	508.2 ns	-62.30% (p=0.000)
Hoglet_Do_EWMA_cancellable-8	593.2 ns	125.9 ns	-78.78% (p=0.000)
Hoglet_Do_EWMA_cancellable-24	501.8 ns	110.5 ns	-77.98% (p=0.000)

Still 4 allocs/op, ~177 → 208 B/op. The context.Background() path is untouched by this change, so its ±1.5% marks the noise floor. The existing sliding-window benchmarks also call with context.Background(), which never starts a watchdog, so they show no change either. The watchdog depends on the caller's context, not on the breaker: a sliding window called with a cancellable context (scratch benchmark in the same run) goes from 1458.5 ns to 598.5 ns on 1 CPU (-58.96%), 580.2 ns to 173.9 ns on 8 (-70.03%) and 504.2 ns to 179.0 ns on 24 (-64.49%).

🤖 Generated with Claude Code

[Copilot]

🟢 Approval recommended

The focused optimization preserves cancellation behavior and includes appropriate performance and cleanup coverage.

0 open findings

What changed in this PR

Optimizes context cancellation monitoring by replacing per-call watchdog goroutines with context.AfterFunc.

Changes:

• Registers and unregisters cancellation callbacks efficiently.
• Adds cancellable-context benchmarking and cleanup coverage.
• Corrects Wrap error documentation.

File	Description
hoglet.go	Implements the AfterFunc watchdog and updates documentation.
hoglet_test.go	Adds benchmark and watchdog unregistration test.

🧠 Review effort: Balanced

---

💡 Add a code-review agent skill or configure MCP servers for context-aware, tailored reviews. Learn more in the docs.