Day 072 — 2026-10-12 | ミドルウェア設計パターン: Edge を本物の OpenTelemetry につなぐ——otelhttp はトレースだけにし、メトリクスは Edge が semconv どおり 1 点だけ書き、ログの 1 行に trace_id・request_id を自動で載せる

📋 コピーpackage main

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

// Outcome は 1 リクエストの「事実」を集める袋（Day 071 と同じ。RequestID だけ足した）。
// 中の部品は書き込むだけで、出力は Edge の defer が 1 回だけ行う。
type Outcome struct {
	RequestID string
	User      string
	Err       error
	ErrStatus int
	Panic     any
	Stack     []byte
}

type outcomeKey struct{}

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

func outcomeOf(r *http.Request) *Outcome { return outcomeFrom(r.Context()) }

// ErrInto は Adapt に渡す LogFunc。記録せずに袋に書く（先勝ち）。
func ErrInto(r *http.Request, status int, err error) {
	if o := outcomeOf(r); o != nil && o.Err == nil {
		o.Err, o.ErrStatus = err, status
	}
}

// PanicInto は Recover に渡す。panic の場所はこの時点のスタックにしか無い。
func PanicInto(r *http.Request, p any) {
	if o := outcomeOf(r); o != nil && o.Panic == nil {
		o.Panic, o.Stack = p, debug.Stack()
	}
}

// Identify は認証の代役。誰のリクエストかを袋に書く。
func Identify(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if o := outcomeOf(r); o != nil {
			o.User = r.Header.Get("X-User")
		}
		next.ServeHTTP(w, r)
	})
}

// class はログの 1 行にだけ出す分類（Day 071 と同じ 5 値）。メトリクスには出さない（今日の決定）。
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 main

import (
	"bytes"
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"log"
	"log/slog"
	"net/http"
	"net/http/httptest"
	"sort"
	"strings"
	"sync"
	"testing"

	"go.opentelemetry.io/otel/codes"
	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"
)

// ---- 出口の受け皿 ----

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 {
	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
}

// rig は本物の OTel SDK（span は SpanRecorder、メトリクスは ManualReader）につないだ Stack。
type rig struct {
	buf *lockedBuf
	sr  *tracetest.SpanRecorder
	rd  *sdkmetric.ManualReader
	tp  *sdktrace.TracerProvider
	mp  *sdkmetric.MeterProvider
	log *slog.Logger
}

func newRig() *rig {
	g := &rig{buf: &lockedBuf{}, sr: tracetest.NewSpanRecorder(), rd: sdkmetric.NewManualReader()}
	g.tp = sdktrace.NewTracerProvider(sdktrace.WithSpanProcessor(g.sr))
	g.mp = sdkmetric.NewMeterProvider(sdkmetric.WithReader(g.rd))
	g.log = slog.New(NewLogHandler(slog.NewJSONHandler(g.buf, nil)))
	return g
}

func (g *rig) stack(h HandlerE) http.Handler { return Stack(h, g.log, g.tp, g.mp, route) }

type point struct {
	name  string
	attrs map[string]string
	count uint64
	exTID []string // exemplar の trace_id
}

func (g *rig) points(t *testing.T) []point {
	t.Helper()
	var rm metricdata.ResourceMetrics
	if err := g.rd.Collect(context.Background(), &rm); err != nil {
		t.Fatal(err)
	}
	var out []point
	for _, sm := range rm.ScopeMetrics {
		for _, m := range sm.Metrics {
			h, ok := m.Data.(metricdata.Histogram[float64])
			if !ok {
				out = append(out, point{name: m.Name + "(非ヒストグラム)"})
				continue
			}
			for _, dp := range h.DataPoints {
				p := point{name: m.Name, attrs: map[string]string{}, count: dp.Count}
				for _, kv := range dp.Attributes.ToSlice() {
					p.attrs[string(kv.Key)] = kv.Value.Emit()
				}
				for _, ex := range dp.Exemplars {
					p.exTID = append(p.exTID, fmt.Sprintf("%x", ex.TraceID))
				}
				out = append(out, p)
			}
		}
	}
	return out
}

