Day 058 — 2026-09-28 | ミドルウェア設計パターン: context.WithValue に何を入れてよいか——キーの同一性・上向きの袋・後で走る goroutine を7つの実験で確かめ、8つの候補を仕分ける

📚 背景知識（読んでから問題へ）

テーマ15の3日目です（期間は 2026-09-25〜2026-10-24）。Day 056・057 のミドルウェアは、どれも r.WithContext(context.WithValue(...)) で下流へ値を渡していました。Day 017 では WithValue の基本（独自型のキー・型アサーションで取り出す）を学んでいます。今日はその先で、ミドルウェアを設計する人が迷う3つの問いを扱います。

1. キーはどう作れば衝突しないのか。「独自型なら安全」はどこまで本当か
2. 下流から上流へ値を返したい（ログにユーザー名を載せたい）とき、context をどう使うか。何が壊れるか
3. 結局、何を context に入れて、何を入れないのか

公式の記述（go doc context.WithValue、Go 1.27.1）

原文の要点は次の3つです（ここでは訳して載せます）。

• context の値は「プロセスや API の境界を越えて運ばれる、リクエストに紐づくデータ」だけに使う。関数の省略可能な引数を渡すためには使わない
• キーは比較できる型でなければならない。パッケージ間の衝突を避けるため、string などの組み込み型にしない。使う側が自分の型を定義する
• interface に入れるときの割り当てを避けるため、キーは struct{} 型にすることが多い。公開するキー変数は、静的な型をポインタか interface にする

標準ライブラリは実際にどう書いているか（Go 1.27.1 のソースを数えた）

