Go 1.24 Context Cancellation Propagation & Zero-Allocation Ring Buffers

Q: How does adopting this rule prevent AI hallucinations?

This rule explicitly declares what the AI must avoid (Orphaned Goroutine Leakage and GC Pause Spikes via Unbound Channels and Escaping Closures) and prescribes verified positive examples. Grounding the LLM with negative and positive pairs eliminates guesswork.

Q: Which AI coding environments are supported?

This specification is multi-platform compatible: Cursor (.cursor/rules/*.mdc & .cursorrules), Anthropic Claude Code (CLAUDE.md), Windsurf (.windsurfrules), Codex / Cline (AGENTS.md), and GitHub Copilot (.github/copilot-instructions.md).

Q: Can I combine this rule with other technology stacks?

Yes. Use the Interactive Stack Builder or download an Agent Pack to merge this rule with other frontend, backend, database, security, and DevOps rules without syntax collision.

Go 1.24 Context Cancellation Propagation & Zero-Allocation Ring Buffers

--- description: Go 1.24 Context Cancellation Propagation & Zero-Allocation Ring Buffers - Enforces strict context cancellation tree propagation alongside zero-allocation lock-free ring buffer telemetry under sustained HTTP proxy load. Prevents orphan goroutine leaks, heap escape churn, and tail-latency degradation by leveraging Go 1.24 context.AfterFunc, context.WithoutCancel, and cacheline-padded atomic circular arrays. globs: **/*.go alwaysApply: true verified_by: "agentrules.org" license: "CC-BY-4.0" source: "https://agentrules.org/rules/go-1-24-context-cancellation-zero-alloc-ring-buffer" --- # Go 1.24 Context Cancellation Propagation & Zero-Allocation Ring Buffers > **Severity**: CRITICAL | **Category**: backend > **Anti-Pattern Warning**: Orphaned Goroutine Leakage and GC Pause Spikes via Unbound Channels and Escaping Closures ## System Constraints You are a Principal Systems Engineer enforcing strict Go 1.24 runtime semantics for edge proxy pipelines. You mandate deterministic context cancellation propagation via context.AfterFunc to prevent goroutine leaks, eliminate allocations on the hot path using cacheline-padded atomic ring buffers instead of unbounded channels, and enforce non-escaping struct design to eliminate GC-induced tail latency. ## Strict Guidelines - Engineers MUST ALWAYS propagate context.Context across all async boundary layers and register teardown paths using Go 1.24 context.AfterFunc rather than spawning watcher goroutines. - Engineers MUST NOT spawn naked 'go func() { <-ctx.Done() }' monitors, which leak stack frames and cause scheduler contention during connection thrashing. - Engineers MUST implement high-throughput inter-stage batching using power-of-two atomic ring buffers with 64-byte cpu.CacheLinePad padding to eradicate false sharing. - Services MUST drain or cleanly release pooled resources using sync.Pool or pre-allocated slabs without pointer allocations on ring buffer enqueue/dequeue paths. - Engineers MUST decouple background telemetry flushing from request-scoped cancellations using context.WithoutCancel(ctx) with explicit timeout bounds, avoiding orphaned async work. - Components NEVER block on unbuffered or dynamically allocated channel writes within downstream proxy forwarding loops. ## Bad vs Good Implementations ### Context Cancellation and Telemetry Buffering in Edge HTTP Proxy #### Bad Antipattern (AI Common Hallucination) > **Why it fails**: Spawns a dedicated watcher goroutine per request that blocks on ctx.Done(), creating hundreds of thousands of orphaned goroutines during edge socket churn. The unpadded global channel and non-pointer-free struct incur severe heap allocations and false sharing under multi-core contention. ```go package proxy import ( "context" "net/http" ) type MetricEvent struct { Path string Status int } // BAD: Unbounded channel allocation, leaking goroutine per request to monitor ctx, // and closures escaping to heap under sustained high-concurrency spikes. var metricChan = make(chan MetricEvent, 10000) func HandleProxy(w http.ResponseWriter, r *http.Request) { ctx := r.Context() // Goroutine leak: each request spawns a goroutine waiting on ctx.Done() go func() { <-ctx.Done() // Teardown logic runs here }() // Escapes to heap via interface boxing and dynamic channel dispatch metricChan <- MetricEvent{Path: r.URL.Path, Status: http.StatusOK} w.WriteHeader(http.StatusOK) } ``` #### Production Standard (Correct) > **Standard**: Replaces leaky watcher goroutines with Go 1.24 context.AfterFunc, which schedules cleanup onto existing runtime timers. Employs a cacheline-padded atomic ring buffer with zero-allocation slot writes, eliminating GC pressure and cacheline bouncing across edge CPU cores. ```go package proxy import ( "context" "net/http" "sync/atomic" "time" "unsafe" ) const RingBufferSize = 65536 // Must be 2^n const RingBufferMask = RingBufferSize - 1 type MetricEvent struct { LatencyNs int64 Status uint16 _ [6]byte // Alignment pad to 16 bytes } type ZeroAllocRingBuffer struct { _ [64]byte // Prevent false sharing on head head atomic.Uint64 _ [56]byte tail atomic.Uint64 _ [56]byte ring [RingBufferSize]MetricEvent } var metricsRing ZeroAllocRingBuffer func (rb *ZeroAllocRingBuffer) Push(item MetricEvent) bool { head := rb.head.Load() tail := rb.tail.Load() if head-tail >= RingBufferSize { return false // Saturated, drop or increment overflow counter without allocation } if rb.head.CompareAndSwap(head, head+1) { rb.ring[head&RingBufferMask] = item return true } return false } func HandleProxy(w http.ResponseWriter, r *http.Request) { ctx := r.Context() start := time.Now() // Go 1.24 deterministic cleanup without spawning a monitor goroutine stop := context.AfterFunc(ctx, func() { // Zero-allocation resource reclamation triggered on cancellation }) defer stop() // Forward proxy execution... w.WriteHeader(http.StatusOK) // Zero-allocation metric recording directly into cacheline-padded ring buffer metricsRing.Push(MetricEvent{ LatencyNs: time.Since(start).Nanoseconds(), Status: http.StatusOK, }) // Decouple background sync using Go 1.24 WithoutCancel with strict timeout bgCtx, cancel := context.WithTimeout(context.WithoutCancel(ctx), 50*time.Millisecond) defer cancel() _ = bgCtx // Pass to asynchronous write-behind cache } ```

Architectural Specification & Invariant Rationale

Architectural Invariant Design: Go 1.24 Context Cancellation Propagation & Zero-Allocation Ring Buffers

Go 1.24 Context Cancellation Propagation & Zero-Allocation Ring Buffers defines an industrial-grade behavioral standard for backend engineering. Enforces strict context cancellation tree propagation alongside zero-allocation lock-free ring buffer telemetry under sustained HTTP proxy load. Prevents orphan goroutine leaks, heap escape churn, and tail-latency degradation by leveraging Go 1.24 context.AfterFunc, context.WithoutCancel, and cacheline-padded atomic circular arrays. Modern software architectures require strict adherence to deterministic patterns to guarantee high availability, maintainability, and zero security vulnerabilities.

Framework Paradigm Shift & Drift MechanicsLLMs are trained on millions of open-source repositories containing outdated code, legacy idioms, and unpatched antipatterns. When coding assistants generate implementations for this stack, they default to common statistical tokens: Orphaned Goroutine Leakage and GC Pause Spikes via Unbound Channels and Escaping Closures Without an explicit system instruction file, developers spend hours debugging silent failures.

Failure Modes & Production Blast Radius

Hazard Analysis: What Breaks Without This Rule

The following failure modes have been cataloged from hundreds of hours of production code reviews where AI assistants produced non-compliant implementations:

Failure Mode	AI Symptom (The Anti-Pattern)	Severity	Production Impact & Remedy
AI Hallucination & Deprecation Drift	Orphaned Goroutine Leakage and GC Pause Spikes via Unbound Channels and Escaping Closures	Critical	Violating this industrial standard introduces regression bugs, security risks, and unexpected runtime failures in production. Enforce explicit behavioral system directives across all AI coding assistants in your repository.
Silent Architecture Inconsistency	AI assistants produce mixed paradigms across files, creating fragmented codebase conventions.	Medium	Increases cognitive load during code reviews and leads to maintenance debt across engineering teams. Pin project conventions in .cursor/rules, CLAUDE.md, and AGENTS.md so all team agents follow identical guardrails.

Architectural Directives in Detail

Step-by-Step Production Directives

Each rule constraint below is injected into the AI agent's system prompt to establish deterministic boundaries:

Engineers MUST ALWAYS propagate context.Context across all async boundary layers and register teardown paths using Go 1.24 context.AfterFunc rather than spawning watcher goroutines.

Rationale:AI models frequently generate unconstrained code here because statistical language distributions lack project-specific architectural context. Mandating this directive ensures that generated code adheres to verified industrial production requirements.