func spanAttr(s sdktrace.ReadOnlySpan, key string) (string, bool) {
	for _, kv := range s.Attributes() {
		if string(kv.Key) == key {
			return kv.Value.Emit(), true
		}
	}
	return "", false
}

func route(*http.Request) string { return "GET /export" }

// ---- 8 つの場面（Day 071 と同じハンドラ） ----

func explodeBeforeCommit(w http.ResponseWriter, r *http.Request) error {
	var m map[string]int
	m["x"]++
	return nil
}

func explodeAfterCommit(w http.ResponseWriter, r *http.Request) error {
	io.WriteString(w, "id,name\n1,alice\n")
	http.NewResponseController(w).Flush()
	var m map[string]int
	m["x"]++
	return nil
}

func streamThenFail(w http.ResponseWriter, r *http.Request) error {
	io.WriteString(w, "id,name\n1,alice\n")
	http.NewResponseController(w).Flush()
	return errors.New("rows.Next: driver: bad connection")
}

func okHandler(w http.ResponseWriter, r *http.Request) error { io.WriteString(w, "ok"); return nil }

type scenario struct {
	name       string
	h          HandlerE
	clientGone bool
	status     int    // ログ・メトリクス・span の status（0 = 送っていない）
	errType    string // メトリクスと span の error.type（"" = 付けない）
	spanErr    bool   // span の状態が Error か
	class      string
	level      string
	errSub     string
	panicFn    string
}

var scenarios = []scenario{
	{"S1 成功", okHandler, false, 200, "", false, ClassOK, "INFO", "", ""},
	{"S2 404", func(w http.ResponseWriter, r *http.Request) error { return fmt.Errorf("repo.Get(42): %w", ErrNotFound) },
		false, 404, "", false, ClassClientError, "INFO", "repo.Get(42)", ""},
	{"S3 送信前の error", func(w http.ResponseWriter, r *http.Request) error { return errors.New("pq: connection refused") },
		false, 500, "500", true, ClassServerError, "ERROR", "connection refused", ""},
	{"S4 送信前の panic", explodeBeforeCommit, false, 500, "500", true, ClassServerError, "ERROR", "", "explodeBeforeCommit"},
	{"S5 送信後の error", streamThenFail, false, 200, "aborted", true, ClassAborted, "ERROR", "bad connection", ""},
	{"S6 送信後の panic", explodeAfterCommit, false, 200, "aborted", true, ClassAborted, "ERROR", "", "explodeAfterCommit"},
	{"S7 相手が先に切った", func(w http.ResponseWriter, r *http.Request) error { return fmt.Errorf("query: %w", r.Context().Err()) },
		true, 499, "", false, ClassClientClosed, "INFO", "context canceled", ""},
	{"S8 期限切れ", func(w http.ResponseWriter, r *http.Request) error {
		return fmt.Errorf("query: %w", context.DeadlineExceeded)
	},
		false, 503, "503", true, ClassServerError, "ERROR", "deadline exceeded", ""},
}

type result struct {
	g       *rig
	code    int
	readErr error
	ridHdr  string
	lines   []map[string]any
	spans   []sdktrace.ReadOnlySpan
	points  []point
}

func run(t *testing.T, sc scenario, hdr map[string]string) result {
	t.Helper()
	g := newRig()
	h := g.stack(sc.h)
	res := result{g: g}
	if sc.clientGone {
		ctx, cancel := context.WithCancel(context.Background())
		cancel()
		r := httptest.NewRequest("GET", "/export", nil).WithContext(ctx)
		r.Header.Set("X-User", "alice")
		for k, v := range hdr {
			r.Header.Set(k, v)
		}
		rec := httptest.NewRecorder()
		h.ServeHTTP(rec, r)
		res.ridHdr = rec.Header().Get("X-Request-Id")
	} else {
		srv := httptest.NewServer(h)
		req, _ := http.NewRequest("GET", srv.URL+"/export", nil)
		req.Header.Set("X-User", "alice")
		for k, v := range hdr {
			req.Header.Set(k, v)
		}
		resp, err := http.DefaultClient.Do(req)
		if err != nil {
			res.readErr = err
		} else {
			_, err = io.ReadAll(resp.Body)
			resp.Body.Close()
			res.code, res.readErr, res.ridHdr = resp.StatusCode, err, resp.Header.Get("X-Request-Id")
		}
		srv.Close()
	}
	res.lines, res.spans, res.points = g.buf.lines(t), g.sr.Ended(), g.points(t)
	return res
}

