Timeout & deadline Timeout & deadline

WithTimeout et WithDeadline posent une limite de temps à un arbre de goroutines. Le defer cancel() n'est pas optionnel : l'oublier, c'est fuir un contexte et les ressources qu'il tenait. Le délai qui descend, et le nettoyage qui remonte. WithTimeout and WithDeadline put a time limit on a tree of goroutines. The defer cancel() isn't optional: forgetting it leaks a context and the resources it held. The deadline flowing down, the cleanup flowing back up.

Audience
Dev qui oublie defer cancel(), ou dont les timeouts en cascade créent des DeadlineExceeded inexpliqués Dev who forgets defer cancel(), or whose cascading timeouts create unexplained DeadlineExceededs
ChapitresChapters
5
LectureReading
≈ 15 min
NiveauLevel
●●○○
Date
Avr 2028 Apr 2028

TimeoutDeadlinecontext

SommaireContents ·
№ 01CadrageFraming3 min

WithTimeout et WithDeadline posent une limite de temps à un arbre entier. Le defer cancel() n'est pas une option.WithTimeout and WithDeadline put a time limit on a whole tree. The defer cancel() is not optional.

Le numéro précédent a posé context.Context comme câble d'annulation explicite. Ce numéro ajoute la dimension temporelle : comment poser une limite de temps à tout un arbre de goroutines. context.WithTimeout et context.WithDeadline créent tous les deux un contexte-fils qui s'annule automatiquement à une échéance — WithTimeout exprime une durée relative (dans 5 secondes), WithDeadline exprime une heure absolue (à 14h30:00). Sous le capot, WithTimeout est simplement WithDeadline(ctx, time.Now().Add(d)) : les deux produisent exactement le même contexte. La différence n'est qu'expressive — durée vs instant — et le bon choix dépend de ce qu'on connaît au moment de l'appel. Ce qui les unit, c'est leur second retour : une fonction cancel. Cette fonction cancel sert à deux choses simultanées. Primo, elle annule le contexte-fils avant son échéance si on finit plus tôt — économiser le timer. Secundo, et c'est la raison pour laquelle elle n'est jamais optionnelle : si on ne l'appelle pas, Go maintient un timer du runtime et des entrées dans l'arbre des contextes jusqu'à ce que le parent s'annule. C'est une fuite discrète, invisible sous faible charge, catastrophique à l'échelle. Le defer cancel() en ligne 2 est donc la règle absolue : créer, différer l'annulation, s'en occuper jamais plus.The previous issue laid context.Context as an explicit cancellation cable. This issue adds the temporal dimension: how to put a time limit on a whole goroutine tree. context.WithTimeout and context.WithDeadline both create a child context that auto-cancels at a deadline — WithTimeout expresses a relative duration (in 5 seconds), WithDeadline expresses an absolute time (at 2:30pm). Under the hood, WithTimeout is simply WithDeadline(ctx, time.Now().Add(d)): both produce exactly the same context. The difference is only expressive — duration vs instant — and the right choice depends on what you know at the call site. What unites them is their second return value: a cancel function. This cancel function serves two simultaneous purposes. First, it cancels the child context before its deadline if you finish sooner — saves the timer. Second, and this is why it's never optional: if you don't call it, Go maintains a runtime timer and entries in the context tree until the parent cancels. It's a discreet leak, invisible under light load, catastrophic at scale. The defer cancel() on line 2 is therefore the absolute rule: create, defer the cancellation, never think about it again.

WithTimeout et WithDeadline : deux expressions, même résultatWithTimeout and WithDeadline: two expressions, same result
// WithTimeout : dans combien de temps ?
ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
defer cancel()   // libère le timer même si on finit avant

// WithDeadline : à quel moment absolu ?
deadline := time.Now().Add(5 * time.Second)
ctx, cancel := context.WithDeadline(ctx, deadline)
defer cancel()

// Les deux produisent le même contexte — c'est l'expression qui diffère.
// ctx.Deadline() retourne l'heure d'expiration dans les deux cas.
La limite descend, le nettoyage remonteThe limit flows down, the cleanup flows back up
WithTimeout
crée l'échéance
↓
ctx.Done()
se ferme à l'expiration
↑
defer cancel()
libère le timer

