La valeur dans le contexte (et pourquoi s'en méfier) The value in the context (and why to distrust it)

WithValue glisse une donnée dans le contexte — pratique, et dangereux. Clés typées, jamais une string nue ; un request ID y a sa place, une dépendance non. Le contexte n'est pas un sac à injection. WithValue slips a datum into the context — handy, and dangerous. Typed keys, never a bare string; a request ID belongs there, a dependency doesn't. The context is not an injection bag.

Audience
Dev qui stocke son logger ou sa DB dans le contexte, ou qui utilise des strings comme clés de WithValue Dev who stores their logger or DB in context, or uses strings as WithValue keys
ChapitresChapters
5
LectureReading
≈ 15 min
NiveauLevel
●●●○
Date
Mai 2028 May 2028

contextValuesAnti-pattern

SommaireContents ·
№ 01CadrageFraming3 min

WithValue glisse une donnée dans le contexte — clé typée, jamais une string. Un request ID y a sa place ; une dépendance non.WithValue slips data into the context — typed key, never a string. A request ID belongs there; a dependency doesn't.

Les deux premiers numéros du volume 8 ont couvert le signal dans le contexte — l'annulation et le temps. context.WithValue ajoute une troisième dimension : la donnée. WithValue prend un contexte parent, une clé, et une valeur, et retourne un nouveau contexte qui les mémorise. La valeur est lisible en aval par ctx.Value(clé) — sans modifier les signatures des fonctions intermédiaires. C'est cette propriété qui rend WithValue tentant : plus besoin de passer un request ID à chaque couche, on le glisse dans le contexte au niveau du middleware et on le lit où on en a besoin. Mais cette même propriété est aussi son danger : elle rend les dépendances implicites, invisibles à la compilation, et difficiles à tracer. Pour choisir la bonne clé, la règle est nette : jamais une string nue, toujours un type défini dans le package qui l'utilise. La raison tient en un mot : collision. Si deux packages utilisent la chaîne "user" comme clé, ctx.Value("user") retourne le premier ou le dernier selon l'ordre d'écriture — sans avertissement, sans erreur. Un type privé non-exporté est, par définition, unique à son package : deux types contextKey définis dans deux packages différents sont deux types distincts en Go, même s'ils ont le même nom. C'est exactement ce qu'on veut.The first two volume 8 issues covered the signal in the context — cancellation and time. context.WithValue adds a third dimension: data. WithValue takes a parent context, a key, and a value, and returns a new context that stores them. The value is readable downstream via ctx.Value(key) — without modifying intermediate function signatures. It's this property that makes WithValue tempting: no more passing a request ID through every layer, you slip it into the context at middleware level and read it where needed. But that same property is also its danger: it makes dependencies implicit, invisible to the compiler, and hard to trace. For choosing the right key, the rule is sharp: never a bare string, always a type defined in the package that uses it. The reason fits in one word: collision. If two packages use the string "user" as a key, ctx.Value("user") returns the first or last depending on write order — without warning, without error. A private unexported type is, by definition, unique to its package: two contextKey types defined in two different packages are two distinct types in Go, even if they have the same name. That's exactly what you want.

WithValue avec clé typée — lire et écrire sans collisionWithValue with typed key — read and write without collision
// Un type de clé privé — jamais une string nue.
type contextKey int
const requestIDKey contextKey = iota

// Écrire dans le contexte
func withRequestID(ctx context.Context, id string) context.Context {
    return context.WithValue(ctx, requestIDKey, id)
}

// Lire depuis le contexte — avec une assertion de type sûre
func requestIDFrom(ctx context.Context) (string, bool) {
    id, ok := ctx.Value(requestIDKey).(string)
    return id, ok
}

// Dans un middleware HTTP :
func requestIDMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        id := r.Header.Get("X-Request-ID")
        if id == "" { id = uuid.New().String() }
        ctx := withRequestID(r.Context(), id)
        next.ServeHTTP(w, r.WithContext(ctx))
    })
}
Ce qui appartient au contexteWhat belongs in context
request ID
✓ appartient ici✓ belongs here
trace ID
✓ appartient ici✓ belongs here
user ID authentifié
✓ appartient ici✓ belongs here
logger
✗ passe explicitement✗ pass explicitly
db *sql.DB
✗ passe explicitement✗ pass explicitly
config
✗ passe explicitement✗ pass explicitly