$(go env GOROOT)/src の中で、cmd/・テスト・vendor を除いた context.WithValue( の呼び出しは 9か所でした（grep で数えた。うち1か所は context.go のコメント内の例）。

string や int をキーにしている箇所は0か所です。また log/slog には、ロガーを context に入れる関数（NewContext・FromContext）がありません（go doc log/slog の一覧で確認）。代わりに InfoContext(ctx, ...) のように context をログ関数へ渡す形になっています。これは今日の問7に効きます。

Value はどう探すか（context.go 776行目 func value）

WithValue は親を指す valueCtx{parent, key, val} を1つ作るだけです。Value(key) は自分から親へ向かって1つずつ key == ctx.key を比べ、見つかったら返します。連結リストを根元へたどるので、かかる時間は「探す値がどれだけ根元にあるか」に比例します。== は interface 同士の比較なので、型と値の両方が一致したときだけ当たります。

実際の net/http サーバーで、ハンドラが受け取る r.Context() を fmt.Sprint すると、ミドルウェアを1つも挟まない状態で次の4段でした（Go 1.27.1 で実測）。

📋 コピーcontext.Background.WithValue(net/http context value http-server, *http.Server).WithValue(net/http context value local-addr, 127.0.0.1:51438).WithCancel.WithCancel

fmt.Sprint(ctx) で段の並びが見えるのは、調べ物のときに便利です。

📝 問題

今日は予測してから実行する問題です。下の3つのファイルと go.mod を1つのディレクトリに置き、実行する前に問1〜問6の答えを自己評価欄に書いてください。そのあと実行して答え合わせをし、問7に答えます。

📋 コピーmkdir day058 && cd day058
# 下の go.mod・main.go・race_test.go・bench_test.go を置く
go run .                                   # 実験1〜4・6 を表示する
go test -race -count=1 -run Race -v .      # 実験5 をデータ競合の検出つきで動かす
go test -count=1 -run Race -v .            # 実験5 を検出なしで動かす
go test -run XXX -bench . -count=3 .       # 実験7 の速さと割り当てを3回測る

go.mod:

📋 コピーmodule day058

go 1.24

実験コード（3ファイル）

📋 コピー// Day 058: context.WithValue の挙動を6つの実験で確かめる。go run . で全部出る。
package main

import (
	"context"
	"fmt"
	"log/slog"
	"os"
	"time"
)

// ---- 実験1: キーの同一性 ----

type ctxKey string // Day 017 で使った「独自の string 型」

// 2つの別パッケージが、それぞれ非公開の key 型を持っている状況を1ファイルで再現する
type pkgAKey int
type pkgBKey int

type contextKey struct{ name string } // net/http と同じ形（http.go 120行目）

func exp1() {
	fmt.Println("== 実験1: どの取り出しが当たるか")
	// 認証パッケージがユーザー名を、課金パッケージがユーザーの数値 ID を、どちらも "user" で入れる
	ctx := context.WithValue(context.Background(), "user", "alice")
	ctx = context.WithValue(ctx, "user", 42)
	name, ok := ctx.Value("user").(string)
	fmt.Printf("  (a) 認証側が \"user\" を string で取り出す : %q ok=%v\n", name, ok)
	fmt.Printf("  (b) \"user\" で入れて ctxKey(\"user\") で取る : %v\n", ctx.Value(ctxKey("user")))

	ctx = context.WithValue(context.Background(), pkgAKey(0), "A の値")
	ctx = context.WithValue(ctx, pkgBKey(0), "B の値")
	fmt.Printf("  (c) pkgAKey(0) で取る : %v / pkgBKey(0) で取る : %v\n", ctx.Value(pkgAKey(0)), ctx.Value(pkgBKey(0)))

	k1 := &contextKey{"http-server"}
	ctx = context.WithValue(context.Background(), k1, "srv")
	fmt.Printf("  (d) 中身が同じ別のポインタ &contextKey{\"http-server\"} で取る : %v\n", ctx.Value(&contextKey{"http-server"}))

	ctx = context.WithValue(context.Background(), contextKey{"http-server"}, "srv")
	fmt.Printf("  (e) 値の contextKey{\"http-server\"} で入れて、別に作った同じ値で取る : %v\n", ctx.Value(contextKey{"http-server"}))
}

// ---- 実験2: 上書きと順序 ----

type userKey struct{}

func exp2() {
	fmt.Println("== 実験2: 上書き・兄弟・順序")
	parent := context.WithValue(context.Background(), userKey{}, "alice")
	child := context.WithValue(parent, userKey{}, "bob")
	sibling := context.WithValue(parent, ctxKey("other"), 1)
	fmt.Printf("  child=%v parent=%v sibling=%v\n", child.Value(userKey{}), parent.Value(userKey{}), sibling.Value(userKey{}))

	// next を呼んだ「後」で値を足すミドルウェア
	var seen any
	handler := func(ctx context.Context) { seen = ctx.Value(userKey{}) }
	mw := func(ctx context.Context) {
		handler(ctx)
		ctx = context.WithValue(ctx, userKey{}, "carol")
		_ = ctx
	}
	mw(context.Background())
	fmt.Printf("  next の後で WithValue したとき、ハンドラが見た値=%v\n", seen)
}

// ---- 実験3: 比較できないキー ----

func try(label string, f func()) {
	defer func() {
		if v := recover(); v != nil {
			fmt.Printf("  %-34s panic: %v\n", label, v)
		}
	}()
	f()
	fmt.Printf("  %-34s ok\n", label)
}

func exp3() {
	fmt.Println("== 実験3: キーに使える型")
	bg := context.Background()
	try("[]string{\"a\"}", func() { _ = context.WithValue(bg, []string{"a"}, 1) })
	try("struct{ tags []string }{}", func() { _ = context.WithValue(bg, struct{ tags []string }{}, 1) })
	try("map[string]int{}", func() { _ = context.WithValue(bg, map[string]int{}, 1) })
	try("[2]string{\"a\", \"b\"}", func() { _ = context.WithValue(bg, [2]string{"a", "b"}, 1) })
	try("nil", func() { _ = context.WithValue(bg, nil, 1) })
}

// ---- 実験4: WithoutCancel ----

type reqIDKey struct{}

func exp4() {
	fmt.Println("== 実験4: レスポンス後に走る処理（監査ログの書き込み等）")
	reqCtx, cancel := context.WithCancel(context.WithValue(context.Background(), reqIDKey{}, "req-42"))
	detached := context.WithoutCancel(reqCtx)
	cancel() // ハンドラが返ると net/http がリクエストの context をキャンセルする
	fmt.Printf("  reqCtx:   Err=%v id=%v\n", reqCtx.Err(), reqCtx.Value(reqIDKey{}))
	fmt.Printf("  detached: Err=%v id=%v\n", detached.Err(), detached.Value(reqIDKey{}))
	bounded, cancel2 := context.WithTimeout(detached, 2*time.Second)
	defer cancel2()
	dl, _ := bounded.Deadline()
	fmt.Printf("  WithTimeout(detached, 2s): Err=%v id=%v 期限あり=%v\n", bounded.Err(), bounded.Value(reqIDKey{}), !dl.IsZero())
}

// ---- 実験6: ロガーを context に入れず、Handler が context から値を読む ----

type ctxHandler struct{ slog.Handler }

func (h ctxHandler) Handle(ctx context.Context, r slog.Record) error {
	if id, ok := ctx.Value(reqIDKey{}).(string); ok {
		r.AddAttrs(slog.String("req_id", id))
	}
	return h.Handler.Handle(ctx, r)
}

func (h ctxHandler) WithAttrs(as []slog.Attr) slog.Handler {
	return ctxHandler{h.Handler.WithAttrs(as)}
}
func (h ctxHandler) WithGroup(n string) slog.Handler { return ctxHandler{h.Handler.WithGroup(n)} }

func exp6() {
	fmt.Println("== 実験6: slog.Handler が context から req_id を読む")
	opts := &slog.HandlerOptions{ReplaceAttr: func(_ []string, a slog.Attr) slog.Attr {
		if a.Key == slog.TimeKey {
			return slog.Attr{}
		}
		return a
	}}
	logger := slog.New(ctxHandler{slog.NewTextHandler(os.Stdout, opts)})
	ctx := context.WithValue(context.Background(), reqIDKey{}, "req-42")
	logger.InfoContext(ctx, "order created", "order", 7)
	logger.Info("order created", "order", 7) // ctx を渡さない版
}

func main() {
	exp1()
	exp2()
	exp3()
	exp4()
	fmt.Println("== 実験5 は go test -race -run Race、実験7 は go test -bench . で")
	exp6()
}

📋 コピーpackage main

import (
	"context"
	"net/http"
	"net/http/httptest"
	"sync"
	"testing"
	"time"
)

// 実験5: 「上向きの袋」— 外側のミドルウェアが可変のポインタを context に入れ、
// 内側のハンドラが書き込み、外側が next の後で読む（chi の RouteContext と同じ形）。
type fields struct{ kv map[string]string }
type fieldsKey struct{}

func addField(ctx context.Context, k, v string) {
	if f, ok := ctx.Value(fieldsKey{}).(*fields); ok {
		f.kv[k] = v
	}
}

func withFields(next http.Handler, got *map[string]string) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		f := &fields{kv: map[string]string{}}
		next.ServeHTTP(w, r.WithContext(context.WithValue(r.Context(), fieldsKey{}, f)))
		*got = f.kv           // アクセスログを書くつもりで読む
		for k := range f.kv { // ログの行を組み立てるつもりで全部なめる
			_ = k
		}
	})
}