// O1: メトリクスは Edge の 1 点だけ（otelhttp は書かない）。名前と属性は OTel HTTP semconv のとおり。
func TestO1_OneSemconvPoint(t *testing.T) {
	for _, sc := range scenarios {
		r := run(t, sc, nil)
		want := map[string]string{"http.request.method": "GET", "url.scheme": "http", "http.route": "GET /export"}
		if sc.status != 0 {
			want["http.response.status_code"] = fmt.Sprint(sc.status)
		}
		if sc.errType != "" {
			want["error.type"] = sc.errType
		}
		if len(r.points) != 1 || r.points[0].name != "http.server.request.duration" || r.points[0].count != 1 ||
			fmt.Sprint(r.points[0].attrs) != fmt.Sprint(want) {
			t.Errorf("%s: points=%+v; want 1 点 %v", sc.name, r.points, want)
		}
	}
}

// O2: span は 1 本。状態・status_code・error.type が全場面で埋まる（otelhttp だけでは S5・S6 が Unset・status なし、S7 が 200）。
func TestO2_SpanFilledEverywhere(t *testing.T) {
	for _, sc := range scenarios {
		r := run(t, sc, nil)
		if len(r.spans) != 1 {
			t.Errorf("%s: span %d 本", sc.name, len(r.spans))
			continue
		}
		s := r.spans[0]
		if (s.Status().Code == codes.Error) != sc.spanErr {
			t.Errorf("%s: span status=%v; want Error=%v", sc.name, s.Status(), sc.spanErr)
		}
		if got, _ := spanAttr(s, "http.response.status_code"); got != fmt.Sprint(sc.status) {
			t.Errorf("%s: span status_code=%q; want %d", sc.name, got, sc.status)
		}
		if got, _ := spanAttr(s, "error.type"); got != sc.errType {
			t.Errorf("%s: span error.type=%q; want %q", sc.name, got, sc.errType)
		}
		if s.Name() != "GET /export" {
			t.Errorf("%s: span name=%q", sc.name, s.Name())
		}
	}
}

// O3: ログは 1 行。Day 071 の中身に加え、trace_id・span_id が span と一致し、request_id が応答ヘッダと一致する。
func TestO3_LogJoinsTrace(t *testing.T) {
	for _, sc := range scenarios {
		r := run(t, sc, nil)
		if len(r.lines) != 1 || len(r.spans) != 1 {
			t.Errorf("%s: lines=%d spans=%d", sc.name, len(r.lines), len(r.spans))
			continue
		}
		l, sp := r.lines[0], r.spans[0].SpanContext()
		if l["level"] != sc.level || l["class"] != sc.class || l["status"] != float64(sc.status) || l["user"] != "alice" {
			t.Errorf("%s: level=%v class=%v status=%v user=%v", sc.name, l["level"], l["class"], l["status"], l["user"])
		}
		if l["trace_id"] != sp.TraceID().String() || l["span_id"] != sp.SpanID().String() {
			t.Errorf("%s: log trace=%v span=%v; span は %s %s", sc.name, l["trace_id"], l["span_id"], sp.TraceID(), sp.SpanID())
		}
		if rid, _ := l["request_id"].(string); rid == "" || rid != r.ridHdr {
			t.Errorf("%s: request_id=%q 応答ヘッダ=%q", sc.name, rid, r.ridHdr)
		}
		e, hasErr := l["err"].(string)
		if (sc.errSub != "") != hasErr || !strings.Contains(e, sc.errSub) {
			t.Errorf("%s: err=%q; want 含む %q", sc.name, e, sc.errSub)
		}
		st, hasStack := l["stack"].(string)
		if (sc.panicFn != "") != hasStack || !strings.Contains(st, sc.panicFn) {
			t.Errorf("%s: stack に %q が無い", sc.name, sc.panicFn)
		}
	}
}