Le contexte porte des métadonnées de la requête, pas des dépendances du programme. La règle : « est-ce que cette valeur change d'une requête à l'autre ? » Si oui, le contexte est le bon endroit. Sinon, passe-la explicitement.Context carries request metadata, not program dependencies. The rule: "does this value change from one request to the next?" If yes, context is the right place. If not, pass it explicitly.

Le réflexe du numéroThe issue's reflex

« Cette valeur est-elle une métadonnée de la requête — un ID, un token, une trace — ou une dépendance du programme — un logger, une base, un client ? » Si c'est une métadonnée : WithValue avec une clé typée, un getter, un setter. Si c'est une dépendance : passe-la explicitement dans les constructeurs ou les arguments. Ce test simple évite 90 % des abus de context.Value dans une base de code."Is this value a request metadata item — an ID, a token, a trace — or a program dependency — a logger, a database, a client?" If it's metadata: WithValue with a typed key, a getter, a setter. If it's a dependency: pass it explicitly in constructors or arguments. This simple test avoids 90% of context.Value abuses in a codebase.

context.Value est O(n)context.Value is O(n)

Chaque appel à context.WithValue crée un nouveau nœud dans la chaîne de contextes. ctx.Value(key) remonte cette chaîne nœud par nœud jusqu'à trouver la clé. Dans une chaîne courte — deux ou trois valeurs — c'est négligeable. Mais si on utilise le contexte comme un sac général et qu'on y empile des dizaines de valeurs, la recherche devient linéaire dans la profondeur de la chaîne. C'est une raison de plus de n'y mettre que ce qui y a vraiment sa place — un nombre raisonnable de métadonnées de requête, pas toutes les dépendances du service.Each call to context.WithValue creates a new node in the context chain. ctx.Value(key) climbs this chain node by node until it finds the key. In a short chain — two or three values — it's negligible. But if you use context as a general bag and pile dozens of values into it, the lookup becomes linear in the chain's depth. It's one more reason to put only what truly belongs there — a reasonable number of request metadata items, not all service dependencies.

№ 02La surpriseThe surprise4 min

Une clé string dans WithValue est une bombe à retardement : deux packages peuvent écrire la même clé et se lire l'un l'autre en silence.A string key in WithValue is a time bomb: two packages can write the same key and silently read each other's values.

context.WithValue accepte un any comme clé, ce qui signifie qu'on peut écrire n'importe quoi — y compris une string. C'est là que le danger commence. Dans un programme de taille réelle, plusieurs packages ajoutent des valeurs au contexte : le middleware d'authentification glisse l'utilisateur, le middleware d'audit glisse ses propres métadonnées, le middleware de tracing glisse le span. Si chacun utilise une string comme clé — "user", "userID", "trace" — la collision n'est qu'une question de temps. Deux packages indépendants utilisent "user" : le dernier middleware à écrire écrase ce que le précédent a mis. En aval, ctx.Value("user") retourne la mauvaise valeur, ou une valeur du mauvais type qui fait silencieusement zéro lors de l'assertion de type — et le code continue, avec un utilisateur nil où il ne devrait pas l'être. Ce genre de bug est particulièrement traître : il n'apparaît qu'à l'exécution, seulement quand les deux middlewares sont actifs ensemble, et la trace d'appel ne pointe pas vers le site de collision mais vers l'endroit où la valeur est consommée. La solution est structurelle : un type non-exporté défini dans le package qui en est propriétaire est, par construction, impossible à reproduire dans un autre package. Deux structs vides nommées authKey dans deux packages différents sont deux types Go distincts. ctx.Value(authKey{}) dans le package auth ne peut jamais retourner la valeur mise par le package audit, parce que le type de clé est différent — la comparaison d'égalité de ctx.Value dépend de la comparabilité des types, et deux types distincts ne sont jamais égaux.context.WithValue accepts any as a key, meaning you can write anything — including a string. That's where the danger starts. In a real-sized program, several packages add values to the context: the auth middleware slips in the user, the audit middleware slips in its own metadata, the tracing middleware slips in the span. If each uses a string as a key — "user", "userID", "trace" — a collision is only a matter of time. Two independent packages use "user": the last middleware to write overwrites what the previous one put. Downstream, ctx.Value("user") returns the wrong value, or a value of the wrong type that silently returns zero on the type assertion — and the code continues, with a nil user where it shouldn't be. This kind of bug is particularly treacherous: it only appears at runtime, only when both middlewares are active together, and the call trace doesn't point to the collision site but to where the value is consumed. The solution is structural: an unexported type defined in the owning package is, by construction, impossible to reproduce in another package. Two empty structs named authKey in two different packages are two distinct Go types. ctx.Value(authKey{}) in the auth package can never return the value put by the audit package, because the key type is different — ctx.Value's equality comparison depends on type comparability, and two distinct types are never equal.