// 同じ goroutine の中で書くだけなら安全
func TestRaceSameGoroutine(t *testing.T) {
	var got map[string]string
	h := withFields(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		addField(r.Context(), "user", "alice")
	}), &got)
	h.ServeHTTP(httptest.NewRecorder(), httptest.NewRequest("GET", "/", nil))
	t.Logf("fields=%v", got)
}

// ハンドラが起こした goroutine が、レスポンスの後に書く
func TestRaceDetachedWriter(t *testing.T) {
	var got map[string]string
	var wg sync.WaitGroup
	h := withFields(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		addField(r.Context(), "user", "alice")
		wg.Add(1)
		go func() {
			defer wg.Done()
			time.Sleep(time.Millisecond)
			addField(r.Context(), "audit", "written") // 外側がもう読んでいるかもしれない
		}()
	}), &got)
	h.ServeHTTP(httptest.NewRecorder(), httptest.NewRequest("GET", "/", nil))
	for range 3 {
		for k := range got { // ログの出力中に map を読み続ける想定
			_ = k
		}
		time.Sleep(time.Millisecond)
	}
	wg.Wait()
	t.Logf("fields=%v", got)
}

// 直し方: 袋への書き込みはハンドラが返る前だけにする。後で走る処理には、
// 必要な値を引数で渡し、context は WithoutCancel で切り離す（袋には触らない）
func TestRaceDetachedFixed(t *testing.T) {
	var got map[string]string
	var wg sync.WaitGroup
	var audited string
	h := withFields(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		addField(r.Context(), "user", "alice")
		addField(r.Context(), "audit", "scheduled") // 返る前に書く
		ctx := context.WithoutCancel(r.Context())
		wg.Add(1)
		go func(ctx context.Context, user string) {
			defer wg.Done()
			time.Sleep(time.Millisecond)
			audited = user // 監査ログを書く想定。袋には書かない
			_ = ctx
		}(ctx, "alice")
	}), &got)
	h.ServeHTTP(httptest.NewRecorder(), httptest.NewRequest("GET", "/", nil))
	for range 3 {
		for k := range got {
			_ = k
		}
		time.Sleep(time.Millisecond)
	}
	wg.Wait()
	t.Logf("fields=%v audited=%s", got, audited)
}

