Day 074 — 2026-10-14 | ミドルウェア設計パターン: Edge を別サービスでも使える部品として切り出す API を決める——何を引数にし、何を既定にし、何を利用者に選ばせないか（積む順 24 通り中 2 通りしか正しくない部品箱をやめ、Config 1 つと起動時の検査にする）

「利用者に選ばせる」ことの値段は、Day 063〜073 のバグ一覧で測れます。各バグについて「この API の形なら、利用者はそのバグを書けるか」を数えてください。書けない形にできたら、その項目は選ばせなくてよい候補です。逆に「選べないと困るサービス」が 3 つの中にあれば、その項目は引数か既定に残します。

• 形: 積む順を利用者に選ばせないなら、組み立ては部品の側が持つ。そのとき設定は構造体か関数オプションか。Go の構造体はフィールドのゼロ値が既定になる。ゼロ値が「安全な側」になるように名前を選ぶ（Day 066 の Public・NoRateLimit と同じ考え方）
• 大域に落ちない: otelhttp は nil を黙って無視して大域に落ちる（config.go 79 行）。Day 073 B1 はそれだった。nil は error、止めたいなら noop を明示、と分ける
• sampler: 利用者の TracerProvider の中身は外から読めない。だが「親が記録した span を渡したら記録するか」は、span を 1 本作ってみれば分かる
• ルート名と探針: mux.Handler(r) はパターンを返す。探針をパスで受け取り、起動時に mux に引かせてパターンに直せば、Filter と Edge と mux が同じものを見る
• 応答後の仕事: WithoutCancel と WithTimeout を別々に使わせると、片方を忘れる（Day 073 W2・W3）。1 つの関数にまとめる

📋 コピーtype Config struct {
	Logger        slog.Handler         // 必須
	Tracer        trace.TracerProvider // 必須（nil は error、止めるなら noop）
	Meter         metric.MeterProvider // 必須
	TrustUpstream bool                 // ゼロ値＝信じない
	Probes        []string             // パス。既定 /healthz・/readyz に足す
}

func New(cfg Config) (*Edge, error)                              // 検査はここで全部
func (e *Edge) Handler(mux *http.ServeMux) (http.Handler, error)  // 積む順は中で固定
func (e *Edge) Logger() *slog.Logger
func E(h HandlerE) http.Handler                                   // error を返すハンドラを mux に登録する口
func SetUser(ctx context.Context, user string)                    // 認証から袋への口
func Detach(ctx context.Context, timeout time.Duration) (context.Context, context.CancelFunc)
func SLI(rm metricdata.ResourceMetrics) float64

📋 コピーpackage edge

import (
	"context"
	"errors"
	"net/http"
	"runtime/debug"
)

// HandlerE は「失敗を error で返す」ハンドラ（Day 069）。E で包んで mux に登録する。
type HandlerE func(w http.ResponseWriter, r *http.Request) error

// StatusError は「クライアントに見せてよい」ステータスと文言を持つ error。
// Msg は 4xx の応答本文に出る。Err は内部の原因で、ログにだけ出る。
type StatusError struct {
	Code int
	Msg  string
	Err  error
}

func (e *StatusError) Error() string {
	if e.Err != nil {
		return e.Msg + ": " + e.Err.Error()
	}
	return e.Msg
}
func (e *StatusError) Unwrap() error { return e.Err }

// ErrNotFound は「対象が無い」を表す番兵。E が 404 にする。
var ErrNotFound = errors.New("not found")

// statusClientClosed は nginx の 499。送らない。ログと集計にだけ使う（公開しない）。
const statusClientClosed = 499

func statusOf(r *http.Request, err error) int {
	var se *StatusError
	switch {
	case errors.As(err, &se):
		if se.Code < 400 || se.Code > 599 {
			return http.StatusInternalServerError
		}
		return se.Code
	case errors.Is(err, context.Canceled) && r.Context().Err() != nil:
		return statusClientClosed
	case errors.Is(err, context.DeadlineExceeded):
		return http.StatusServiceUnavailable
	case errors.Is(err, ErrNotFound):
		return http.StatusNotFound
	}
	return http.StatusInternalServerError
}