Deux packages, une même clé string — le dernier écrit gagneTwo packages, one string key — last writer wins
// Package auth
func withUser(ctx context.Context, u *User) context.Context {
    return context.WithValue(ctx, "user", u)   // clé : string "user"
}

// Package audit (dans le même programme, ajouté six mois plus tard)
func withUser(ctx context.Context, u AuditUser) context.Context {
    return context.WithValue(ctx, "user", u)   // même clé : collision !
}

// Dans un handler, plus loin en aval :
u := ctx.Value("user")   // quel "user" ? auth.User ou AuditUser ?
                          // Ça dépend de l'ordre des middlewares — bug silencieux.

Les deux packages écrivent "user" : ce n'est pas une erreur de compilation, pas un panic à l'exécution. C'est une valeur silencieusement remplacée, lue avec le mauvais type, et une assertion de type à deux retours qui rend le zero value de *User — nil — sans erreur. Le bug se manifeste dans le comportement du handler (utilisateur nil, permission incorrecte) mais la trace ne pointe pas vers la collision. La string comme clé de contexte est un antipattern que les linters Go signalent désormais explicitement.Both packages write "user": not a compile error, not a runtime panic. It's a value silently replaced, read with the wrong type, and a two-value type assertion yielding the zero value of *User — nil — without error. The bug manifests in handler behavior (nil user, wrong permission) but the trace doesn't point to the collision. A string as a context key is an antipattern that Go linters now explicitly flag.

La règle de la clé : jamais un type built-inThe key rule: never a built-in type

Go le dit clairement : « avoid using built-in types as keys to avoid collisions between packages using context. » Cela vise les strings et les ints — les types partagés par tous les packages. Un type défini dans le package en est propriétaire au sens du système de types : même nommé pareil dans un autre package, il est différent. La forme canonique est un type non-exporté (minuscule) basé sur struct ou int, avec un seul getter et un seul setter exportés — jamais la clé elle-même.Go says it clearly: "avoid using built-in types as keys to avoid collisions between packages using context." This targets strings and ints — types shared by all packages. A type defined in the package owns it in the type system sense: even if named the same in another package, it's different. The canonical form is an unexported type (lowercase) based on struct or int, with a single exported getter and setter — never the key itself.

Une clé string dans WithValue, c'est une convention. Un type privé, c'est une garantie — le compilateur l'enforce, pas la documentation.A string key in WithValue is a convention. A private type is a guarantee — the compiler enforces it, not the docs.
№ 03La mécaniqueThe mechanics5 min

Un type privé + un getter + un setter : le pattern qui encapsule WithValue et rend la valeur sûre à toutes ses utilisations.A private type + a getter + a setter: the pattern that encapsulates WithValue and makes the value safe at every use.