📋 コピーpackage main

import (
	"context"
	"fmt"
	"net/http"
	"net/http/httptest"
	"testing"
)

type benchKey int

// 実験7a: 取り出しの速さは、目的の値がどれだけ深いところにあるかで決まる
func BenchmarkValueDepth(b *testing.B) {
	for _, depth := range []int{1, 8, 32, 128} {
		ctx := context.WithValue(context.Background(), reqIDKey{}, "req-42") // 一番根元に置く
		for i := range depth - 1 {
			ctx = context.WithValue(ctx, benchKey(i), i)
		}
		b.Run(fmt.Sprintf("depth=%d", depth), func(b *testing.B) {
			for b.Loop() {
				_ = ctx.Value(reqIDKey{})
			}
		})
	}
}

// 実験7b: 1回の WithValue の割り当て（キーと値の型で変わるか）
var sink context.Context
var sinkReq *http.Request

func BenchmarkWithValueAlloc(b *testing.B) {
	bg := context.Background()
	id := fmt.Sprint("req-", 42) // 実行時に作った文字列（定数ではない）
	n := 4242
	cases := []struct {
		name string
		f    func() context.Context
	}{
		{"key=struct{}/val=定数string", func() context.Context { return context.WithValue(bg, reqIDKey{}, "req-42") }},
		{"key=struct{}/val=実行時string", func() context.Context { return context.WithValue(bg, reqIDKey{}, id) }},
		{"key=struct{}/val=*T", func() context.Context { return context.WithValue(bg, reqIDKey{}, &n) }},
		{"key=struct{}/val=int(4242)", func() context.Context { return context.WithValue(bg, reqIDKey{}, n) }},
		{"key=ctxKey(string定数)/val=*T", func() context.Context { return context.WithValue(bg, ctxKey("user"), &n) }},
	}
	for _, c := range cases {
		b.Run(c.name, func(b *testing.B) {
			b.ReportAllocs()
			for b.Loop() {
				sink = c.f()
			}
		})
	}
}

// 実験7c: ミドルウェアが値を1つ足すたびの r.WithContext（Request の浅いコピー）
func BenchmarkRequestWithContext(b *testing.B) {
	r := httptest.NewRequest("GET", "/api/v1/orders/42", nil)
	b.ReportAllocs()
	for b.Loop() {
		sinkReq = r.WithContext(context.WithValue(r.Context(), reqIDKey{}, "req-42"))
	}
}