// O4: 来た X-Request-Id は、短く安全な文字だけなら引き継ぐ。改行入り・65 文字は作り直す。
func TestO4_RequestIDInput(t *testing.T) {
	cases := []struct {
		in   string
		keep bool
	}{
		{"abc-123_X.y", true},
		{strings.Repeat("a", 64), true},
		{strings.Repeat("a", 65), false},
		{"x\" level=ERROR", false},
		{"", false},
	}
	for _, c := range cases {
		r := run(t, scenarios[0], map[string]string{"X-Request-Id": c.in})
		if len(r.lines) != 1 {
			t.Fatalf("in=%q: ログ %d 行", c.in, len(r.lines))
		}
		rid, _ := r.lines[0]["request_id"].(string)
		if c.keep && rid != c.in || !c.keep && (rid == c.in || len(rid) != 16) || rid != r.ridHdr {
			t.Errorf("in=%q: request_id=%q 応答ヘッダ=%q keep=%v", c.in, rid, r.ridHdr, c.keep)
		}
	}
}

// O5: 失敗の点には exemplar が付き、その trace_id が span と同じ（メトリクスからトレースへ飛べる）。
func TestO5_ExemplarLinksTrace(t *testing.T) {
	for _, sc := range []scenario{scenarios[2], scenarios[4], scenarios[5]} { // S3・S5・S6
		r := run(t, sc, nil)
		if len(r.points) != 1 || len(r.spans) != 1 {
			t.Fatalf("%s: points=%d spans=%d", sc.name, len(r.points), len(r.spans))
		}
		tid := r.spans[0].SpanContext().TraceID().String()
		if len(r.points[0].exTID) != 1 || r.points[0].exTID[0] != tid {
			t.Errorf("%s: exemplar=%v; want [%s]", sc.name, r.points[0].exTID, tid)
		}
	}
}

// serve は実サーバーを通さずに呼ぶ。送信後の切断は panic(http.ErrAbortHandler) で出てくるので受け止める。
func serve(h http.Handler, r *http.Request) {
	defer func() {
		if p := recover(); p != nil && p != http.ErrAbortHandler {
			panic(p)
		}
	}()
	h.ServeHTTP(httptest.NewRecorder(), r)
}

// O6: SLI はメトリクスだけから出る。499 は分母から外し、aborted と 5xx は失敗、4xx は成功。
func TestO6_SLIFromMetrics(t *testing.T) {
	g := newRig()
	mix := []struct {
		sc scenario
		n  int
	}{{scenarios[0], 900}, {scenarios[1], 40}, {scenarios[6], 30}, {scenarios[4], 20}, {scenarios[2], 10}}
	for _, m := range mix {
		h := g.stack(m.sc.h)
		for i := 0; i < m.n; i++ {
			r := httptest.NewRequest("GET", "/export", nil)
			if m.sc.clientGone {
				ctx, cancel := context.WithCancel(context.Background())
				cancel()
				r = r.WithContext(ctx)
			}
			serve(h, r)
		}
	}
	var rm metricdata.ResourceMetrics
	g.rd.Collect(context.Background(), &rm)
	if got, want := SLIFrom(rm), 940.0/970.0; got != want {
		t.Fatalf("SLI=%v; want %v", got, want)
	}
	if SLIFrom(metricdata.ResourceMetrics{}) != 1 {
		t.Fatal("点が無ければ 1")
	}
}