Le délai descend dans l'arbre via le contexte. Le cancel() remonte dans le code via le defer — toujours en deuxième ligne après WithTimeout.The deadline flows down the tree via the context. The cancel() comes back in code via defer — always the second line after WithTimeout.

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

« Ai-je créé un contexte avec timeout ou deadline ? Alors la ligne suivante est defer cancel(). » Sans exception — même si on sait que le contexte sera annulé par le parent avant l'échéance, parce que defer cancel() sur un contexte déjà annulé est un no-op, et qu'omettre un defer cancel() sur un contexte vivant est une fuite silencieuse. La règle vaut dans les tests comme en production."Did I create a context with timeout or deadline? Then the next line is defer cancel()." No exception — even if you know the context will be canceled by the parent before the deadline, because defer cancel() on an already-canceled context is a no-op, and omitting a defer cancel() on a live context is a silent leak. The rule holds in tests as in production.

Quand choisir WithTimeout vs WithDeadline ?When to choose WithTimeout vs WithDeadline?

WithTimeout convient quand on connaît une durée — « cette requête SQL ne doit pas dépasser 3 secondes ». WithDeadline convient quand on a une heure cible déjà calculée — un budget de délai partagé entre plusieurs sous-appels, ou une coordination avec une horloge externe. En pratique, WithTimeout couvre 90 % des cas parce que les délais sont le plus souvent relatifs au moment de l'appel. Mais si la couche supérieure a déjà calculé une deadline absolue et la passe en paramètre, préférer WithDeadline évite de la recalculer en durée.WithTimeout suits when you know a duration — 'this SQL query must not exceed 3 seconds.' WithDeadline suits when you have an already-computed target time — a deadline budget shared across several sub-calls, or coordination with an external clock. In practice, WithTimeout covers 90% of cases because deadlines are most often relative to the call moment. But if the upper layer has already computed an absolute deadline and passes it as a parameter, preferring WithDeadline avoids recomputing it as a duration.

№ 02La surpriseThe surprise4 min

Oublier defer cancel(), c'est laisser tourner un timer par requête jusqu'à son expiration — silencieux, et qui s'accumule.Forgetting defer cancel() leaves a timer running per request until it expires — silent, and it accumulates.

On pourrait croire que oublier defer cancel() n'est qu'une négligence cosmétique : si le timeout expire, le contexte est annulé de toute façon, non ? C'est vrai. Mais le point n'est pas l'annulation — c'est ce qui se passe quand on finit avant l'échéance. Un service HTTP avec un timeout de 3 secondes répond en réalité en 50 ms dans 99 % des cas. Sans defer cancel(), chacun de ces 99 % laisse un timer actif pendant les 2950 ms restantes. À 10 000 requêtes par seconde, c'est 10 000 timers par seconde créés, chacun vivant 3 secondes : à tout moment, 30 000 timers restent armés dans le runtime, chacun retenant son contexte, consommant de la mémoire et alourdissant le tas de timers. Go ne peut pas savoir qu'on a fini plus tôt — il n'a que l'échéance qu'on lui a donnée. defer cancel() est le signal explicite que le travail est terminé et que les ressources associées au contexte peuvent être libérées immédiatement. Sans lui, chaque appel à WithTimeout ou WithDeadline est une micro-fuite qui s'accumule silencieusement. Un profil heap montre cette accumulation sous la forme d'allocations dans context.WithDeadline — c'est souvent la première signature d'un defer cancel() manquant dans une base de code sous charge.You might think that forgetting defer cancel() is merely cosmetic negligence: if the timeout expires, the context gets canceled anyway, right? True. But the point isn't the cancellation — it's what happens when you finish before the deadline. An HTTP service with a 3-second timeout actually responds in 50ms in 99% of cases. Without defer cancel(), each of those 99% leaves an active timer for the remaining 2950ms. At 10,000 requests per second, that's 10,000 timers per second created, each living 3 seconds: at any moment, 30,000 timers stay armed in the runtime, each holding on to its context, consuming memory and weighing down the timer heap. Go can't know you finished earlier — it only has the deadline you gave it. defer cancel() is the explicit signal that the work is done and the resources associated with the context can be freed immediately. Without it, every call to WithTimeout or WithDeadline is a micro-leak that accumulates silently. A heap profile shows this accumulation as allocations in context.WithDeadline — it's often the first signature of a missing defer cancel() in a codebase under load.