問1（実験1: キーの同一性）

(a)〜(e) の5つの取り出しは、それぞれ何を返しますか。(a) は ok の値も答えてください。

問2（実験2: 上書きと順序）

child・parent・sibling がそれぞれ userKey{} で返す値と、「next の後で WithValue したとき」にハンドラが見た値を答えてください。

問3（実験3: キーに使える型）

5つのキーのうち、panic するものはどれですか。panic の文言も予想してください。コンパイルエラーになるものはありますか。

問4（実験4: WithoutCancel）

reqCtx をキャンセルした後の、reqCtx・detached・bounded それぞれの Err() と req_id を答えてください。

問5（実験5: 上向きの袋）

withFields は「外側のミドルウェアがポインタを context に入れ、内側が書き込み、外側が next の後で読む」形です。3つのテストのうち、

• -race 付きで FAIL するのはどれか
• -race 無しでも FAIL するか

を答えてください。

問6（実験7: 速さと割り当て）

Apple M1 での値を、桁で予想してください。

• 根元の値を探すとき、段数 1・8・32・128 でそれぞれ何 ns か
• WithValue 1回の割り当ての回数とバイト数。5つの組み合わせで違いはあるか
• r.WithContext(context.WithValue(...)) 1回の割り当ての回数とバイト数

問7（判断: 何を context に入れるか）

次の8つの候補を「入れる／入れない／入れるが境界で取り出す」に仕分け、それぞれ理由を1行で書いてください。入れないものには、代わりにどう渡すかも書きます。

💡 ヒント

📋 コピーQ1. その値は「このリクエストが何者か」を表すか、それとも「処理のやり方」を変えるか
      → 前者なら context の候補。後者（ページサイズ・DB 接続・フラグ）なら引数か構造体のフィールド
Q2. その値が無いとき、関数は正しく動けるか
      → 動けない（必須）なら、関数のシグネチャに出す。context に隠すと、呼び出し側が入れ忘れても
        コンパイルは通り、実行時に初めて壊れる

✅ 模範解答

📋 コピー== 実験1: どの取り出しが当たるか
  (a) 認証側が "user" を string で取り出す : "" ok=false
  (b) "user" で入れて ctxKey("user") で取る : <nil>
  (c) pkgAKey(0) で取る : A の値 / pkgBKey(0) で取る : B の値
  (d) 中身が同じ別のポインタ &contextKey{"http-server"} で取る : <nil>
  (e) 値の contextKey{"http-server"} で入れて、別に作った同じ値で取る : srv
== 実験2: 上書き・兄弟・順序
  child=bob parent=alice sibling=alice
  next の後で WithValue したとき、ハンドラが見た値=<nil>
== 実験3: キーに使える型
  []string{"a"}                      panic: key is not comparable
  struct{ tags []string }{}          panic: key is not comparable
  map[string]int{}                   panic: key is not comparable
  [2]string{"a", "b"}                ok
  nil                                panic: nil key
== 実験4: レスポンス後に走る処理（監査ログの書き込み等）
  reqCtx:   Err=context canceled id=req-42
  detached: Err=<nil> id=req-42
  WithTimeout(detached, 2s): Err=<nil> id=req-42 期限あり=true
== 実験5 は go test -race -run Race、実験7 は go test -bench . で
== 実験6: slog.Handler が context から req_id を読む
level=INFO msg="order created" order=7 req_id=req-42
level=INFO msg="order created" order=7

📋 コピー=== RUN   TestRaceSameGoroutine
    race_test.go:41: fields=map[user:alice]
--- PASS: TestRaceSameGoroutine (0.00s)
=== RUN   TestRaceDetachedWriter
WARNING: DATA RACE
    race_test.go:65: fields=map[audit:written user:alice]