func publicMsg(err error, status int) string {
	var se *StatusError
	if errors.As(err, &se) && se.Msg != "" && status < 500 {
		return se.Msg
	}
	if status >= 500 {
		return "internal error"
	}
	return http.StatusText(status)
}

// commitWriter は「送り始めたか・何番を送ったか」だけを覚える（Day 069・070・071 の obsWriter と同じもの）。
type commitWriter struct {
	http.ResponseWriter
	status int
}

func (w *commitWriter) WriteHeader(code int) {
	if w.status == 0 && (code >= 200 || code == http.StatusSwitchingProtocols) {
		w.status = code
	}
	w.ResponseWriter.WriteHeader(code)
}

func (w *commitWriter) Write(b []byte) (int, error) {
	if w.status == 0 {
		w.status = http.StatusOK
	}
	return w.ResponseWriter.Write(b)
}

func (w *commitWriter) Unwrap() http.ResponseWriter { return w.ResponseWriter }

// E は HandlerE を http.Handler にする（Day 069 の Adapt。error は記録せず袋に書くだけ＝Day 071 の ErrInto）。
// Edge の外で使っても動くが、そのときは error がどこにも記録されない。
func E(h HandlerE) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		cw := &commitWriter{ResponseWriter: w}
		err := h(cw, r)
		if err == nil {
			return
		}
		if cw.status != 0 {
			errInto(r, cw.status, err)
			if cw.status < 400 {
				panic(http.ErrAbortHandler)
			}
			return
		}
		status := statusOf(r, err)
		errInto(r, status, err)
		if status == statusClientClosed {
			return
		}
		http.Error(cw, publicMsg(err, status), status)
	})
}

// ---- 袋（Day 071）: 部品は書くだけ、出力は Edge の defer が 1 回だけ ----

type outcome struct {
	requestID string
	route     string // mux が選んだパターン（http.route）。外側で 1 回だけ決める
	probe     bool
	user      string
	err       error
	panic     any
	stack     []byte
}

type outcomeKey struct{}

func outcomeFrom(ctx context.Context) *outcome {
	o, _ := ctx.Value(outcomeKey{}).(*outcome)
	return o
}

func errInto(r *http.Request, _ int, err error) {
	if o := outcomeFrom(r.Context()); o != nil && o.err == nil {
		o.err = err
	}
}

// SetUser は認証ミドルウェアが「誰の要求か」を Edge に知らせる口。Edge の行の user に出る。
// Edge の外（ctx に袋が無い）では何もしない。
func SetUser(ctx context.Context, user string) {
	if o := outcomeFrom(ctx); o != nil {
		o.user = user
	}
}

// recoverMW は Day 070 の Recover。panic を回収して 500、送信後なら切断。中身は袋に書く。
func recoverMW(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		cw := &commitWriter{ResponseWriter: w}
		defer func() {
			p := recover()
			if p == nil {
				return
			}
			if p == http.ErrAbortHandler {
				panic(p)
			}
			if o := outcomeFrom(r.Context()); o != nil && o.panic == nil {
				o.panic, o.stack = p, debug.Stack()
			}
			if cw.status != 0 {
				panic(http.ErrAbortHandler)
			}
			http.Error(cw, "internal error", http.StatusInternalServerError)
		}()
		next.ServeHTTP(cw, r)
	})
}

const (
	classOK           = "ok"
	classClientError  = "client_error"
	classClientClosed = "client_closed"
	classServerError  = "server_error"
	classAborted      = "aborted"
)

func classOf(status int, aborted bool) string {
	switch {
	case aborted:
		return classAborted
	case status == statusClientClosed:
		return classClientClosed
	case status >= 500:
		return classServerError
	case status >= 400:
		return classClientError
	}
	return classOK
}

📋 コピーpackage edge