Sans defer cancel() : un timer par appel, actif jusqu'à l'échéanceWithout defer cancel(): one timer per call, active until the deadline
func fetchUser(id int) (*User, error) {
    // On oublie defer cancel() — le timer et l'entrée dans l'arbre restent actifs
    ctx, _ := context.WithTimeout(context.Background(), 3*time.Second)

    req, _ := http.NewRequestWithContext(ctx, "GET", userServiceURL(id), nil)
    resp, err := http.DefaultClient.Do(req)
    if err != nil { return nil, err }
    defer resp.Body.Close()
    // … decode
}
// Résultat : un timer (et son contexte) par appel, retenu jusqu'à 3s après l'appel.
// Sous 10 000 req/s → 30 000 timers en vol à tout moment.

L'underscore _ à la place de cancel est le geste qui crée la fuite. Le compilateur Go ne l'interdit pas — c'est go vet, via son check lostcancel, qui signale un cancel jeté ou jamais appelé. Sous faible charge, la fuite est invisible. Sous forte charge, les timers et leurs contextes s'accumulent jusqu'à peser sur la mémoire. Le timeout de 3 secondes, pensé comme protection, devient la durée de vie d'un objet qui aurait dû mourir en 50 ms.The underscore _ instead of cancel is the gesture creating the leak. The Go compiler doesn't forbid it — it's go vet, through its lostcancel check, that flags a cancel discarded or never called. Under light load, the leak is invisible. Under heavy load, timers and their contexts accumulate until they weigh on memory. The 3-second timeout, conceived as protection, becomes the lifetime of an object that should have died in 50ms.

cancel() est idempotent — l'appeler deux fois ne casse riencancel() is idempotent — calling it twice breaks nothing

La fonction cancel renvoyée par WithTimeout et WithDeadline est sûre à appeler plusieurs fois — les appels suivants au premier sont des no-ops. C'est ce qui rend defer cancel() toujours correct : si le timeout expire avant la fin du travail, Go annule le contexte et appelle cancel() en interne ; quand le defer s'exécute à son tour, il appelle cancel() à nouveau, et rien ne se passe. L'idempotence de cancel() signifie qu'il n'y a jamais de raison de ne pas appeler defer cancel() — aucun risque de double libération, aucun risque d'annuler quelque chose qui ne devrait pas l'être.The cancel function returned by WithTimeout and WithDeadline is safe to call multiple times — subsequent calls after the first are no-ops. That's what makes defer cancel() always correct: if the timeout expires before the work finishes, Go cancels the context and calls cancel() internally; when the defer executes in turn, it calls cancel() again, and nothing happens. cancel()'s idempotence means there is never a reason not to call defer cancel() — no risk of double-free, no risk of canceling something that shouldn't be.

Le timeout protège contre les appels trop longs. Le defer cancel() protège contre les timers qui s'accumulent quand tout va vite.The timeout protects against calls that take too long. The defer cancel() protects against timers that accumulate when everything goes fast.
№ 03La mécaniqueThe mechanics5 min

ctx.Done() se ferme à l'expiration. ctx.Err() dit pourquoi : DeadlineExceeded ou Canceled.ctx.Done() closes on expiry. ctx.Err() says why: DeadlineExceeded or Canceled.