Le chapitre précédent a posé la règle de la clé. Ce chapitre montre le pattern complet qui en découle : un type de clé non-exporté, un setter qui encapsule WithValue, et un getter qui encapsule ctx.Value avec une assertion de type sûre. Ce pattern a trois propriétés. Premièrement, l'encapsulation de la clé : ni le type de clé ni la clé concrète ne sont jamais exportés. Le package en est le seul propriétaire ; nul autre code ne peut lire ou écrire cette valeur dans le contexte sans passer par les fonctions exportées. Deuxièmement, la sécurité de l'assertion de type : ctx.Value retourne un any — la valeur n'a aucun type au moment de la lecture. L'assertion de type à deux retours — val, ok := ctx.Value(key).(Type) — est la seule façon sûre de la consommer : si la valeur est absente, ok est false et val est le zero value du type, sans panic. Une assertion à un seul retour — val := ctx.Value(key).(Type) — panique si la valeur est nil ou d'un type incorrect. Troisièmement, la lisibilité du site d'appel : trace.From(ctx) dit clairement ce qu'on cherche, où on le cherche, et que l'absence est gérée. C'est beaucoup plus lisible qu'un ctx.Value(traceKey{}).(string) inline, qui force le lecteur à connaître le type de clé et à se souvenir de vérifier ok.The previous chapter established the key rule. This chapter shows the complete pattern that follows from it: an unexported key type, a setter that encapsulates WithValue, and a getter that encapsulates ctx.Value with a safe type assertion. This pattern has three properties. First, key encapsulation: neither the key type nor the concrete key is ever exported. The package is the sole owner; no other code can read or write this value in the context without going through the exported functions. Second, type assertion safety: ctx.Value returns an any — the value has no type at read time. The two-return type assertion — val, ok := ctx.Value(key).(Type) — is the only safe way to consume it: if the value is absent, ok is false and val is the type's zero value, without panic. A single-return assertion — val := ctx.Value(key).(Type) — panics if the value is nil or of the wrong type. Third, call site readability: trace.From(ctx) clearly says what you're looking for, where you're looking, and that absence is handled. Much more readable than an inline ctx.Value(traceKey{}).(string), which forces the reader to know the key type and remember to check ok.

Le package trace — propriétaire de sa clé, de son setter et de son getterThe trace package — owner of its key, setter, and getter
// middleware/trace/trace.go — le package est propriétaire de sa clé
package trace

type key struct{}   // non-exporté : isolé au package trace

// Setter : encapsule WithValue — seul ce package peut écrire
func With(ctx context.Context, spanID string) context.Context {
    return context.WithValue(ctx, key{}, spanID)
}

// Getter : encapsule Value + assertion de type
func From(ctx context.Context) (string, bool) {
    id, ok := ctx.Value(key{}).(string)
    return id, ok
}

// Usage dans un handler :
func handle(ctx context.Context) {
    if spanID, ok := trace.From(ctx); ok {
        log.Printf("span=%s", spanID)
    }
}

Le type key non-exporté garantit l'isolation. With et From sont les seuls points d'entrée — ils forment une interface propre sur une mécanique bas niveau. Le site d'appel ne voit jamais le type de clé ni l'assertion de type : il appelle trace.From(ctx) comme il appellerait n'importe quelle autre fonction, et reçoit une valeur typée et un booléen — contrat clair, pas de surprise.The unexported key type guarantees isolation. With and From are the only entry points — they form a clean interface over low-level mechanics. The call site never sees the key type or the type assertion: it calls trace.From(ctx) like any other function, and gets a typed value and a boolean — clear contract, no surprise.

Le type de clé non-exporté est la frontière. Le getter et le setter en sont les gardiens — la seule façon d'entrer et de sortir sans collision.The unexported key type is the boundary. The getter and setter are its guardians — the only way in and out without collision.
№ 04Le piègeThe trap4 min

Le contexte n'est pas un sac à injection. Logger, *sql.DB, client HTTP : ces dépendances passent en argument, pas en valeur de contexte.Context is not an injection bag. Logger, *sql.DB, HTTP client: these dependencies go in arguments, not context values.