import (
	"context"
	"log/slog"
	"slices"

	"go.opentelemetry.io/otel/trace"
)

// logHandler は Day 073 の修正版 LogHandler（WithGroup の後でも trace_id・span_id・request_id は最上位）。
// 公開しない: 利用者は (*Edge).Logger だけを使う。包み忘れ・二重包みを型で起こさないため。
type logHandler struct {
	root   slog.Handler
	cur    slog.Handler
	replay []func(slog.Handler) slog.Handler
}

func (h *logHandler) Enabled(ctx context.Context, l slog.Level) bool { return h.cur.Enabled(ctx, l) }

func keysInto(ctx context.Context, buf []slog.Attr) []slog.Attr {
	if sc := trace.SpanContextFromContext(ctx); sc.IsValid() {
		buf = append(buf, slog.String("trace_id", sc.TraceID().String()), slog.String("span_id", sc.SpanID().String()))
	}
	if o := outcomeFrom(ctx); o != nil {
		buf = append(buf, slog.String("request_id", o.requestID))
	}
	return buf
}

func (h *logHandler) Handle(ctx context.Context, rec slog.Record) error {
	var arr [3]slog.Attr
	ks := keysInto(ctx, arr[:0])
	if len(h.replay) == 0 || len(ks) == 0 {
		rec.AddAttrs(ks...)
		return h.cur.Handle(ctx, rec)
	}
	hh := h.root.WithAttrs(slices.Clone(ks))
	for _, f := range h.replay {
		hh = f(hh)
	}
	return hh.Handle(ctx, rec)
}

func (h *logHandler) WithAttrs(as []slog.Attr) slog.Handler {
	if len(as) == 0 {
		return h
	}
	if len(h.replay) == 0 {
		r := h.root.WithAttrs(as)
		return &logHandler{root: r, cur: r}
	}
	as = slices.Clone(as)
	return &logHandler{root: h.root, cur: h.cur.WithAttrs(as),
		replay: append(slices.Clip(h.replay), func(x slog.Handler) slog.Handler { return x.WithAttrs(as) })}
}

func (h *logHandler) WithGroup(name string) slog.Handler {
	if name == "" {
		return h
	}
	return &logHandler{root: h.root, cur: h.cur.WithGroup(name),
		replay: append(slices.Clip(h.replay), func(x slog.Handler) slog.Handler { return x.WithGroup(name) })}
}

📋 コピーpackage edge_test

import (
	"bytes"
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"log/slog"
	"math/rand/v2"
	"net/http"
	"net/http/httptest"
	"strconv"
	"strings"
	"sync"
	"testing"
	"time"

	"d74/edge"

	"go.opentelemetry.io/otel/baggage"
	metricnoop "go.opentelemetry.io/otel/metric/noop"
	sdkmetric "go.opentelemetry.io/otel/sdk/metric"
	"go.opentelemetry.io/otel/sdk/metric/metricdata"
	sdktrace "go.opentelemetry.io/otel/sdk/trace"
	"go.opentelemetry.io/otel/sdk/trace/tracetest"
	tracenoop "go.opentelemetry.io/otel/trace/noop"
)

// このテストは package edge_test（外から見える API だけ）で書く。利用者が書けることだけを確かめるため。

type lockedBuf struct {
	mu sync.Mutex
	b  bytes.Buffer
}

func (l *lockedBuf) Write(p []byte) (int, error) {
	l.mu.Lock()
	defer l.mu.Unlock()
	return l.b.Write(p)
}

func (l *lockedBuf) lines(t *testing.T) []map[string]any {
	t.Helper()
	l.mu.Lock()
	defer l.mu.Unlock()
	var out []map[string]any
	for _, s := range strings.Split(strings.TrimSpace(l.b.String()), "\n") {
		if s == "" {
			continue
		}
		var m map[string]any
		if err := json.Unmarshal([]byte(s), &m); err != nil {
			t.Fatalf("JSON でない行: %q", s)
		}
		out = append(out, m)
	}
	return out
}