--- FAIL: TestRaceDetachedWriter (0.00s)
=== RUN   TestRaceDetachedFixed
    race_test.go:94: fields=map[audit:scheduled user:alice] audited=alice
--- PASS: TestRaceDetachedFixed (0.00s)
FAIL

📋 コピー// Package lintdemo はキーの型をリンターが見るかを確かめるためだけのもの。
package lintdemo

import "context"

type ctxKey string

type userKey struct{}

func WithStringKey(ctx context.Context) context.Context {
	return context.WithValue(ctx, "user", "alice")
}
func WithIntKey(ctx context.Context) context.Context { return context.WithValue(ctx, 1, "alice") }
func WithNamedString(ctx context.Context) context.Context {
	return context.WithValue(ctx, ctxKey("user"), "alice")
}
func WithStructKey(ctx context.Context) context.Context {
	return context.WithValue(ctx, userKey{}, "alice")
}

📋 コピー[go vet]      指摘0件
[staticcheck] lintdemo.go:10:89: SA1029: should not use built-in type string as key for value; define your own type to avoid collisions
              lintdemo.go:11:89: SA1029: should not use built-in type int as key for value; define your own type to avoid collisions

🪜 Step-by-Step 解説

Step 1: キーを「型」で守る仕組みを理解する

value 関数の比較は key == ctx.key の1行です。interface の == は型と値の両方を見るので、自分のパッケージにしか無い型をキーにすれば、他のパッケージは同じキーを作れません。これが公式の「組み込み型にしない」の理由です（問1(a)(b)(c)）。

Day 017 で使った type ctxKey string も、この点では安全です。ただし同じパッケージの中で ctxKey("user") を2か所で別の意味に使えば衝突します。struct{} 型を値ごとに1つ作る（type userKey struct{}・type reqIDKey struct{}）と、同じパッケージ内でも型でしか作れないので、打ち間違いで衝突することがありません。割り当ては問6のとおり、どちらも0です。

Step 2: 公開するならポインタ、使わせるなら関数

net/http はキーを公開しています（http.ServerContextKey）。ここで値の構造体にすると、外のパッケージが contextKey{"http-server"} を作れれば偽造できてしまいます（contextKey は非公開の型なので実際には作れませんが、公開の型だったら作れる）。ポインタなら、同じ中身でも別のポインタは別のキーです（問1(d)）。

ただし多くの場合、キーそのものは公開せず、公式ドキュメントの例のように NewContext(ctx, u)・FromContext(ctx) (u, ok) の2つの関数だけを公開します。型アサーションを1か所に閉じ込めることで、問1(a)の「黙って空になる」を防げます。

Step 3: context は下にしか流れない。上に返すならポインタ、ただし期限つき

問2のとおり、ハンドラが WithValue しても外側のミドルウェアには見えません。それでもアクセスログに「ハンドラが決めた値」を載せたいとき、実務ではポインタを先に入れておき、内側がその指す先に書く「上向きの袋」を使います。chi の RouteContext も同じ形で、Day 057 で見たとおり Request のコピーに強いという利点があります。

この形は 「書き込みはハンドラが返るまで」 という暗黙の約束の上に成り立っています。問5の TestRaceDetachedWriter は、この約束を goroutine が破った例です。-race 無しでは通るので、CI で go test -race を回していなければ見つかりません。

Step 4: レスポンスの後に走る処理には WithoutCancel ＋ 上限

ハンドラが返ると、net/http はリクエストの context をキャンセルします。その後に監査ログを DB に書く goroutine が r.Context() をそのまま使うと、書き込みは context canceled で失敗します。Go 1.21 で入った context.WithoutCancel は、値（リクエスト ID など）を残したままキャンセルだけを切り離します（問4）。切り離すと止める手段が無くなるので、WithTimeout で上限を付け直します。そして、その goroutine は袋に触らない（TestRaceDetachedFixed）。

Step 5: 「何者か」と「どうやるか」で仕分ける