WithValue est tentant comme contournement de la verbosité : si passer le logger et la base de données à chaque fonction est fastidieux, pourquoi ne pas les glisser dans le contexte ? Beaucoup de codebases font ce choix — on le voit dans des wrappers de logger « context-aware » qui extraient le logger du contexte, ou des helpers de base « get DB from ctx ». Le problème est structurel : une dépendance dans le contexte est invisible à la compilation, impossible à mocker proprement en test, et son absence produit un panic plutôt qu'une erreur de type. Prenons le logger. ctx.Value(loggerKey{}) peut retourner nil si le middleware qui le glisse n'est pas monté, ou une valeur d'un type inattendu. Dans un test unitaire qui passe context.Background() sans initialiser la chaîne de middlewares, toute fonction qui extrait le logger du contexte panique — ou pire, continue silencieusement avec un logger nil. La signature de la fonction ne dit rien sur cette dépendance : rien dans func handleOrder(ctx context.Context) error n'indique qu'elle a besoin d'un logger et d'une base. Pour un nouvel arrivant, c'est une boîte noire. La vraie question, c'est celle du chapitre 1 : est-ce que cette valeur change d'une requête à l'autre ? Un logger, non — c'est une dépendance du service entier. Une base de données, non — c'est une ressource du processus. Un request ID, oui — il est unique à la requête. La frontière est là.WithValue is tempting as a verbosity workaround: if passing the logger and database to every function is tedious, why not slip them into the context? Many codebases make this choice — you see it in 'context-aware' logger wrappers that extract the logger from the context, or 'get DB from ctx' database helpers. The problem is structural: a dependency in the context is invisible to the compiler, impossible to mock cleanly in tests, and its absence produces a panic rather than a type error. Take the logger. ctx.Value(loggerKey{}) may return nil if the middleware that slips it in isn't mounted, or a value of an unexpected type. In a unit test that passes context.Background() without initializing the middleware chain, any function that extracts the logger from the context panics — or worse, continues silently with a nil logger. The function's signature says nothing about this dependency: nothing in func handleOrder(ctx context.Context) error indicates it needs a logger and a database. For a newcomer, it's a black box. The real question is the one from chapter 1: does this value change from one request to the next? A logger, no — it's a service-wide dependency. A database, no — it's a process resource. A request ID, yes — it's unique to the request. The boundary is there.

Dépendances dans le contexte : contrat invisible, tests impossiblesDependencies in context: invisible contract, impossible tests
// ❌ Antipattern : injecter le logger et la DB via le contexte
func withLogger(ctx context.Context, l *slog.Logger) context.Context {
    return context.WithValue(ctx, loggerKey{}, l)
}
func withDB(ctx context.Context, db *sql.DB) context.Context {
    return context.WithValue(ctx, dbKey{}, db)
}

func handleOrder(ctx context.Context) error {
    log := ctx.Value(loggerKey{}).(*slog.Logger)   // panic si absent
    db  := ctx.Value(dbKey{}).(*sql.DB)            // invisible à la compilation

    log.Info("handling order")
    return createOrder(ctx, db)   // dépendances cachées, tests difficiles
}

La signature de handleOrder ne révèle rien de ses dépendances. Un test qui passe context.Background() va paniquer à l'extraction du logger — ou réussir si on monte toute la chaîne de middlewares juste pour ce test, ce qui dépasse le périmètre d'un test unitaire. Les dépendances dans le contexte ne peuvent pas être vérifiées statiquement : si on renomme la clé dans un package, les autres packages qui en dépendent compilent toujours, mais paniquent à l'exécution.handleOrder's signature reveals nothing about its dependencies. A test passing context.Background() will panic on logger extraction — or pass if you mount the full middleware chain just for that test, which exceeds a unit test's scope. Context dependencies can't be statically verified: if you rename the key in one package, other dependent packages still compile, but panic at runtime.

La question de triThe sorting question

Une seule question pour décider : « Cette valeur est-elle spécifique à cette requête, ou au service entier ? » Spécifique à la requête : request ID, trace span, user ID authentifié, locale — WithValue. Du service entier : logger, base de données, configuration, client HTTP — constructeur ou argument explicite. Un logger peut être enrichi avec le request ID via slog.With pour les logs corrélés — c'est de la composition, pas de l'injection dans le contexte.One question to decide: "Is this value specific to this request, or to the whole service?" Specific to the request: request ID, trace span, authenticated user ID, locale — WithValue. Whole service: logger, database, configuration, HTTP client — constructor or explicit argument. A logger can be enriched with the request ID via slog.With for correlated logs — that's composition, not context injection.

L'exception : slog et les loggers contextuelsThe exception: slog and contextual loggers