Un contexte avec timeout se comporte comme un WithCancel ordinaire, avec une annulation automatique en plus : quand l'échéance arrive, le runtime ferme ctx.Done() exactement comme cancel() l'aurait fait. Le pattern d'écoute est donc identique — select sur ctx.Done() aux côtés de l'opération longue — mais la cause de la fermeture varie. C'est ctx.Err() qui dit pourquoi Done() s'est fermé : context.DeadlineExceeded si c'est le timer qui a expiré, context.Canceled si c'est un appel explicite à cancel(). Cette distinction compte. Un DeadlineExceeded signale que le travail a pris trop longtemps — il peut indiquer un sous-système lent, une charge inhabituelle, un dimensionnement à revoir. Un Canceled signale une interruption volontaire — l'utilisateur a annulé, le parent a décidé d'arrêter. Les deux méritent des logs différents, des métriques différentes, et parfois des comportements différents en aval. La méthode ctx.Deadline() permet de consulter l'heure d'expiration absolue — utile pour décider si un budget de temps restant vaut la peine de tenter un appel en aval. Si time.Until(deadline) est sous le seuil minimum que l'appel nécessite, il vaut mieux retourner DeadlineExceeded immédiatement plutôt que de lancer un appel voué à l'échec.A context with a timeout behaves like an ordinary WithCancel, with an automatic cancellation added: when the deadline arrives, the runtime closes ctx.Done() exactly as cancel() would have. The listening pattern is therefore identical — select on ctx.Done() alongside the long operation — but the reason for the close varies. It's ctx.Err() that says why Done() closed: context.DeadlineExceeded if the timer expired, context.Canceled if there was an explicit call to cancel(). This distinction matters. A DeadlineExceeded signals the work took too long — it may indicate a slow subsystem, unusual load, or sizing to reconsider. A Canceled signals a voluntary interruption — the user canceled, the parent decided to stop. Both deserve different logs, different metrics, and sometimes different downstream behaviors. The ctx.Deadline() method lets you consult the absolute expiry time — useful for deciding whether remaining time budget is worth attempting a downstream call. If time.Until(deadline) is below the minimum threshold the call needs, it's better to return DeadlineExceeded immediately rather than launching a call doomed to fail.

WithTimeout + errors.Is pour identifier DeadlineExceededWithTimeout + errors.Is to identify DeadlineExceeded
func callAPI(ctx context.Context, url string) (*Response, error) {
    ctx, cancel := context.WithTimeout(ctx, 2*time.Second)
    defer cancel()

    req, _ := http.NewRequestWithContext(ctx, "GET", url, nil)
    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        // Distinguer timeout de tout autre erreur réseau
        if errors.Is(err, context.DeadlineExceeded) {
            return nil, fmt.Errorf("API timeout après 2s : %w", err)
        }
        return nil, err
    }
    defer resp.Body.Close()
    // … decode response
    return decode(resp)
}

Quand http.DefaultClient.Do(req) échoue parce que le timeout a expiré, il remonte une erreur qui enveloppe context.DeadlineExceeded. errors.Is traverse la chaîne d'enveloppement — on ne compare jamais directement deux erreurs avec == quand elles peuvent être wrappées. Le message d'erreur contextualisé en amont identifie la cause dans les logs sans avoir à relire la trace d'appel.When http.DefaultClient.Do(req) fails because the timeout expired, it surfaces an error wrapping context.DeadlineExceeded. errors.Is traverses the wrapping chain — never compare two errors directly with == when they can be wrapped. The contextualized error message upstream identifies the cause in logs without having to re-read the call trace.

ctx.Done() dit quand c'est fini. ctx.Err() dit pourquoi — et les deux réponses ne méritent pas le même traitement.ctx.Done() says when it's over. ctx.Err() says why — and the two answers don't deserve the same treatment.
№ 04Le piègeThe trap4 min

Un WithTimeout sur un contexte déjà expiré crée un fils déjà annulé. Il faut vérifier le budget avant de poser une nouvelle limite.A WithTimeout on an already-expired context creates an already-canceled child. You must check the budget before setting a new limit.