type rig struct {
	buf *lockedBuf
	sr  *tracetest.SpanRecorder
	rd  *sdkmetric.ManualReader
	cfg edge.Config
}

func newRig(sampler sdktrace.Sampler) *rig {
	g := &rig{buf: &lockedBuf{}, sr: tracetest.NewSpanRecorder(), rd: sdkmetric.NewManualReader()}
	opts := []sdktrace.TracerProviderOption{sdktrace.WithSpanProcessor(g.sr)}
	if sampler != nil {
		opts = append(opts, sdktrace.WithSampler(sampler))
	}
	g.cfg = edge.Config{
		Logger: slog.NewJSONHandler(g.buf, nil),
		Tracer: sdktrace.NewTracerProvider(opts...),
		Meter:  sdkmetric.NewMeterProvider(sdkmetric.WithReader(g.rd)),
	}
	return g
}

func (g *rig) build(t *testing.T, mux *http.ServeMux) (*edge.Edge, http.Handler) {
	t.Helper()
	e, err := edge.New(g.cfg)
	if err != nil {
		t.Fatal(err)
	}
	h, err := e.Handler(mux)
	if err != nil {
		t.Fatal(err)
	}
	return e, h
}

func (g *rig) metrics(t *testing.T) (metricdata.ResourceMetrics, map[string]uint64) {
	t.Helper()
	var rm metricdata.ResourceMetrics
	if err := g.rd.Collect(context.Background(), &rm); err != nil {
		t.Fatal(err)
	}
	byRoute := map[string]uint64{}
	for _, sm := range rm.ScopeMetrics {
		for _, m := range sm.Metrics {
			if h, ok := m.Data.(metricdata.Histogram[float64]); ok {
				for _, dp := range h.DataPoints {
					v, _ := dp.Attributes.Value("http.route")
					byRoute[v.AsString()] += dp.Count
				}
			}
		}
	}
	return rm, byRoute
}

func do(h http.Handler, method, path string, hdr map[string]string) *httptest.ResponseRecorder {
	r := httptest.NewRequest(method, path, nil)
	for k, v := range hdr {
		r.Header.Set(k, v)
	}
	w := httptest.NewRecorder()
	h.ServeHTTP(w, r)
	return w
}

const (
	upSampled = "4bf92f3577b34da6ffffffffffffffff"
	upParent  = "00f067aa0ba902b7"
)

func okMux() *http.ServeMux {
	mux := http.NewServeMux()
	mux.Handle("GET /export", edge.E(func(w http.ResponseWriter, r *http.Request) error {
		io.WriteString(w, "id,name\n")
		return nil
	}))
	return mux
}

// K1: 必須の 3 つが無ければ、1 回の New でまとめて error（大域や何もしないものに黙って落ちない）。
func TestK1_RequiredFieldsFailFast(t *testing.T) {
	_, err := edge.New(edge.Config{})
	if err == nil {
		t.Fatal("ゼロ値の Config で New が通った")
	}
	for _, f := range []string{"Logger", "Tracer", "Meter"} {
		if !strings.Contains(err.Error(), "Config."+f) {
			t.Errorf("error に %s が無い: %v", f, err)
		}
	}
}

// K2: 止めたいなら noop を明示すれば通る（「黙って止まる」と「明示して止める」を分ける）。
func TestK2_ExplicitNoopAccepted(t *testing.T) {
	buf := &lockedBuf{}
	e, err := edge.New(edge.Config{Logger: slog.NewJSONHandler(buf, nil),
		Tracer: tracenoop.NewTracerProvider(), Meter: metricnoop.NewMeterProvider()})
	if err != nil {
		t.Fatal(err)
	}
	h, _ := e.Handler(okMux())
	if w := do(h, "GET", "/export", nil); w.Code != 200 || len(buf.lines(t)) != 1 {
		t.Fatalf("code=%d lines=%d", w.Code, len(buf.lines(t)))
	}
}