La bibliothèque standard Go 1.21 a introduit slog.InfoContext, slog.ErrorContext et al. — des variantes qui transmettent le ctx au Handler de slog. Les handlers standard (texte, JSON) n'en font rien ; un Handler personnalisé peut y lire des attributs stockés dans le contexte (trace ID, request ID). C'est un usage légitime de WithValue : ces métadonnées de corrélation changent par requête et enrichissent les logs sans modifier les signatures de toutes les fonctions intermédiaires. La distinction est fine : on ne glisse pas le logger lui-même dans le contexte, mais des attributs que le logger saura extraire du contexte. Le logger reste une dépendance explicite ; le contexte porte les métadonnées qu'il enrichira.The Go 1.21 standard library introduced slog.InfoContext, slog.ErrorContext, et al. — variants that pass the ctx on to slog's Handler. The standard handlers (text, JSON) ignore it; a custom Handler can read attributes stored in the context from it (trace ID, request ID). This is a legitimate use of WithValue: these correlation metadata items change per request and enrich logs without modifying all intermediate function signatures. The distinction is subtle: you don't slip the logger itself into the context, but attributes the logger knows how to extract from the context. The logger stays an explicit dependency; context carries the metadata it will enrich.

Le contexte porte ce qui est de la requête. Les dépendances du service restent dans les structs — visibles, statiques, testables.Context carries what belongs to the request. Service dependencies stay in structs — visible, static, testable.
№ 05Bilan & éditoWrap-up & editorial2 min

context.WithValue est juste pour les métadonnées de requête. Une clé typée, un getter, un setter — jamais une string, jamais une dépendance.context.WithValue is right for request metadata. A typed key, a getter, a setter — never a string, never a dependency.

Ce dernier numéro du volume 8 a fermé le troisième usage de context.Context : la donnée. WithValue glisse une paire clé-valeur dans le contexte, lisible par toute fonction en aval sans modifier les signatures intermédiaires — utile pour les métadonnées de requête qui traversent beaucoup de couches. Mais sa commodité cache deux pièges. Le premier : une clé string ou int peut entrer en collision avec celle d'un autre package, silencieusement, et retourner la mauvaise valeur sans erreur. La solution est structurelle — un type non-exporté défini dans le package propriétaire rend la collision physiquement impossible, garantie par le système de types. Le second : WithValue est tentant comme mécanisme d'injection de dépendances. Un logger, une base de données, un client HTTP — les glisser dans le contexte évite de les passer partout. Mais cela rend les dépendances invisibles à la compilation, impossibles à mocker proprement, et leur absence produit des panics à l'exécution plutôt que des erreurs statiques. Le test séparateur est simple : est-ce que cette valeur change d'une requête à l'autre ? Si oui, le contexte est le bon endroit, avec la discipline du type privé et du getter. Sinon, c'est une dépendance du service — elle passe dans les constructeurs ou les arguments explicites. Ce volume 8 a couvert les trois dimensions de context.Context : l'annulation, le temps, et la donnée. Ce sont les outils qui permettent à un programme concurrent Go d'orchestrer son arrêt, de respecter les délais de ses clients, et de propager ses métadonnées sans gonfler ses signatures.This last volume 8 issue closed the third use of context.Context: data. WithValue slips a key-value pair into the context, readable by any downstream function without modifying intermediate signatures — useful for request metadata that crosses many layers. But its convenience hides two traps. First: a string or int key can collide with another package's, silently, and return the wrong value without error. The solution is structural — an unexported type defined in the owning package makes collision physically impossible, guaranteed by the type system. Second: WithValue is tempting as a dependency injection mechanism. A logger, a database, an HTTP client — slipping them into context avoids passing them everywhere. But it makes dependencies invisible to the compiler, impossible to mock cleanly, and their absence produces runtime panics rather than static errors. The separating test is simple: does this value change from one request to the next? If yes, context is the right place, with the discipline of the private type and getter. If not, it's a service dependency — it goes in constructors or explicit arguments. This volume 8 covered context.Context's three dimensions: cancellation, time, and data. These are the tools that let a concurrent Go program orchestrate its shutdown, respect its clients' deadlines, and propagate its metadata without bloating its signatures.