La propagation en cascade des contextes crée un piège subtil dans les architectures multi-couches. Un handler reçoit un contexte avec un timeout de 30 secondes. Il appelle un service avec WithTimeout(ctx, 5s). Ce service appelle une base avec WithTimeout(ctx, 2s). Jusqu'ici, tout va bien : chaque fils ne peut expirer qu'avant son parent, jamais après — c'est une propriété de l'arbre des contextes. Mais voici le piège : si le handler crée son WithTimeout(ctx, 5s) sur un ctx dont il ne connaît pas l'état, et que ce ctx est déjà expiré ou n'a plus que 200 ms — la requête SQL de 2 secondes va systématiquement échouer en DeadlineExceeded avant même de démarrer. La couche service se plaint de la base, la base semble lente, mais le vrai problème est en haut : le budget de temps est épuisé avant d'arriver à la couche qui travaille réellement. La bonne pratique est de consulter ctx.Deadline() avant de poser une nouvelle limite temporelle, et d'allouer le sous-timeout comme une fraction du budget restant — pas une valeur absolue fixe. Cela permet à chaque couche de s'adapter à ce qui lui a été transmis plutôt que de supposer un budget illimité. Si le budget résiduel est trop court pour que l'opération soit utile, mieux vaut retourner une erreur explicite immédiatement.Cascading context propagation creates a subtle trap in multi-layer architectures. A handler receives a context with a 30-second timeout. It calls a service with WithTimeout(ctx, 5s). That service calls a database with WithTimeout(ctx, 2s). So far, fine: each child can only expire before its parent, never after — it's a property of the context tree. But here's the trap: if the handler creates its WithTimeout(ctx, 5s) on a ctx whose state it doesn't know, and that ctx is already expired or has less than 200ms left — the 2-second SQL query will systematically fail with DeadlineExceeded before even starting. The service layer blames the database, the database seems slow, but the real problem is upstream: the time budget is exhausted before reaching the layer that does the actual work. The best practice is to consult ctx.Deadline() before setting a new time limit, and allocate the sub-timeout as a fraction of the remaining budget — not a fixed absolute value. This lets each layer adapt to what was passed to it rather than assuming unlimited budget. If the residual budget is too short for the operation to be useful, better to return an explicit error immediately.

Timeout fixe : ignorance du budget résiduel du parentFixed timeout: ignorance of parent's residual budget
func handleRequest(w http.ResponseWriter, r *http.Request) {
    // Supposons que r.Context() porte déjà un timeout de 30s (posé par un middleware).
    ctx := r.Context()

    // ❌ On crée un NOUVEAU timeout de 5s — mais si r.Context() expire
    // avant 5s, les deux s'appliquent (le premier qui expire gagne).
    // Si r.Context() a déjà expiré, ce WithTimeout crée un ctx déjà annulé.
    ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
    defer cancel()

    data, err := fetchFromDB(ctx)   // ok : ctx est le fils du ctx de r
    if err != nil {
        http.Error(w, "db error", 500)
        return
    }
    // …
}

Le WithTimeout(ctx, 5s) est correct structurellement — le fils ne peut pas vivre plus longtemps que son parent. Mais il ignore si le parent a déjà consommé son budget. Si le ctx de la requête HTTP a 200 ms restants quand on arrive ici, le nouveau fils a 200 ms (le minimum des deux) — pas 5 secondes. Les 2 secondes allouées à la DB ensuite seront encore réduites. Tout le monde se plaint en cascade de la couche d'en dessous, alors que le budget était épuisé en haut.The WithTimeout(ctx, 5s) is structurally correct — the child can't outlive its parent. But it ignores whether the parent has already consumed its budget. If the HTTP request's ctx has 200ms left when we arrive here, the new child has 200ms (the minimum of the two) — not 5 seconds. The 2 seconds allocated to the DB afterward will be cut down further. Everyone cascades complaints to the layer below, while the budget was exhausted at the top.

La règle de répartition du tempsThe time allocation rule

Une architecture distribuée saine répartit le budget de temps entre les couches plutôt que de poser des timeouts absolus indépendants. L'idée directrice : « quelle fraction de ce qui me reste puis-je allouer à cette opération ? » — pas « quel timeout fixe convient à cette opération ? ». La fraction est ajustable par configuration ; la valeur absolue est rigide. Et si aucune deadline n'existe dans le ctx parent (ok == false), on pose son propre timeout absolu normalement.A healthy distributed architecture allocates the time budget across layers rather than setting independent absolute timeouts. The guiding idea: "what fraction of what I have left can I allocate to this operation?" — not "what fixed timeout suits this operation?" The fraction is configurable; the absolute value is rigid. And if no deadline exists in the parent ctx (ok == false), set your own absolute timeout normally.