// O7: 200 本同時。ログの trace_id は 200 種類で、span の集合と一致し、user と err が混ざらない（-race で）。
func TestO7_Concurrent(t *testing.T) {
	g := newRig()
	h := g.stack(func(w http.ResponseWriter, r *http.Request) error {
		if u := r.Header.Get("X-User"); u[len(u)-1]%2 == 0 {
			return fmt.Errorf("fail for %s", u)
		}
		io.WriteString(w, "ok")
		return nil
	})
	var wg sync.WaitGroup
	for i := 0; i < 200; i++ {
		wg.Add(1)
		go func(i int) {
			defer wg.Done()
			r := httptest.NewRequest("GET", "/export", nil)
			r.Header.Set("X-User", fmt.Sprintf("u%03d", i))
			h.ServeHTTP(httptest.NewRecorder(), r)
		}(i)
	}
	wg.Wait()
	lines, spans := g.buf.lines(t), g.sr.Ended()
	var fromLog, fromSpan []string
	for _, l := range lines {
		u, _ := l["user"].(string)
		e, hasErr := l["err"].(string)
		if hasErr != (u[len(u)-1]%2 == 0) || (hasErr && e != "fail for "+u) {
			t.Fatalf("混ざった: user=%s err=%q", u, e)
		}
		fromLog = append(fromLog, fmt.Sprint(l["trace_id"]))
	}
	for _, s := range spans {
		fromSpan = append(fromSpan, s.SpanContext().TraceID().String())
	}
	sort.Strings(fromLog)
	sort.Strings(fromSpan)
	uniq := map[string]bool{}
	for _, s := range fromLog {
		uniq[s] = true
	}
	if len(lines) != 200 || len(uniq) != 200 || strings.Join(fromLog, ",") != strings.Join(fromSpan, ",") {
		t.Fatalf("lines=%d 種類=%d spans=%d 一致=%v", len(lines), len(uniq), len(spans), strings.Join(fromLog, ",") == strings.Join(fromSpan, ","))
	}
}

// O8: Recover を付け忘れて S4。何も送らずに切ったので status は 0（メトリクスに status_code なし）、error.type=aborted。
func TestO8_NoRecoverNothingSent(t *testing.T) {
	g := newRig()
	h := Traced(Edge(g.log, g.mp, route)(Identify(Adapt(explodeBeforeCommit, ErrInto))), g.tp, route) // Recover なし
	srv := httptest.NewUnstartedServer(h)
	srv.Config.ErrorLog = log.New(io.Discard, "", 0)
	srv.Start()
	_, err := http.Get(srv.URL)
	srv.Close()
	pts, lines, spans := g.points(t), g.buf.lines(t), g.sr.Ended()
	want := map[string]string{"http.request.method": "GET", "url.scheme": "http", "http.route": "GET /export", "error.type": "aborted"}
	if err == nil || len(pts) != 1 || fmt.Sprint(pts[0].attrs) != fmt.Sprint(want) {
		t.Fatalf("err=%v points=%+v", err, pts)
	}
	if len(lines) != 1 || lines[0]["status"] != float64(0) || !strings.Contains(fmt.Sprint(lines[0]["stack"]), "explodeBeforeCommit") {
		t.Fatalf("lines=%v", lines)
	}
	if len(spans) != 1 {
		t.Fatalf("span %d 本", len(spans))
	}
	if _, has := spanAttr(spans[0], "http.response.status_code"); has || spans[0].Status().Code != codes.Error {
		t.Fatalf("span status=%v status_code あり=%v", spans[0].Status(), has)
	}
}

// O9: クライアントに届くもの（Day 071 の R5 と同じ約束）。送信後の失敗は完全な 200 にしない。
func TestO9_ClientView(t *testing.T) {
	for _, sc := range scenarios[2:6] { // S3〜S6
		r := run(t, sc, nil)
		if sc.class == ClassAborted {
			if !errors.Is(r.readErr, io.ErrUnexpectedEOF) {
				t.Errorf("%s: readErr=%v; want unexpected EOF", sc.name, r.readErr)
			}
		} else if r.readErr != nil || r.code != sc.status {
			t.Errorf("%s: %d %v", sc.name, r.code, r.readErr)
		}
	}
}