L'idéeThe ideaLa règleThe ruleSi tu la ratesIf you miss it
Type privéPrivate typeJamais string ou int comme clé — toujours un type non-exporté du package propriétaire.Never string or int as key — always an unexported type from the owning package.Collision silencieuse entre packages, valeur du mauvais type.Silent collision between packages, value of wrong type.
Getter + SetterGetter + SetterEncapsuler WithValue et ctx.Value — ne jamais exposer la clé.Encapsulate WithValue and ctx.Value — never expose the key.Assertion de type inline, vérification ok oubliée, panic en production.Inline type assertion, ok check forgotten, panic in production.
Métadonnée, pas dépendanceMetadata, not dependency« Change-t-elle par requête ? » Oui → ctx. Non → constructeur ou argument."Does it change per request?" Yes → ctx. No → constructor or argument.Dépendances invisibles, tests qui paniquent, contrats implicites.Invisible dependencies, panicking tests, implicit contracts.
Assertion à 2 retours2-return assertionToujours val, ok := ctx.Value(k).(T) — jamais l'assertion à un retour.Always val, ok := ctx.Value(k).(T) — never the single-return assertion.Panic si la valeur est absente ou du mauvais type — courant dans les tests.Panic if value is absent or wrong type — common in tests.
Le contexte est un câble d'annulation, un chronomètre, et une enveloppe de métadonnées. Il n'est pas un conteneur d'injection — les dépendances restent explicites.Context is a cancellation cable, a stopwatch, and a metadata envelope. It is not an injection container — dependencies stay explicit.
Mot de l'éditeur · clôture du volume 8From the editor · closing volume 8

Le volume 8 a porté sur l'orchestration du travail concurrent. La vraie leçon : coordonner n'est pas contrôler — c'est signaler.Volume 8 was about orchestrating concurrent work. The real lesson: coordinating is not controlling — it's signaling.

Trois numéros sur context.Context, regardé sous trois angles. Le premier a posé le câble : un arbre immuable de contextes que chaque couche reçoit et transmet, sans le stocker, toujours en premier argument. L'annulation descend, le signal se propage, et chaque goroutine qui écoute ctx.Done() peut s'arrêter proprement quand le travail devient inutile. Le deuxième a ajouté le temps : WithTimeout et WithDeadline pour poser une limite à un arbre entier, defer cancel() pour libérer les ressources quand on finit avant l'échéance, ctx.Err() pour distinguer timeout de cancel. Et la discipline du budget : fractionner le temps restant plutôt que de poser des valeurs absolues ignorant ce que le parent a transmis. Le troisième a tracé la frontière de WithValue : métadonnée de requête oui, dépendance de service non — clé typée, getter, assertion à deux retours. Ce qui relie les trois numéros, c'est une idée simple et profonde : en Go, la coordination entre goroutines ne se fait pas par partage d'état, elle se fait par signal explicite. Le contexte est ce signal — descendant, propagé, lisible simultanément par autant de goroutines qu'on veut, sans synchronisation. Maîtriser context.Context, c'est comprendre comment un programme Go peut arrêter du travail sans le brutaliser, respecter les délais sans les deviner, et transporter des informations transverses sans sacrifier la lisibilité des signatures. Le volume suivant descend d'un cran : comment Go gère la mémoire, comment l'escape analysis décide où les variables vivent, et ce que le ramasse-miettes fait pendant qu'on travaille.Three issues on context.Context, examined from three angles. The first laid the cable: an immutable context tree that each layer receives and forwards, without storing it, always as first argument. Cancellation flows down, the signal propagates, and every goroutine listening to ctx.Done() can stop cleanly when work becomes useless. The second added time: WithTimeout and WithDeadline to put a limit on a whole tree, defer cancel() to free resources when you finish before the deadline, ctx.Err() to distinguish timeout from cancel. And the budget discipline: fractionating remaining time rather than setting absolute values that ignore what the parent passed. The third drew WithValue's boundary: request metadata yes, service dependency no — typed key, getter, two-return assertion. What links the three issues is a simple and deep idea: in Go, coordination between goroutines doesn't happen through shared state, it happens through explicit signal. Context is that signal — descending, propagated, readable simultaneously by as many goroutines as you want, without synchronization. Mastering context.Context is understanding how a Go program can stop work without brutalizing it, respect deadlines without guessing them, and carry cross-cutting information without sacrificing signature readability. The next volume descends one level: how Go manages memory, how escape analysis decides where variables live, and what the garbage collector does while you work.