問7の仕分けは、ヒント3の2問に集約されます。context に入れてよいのは「このリクエストが何者か」を表し、無くても処理の正しさが変わらないもの（①②）。必須の値（③）は境界まで context で運び、そこで取り出して引数にします。「どうやるか」を変えるもの（④⑤⑦⑧）は、引数か構造体のフィールドです。

🧭 設計思想・なぜこう書くのか

Go の関数は、何を必要としているかをシグネチャで示すことを大事にします。context.Context の値は、この原則にわざと穴を開ける仕組みです。穴が必要なのは、http.Handler のようにシグネチャを変えられない境界を越えて、リクエストの素性（誰か・どのトレースか）を運ぶためです。

だから公式は値の用途を「境界を越えて運ばれるリクエストのデータ」に絞り、キーに型を要求し、取り出しは any を返すというあえて使いにくい APIにしています。型安全なジェネリクス版（context.Value[T] のようなもの）が標準に入っていないのも、使いやすくすると穴が広がるからだと読めます（これは筆者の解釈で、Go チームの公式の説明ではありません）。

もう1つは「不変」です。WithValue は親を書き換えないので、ある context を複数の goroutine に渡しても、context 自体は安全です（問2）。危ないのは、不変の箱に可変のポインタを入れたときだけです（問5）。

🌐 他言語との比較

他の言語が「暗黙に引き継ぐ」仕組みを選んだのに対し、Go は ctx を全関数の第1引数に書かせる手間と引き換えに、流れを目に見えるようにしました。上の表の各仕組みの説明は、各言語の公式ドキュメントの記述によるもので、今日は実行して確かめていません。

🏭 実務での使いどころ

• ミドルウェアのパッケージを作るとき: キーは type xxxKey struct{} で非公開にし、WithXxx(ctx, v)・XxxFrom(ctx) (v, ok) の2関数だけを公開する。型アサーションはこの2関数の中だけ
• CI に入れるもの: staticcheck（golangci-lint 経由でも可）の SA1029 で組み込み型のキーを止める。go vet は見ない（実測）。go test -race で問5の形を止める
• ログの req_id が一部の行だけ空になっていたら: slog.Info（context 無し）を呼んでいる行か、Request をコピーする前の context を使っている行。実験6の2行目がその形
• 非同期の監査ログ・メール送信: context.WithoutCancel(r.Context()) ＋ WithTimeout。値を引数でも渡し、袋には触らない
• コードレビューで ctx.Value( を見たら: その値が無いときに関数が正しく動くかを聞く。動かないなら引数にする

⚠️ よくある誤解・ミス

🚧 扱わなかった範囲

• *sql.Tx を context に入れる案の実装と実測: 表の「Commit 後の Tx を触る経路」は database/sql の ErrTxDone の説明からの推論で、今日は再現していません
• OpenTelemetry・gRPC-go の実物: API 名を挙げただけで、依存を足して動かしてはいません。span が context の何段目に入るか、取り出しに何 ns かかるかは測っていません
• context.AfterFunc（Go 1.21）: キャンセル時に関数を走らせる仕組み。今日の「値」の論点から外れるので扱っていません
• context を構造体のフィールドに持つことの是非: Go ブログ "Contexts and structs"（2021）の話題。今日は「値」に絞りました
• 他言語の比較表: 各言語の公式ドキュメントの記述によるもので、動かして比べてはいません

🚀 次のステップ

• 発展: 実験6の ctxHandler を、①リクエスト ID だけでなく③主体の ID も載せるように広げ、slog.Info（context 無し）で呼ばれた行を数えるテストを書いてみましょう。「context を渡し忘れたログ」を CI で見つける仕組みになります
• 次回予告: 同じテーマ15のまま、切り口を「実装」に替えます。ルートごとに違う上限を持つレート制限ミドルウェア（トークンバケット、キーは今日の③主体、超えたら 429 と Retry-After）を、Day 057 の宣言表に1列足す形で実装します

🎯 自己評価（解いた後に記入）

自分の回答

気づき・メモ