// O10: 未知のメソッドは _OTHER にまとめる（任意の文字列で系列を増やされない）。
func TestO10_UnknownMethod(t *testing.T) {
	g := newRig()
	h := g.stack(okHandler)
	for _, m := range []string{"PROPFIND", "X-SCAN-1", "X-SCAN-2"} {
		h.ServeHTTP(httptest.NewRecorder(), httptest.NewRequest(m, "/export", nil))
	}
	pts := g.points(t)
	if len(pts) != 1 || pts[0].attrs["http.request.method"] != "_OTHER" || pts[0].count != 3 {
		t.Fatalf("points=%+v; want _OTHER の 1 系列に 3 件", pts)
	}
}

// O11: ハンドラが logger.With(...) で書いた行にも、同じ trace_id・request_id が付く。
func TestO11_HandlerLogWithAttrs(t *testing.T) {
	g := newRig()
	jobLog := g.log.With("job", "export")
	h := g.stack(func(w http.ResponseWriter, r *http.Request) error {
		jobLog.InfoContext(r.Context(), "rows", "n", 2)
		io.WriteString(w, "ok")
		return nil
	})
	h.ServeHTTP(httptest.NewRecorder(), httptest.NewRequest("GET", "/export", nil))
	lines := g.buf.lines(t)
	if len(lines) != 2 || lines[0]["job"] != "export" || 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)
	}
}

3 つの出口は、どれも「Edge の defer の時点で r.Context() に何が入っているか」で決まります。otelhttp は Edge の外にあるので、Edge が受け取る r.Context() にはもう span が入っています。その ctx を、メトリクスの Record・span の操作・slog の 3 つすべてに渡してください。

• メトリクス: httpconv.NewServerRequestDuration(mp.Meter(...)) で semconv どおりの名前・単位・バケットのヒストグラムが作れる。Record(ctx, 秒, method, scheme, attrs...)。status_code は送ったときだけ、error.type は失敗のときだけ付ける
• 二重計上を止める: otelhttp には otelhttp.WithMeterProvider(noop.NewMeterProvider()) を渡す
• S5・S6 の span: otelhttp は panic が通り抜けると 193 行に届かない。だから Edge が trace.SpanFromContext(ctx).SetStatus(codes.Error, …) と status_code を書く。otelhttp が後から上書きすることも無い（届かないので）
• S7 の span: 予想 P1 を確かめる。otelhttp は Edge が戻った後に status_code を書く。SDK の SetAttributes は後勝ち。では otelhttp が読む値（rww.StatusCode()）そのものを 499 にするには？
• ログ: slog.Handler を包み、Handle(ctx, rec) の中で trace.SpanContextFromContext(ctx) と袋から値を取り rec.AddAttrs(...) する。WithAttrs・WithGroup も包み直して返す（O11）
• request_id: 外から来た値は長さと文字種を見る。ダメなら crypto/rand で 8 バイト → 16 桁の 16 進

📋 コピーfunc Edge(log *slog.Logger, mp metric.MeterProvider, routeOf func(*http.Request) string) func(http.Handler) http.Handler {
	dur, _ := httpconv.NewServerRequestDuration(mp.Meter("d72/edge"))
	return func(next http.Handler) http.Handler {
		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			o := &Outcome{RequestID: requestID(r)}
			w.Header().Set("X-Request-Id", o.RequestID)
			ow := &obsWriter{ResponseWriter: w}
			r = r.WithContext(context.WithValue(r.Context(), outcomeKey{}, o))
			defer func() {
				p := recover()
				// status: aborted で 0 → 0 のまま（何も送っていない）
				//         aborted でなく 0 → 200。ctx が切れていれば 499 にして ow.WriteHeader(499)
				// dur.Record(r.Context(), …)                      ← exemplar のため ctx を渡す
				// span := trace.SpanFromContext(r.Context())     ← error.type、aborted なら Error と status_code
				// log.LogAttrs(r.Context(), level, "request", …) ← LogHandler が trace_id を足す
				// p != nil → panic(p)
			}()
			next.ServeHTTP(ow, r)
		})
	}
}