From 9f05e6ac2954e8da02ea3a60a41a7ee92885ba83 Mon Sep 17 00:00:00 2001 From: Konstantin Zaytcev Date: Fri, 23 Oct 2026 14:26:21 +0300 Subject: [PATCH 1/2] fix(nethttp): observe committed responses and accepted writes --- README.md | 24 ++ go.mod | 1 + go.sum | 2 + integrations/nethttp/middleware.go | 125 +------ .../nethttp/response_observation_test.go | 257 ++++++++++++++ integrations/nethttp/response_writer.go | 147 ++++++++ integrations/nethttp/response_writer_test.go | 325 ++++++++++++++++++ 7 files changed, 773 insertions(+), 108 deletions(-) create mode 100644 integrations/nethttp/response_observation_test.go create mode 100644 integrations/nethttp/response_writer.go create mode 100644 integrations/nethttp/response_writer_test.go diff --git a/README.md b/README.md index ebbd7ab..ea2d9a7 100644 --- a/README.md +++ b/README.md @@ -109,6 +109,30 @@ func main() { } ``` +### HTTP response observation + +The middleware records the first final HTTP status. Informational responses can +precede it; status 101 is terminal. Writes and supported flush operations establish +an implicit 200. Streaming and string writes follow the same accounting, and the +wrapper preserves the underlying optional writer interfaces. Put this middleware +outside other response-writer middleware, so controller operations from inner +handlers reach its hooks. An outer writer that exposes controller capabilities +only through `Unwrap` can let `http.ResponseController` bypass observation; that +ordering is unsupported and can produce an incorrect recorded status. An outer +writer is compatible only when it directly delegates those capabilities. Verify +the writer order when adopting the middleware in an existing server stack. + +Handled-failure snippets contain only bytes accepted by the underlying writer. +`responseAcceptedBytes` counts those bytes; buffering and HEAD responses mean this +does not prove delivery to the client. Use `WithHandled5xxMaxBodyBytes(0)` to omit +response snippets while retaining failure status and accepted-byte count. + +A panic after a committed response retains that status and does not append a +fallback body. With `WithRepanic(true)`, an uncommitted panic is rethrown for outer +recovery; its future HTTP status is unknown, so the transaction omits the status +measurement. A hijacked connection without an observed status has the same +unknown-status boundary. An ordinary empty handler defaults to 200 on return. + ## Branded surface - `Duck` is the main runtime facade. diff --git a/go.mod b/go.mod index 80715d9..c2cdc54 100644 --- a/go.mod +++ b/go.mod @@ -3,6 +3,7 @@ module github.com/duckbugio/duckbug-go go 1.25.13 require ( + github.com/felixge/httpsnoop v1.1.0 github.com/rs/zerolog v1.35.1 github.com/santhosh-tekuri/jsonschema/v6 v6.0.3 go.uber.org/zap v1.28.0 diff --git a/go.sum b/go.sum index 0b4849e..4b5012c 100644 --- a/go.sum +++ b/go.sum @@ -4,6 +4,8 @@ github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/dlclark/regexp2 v1.11.0 h1:G/nrcoOa7ZXlpoa/91N3X7mM3r8eIlMBBJZvsz/mxKI= github.com/dlclark/regexp2 v1.11.0/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8= +github.com/felixge/httpsnoop v1.1.0 h1:3YtUj32ZZkqZtt3sZZsClsymw/QDuVfpNhoA31zeORc= +github.com/felixge/httpsnoop v1.1.0/go.mod h1:Zqxgdd+1Rkcz8euOqdr7lqgCRJztwr5hp9vDSi5UZCE= github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI= github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= diff --git a/integrations/nethttp/middleware.go b/integrations/nethttp/middleware.go index c6f381c..8708633 100644 --- a/integrations/nethttp/middleware.go +++ b/integrations/nethttp/middleware.go @@ -1,10 +1,8 @@ package nethttp import ( - "bufio" "bytes" "encoding/json" - "errors" "fmt" "io" "math/rand" @@ -66,32 +64,27 @@ func Middleware(duck *duckbug.Duck, options ...Option) func(http.Handler) http.H ctx := pond.WithRequestContext(r.Context(), reqCtx) r = r.WithContext(ctx) - tracker := &responseWriterTracker{ - ResponseWriter: w, - statusCode: http.StatusOK, - captureResponse: config.CaptureHandled5xx, - maxResponseBytes: config.Handled5xxMaxBodyBytes, - } + tracker := newResponseWriterTracker(w, config) tx := startTransaction(duck, r, config) defer func() { if recovered := recover(); recovered != nil { - tracker.statusCode = http.StatusInternalServerError if duck != nil && config.CapturePanics { duck.QuackRecoveredPanicContext(r.Context(), recovered, "nethttp_middleware") } - captureTransaction(duck, r, tracker.statusCode, tx, true, config) if config.Repanic { + captureTransaction(duck, r, tracker.responseStatus(false), tx, true, config) panic(recovered) } - if !tracker.wroteHeader { - http.Error(tracker, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError) + if !tracker.wroteHeader && !tracker.hijacked { + http.Error(tracker.writer, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError) } + captureTransaction(duck, r, tracker.responseStatus(false), tx, true, config) } }() - next.ServeHTTP(tracker, r) + next.ServeHTTP(tracker.writer, r) captureHandled5xx(duck, r, tracker, config) - captureTransaction(duck, r, tracker.statusCode, tx, false, config) + captureTransaction(duck, r, tracker.responseStatus(true), tx, false, config) }) } } @@ -179,95 +172,6 @@ func IsInternalRequest(r *http.Request) bool { return sdkrequest.IsInternalRequest(r) } -type responseWriterTracker struct { - http.ResponseWriter - statusCode int - wroteHeader bool - captureResponse bool - maxResponseBytes int - responseBody strings.Builder - truncated bool -} - -func (w *responseWriterTracker) WriteHeader(statusCode int) { - w.statusCode = statusCode - w.wroteHeader = true - w.ResponseWriter.WriteHeader(statusCode) -} - -func (w *responseWriterTracker) Write(data []byte) (int, error) { - w.captureBody(data) - if !w.wroteHeader { - w.statusCode = http.StatusOK - } - w.wroteHeader = true - return w.ResponseWriter.Write(data) -} - -func (w *responseWriterTracker) captureBody(data []byte) { - if !w.captureResponse || len(data) == 0 || w.truncated { - return - } - remaining := w.maxResponseBytes - w.responseBody.Len() - if remaining <= 0 { - w.truncated = true - return - } - if len(data) > remaining { - _, _ = w.responseBody.Write(data[:remaining]) - w.truncated = true - return - } - _, _ = w.responseBody.Write(data) -} - -func (w *responseWriterTracker) Hijack() (net.Conn, *bufio.ReadWriter, error) { - hijacker, ok := w.ResponseWriter.(http.Hijacker) - if !ok { - return nil, nil, errors.New("response writer does not implement http.Hijacker") - } - return hijacker.Hijack() -} - -func (w *responseWriterTracker) Flush() { - flusher, ok := w.ResponseWriter.(http.Flusher) - if !ok { - return - } - flusher.Flush() -} - -func (w *responseWriterTracker) Push(target string, opts *http.PushOptions) error { - pusher, ok := w.ResponseWriter.(http.Pusher) - if !ok { - return http.ErrNotSupported - } - return pusher.Push(target, opts) -} - -func (w *responseWriterTracker) ReadFrom(r io.Reader) (int64, error) { - readerFrom, ok := w.ResponseWriter.(io.ReaderFrom) - if !ok { - return io.Copy(w.ResponseWriter, r) - } - return readerFrom.ReadFrom(r) -} - -func (w *responseWriterTracker) Unwrap() http.ResponseWriter { - return w.ResponseWriter -} - -func (w *responseWriterTracker) responseSnippet() string { - body := strings.TrimSpace(w.responseBody.String()) - if body == "" { - return "" - } - if w.truncated { - return body + "...(truncated)" - } - return body -} - func shouldIgnoreRequest(r *http.Request, config Config) bool { if r == nil { return true @@ -336,7 +240,9 @@ func captureTransaction( return } - tx.AddMeasurement("http.response.status_code", statusCode, "code") + if statusCode != 0 { + tx.AddMeasurement("http.response.status_code", statusCode, "code") + } tx.Finish(transactionStatusFromHTTPStatus(statusCode)) duck.CaptureTransactionContext(r.Context(), tx) } @@ -365,10 +271,11 @@ func captureHandled5xx( responseBody := tracker.responseSnippet() responseMessage := extractResponseMessage(responseBody) details := map[string]any{ - "method": method, - "path": path, - "status": tracker.statusCode, - "userAgent": userAgent, + "method": method, + "path": path, + "status": tracker.statusCode, + "userAgent": userAgent, + "responseAcceptedBytes": tracker.acceptedBytes, } if responseMessage != "" { details["responseMessage"] = responseMessage @@ -427,6 +334,8 @@ func shouldCaptureTransaction(sampleRate float64, statusCode int) bool { func transactionStatusFromHTTPStatus(statusCode int) string { switch { + case statusCode == 0: + return "unknown_error" case statusCode >= http.StatusInternalServerError: return "internal_error" case statusCode >= http.StatusBadRequest: diff --git a/integrations/nethttp/response_observation_test.go b/integrations/nethttp/response_observation_test.go new file mode 100644 index 0000000..84ad860 --- /dev/null +++ b/integrations/nethttp/response_observation_test.go @@ -0,0 +1,257 @@ +package nethttp + +import ( + "bufio" + "errors" + "net" + "net/http" + "net/http/httptest" + "strings" + "testing" + + duckbug "github.com/duckbugio/duckbug-go" + "github.com/duckbugio/duckbug-go/pond" +) + +func observerTestDuck(provider *captureProvider) *duckbug.Duck { + return duckbug.NewDuck(duckbug.Config{ + Providers: []duckbug.Provider{provider}, + Pond: pond.New(pond.Config{EnvProvider: func() map[string]string { return nil }}), + }) +} + +func observerCapturedEvents(provider *captureProvider) []duckbug.Event { + provider.mu.Lock() + defer provider.mu.Unlock() + return append([]duckbug.Event(nil), provider.events...) +} + +func assertObserverTransactionStatus(t *testing.T, provider *captureProvider, status int) { + t.Helper() + transactions := 0 + for _, event := range observerCapturedEvents(provider) { + if event.Type != duckbug.EventTypeTransaction { + continue + } + transactions++ + if status == 0 { + if value := event.Payload["measurements"]; value != nil { + if _, exists := asMap(t, value)["http.response.status_code"]; exists { + t.Fatal("uncommitted response fabricated a status measurement") + } + } + if event.Payload["status"] != "unknown_error" { + t.Fatalf("unobserved status was reported as %v", event.Payload["status"]) + } + continue + } + measurements := asMap(t, event.Payload["measurements"]) + measurement := asMap(t, measurements["http.response.status_code"]) + if measurement["value"] != float64(status) { + t.Fatalf("expected status %d, got %v", status, measurement["value"]) + } + } + if transactions != 1 { + t.Fatalf("expected one transaction, got %d", transactions) + } +} + +func TestMiddlewarePanicPreservesObservedResponse(t *testing.T) { + for _, committed := range []bool{false, true} { + for _, repanic := range []bool{false, true} { + provider := &captureProvider{} + duck := observerTestDuck(provider) + p := newResponseProbe() + handler := Middleware(duck, WithRepanic(repanic), WithCaptureTransactions(true))( + http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { + if committed { + _, _ = w.Write([]byte("accepted")) + } + panic("fixture panic") + })) + var recovered any + func() { + defer func() { recovered = recover() }() + handler.ServeHTTP(p, httptest.NewRequest(http.MethodGet, "http://fixture.test/", nil)) + }() + if repanic != (recovered != nil) { + t.Fatalf("repanic=%t recovered=%v", repanic, recovered) + } + status := http.StatusInternalServerError + if committed { + status = http.StatusOK + if p.body.String() != "accepted" { + t.Fatal("panic recovery appended a second response after commitment") + } + } else if repanic { + status = 0 + if p.body.Len() != 0 || p.status != 0 { + t.Fatal("repanic fabricated an outer recovery response") + } + } + assertObserverTransactionStatus(t, provider, status) + panics := 0 + for _, event := range observerCapturedEvents(provider) { + if event.Type == duckbug.EventTypeError && event.Payload["mechanism"] == "nethttp_middleware" { + panics++ + } + } + if panics != 1 { + t.Fatalf("expected one panic incident, got %d", panics) + } + } + } +} + +func TestMiddlewareCapturesOnlyAcceptedResponsePrefix(t *testing.T) { + for _, cap := range []int{0, 32} { + provider := &captureProvider{} + duck := observerTestDuck(provider) + p := newResponseProbe() + sentinel := errors.New("fixture write failed") + p.limit, p.err = 3, sentinel + handler := Middleware(duck, WithCaptureHandled5xx(true), WithCaptureTransactions(true), WithHandled5xxMaxBodyBytes(cap))( + http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { + w.WriteHeader(http.StatusInternalServerError) + n, err := w.Write([]byte("abc-unaccepted-private")) + if n != 3 || err != sentinel { + t.Fatal("observer changed the original write result") + } + })) + handler.ServeHTTP(p, httptest.NewRequest(http.MethodGet, "http://fixture.test/", nil)) + assertObserverTransactionStatus(t, provider, 500) + handled := 0 + for _, event := range observerCapturedEvents(provider) { + if event.Type != duckbug.EventTypeError { + continue + } + handled++ + context := asMap(t, event.Payload["context"]) + if context["status"] != float64(500) || context["responseAcceptedBytes"] != float64(3) { + t.Fatal("handled event disagrees with accepted response") + } + if strings.Contains(asString(context["responseBody"]), "unaccepted-private") { + t.Fatal("attempted but unaccepted bytes entered the incident") + } + if cap == 0 { + if context["responseBody"] != nil || context["responseMessage"] != nil { + t.Fatal("disabled response capture copied a payload") + } + } else if context["responseBody"] != "abc" { + t.Fatalf("expected accepted prefix, got %v", context["responseBody"]) + } + } + if handled != 1 { + t.Fatalf("expected one handled failure, got %d", handled) + } + } +} + +func asString(value any) string { + result, _ := value.(string) + return result +} + +func TestMiddlewareDoesNotReportIgnoredFinalStatusAsFailure(t *testing.T) { + provider := &captureProvider{} + duck := observerTestDuck(provider) + p := newResponseProbe() + handler := Middleware(duck, WithCaptureHandled5xx(true), WithCaptureTransactions(true))( + http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { + w.WriteHeader(http.StatusOK) + w.WriteHeader(http.StatusInternalServerError) + })) + handler.ServeHTTP(p, httptest.NewRequest(http.MethodGet, "http://fixture.test/", nil)) + assertObserverTransactionStatus(t, provider, 200) + for _, event := range observerCapturedEvents(provider) { + if event.Type == duckbug.EventTypeError { + t.Fatal("an ignored status attempt created a false handled error") + } + } +} + +type unwrapOnlyResponseWriter struct{ http.ResponseWriter } + +func (w unwrapOnlyResponseWriter) Unwrap() http.ResponseWriter { return w.ResponseWriter } + +func TestMiddlewareObservesControllerThroughInnerUnwrapWriter(t *testing.T) { + provider := &captureProvider{} + duck := observerTestDuck(provider) + p := &capableResponseProbe{responseProbe: newResponseProbe()} + handler := Middleware(duck, WithCaptureHandled5xx(true), WithCaptureTransactions(true))( + http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { + controller := http.NewResponseController(unwrapOnlyResponseWriter{w}) + if err := controller.Flush(); err != nil { + t.Fatalf("flush: %v", err) + } + w.WriteHeader(http.StatusInternalServerError) + })) + handler.ServeHTTP(p, httptest.NewRequest(http.MethodGet, "http://fixture.test/", nil)) + if p.status != http.StatusOK || p.flushes != 1 { + t.Fatalf("wire status=%d flushes=%d", p.status, p.flushes) + } + assertObserverTransactionStatus(t, provider, http.StatusOK) + for _, event := range observerCapturedEvents(provider) { + if event.Type == duckbug.EventTypeError { + t.Fatal("controller flush created a false handled error") + } + } +} + +func TestMiddlewarePanicAfterInnerControllerHijack(t *testing.T) { + for _, repanic := range []bool{false, true} { + provider := &captureProvider{} + duck := observerTestDuck(provider) + conn, peer := net.Pipe() + buffer := bufio.NewReadWriter(bufio.NewReader(conn), bufio.NewWriter(conn)) + p := &capableResponseProbe{responseProbe: newResponseProbe(), conn: conn, buffer: buffer} + handler := Middleware(duck, WithRepanic(repanic), WithCaptureTransactions(true))( + http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { + gotConn, gotBuffer, err := http.NewResponseController(unwrapOnlyResponseWriter{w}).Hijack() + if err != nil || gotConn != conn || gotBuffer != buffer { + t.Fatalf("hijack changed the connection, buffer or error: %v", err) + } + panic("fixture panic after hijack") + })) + var recovered any + func() { + defer func() { recovered = recover() }() + handler.ServeHTTP(p, httptest.NewRequest(http.MethodGet, "http://fixture.test/", nil)) + }() + _ = conn.Close() + _ = peer.Close() + if repanic != (recovered != nil) || !p.wasHijacked || p.status != 0 || p.body.Len() != 0 { + t.Fatalf("repanic=%t recovered=%v hijacked=%t status=%d bytes=%d", repanic, recovered, p.wasHijacked, p.status, p.body.Len()) + } + assertObserverTransactionStatus(t, provider, 0) + } +} + +func TestMiddlewarePanicAfterInformationalResponse(t *testing.T) { + for _, repanic := range []bool{false, true} { + provider := &captureProvider{} + duck := observerTestDuck(provider) + p := newResponseProbe() + handler := Middleware(duck, WithRepanic(repanic), WithCaptureTransactions(true))( + http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { + w.WriteHeader(http.StatusEarlyHints) + panic("fixture panic after early hints") + })) + var recovered any + func() { + defer func() { recovered = recover() }() + handler.ServeHTTP(p, httptest.NewRequest(http.MethodGet, "http://fixture.test/", nil)) + }() + if repanic != (recovered != nil) || len(p.codes) == 0 || p.codes[0] != http.StatusEarlyHints { + t.Fatal("informational response or panic propagation changed") + } + status := http.StatusInternalServerError + if repanic { + status = 0 + } + if p.status != status { + t.Fatalf("expected final status %d, got %d", status, p.status) + } + assertObserverTransactionStatus(t, provider, status) + } +} diff --git a/integrations/nethttp/response_writer.go b/integrations/nethttp/response_writer.go new file mode 100644 index 0000000..fd1984f --- /dev/null +++ b/integrations/nethttp/response_writer.go @@ -0,0 +1,147 @@ +package nethttp + +import ( + "bufio" + "errors" + "io" + "net" + "net/http" + "strings" + + "github.com/felixge/httpsnoop" +) + +type responseWriterTracker struct { + writer http.ResponseWriter + statusCode int + wroteHeader bool + hijacked bool + acceptedBytes int64 + captureResponse bool + maxResponseBytes int + responseBody strings.Builder + truncated bool +} + +func newResponseWriterTracker(w http.ResponseWriter, config Config) *responseWriterTracker { + // shortcut: outer Unwrap-only writers can bypass hooks; add a controller bridge if arbitrary outer chains are required. + t := &responseWriterTracker{captureResponse: config.CaptureHandled5xx, maxResponseBytes: config.Handled5xxMaxBodyBytes} + t.writer = httpsnoop.Wrap(w, httpsnoop.Hooks{ + WriteHeader: func(next httpsnoop.WriteHeaderFunc) httpsnoop.WriteHeaderFunc { + return func(code int) { + if t.wroteHeader || t.hijacked { + return + } + next(code) + if code >= 100 && code < 200 && code != http.StatusSwitchingProtocols { + return + } + t.statusCode, t.wroteHeader = code, true + } + }, + Write: func(next httpsnoop.WriteFunc) httpsnoop.WriteFunc { + return func(data []byte) (int, error) { + n, err := next(data) + err = t.recordWrite(n, len(data), err) + if n > 0 && !t.hijacked { + t.captureBody(data[:n]) + } + return n, err + } + }, + WriteString: func(next httpsnoop.WriteStringFunc) httpsnoop.WriteStringFunc { + return func(data string) (int, error) { + n, err := next(data) + err = t.recordWrite(n, len(data), err) + if n > 0 && !t.hijacked && t.captureResponse && !t.truncated { + remaining := max(0, t.maxResponseBytes-t.responseBody.Len()) + t.captureBody([]byte(data[:min(n, remaining)])) + if n > remaining { + t.truncated = true + } + } + return n, err + } + }, + ReadFrom: func(httpsnoop.ReadFromFunc) httpsnoop.ReadFromFunc { + return func(src io.Reader) (int64, error) { + // Observe accepted writes; the underlying zero-copy path bypasses them. + return io.Copy(struct{ io.Writer }{t.writer}, src) + } + }, + Flush: func(next httpsnoop.FlushFunc) httpsnoop.FlushFunc { + return func() { next(); t.commitImplicit() } + }, + FlushError: func(next httpsnoop.FlushErrorFunc) httpsnoop.FlushErrorFunc { + return func() error { + err := next() + if !errors.Is(err, http.ErrNotSupported) && !errors.Is(err, http.ErrHijacked) { + t.commitImplicit() + } + return err + } + }, + Hijack: func(next httpsnoop.HijackFunc) httpsnoop.HijackFunc { + return func() (net.Conn, *bufio.ReadWriter, error) { + conn, buffer, err := next() + if err == nil { + t.hijacked = true + } + return conn, buffer, err + } + }, + }) + return t +} + +func (t *responseWriterTracker) recordWrite(n, requested int, err error) error { + if !errors.Is(err, http.ErrHijacked) && !t.hijacked { + t.commitImplicit() + t.acceptedBytes += int64(n) + } + if n < requested && err == nil { + return io.ErrShortWrite + } + return err +} + +func (t *responseWriterTracker) commitImplicit() { + if !t.wroteHeader && !t.hijacked { + t.statusCode, t.wroteHeader = http.StatusOK, true + } +} + +func (t *responseWriterTracker) responseStatus(finished bool) int { + if !t.wroteHeader && finished && !t.hijacked { + return http.StatusOK + } + return t.statusCode +} + +func (t *responseWriterTracker) captureBody(data []byte) { + if !t.captureResponse || len(data) == 0 || t.truncated { + return + } + remaining := t.maxResponseBytes - t.responseBody.Len() + if remaining <= 0 { + t.truncated = true + return + } + if len(data) > remaining { + _, _ = t.responseBody.Write(data[:remaining]) + t.truncated = true + return + } + _, _ = t.responseBody.Write(data) +} + +func (t *responseWriterTracker) responseSnippet() string { + body := strings.TrimSpace(t.responseBody.String()) + if body == "" { + return "" + } + if t.truncated { + return body + "...(truncated)" + } + return body +} diff --git a/integrations/nethttp/response_writer_test.go b/integrations/nethttp/response_writer_test.go new file mode 100644 index 0000000..10f1c34 --- /dev/null +++ b/integrations/nethttp/response_writer_test.go @@ -0,0 +1,325 @@ +package nethttp + +import ( + "bufio" + "bytes" + "errors" + "io" + "net" + "net/http" + "net/http/httptest" + "net/http/httptrace" + "net/textproto" + "reflect" + "strings" + "testing" + "time" +) + +type responseProbe struct { + header http.Header + codes []int + status int + body bytes.Buffer + limit int + err error +} + +func newResponseProbe() *responseProbe { return &responseProbe{header: make(http.Header), limit: -1} } +func (p *responseProbe) Header() http.Header { return p.header } +func (p *responseProbe) WriteHeader(code int) { + if p.status != 0 { + return + } + if code < 100 || code > 999 { + panic("invalid fixture HTTP status") + } + p.codes = append(p.codes, code) + if code >= 200 || code == 101 { + p.status = code + } +} +func (p *responseProbe) Write(data []byte) (int, error) { + if p.status == 0 { + p.WriteHeader(200) + } + n := len(data) + if p.limit >= 0 { + n = min(n, p.limit) + } + _, _ = p.body.Write(data[:n]) + return n, p.err +} + +type capableResponseProbe struct { + *responseProbe + flushes, pushes, copies, strings int + flushErr, hijackErr error + conn net.Conn + buffer *bufio.ReadWriter + readDeadline, writeDeadline time.Time + duplex bool + wasHijacked bool +} + +func (p *capableResponseProbe) Write(data []byte) (int, error) { + if p.wasHijacked { + return 0, http.ErrHijacked + } + return p.responseProbe.Write(data) +} + +func (p *capableResponseProbe) Flush() { p.WriteHeader(200); p.flushes++ } +func (p *capableResponseProbe) FlushError() error { + if !errors.Is(p.flushErr, http.ErrNotSupported) { + p.Flush() + } + return p.flushErr +} +func (p *capableResponseProbe) Push(string, *http.PushOptions) error { p.pushes++; return nil } +func (p *capableResponseProbe) ReadFrom(src io.Reader) (int64, error) { + p.copies++ + return io.Copy(p.responseProbe, src) +} +func (p *capableResponseProbe) WriteString(s string) (int, error) { + p.strings++ + return p.Write([]byte(s)) +} +func (p *capableResponseProbe) Hijack() (net.Conn, *bufio.ReadWriter, error) { + if p.hijackErr == nil { + p.wasHijacked = true + } + return p.conn, p.buffer, p.hijackErr +} +func (p *capableResponseProbe) SetReadDeadline(value time.Time) error { + p.readDeadline = value + return nil +} +func (p *capableResponseProbe) SetWriteDeadline(value time.Time) error { + p.writeDeadline = value + return nil +} +func (p *capableResponseProbe) EnableFullDuplex() error { p.duplex = true; return nil } + +func observeProbe(p http.ResponseWriter, cap int) *responseWriterTracker { + return newResponseWriterTracker(p, Config{CaptureHandled5xx: true, Handled5xxMaxBodyBytes: cap}) +} + +func TestResponseObserverFirstFinalStatus(t *testing.T) { + for _, test := range []struct { + name string + run func(http.ResponseWriter) + codes []int + status int + }{ + {"explicit final", func(w http.ResponseWriter) { w.WriteHeader(200); w.WriteHeader(500) }, []int{200}, 200}, + {"implicit write", func(w http.ResponseWriter) { _, _ = w.Write([]byte("ok")); w.WriteHeader(500) }, []int{200}, 200}, + {"empty write commits", func(w http.ResponseWriter) { _, _ = w.Write(nil); w.WriteHeader(500) }, []int{200}, 200}, + {"informational", func(w http.ResponseWriter) { w.WriteHeader(100); w.WriteHeader(103); w.WriteHeader(201) }, []int{100, 103, 201}, 201}, + {"switching is terminal", func(w http.ResponseWriter) { w.WriteHeader(101); w.WriteHeader(500) }, []int{101}, 101}, + } { + t.Run(test.name, func(t *testing.T) { + p := newResponseProbe() + observer := observeProbe(p, 32) + test.run(observer.writer) + if p.status != test.status || observer.responseStatus(false) != test.status || !reflect.DeepEqual(p.codes, test.codes) { + t.Fatalf("wire=%d observer=%d codes=%v", p.status, observer.statusCode, p.codes) + } + }) + } + t.Run("invalid header does not commit", func(t *testing.T) { + observer := observeProbe(newResponseProbe(), 32) + func() { + defer func() { + if recover() == nil { + t.Error("expected invalid-header panic") + } + }() + observer.writer.WriteHeader(42) + }() + if observer.wroteHeader || observer.responseStatus(false) != 0 { + t.Fatal("panicking header became an observed commitment") + } + }) +} + +func TestResponseObserverAcceptedPrefixAndCopyPaths(t *testing.T) { + sentinel := errors.New("fixture write failed") + for _, useString := range []bool{false, true} { + for _, writeErr := range []error{nil, sentinel} { + p := &capableResponseProbe{responseProbe: newResponseProbe()} + p.limit, p.err = 2, writeErr + observer := observeProbe(p, 32) + var n int + var err error + if useString { + n, err = io.WriteString(observer.writer, "abcdef") + } else { + n, err = observer.writer.Write([]byte("abcdef")) + } + expected := writeErr + if expected == nil { + expected = io.ErrShortWrite + } + if n != 2 || err != expected || observer.acceptedBytes != 2 || observer.responseSnippet() != "ab" || p.body.String() != "ab" { + t.Fatalf("string=%t n=%d err=%v accepted=%d captured=%q", useString, n, err, observer.acceptedBytes, observer.responseSnippet()) + } + if useString && p.strings != 1 { + t.Fatal("StringWriter observation bypassed the supported underlying method") + } + } + } + t.Run("capture cap across writes", func(t *testing.T) { + observer := observeProbe(newResponseProbe(), 5) + _, _ = observer.writer.Write([]byte("abc")) + _, _ = observer.writer.Write([]byte("defgh")) + if observer.acceptedBytes != 8 || observer.responseSnippet() != "abcde...(truncated)" { + t.Fatal("capture cap changed accepted byte accounting") + } + }) + for _, name := range []string{"empty", "source failure", "partial write"} { + t.Run("ReaderFrom "+name, func(t *testing.T) { + p := &capableResponseProbe{responseProbe: newResponseProbe()} + observer := observeProbe(p, 32) + var src io.Reader = struct{ io.Reader }{strings.NewReader("")} + if name == "source failure" { + src = observerReaderFunc(func([]byte) (int, error) { return 0, sentinel }) + } + if name == "partial write" { + src = struct{ io.Reader }{strings.NewReader("abcdef")} + p.limit, p.err = 2, sentinel + } + n, err := io.Copy(observer.writer, src) + if p.copies != 0 { + t.Fatal("underlying ReaderFrom bypassed observing writes") + } + if name == "partial write" { + if n != 2 || err != sentinel || observer.responseSnippet() != "ab" || observer.acceptedBytes != 2 { + t.Fatalf("n=%d err=%v captured=%q", n, err, observer.responseSnippet()) + } + return + } + if n != 0 || observer.wroteHeader || observer.responseStatus(false) != 0 || observer.responseStatus(true) != 200 { + t.Fatal("empty/failed source committed a response") + } + if name == "source failure" && err != sentinel { + t.Fatal("source error identity changed") + } + }) + } +} + +type observerReaderFunc func([]byte) (int, error) + +func (f observerReaderFunc) Read(p []byte) (int, error) { return f(p) } + +func TestResponseObserverOptionalInterfacesAndHijack(t *testing.T) { + minimal := observeProbe(newResponseProbe(), 32) + if _, ok := minimal.writer.(http.Flusher); ok { + t.Fatal("invented Flusher") + } + if _, ok := minimal.writer.(http.Hijacker); ok { + t.Fatal("invented Hijacker") + } + if _, ok := minimal.writer.(http.Pusher); ok { + t.Fatal("invented Pusher") + } + if _, ok := minimal.writer.(io.ReaderFrom); ok { + t.Fatal("invented ReaderFrom") + } + if _, ok := minimal.writer.(io.StringWriter); ok { + t.Fatal("invented StringWriter") + } + if unwrapped, ok := minimal.writer.(interface{ Unwrap() http.ResponseWriter }); !ok || unwrapped.Unwrap() == nil { + t.Fatal("underlying writer cannot be unwrapped") + } + recorder := httptest.NewRecorder() + flusher := observeProbe(recorder, 32) + flusher.writer.(http.Flusher).Flush() + flusher.writer.WriteHeader(500) + if recorder.Code != 200 || flusher.statusCode != 200 { + t.Fatal("Flusher-only commitment was lost") + } + if err := http.NewResponseController(minimal.writer).Flush(); !errors.Is(err, http.ErrNotSupported) || minimal.wroteHeader { + t.Fatal("unsupported flush appeared successful") + } + p := &capableResponseProbe{responseProbe: newResponseProbe()} + observer := observeProbe(p, 32) + if err := observer.writer.(http.Pusher).Push("/asset", nil); err != nil || observer.wroteHeader { + t.Fatal("push committed its parent") + } + controller := http.NewResponseController(observer.writer) + deadline := time.Now().Add(time.Minute) + if controller.SetReadDeadline(deadline) != nil || controller.SetWriteDeadline(deadline) != nil || controller.EnableFullDuplex() != nil || !p.duplex || p.readDeadline != deadline || p.writeDeadline != deadline { + t.Fatal("controller capabilities were lost") + } + if err := controller.Flush(); err != nil || p.flushes != 1 || observer.responseStatus(false) != 200 { + t.Fatal("FlushError did not establish implicit status") + } + observer.writer.WriteHeader(500) + if p.status != 200 || observer.statusCode != 200 { + t.Fatal("late status overwrote flush commitment") + } + unsupported := &capableResponseProbe{responseProbe: newResponseProbe(), flushErr: http.ErrNotSupported} + noFlush := observeProbe(unsupported, 32) + if err := http.NewResponseController(noFlush.writer).Flush(); !errors.Is(err, http.ErrNotSupported) || noFlush.wroteHeader { + t.Fatal("unsupported FlushError committed") + } + t.Run("successful hijack", func(t *testing.T) { + left, right := net.Pipe() + defer left.Close() + defer right.Close() + p := &capableResponseProbe{responseProbe: newResponseProbe(), conn: left, buffer: bufio.NewReadWriter(bufio.NewReader(left), bufio.NewWriter(left))} + observer := observeProbe(p, 32) + conn, buffer, err := observer.writer.(http.Hijacker).Hijack() + if err != nil || conn != left || buffer != p.buffer || !observer.hijacked || observer.responseStatus(true) != 0 { + t.Fatal("hijack identity/status changed") + } + if n, err := observer.writer.Write([]byte("rejected")); n != 0 || err != http.ErrHijacked || observer.wroteHeader || observer.acceptedBytes != 0 || observer.responseSnippet() != "" { + t.Fatal("rejected write after hijack fabricated HTTP commitment or bytes") + } + }) + t.Run("failed hijack", func(t *testing.T) { + sentinel := errors.New("hijack failed") + p := &capableResponseProbe{responseProbe: newResponseProbe(), hijackErr: sentinel} + observer := observeProbe(p, 32) + _, _, err := observer.writer.(http.Hijacker).Hijack() + if err != sentinel || observer.hijacked { + t.Fatal("failed hijack changed state") + } + observer.writer.WriteHeader(201) + if observer.statusCode != 201 { + t.Fatal("failed hijack prevented response") + } + }) +} + +func TestMiddlewareInformationalResponseOnRealWire(t *testing.T) { + provider := &captureProvider{} + duck := observerTestDuck(provider) + server := httptest.NewServer(Middleware(duck, WithCaptureTransactions(true), WithCaptureHandled5xx(true))(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { + w.WriteHeader(103) + w.WriteHeader(201) + _, _ = io.WriteString(w, "created") + }))) + defer server.Close() + var informational []int + req, err := http.NewRequest(http.MethodGet, server.URL, nil) + if err != nil { + t.Fatal(err) + } + req = req.WithContext(httptrace.WithClientTrace(req.Context(), &httptrace.ClientTrace{Got1xxResponse: func(code int, _ textproto.MIMEHeader) error { informational = append(informational, code); return nil }})) + response, err := server.Client().Do(req) + if err != nil { + t.Fatal(err) + } + defer response.Body.Close() + body, err := io.ReadAll(response.Body) + if err != nil { + t.Fatal(err) + } + if response.StatusCode != 201 || string(body) != "created" || !reflect.DeepEqual(informational, []int{103}) { + t.Fatalf("status=%d body=%q informational=%v", response.StatusCode, body, informational) + } + assertObserverTransactionStatus(t, provider, 201) +} From e4f6b8a68910676484cb835c303eaf3b81756751 Mon Sep 17 00:00:00 2001 From: Konstantin Zaytcev Date: Fri, 23 Oct 2026 14:33:50 +0300 Subject: [PATCH 2/2] fix(deps): update HTTP/2 security fixes and Go floor --- .github/dependabot.yml | 6 ++---- .github/workflows/go-checks.yml | 4 ++-- README.md | 2 +- go.mod | 8 ++++---- go.sum | 12 ++++++------ 5 files changed, 15 insertions(+), 17 deletions(-) diff --git a/.github/dependabot.yml b/.github/dependabot.yml index a73fd7a..876673a 100644 --- a/.github/dependabot.yml +++ b/.github/dependabot.yml @@ -3,10 +3,8 @@ updates: # The gate sat red from 30 July onwards because grpc stayed on a vulnerable # version and nothing said so out loud. This is the part that says so. # - # It proposes, it does not decide: expect it to offer the grpc upgrade that - # was declined on purpose, because that one pulls x/net past go 1.26 and takes - # the module floor with it, dropping every Go 1.25 consumer. Read what an - # upgrade does to the floor before merging it. + # It proposes, it does not decide. Security fixes in x/net already require + # Go 1.26; read what each later upgrade does to the module floor before merging. - package-ecosystem: gomod directory: / schedule: diff --git a/.github/workflows/go-checks.yml b/.github/workflows/go-checks.yml index eef3a45..6f47900 100644 --- a/.github/workflows/go-checks.yml +++ b/.github/workflows/go-checks.yml @@ -32,8 +32,8 @@ jobs: fail-fast: false matrix: go-version: - - "1.25.13" - - "1.26.1" + - "1.26.10" + - "1.27.3" steps: - name: Checkout diff --git a/README.md b/README.md index ea2d9a7..0f68a95 100644 --- a/README.md +++ b/README.md @@ -12,7 +12,7 @@ This module follows the DuckBug SDK architecture from `duckbug-sdk-spec`, while ## Compatibility -- Go `1.25.13+`. The `go` directive in `go.mod` is the source of truth; this line is a copy for readers and loses to it if the two ever disagree. The floor is a patched release of the 1.25 line: earlier 1.25 patches carry advisories in `crypto/tls`, `encoding/asn1`, `net/url` and `net/http` that this module's HTTP transport reaches. +- Go `1.26.10+`. The `go` directive in `go.mod` is the source of truth. The HTTP/2 security fixes in `golang.org/x/net` require Go 1.26; the minimum uses the current patched 1.26 release. Upgrading from SDK 0.4 also requires upgrading consumers still using Go 1.25. - Every change is validated on that minimum and on the current Go release. The exact versions are the matrix in the CI workflow under `.github/workflows/`, and are not repeated here. - Releases are expected to be published via git tags in the `v*` format. diff --git a/go.mod b/go.mod index c2cdc54..5f42775 100644 --- a/go.mod +++ b/go.mod @@ -1,6 +1,6 @@ module github.com/duckbugio/duckbug-go -go 1.25.13 +go 1.26.10 require ( github.com/felixge/httpsnoop v1.1.0 @@ -14,9 +14,9 @@ require ( github.com/mattn/go-colorable v0.1.14 // indirect github.com/mattn/go-isatty v0.0.20 // indirect go.uber.org/multierr v1.10.0 // indirect - golang.org/x/net v0.58.0 // indirect - golang.org/x/sys v0.47.0 // indirect - golang.org/x/text v0.41.0 // indirect + golang.org/x/net v0.60.0 // indirect + golang.org/x/sys v0.48.0 // indirect + golang.org/x/text v0.42.0 // indirect google.golang.org/genproto/googleapis/rpc v0.0.0-20260526163538-3dc84a4a5aaa // indirect google.golang.org/protobuf v1.36.11 // indirect ) diff --git a/go.sum b/go.sum index 4b5012c..e75b3be 100644 --- a/go.sum +++ b/go.sum @@ -48,13 +48,13 @@ go.uber.org/zap v1.28.0 h1:IZzaP1Fv73/T/pBMLk4VutPl36uNC+OSUh3JLG3FIjo= go.uber.org/zap v1.28.0/go.mod h1:rDLpOi171uODNm/mxFcuYWxDsqWSAVkFdX4XojSKg/Q= go.yaml.in/yaml/v3 v3.0.4 h1:tfq32ie2Jv2UxXFdLJdh3jXuOzWiL1fo0bu/FbuKpbc= go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg= -golang.org/x/net v0.58.0 h1:ynWG7rqYi4ccpTEuPZ2QGWHktVEM9DMCj9yzDE0Q7To= -golang.org/x/net v0.58.0/go.mod h1:YwCddHnFlT7eLQqVprV19OnhLGtc5xOKgE0RyqgfWAU= +golang.org/x/net v0.60.0 h1:79p50tfZlm0J9YfoDsSi639qSXNGVwEzOPLCxM2FsYU= +golang.org/x/net v0.60.0/go.mod h1:2DA/G1UfVbCpQPeWTmMPGY7Cs2PkBkwu743bVX5PIVg= golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.47.0 h1:o7XGOvZQCADBQQ4Y7VNq2dRWQR7JmOUW8Kxx4ZsNgWs= -golang.org/x/sys v0.47.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= -golang.org/x/text v0.41.0 h1:vz/seA0lnX87Othu2f/0L24RcgrXD9/YFTSuGjj3rH8= -golang.org/x/text v0.41.0/go.mod h1:jvf1O8ajNzZqhSrQBPbutR/EB83Cc0CFrezNQIwbb5M= +golang.org/x/sys v0.48.0 h1:bbX/i/6MgT9BVLM9RT1thmxL04yeTAhbEz4SyadbXoo= +golang.org/x/sys v0.48.0/go.mod h1:hNLxWAXmnKAxqDtdwIYC4bM9oQPEecfsnNMuSxOs3og= +golang.org/x/text v0.42.0 h1:JbOZXgfeCPU9gacVtYliJqOhD+zhrEqK4LfdpmlUZqI= +golang.org/x/text v0.42.0/go.mod h1:ojzP1Z+2QtioaF8DTtO8K5q7JWVVYwZKenzujK0Zd0E= gonum.org/v1/gonum v0.17.0 h1:VbpOemQlsSMrYmn7T2OUvQ4dqxQXU+ouZFQsZOx50z4= gonum.org/v1/gonum v0.17.0/go.mod h1:El3tOrEuMpv2UdMrbNlKEh9vd86bmQ6vqIcDwxEOc1E= google.golang.org/genproto/googleapis/rpc v0.0.0-20260526163538-3dc84a4a5aaa h1:mZHHdPZl0dbGHCflZgAq/Q468DWVFcU2whhB2KAo8fk=