// K3: 親を見ない sampler は起動時に断る。自己点検の span はエクスポーターに出ない。
func TestK3_SamplerSelfCheck(t *testing.T) {
	cases := []struct {
		name string
		s    sdktrace.Sampler
		ok   bool
	}{
		{"SDK 既定", nil, true},
		{"ParentBased(Ratio 0.1)", sdktrace.ParentBased(sdktrace.TraceIDRatioBased(0.1)), true},
		{"ParentBased(Never)", sdktrace.ParentBased(sdktrace.NeverSample()), true},
		{"Ratio 0.1 裸", sdktrace.TraceIDRatioBased(0.1), false},
		{"Ratio 0.5 裸", sdktrace.TraceIDRatioBased(0.5), false},
		{"Always 裸", sdktrace.AlwaysSample(), false},
		{"Never 裸", sdktrace.NeverSample(), false},
		// 上流が記録したものをさらに間引く正当な設定も断る（設計上の割り切り。「迷った他案」参照）
		{"ParentBased＋RemoteSampled を比率に", sdktrace.ParentBased(sdktrace.AlwaysSample(), sdktrace.WithRemoteParentSampled(sdktrace.TraceIDRatioBased(0.5))), false},
	}
	for _, c := range cases {
		g := newRig(c.s)
		_, err := edge.New(g.cfg)
		if (err == nil) != c.ok {
			t.Errorf("%s: err=%v; want ok=%v", c.name, err, c.ok)
		}
		if err != nil && !strings.Contains(err.Error(), "ParentBased") {
			t.Errorf("%s: 直し方が書かれていない: %v", c.name, err)
		}
		if n := len(g.sr.Ended()); n != 0 {
			t.Errorf("%s: 自己点検の span が %d 本エクスポートされた", c.name, n)
		}
	}
}

// K4: 社内の入口（TrustUpstream=true）は上流の trace と X-Request-Id を引き継ぐ。baggage は入れない。
func TestK4_InternalContinuesUpstream(t *testing.T) {
	g := newRig(nil)
	g.cfg.TrustUpstream = true
	n := -1
	mux := http.NewServeMux()
	mux.Handle("GET /export", edge.E(func(w http.ResponseWriter, r *http.Request) error {
		n = baggage.FromContext(r.Context()).Len()
		return nil
	}))
	_, h := g.build(t, mux)
	w := do(h, "GET", "/export", map[string]string{
		"traceparent": "00-" + upSampled + "-" + upParent + "-01", "baggage": "role=admin", "X-Request-Id": "bff-123"})
	s := g.sr.Ended()
	if len(s) != 1 || s[0].SpanContext().TraceID().String() != upSampled || s[0].Parent().SpanID().String() != upParent {
		t.Fatalf("spans=%d; want 上流の続き", len(s))
	}
	if n != 0 || w.Header().Get("X-Request-Id") != "bff-123" {
		t.Fatalf("baggage=%d request_id=%q", n, w.Header().Get("X-Request-Id"))
	}
}

// K5: 既定（TrustUpstream=false）は、外から来た traceparent を親にせず link にし、X-Request-Id も作り直す。
func TestK5_DefaultDistrustsHeaders(t *testing.T) {
	g := newRig(nil)
	_, h := g.build(t, okMux())
	w := do(h, "GET", "/export", map[string]string{
		"traceparent": "00-" + upSampled + "-" + upParent + "-01", "X-Request-Id": "attacker-chosen"})
	s := g.sr.Ended()
	if len(s) != 1 || s[0].Parent().IsValid() || s[0].SpanContext().TraceID().String() == upSampled {
		t.Fatalf("既定で外の trace を親にした")
	}
	if len(s[0].Links()) != 1 || s[0].Links()[0].SpanContext.TraceID().String() != upSampled {
		t.Fatalf("links=%v; want 外の trace への link 1 本", s[0].Links())
	}
	if id := w.Header().Get("X-Request-Id"); id == "attacker-chosen" || len(id) != 16 {
		t.Fatalf("request_id=%q; want 作り直した 16 桁", id)
	}
}