Propagation inverse : quand le fils expire avant le parentReverse propagation: when the child expires before the parent

Un fils avec un timeout plus court que son parent expire avant lui — c'est attendu. Ce qui est inattendu, c'est qu'à ce moment, ctx.Done() du fils se ferme, mais ctx.Done() du parent reste ouvert. C'est une propriété de l'arbre : l'expiration se propage vers les feuilles, jamais vers la racine. Cela signifie que si on écoute le fils dans un select et qu'il expire, on récupère context.DeadlineExceeded du fils — et le parent, lui, peut continuer à lancer d'autres sous-opérations avec le budget restant. C'est ce qui permet à un handler de relancer un appel de secours (fallback) après un timeout d'appel principal : le contexte parent est encore vivant.A child with a shorter timeout than its parent expires before it — that's expected. What's unexpected is that at that moment, the child's ctx.Done() closes, but the parent's ctx.Done() stays open. It's a tree property: expiry propagates toward leaves, never toward the root. This means that if you listen to the child in a select and it expires, you get the child's context.DeadlineExceeded — and the parent can keep launching other sub-operations with the remaining budget. That's what lets a handler retry a fallback call after a primary call timeout: the parent context is still alive.

Un timeout fixe suppose un budget infini. Consulter ctx.Deadline() et fractionner, c'est respecter ce que le parent a transmis.A fixed timeout assumes infinite budget. Consulting ctx.Deadline() and fractioning respects what the parent passed down.
№ 05Bilan & éditoWrap-up & editorial2 min

Le timeout descend dans l'arbre. Le defer cancel() le nettoie à la sortie. ctx.Err() dit pourquoi — et la réponse change le comportement.The timeout flows down the tree. The defer cancel() cleans it up on exit. ctx.Err() says why — and the answer changes behavior.

Ce numéro a couvert la dimension temporelle de context.Context : comment poser une limite de temps à un arbre de goroutines, et ce qui arrive quand cette limite est atteinte. WithTimeout et WithDeadline sont deux syntaxes pour la même opération — une durée relative ou un instant absolu. Les deux produisent un contexte-fils qui s'annule automatiquement, et une fonction cancel qu'on diffère immédiatement : sans ce defer, chaque appel laisse un timer actif pendant toute la durée du timeout, accumulant des goroutines silencieusement jusqu'à dégrader les performances sous charge. Quand le timeout expire, ctx.Done() se ferme — comme pour toute annulation — et ctx.Err() retourne context.DeadlineExceeded plutôt que context.Canceled : deux causes, deux comportements en aval, deux classes de métriques. Le piège de fin de volume : un WithTimeout sur un contexte déjà contraint hérite de la contrainte la plus stricte. En multicouche, poser un timeout absolu sans consulter ctx.Deadline() revient à ignorer le budget déjà alloué par le parent — on crée des DeadlineExceeded en cascade que les logs attribuent à la mauvaise couche. La discipline est de fractionner le budget restant plutôt que de réinitialiser une valeur fixe. Reste un usage de context.Context qu'on n'a pas touché : glisser une donnée dans le contexte. C'est l'objet du dernier numéro du volume.This issue covered the temporal dimension of context.Context: how to put a time limit on a goroutine tree, and what happens when that limit is reached. WithTimeout and WithDeadline are two syntaxes for the same operation — a relative duration or an absolute instant. Both produce a child context that auto-cancels, and a cancel function you defer immediately: without that defer, every call leaves an active timer for the full timeout duration, silently accumulating goroutines until performance degrades under load. When the timeout expires, ctx.Done() closes — as with any cancellation — and ctx.Err() returns context.DeadlineExceeded rather than context.Canceled: two causes, two downstream behaviors, two metric classes. The end-of-volume trap: a WithTimeout on an already-constrained context inherits the tighter constraint. In multi-layer architectures, setting an absolute timeout without consulting ctx.Deadline() means ignoring the budget already allocated by the parent — you create cascading DeadlineExceededs that logs attribute to the wrong layer. The discipline is to fraction the remaining budget rather than resetting a fixed value. One use of context.Context remains untouched: slipping data into the context. That's the last issue of the volume.

