This article was accepted into the corpus but its outbound wikilinks were never NER-processed — typical at the deepest BFS hop or when the run's entity cap was reached. No expansion funnel to show.
| context (Go package) | |
|---|---|
| Name | context (Go package) |
| Author | Rob Pike, Ken Thompson |
| Developer | |
| Released | 2014 |
| Programming language | Go |
| License | BSD-3-Clause |
| Repository | golang/go |
context (Go package)
The context package in Go provides a standard mechanism for request-scoped values, cancellation signals, and deadlines for goroutines. It was introduced to coordinate work across API boundaries in networking, server frameworks, and distributed systems, and is widely used in projects such as Kubernetes, Docker, gRPC, and Prometheus.
The package offers types and functions to propagate cancellation and timing across API boundaries following design ideas from systems like Plan 9, Unix, and projects at Google. Influential contributors include Rob Pike and Russ Cox, and the package became central to implementations in Kubernetes, Docker, gRPC, Prometheus, Etcd, and Istio. It integrates with libraries such as net/http, database/sql, grpc-go, and frameworks used at Amazon Web Services, Microsoft Azure, and Google Cloud Platform. Contexts are immutable, composable, and intended to avoid global state patterns used in older codebases from projects like Apache HTTP Server or Nginx.
The core exported identifiers are types and functions including Context, Background, TODO, WithCancel, WithDeadline, WithTimeout, WithValue, Done, Err, and Deadline. Typical use involves passing a Context as the first parameter to functions and methods, following conventions adopted by libraries like net/http and database/sql. The Context interface defines Deadline(), Done(), Err(), and Value(), which interact with cancellation and value propagation seen in systems engineered at Google and adopted in efforts like Kubernetes SIGs and gRPC Authors.
Cancellation flows via the Done channel returned by Context.Done and follows patterns embraced in distributed systems such as Raft implementations in Etcd and coordination code in Kubernetes Controller Manager. Parent contexts cancel children when WithCancel, WithDeadline, or WithTimeout are used, mirroring cancellation propagation mechanisms in reactive platforms like RxJava and actor systems used by Akka. Err returns context.Canceled or context.DeadlineExceeded, analogous to status semantics in gRPC and error models in Google Cloud APIs.
WithTimeout and WithDeadline enable bounded execution windows and align with timeout strategies used in clients for HTTP/2, gRPC, and cloud SDKs from Amazon, Google, and Microsoft. Deadlines are absolute times using types from the time package and cooperate with network stack components such as net.Conn wrappers and middleware in servers like Caddy or Envoy. Timeouts are crucial for circuit breakers and load shedding patterns seen in Netflix OSS projects such as Hystrix and resilience libraries used by Spring Framework.
Recommended patterns include using context.Background as root in main functions and server initialization (mirroring init patterns in Systemd services), and context.TODO for incomplete refactors. Avoid using context for optional parameters or to store large values; instead, follow dependency injection patterns used by frameworks like Google Cloud Pub/Sub clients and libraries in HashiCorp projects. Cancel contexts promptly to release resources, and prefer explicit propagation across API boundaries as enforced in ecosystems like Kubernetes API Machinery and gRPC service handlers. Use WithCancel in request handlers in servers such as nginx-backed proxies and when integrating with orchestrators like Mesos or Nomad.
Context is an interface implemented by concrete types created by functions like WithCancel, WithDeadline, and WithValue. The implementation uses channels and mutexes similar to concurrency patterns described by Rob Pike and employed in Go runtime internals. Cancellation uses closed channels to signal all waiters, and value storage is via a chain of contexts forming a linked list of key/value pairs. Care is taken to avoid interface-based boxing overhead and to enable GC of canceled contexts; similar considerations appear in runtime optimizations in projects like LLVM and Glibc.
Examples include creating request-scoped contexts in HTTP handlers using context.WithTimeout and passing them into database queries via database/sql and into gRPC client calls in grpc-go. Common pitfalls: storing request-scoped large structs in Context (contrast with patterns in Dagger or Packer), failing to cancel contexts (leading to goroutine leaks seen in production bugs at companies like Google and Facebook), and using context.Background in libraries instead of accepting a Context parameter (which broke abstractions in early versions of codebases such as Docker and Kubernetes). Debugging tools include tracing integrations with OpenTelemetry, Jaeger, and profiling with pprof to trace cancellations and latency.
Category:Go (programming language) libraries