// K6: http.route は mux が選んだパターン。生パスを 100 種類送っても系列は 1 つ。どこにも当たらない要求は unmatched。
func TestK6_RouteIsMuxPattern(t *testing.T) {
	g := newRig(nil)
	mux := http.NewServeMux()
	mux.Handle("GET /users/{id}", edge.E(func(w http.ResponseWriter, r *http.Request) error { return nil }))
	_, h := g.build(t, mux)
	for i := 0; i < 100; i++ {
		do(h, "GET", "/users/"+strconv.Itoa(i), nil)
	}
	do(h, "GET", "/nope", nil)
	_, byRoute := g.metrics(t)
	if len(byRoute) != 2 || byRoute["GET /users/{id}"] != 100 || byRoute["unmatched"] != 1 {
		t.Fatalf("routes=%v", byRoute)
	}
}

// K7: 探針は mux のパターンで判定する。span もメトリクスも作らず、失敗だけログに残す。
func TestK7_ProbesByPattern(t *testing.T) {
	g := newRig(nil)
	g.cfg.Probes = []string{"/livez"}
	mux := okMux()
	mux.Handle("GET /healthz", edge.E(func(w http.ResponseWriter, r *http.Request) error { return nil }))
	mux.Handle("GET /readyz", edge.E(func(w http.ResponseWriter, r *http.Request) error {
		return &edge.StatusError{Code: 503, Msg: "not ready", Err: errors.New("warming up")}
	}))
	mux.Handle("/livez", edge.E(func(w http.ResponseWriter, r *http.Request) error { return nil })) // メソッドなしの登録
	_, h := g.build(t, mux)
	for _, p := range []string{"/healthz", "/readyz", "/livez"} {
		for i := 0; i < 10; i++ {
			do(h, "GET", p, nil)
		}
	}
	for i := 0; i < 9; i++ {
		do(h, "GET", "/export", nil)
	}
	do(h, "POST", "/export", nil) // 405（パターン無し＝unmatched。利用者の要求として数える）
	rm, byRoute := g.metrics(t)
	lines := g.buf.lines(t)
	if len(byRoute) != 2 || byRoute["GET /export"] != 9 || byRoute["unmatched"] != 1 {
		t.Errorf("routes=%v; want GET /export 9・unmatched 1", byRoute)
	}
	if n := len(g.sr.Ended()); n != 10 {
		t.Errorf("span %d 本; want 10", n)
	}
	if len(lines) != 20 { // export 10＋readyz の失敗 10
		t.Errorf("ログ %d 行; want 20", len(lines))
	}
	if got := edge.SLI(rm); got != 1 {
		t.Errorf("SLI=%v; want 1（405 はクライアントの誤り）", got)
	}
}

// K8: 明示した探針が mux に無い・広いパターンに落ちる・書式が違う、はすべて起動時に error。
// 既定の探針（/healthz・/readyz）は、登録されていなければ黙って使わない（"/" に落ちても探針にしない）。
func TestK8_ProbeMistakesAtStartup(t *testing.T) {
	g := newRig(nil)
	g.cfg.Probes = []string{"GET /livez"}
	if _, err := edge.New(g.cfg); err == nil {
		t.Error("メソッド付きの探針が通った")
	}
	g.cfg.Probes = []string{"/livez"}
	e, _ := edge.New(g.cfg)
	if _, err := e.Handler(okMux()); err == nil || !strings.Contains(err.Error(), "/livez") {
		t.Errorf("未登録の探針: err=%v", err)
	}
	catchAll := http.NewServeMux()
	catchAll.Handle("/", edge.E(func(w http.ResponseWriter, r *http.Request) error { return nil }))
	if _, err := e.Handler(catchAll); err == nil {
		t.Error("\"/\" に落ちる探針が通った")
	}
	g2 := newRig(nil)
	_, h := g2.build(t, catchAll)
	do(h, "GET", "/healthz", nil) // "/" が受ける。利用者の要求として数える
	if _, byRoute := g2.metrics(t); byRoute["/"] != 1 {
		t.Errorf("routes=%v; want \"/\" に 1（既定の探針が \"/\" を飲み込まない）", byRoute)
	}
}