L'idéeThe ideaLa règleThe ruleSi tu la ratesIf you miss it
defer cancel()defer cancel()Toujours en deuxième ligne après WithTimeout ou WithDeadline — sans exception.Always the second line after WithTimeout or WithDeadline — no exception.Des timers et leurs contextes qui s'accumulent silencieusement sous charge.Timers and their contexts silently accumulating under load.
ctx.Err()ctx.Err()Distinguer DeadlineExceeded de Canceled dans les logs et métriques.Distinguish DeadlineExceeded from Canceled in logs and metrics.Des alertes de latence sur des annulations volontaires, du bruit inutile.Latency alerts on voluntary cancellations, useless noise.
Budget résiduelResidual budgetConsulter ctx.Deadline() avant un sous-timeout ; allouer une fraction, pas une valeur fixe.Consult ctx.Deadline() before a sub-timeout; allocate a fraction, not a fixed value.Des DeadlineExceeded en cascade attribués à la mauvaise couche.Cascading DeadlineExceededs attributed to the wrong layer.
Héritage strictStrict inheritanceUn fils expire toujours avant ou en même temps que son parent — jamais après.A child always expires before or at the same time as its parent — never after.Un timeout fils supposé de 5s qui dure en réalité 200ms selon l'état du parent.A child timeout supposedly 5s that actually lasts 200ms depending on parent state.
Un timeout sans defer cancel() est une demi-mesure. L'un coupe le travail long ; l'autre libère le travail court — les deux ensemble forment la paire.A timeout without defer cancel() is a half-measure. One cuts long work; the other frees short work — both together form the pair.
Mot de l'éditeur · avant-dernier numéro du volume 8From the editor · penultimate issue of volume 8

Le volume 8 a couvert l'annulation et le temps. Il reste un usage de context.Context que la plupart abusent : y glisser des données.Volume 8 covered cancellation and time. One use of context.Context remains that most people abuse: slipping data into it.

Deux numéros ont établi context.Context comme câble d'annulation : premier argument, jamais stocké, propagé jusqu'au dernier appel bloquant. Le premier a décrit la structure de l'arbre et la mécanique du signal. Le second a ajouté le temps : WithTimeout, defer cancel(), la distinction entre DeadlineExceeded et Canceled, et le piège des timeouts absolus dans un arbre contraint. Il reste un troisième usage de Context, moins évident et plus controversé : WithValue. Context.WithValue permet de glisser une paire clé-valeur dans le contexte, lisible par toute fonction en aval. C'est pratique pour propager un request ID, un trace ID, ou les valeurs d'authentification d'une requête HTTP — sans alourdir toutes les signatures intermédiaires. Mais c'est aussi la porte d'entrée d'un antipattern qu'on voit partout : injecter des dépendances (loggers, bases de données, clients HTTP) via le contexte pour éviter de les passer explicitement. Le dernier numéro du volume trace la frontière : ce qui a sa place dans le contexte, ce qui n'y a pas sa place, et pourquoi les clés doivent être typées plutôt que des strings nues. Vol. 8 №03 — La valeur dans le contexte.Two issues established context.Context as a cancellation cable: first argument, never stored, propagated to the last blocking call. The first described the tree structure and signal mechanics. The second added time: WithTimeout, defer cancel(), the distinction between DeadlineExceeded and Canceled, and the trap of absolute timeouts in a constrained tree. One third use of Context remains, less obvious and more controversial: WithValue. context.WithValue lets you slip a key-value pair into the context, readable by any downstream function. It's convenient for propagating a request ID, a trace ID, or an HTTP request's authentication values — without burdening all intermediate signatures. But it's also the entry point for an antipattern seen everywhere: injecting dependencies (loggers, databases, HTTP clients) via context to avoid passing them explicitly. The volume's last issue draws the line: what belongs in context, what doesn't, and why keys must be typed rather than bare strings. Vol. 8 №03 — The value in the context.