// K9: e.Logger() は WithGroup の後でも鍵が最上位。
func TestK9_LoggerKeysTopLevel(t *testing.T) {
	g := newRig(nil)
	mux := http.NewServeMux()
	var e *edge.Edge
	mux.Handle("GET /export", edge.E(func(w http.ResponseWriter, r *http.Request) error {
		e.Logger().WithGroup("job").InfoContext(r.Context(), "rows", "n", 2)
		return nil
	}))
	e, h := g.build(t, mux)
	do(h, "GET", "/export", nil)
	lines := g.buf.lines(t)
	if len(lines) != 2 || lines[0]["trace_id"] == nil || lines[0]["trace_id"] != lines[1]["trace_id"] ||
		lines[0]["request_id"] != lines[1]["request_id"] {
		t.Fatalf("lines=%v", lines)
	}
	if job, _ := lines[0]["job"].(map[string]any); job["trace_id"] != nil || job["n"] != float64(2) {
		t.Fatalf("job=%v", job)
	}
}

// K10: Detach は値を残し cancel を外し、期限を必ず掛ける（実サーバー）。0 以下は panic。
func TestK10_Detach(t *testing.T) {
	for _, c := range []struct {
		delay, timeout time.Duration
		want           string
	}{{30 * time.Millisecond, time.Second, "audit"}, {500 * time.Millisecond, 20 * time.Millisecond, "audit failed"}} {
		g := newRig(nil)
		var wg sync.WaitGroup
		var e *edge.Edge
		mux := http.NewServeMux()
		mux.Handle("GET /export", edge.E(func(w http.ResponseWriter, r *http.Request) error {
			ctx, cancel := edge.Detach(r.Context(), c.timeout)
			wg.Add(1)
			go func() {
				defer wg.Done()
				defer cancel()
				select {
				case <-time.After(c.delay):
					e.Logger().InfoContext(ctx, "audit")
				case <-ctx.Done():
					e.Logger().ErrorContext(ctx, "audit failed", "err", ctx.Err().Error())
				}
			}()
			io.WriteString(w, "ok")
			return nil
		}))
		e, h := g.build(t, mux)
		srv := httptest.NewServer(h)
		resp, err := http.Get(srv.URL + "/export")
		if err != nil {
			t.Fatal(err)
		}
		io.ReadAll(resp.Body)
		resp.Body.Close()
		start := time.Now()
		wg.Wait()
		srv.Close()
		var edgeL, audit map[string]any
		for _, l := range g.buf.lines(t) {
			if l["msg"] == "request" {
				edgeL = l
			} else {
				audit = l
			}
		}
		if audit == nil || audit["msg"] != c.want || audit["request_id"] != edgeL["request_id"] || audit["trace_id"] != edgeL["trace_id"] {
			t.Errorf("audit=%v edge=%v; want %s", audit, edgeL, c.want)
		}
		if c.want == "audit failed" && (!strings.Contains(audit["err"].(string), "deadline") || time.Since(start) > 300*time.Millisecond) {
			t.Errorf("期限で諦めていない: %v（待ち %v）", audit["err"], time.Since(start))
		}
	}
	defer func() {
		if recover() == nil {
			t.Error("Detach(ctx, 0) が panic しなかった")
		}
	}()
	edge.Detach(context.Background(), 0)
}

// K11: Recover は外せない。panic は 500・ログ 1 行（user・panic・stack 付き）。user は SetUser で利用者の認証から入る。
func TestK11_PanicOneLineWithUser(t *testing.T) {
	g := newRig(nil)
	auth := func(next http.Handler) http.Handler {
		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			edge.SetUser(r.Context(), r.Header.Get("X-User"))
			next.ServeHTTP(w, r)
		})
	}
	mux := http.NewServeMux()
	mux.Handle("GET /export", auth(edge.E(func(w http.ResponseWriter, r *http.Request) error {
		var m map[string]int
		m["x"] = 1
		return nil
	})))
	_, h := g.build(t, mux)
	w := do(h, "GET", "/export", map[string]string{"X-User": "alice"})
	lines := g.buf.lines(t)
	if w.Code != 500 || len(lines) != 1 || lines[0]["user"] != "alice" || lines[0]["panic"] == nil ||
		!strings.Contains(lines[0]["stack"].(string), "edge_test.go") || strings.Contains(w.Body.String(), "nil map") {
		t.Fatalf("code=%d body=%q lines=%v", w.Code, w.Body.String(), lines)
	}
}

// K12: New の後で呼び出し側が Probes のスライスを書き換えても、Edge は変わらない。
func TestK12_ConfigCopied(t *testing.T) {
	g := newRig(nil)
	probes := []string{"/livez"}
	g.cfg.Probes = probes
	e, err := edge.New(g.cfg)
	if err != nil {
		t.Fatal(err)
	}
	probes[0] = "/nope"
	mux := okMux()
	mux.Handle("GET /livez", edge.E(func(w http.ResponseWriter, r *http.Request) error { return nil }))
	if _, err := e.Handler(mux); err != nil {
		t.Fatalf("書き換えが Edge に届いた: %v", err)
	}
}

// K13: SLI は Day 073 の D8 と同じ配分で 0.9（探針 120 件は入らない）。
func TestK13_SLI(t *testing.T) {
	g := newRig(nil)
	mux := http.NewServeMux()
	mux.Handle("GET /healthz", edge.E(func(w http.ResponseWriter, r *http.Request) error { return nil }))
	mux.Handle("GET /readyz", edge.E(func(w http.ResponseWriter, r *http.Request) error {
		return &edge.StatusError{Code: 503, Msg: "not ready"}
	}))
	mux.Handle("GET /export", edge.E(func(w http.ResponseWriter, r *http.Request) error {
		if r.Header.Get("X-Fail") != "" {
			return errors.New("pq: connection refused")
		}
		return nil
	}))
	_, h := g.build(t, mux)
	for i := 0; i < 100; i++ {
		do(h, "GET", "/healthz", nil)
	}
	for i := 0; i < 20; i++ {
		do(h, "GET", "/readyz", nil)
	}
	for i := 0; i < 9; i++ {
		do(h, "GET", "/export", nil)
	}
	do(h, "GET", "/export", map[string]string{"X-Fail": "1"})
	if rm, _ := g.metrics(t); edge.SLI(rm) != 0.9 {
		t.Fatalf("SLI=%v", edge.SLI(rm))
	}
}

// K14: 外の利用者が flags=01 を付けて送ると、引き継ぐ設定では比率を無視して全件が記録される（記録量の水増し）。
// 既定（信じない）なら、自分の比率に戻る。乱数の種を固定して 2,000 件。
func TestK14_ForcedSamplingNeedsTrust(t *testing.T) {
	got := map[bool]int{}
	for _, trust := range []bool{false, true} {
		g := newRig(sdktrace.ParentBased(sdktrace.TraceIDRatioBased(0.1)))
		g.cfg.TrustUpstream = trust
		_, h := g.build(t, okMux())
		rng := rand.New(rand.NewPCG(1, 2))
		for i := 0; i < 2000; i++ {
			tp := fmt.Sprintf("00-%016x%016x-%s-01", rng.Uint64(), rng.Uint64(), upParent)
			do(h, "GET", "/export", map[string]string{"traceparent": tp})
		}
		got[trust] = len(g.sr.Ended())
	}
	t.Logf("flags=01 を 2,000 件: 信じない %d 件記録・信じる %d 件記録", got[false], got[true])
	if got[true] != 2000 || got[false] > 300 {
		t.Fatalf("got=%v", got)
	}
}