diff --git a/server/traffic_stream_test.go b/server/traffic_stream_test.go new file mode 100644 index 0000000..5e03f70 --- /dev/null +++ b/server/traffic_stream_test.go @@ -0,0 +1,89 @@ +package server + +import ( + "encoding/json" + "testing" +) + +func TestTrafficStreamRoute(t *testing.T) { + s, request := ingestServer(t) + db := s.m.Traffic().DB() + if _, err := db.Exec(`INSERT INTO exchanges(id,ts,host,method,url_template,url,status,content_type,req_len,resp_len,path) +VALUES('1-0001',1,'ws.example.com','GET','/ws','wss://ws.example.com/ws',101,'websocket',0,0,'')`); err != nil { + t.Fatal(err) + } + if _, err := db.Exec(`INSERT INTO exchange_bodies(id,req_head,resp_head) VALUES('1-0001','GET /ws HTTP/1.1\n','HTTP/1.1 101 Switching Protocols\n')`); err != nil { + t.Fatal(err) + } + const total = 250 + tx, err := db.Begin() + if err != nil { + t.Fatal(err) + } + for i := 1; i <= total; i++ { + kind, payload := 1, []byte("hello") + if i%2 == 0 { + kind, payload = 2, []byte{0, 1, 2} + } + if _, err := tx.Exec(`INSERT INTO stream_messages(exchange_id,seq,ts,direction,kind,size,payload) VALUES('1-0001',?,1,'c2s',?,?,?)`, i, kind, len(payload), payload); err != nil { + t.Fatal(err) + } + } + if err := tx.Commit(); err != nil { + t.Fatal(err) + } + + type page struct { + Items []struct { + Seq int64 `json:"seq"` + Type string `json:"type"` + Payload string `json:"payload"` + Encoding string `json:"encoding"` + } `json:"items"` + Total int `json:"total"` + } + get := func(path string, wantStatus int) page { + t.Helper() + w := request("GET", path, "") + if w.Code != wantStatus { + t.Fatalf("GET %s = %d %s, want %d", path, w.Code, w.Body, wantStatus) + } + var p page + if wantStatus == 200 { + if err := json.Unmarshal(w.Body.Bytes(), &p); err != nil { + t.Fatalf("GET %s: %v in %s", path, err, w.Body) + } + } + return p + } + + get("/api/traffic/stream", 400) + if p := get("/api/traffic/stream?exchange=nope", 200); p.Items == nil || len(p.Items) != 0 || p.Total != 0 { + t.Fatalf("unknown exchange = %+v, want items [] and total 0", p) + } + p := get("/api/traffic/stream?exchange=1-0001", 200) + if p.Total != total || len(p.Items) != 50 || p.Items[0].Seq != 1 { + t.Fatalf("default page: total %d, %d items, first seq %d", p.Total, len(p.Items), p.Items[0].Seq) + } + if first, second := p.Items[0], p.Items[1]; first.Type != "text" || first.Payload != "hello" || second.Type != "binary" || second.Encoding != "base64" || second.Payload != "AAEC" { + t.Fatalf("payloads %+v %+v", first, second) + } + if p := get("/api/traffic/stream?exchange=1-0001&limit=500", 200); len(p.Items) != 200 { + t.Fatalf("limit=500 returned %d items, want the 200 cap", len(p.Items)) + } + if p := get("/api/traffic/stream?exchange=1-0001&offset=-5&limit=1", 200); len(p.Items) != 1 || p.Items[0].Seq != 1 { + t.Fatalf("negative offset: %+v, want seq 1", p.Items) + } + if p := get("/api/traffic/stream?exchange=1-0001&offset=248&limit=10", 200); len(p.Items) != 2 || p.Items[0].Seq != 249 { + t.Fatalf("last page: %+v, want seqs 249 and 250", p.Items) + } + + w := request("GET", "/api/traffic/exchange?id=1-0001", "") + var ex struct { + StreamCount int `json:"stream_count"` + StreamKind string `json:"stream_kind"` + } + if err := json.Unmarshal(w.Body.Bytes(), &ex); err != nil || w.Code != 200 || ex.StreamCount != total || ex.StreamKind != "websocket" { + t.Fatalf("exchange = %d %s", w.Code, w.Body) + } +} diff --git a/traffic/stream.go b/traffic/stream.go index 2d18cce..c502ebc 100644 --- a/traffic/stream.go +++ b/traffic/stream.go @@ -30,9 +30,12 @@ const ( // values go-mitmproxy reports in WebSocketMessage.Type. wsText = 1 wsBinary = 2 - // streamPreview caps one message's payload in a StreamMessages row when the - // payload spilled to the blob store; the hash points at the rest. + // streamPreview caps one message's payload in a StreamMessages row; a longer + // payload lives in the blob store and the row carries its hash. streamPreview = 4 * 1024 + // maxStreamInline is the inline threshold for message payloads: anything + // longer spills to the blob store, so a page of 200 rows stays bounded. + maxStreamInline = streamPreview // toolStreamPreview caps one message's preview in traffic_messages, so a page // of messages stays small in the agent's context. toolStreamPreview = 1024 @@ -47,7 +50,8 @@ type streamState struct { consumed int // library messages/events already handled seq int64 stored int - // storedBytes counts the payload bytes kept, after truncation. + // storedBytes counts what the kept messages occupy: the payload after + // truncation, plus the inline preview spill keeps for a spilled payload. storedBytes int64 dropped bool droppedMsgs int64 @@ -59,7 +63,7 @@ type streamState struct { // streamRow is one stream_messages row before it is written. type streamRow struct { - ts int64 // unix milliseconds + ts int64 // unix seconds, like exchanges.ts; seq carries the order direction string kind int event string @@ -154,8 +158,9 @@ func (s *sink) startStream(f *mproxy.Flow, kind string) { // libMutex returns the unexported mu sync.Mutex that go-mitmproxy holds while it // appends to WebSocketData.Messages / SSEData.Events. The library exposes no // accessor, and the two WebSocket goroutines append concurrently, so reading the -// slice without that lock is a data race. Nil when the field is absent (a library -// change), in which case the read falls back to unlocked. +// slice without that lock is a data race. Reaching a private field ties this to +// the pinned go-mitmproxy v1.9.2: TestLibMutexFound is the upgrade guard. Nil +// when the field is absent, and then nothing is read (see lockLib). func libMutex(v any) *sync.Mutex { rv := reflect.ValueOf(v) if rv.Kind() != reflect.Pointer || rv.IsNil() { @@ -170,23 +175,28 @@ func libMutex(v any) *sync.Mutex { var libMutexMissing sync.Once -func lockLib(v any) func() { +// lockLib takes the library's lock on v. ok is false when the lock cannot be +// found; callers then read nothing rather than race the library. +func lockLib(v any) (unlock func(), ok bool) { mu := libMutex(v) if mu == nil { libMutexMissing.Do(func() { - log.Printf("[traffic] go-mitmproxy stream data has no mu field; reading stream messages without its lock") + log.Printf("[traffic] go-mitmproxy stream data has no mu field; stream messages are not recorded") }) - return func() {} + return nil, false } mu.Lock() - return mu.Unlock + return mu.Unlock, true } // wsMessagesSince returns every WebSocket message appended since the last call, // in the library's order, so each is handled exactly once whichever goroutine's // hook gets there first. The library slice itself is never modified. func wsMessagesSince(ws *mproxy.WebSocketData, st *streamState) []streamRow { - unlock := lockLib(ws) + unlock, ok := lockLib(ws) + if !ok { + return nil + } msgs := ws.Messages if st.consumed > len(msgs) { st.consumed = len(msgs) @@ -209,14 +219,17 @@ func wsMessagesSince(ws *mproxy.WebSocketData, st *streamState) []streamRow { if m.Type == wsBinary { ctype = "application/octet-stream" } - rows = append(rows, streamRow{ts: m.Timestamp.UnixMilli(), direction: dir, kind: m.Type, size: len(m.Content), payload: m.Content, ctype: ctype}) + rows = append(rows, streamRow{ts: m.Timestamp.Unix(), direction: dir, kind: m.Type, size: len(m.Content), payload: m.Content, ctype: ctype}) } return rows } // sseEventsSince is wsMessagesSince for Server-Sent Events. func sseEventsSince(sse *mproxy.SSEData, st *streamState) []streamRow { - unlock := lockLib(sse) + unlock, ok := lockLib(sse) + if !ok { + return nil + } events := sse.Events if st.consumed > len(events) { st.consumed = len(events) @@ -230,7 +243,7 @@ func sseEventsSince(sse *mproxy.SSEData, st *streamState) []streamRow { continue } st.respBytes += int64(len(e.Raw)) - rows = append(rows, streamRow{ts: e.Time.UnixMilli(), direction: "s2c", event: e.Event, eventID: e.ID, + rows = append(rows, streamRow{ts: e.Time.Unix(), direction: "s2c", event: e.Event, eventID: e.ID, retry: e.Retry, size: len(e.Data), payload: []byte(e.Data), ctype: "text/event-stream"}) } return rows @@ -333,7 +346,8 @@ func (t *Traffic) persistStream(st *streamState, rows []streamRow) { r.payload = r.payload[:maxStreamPayload] r.truncated = true } - if st.dropped || st.stored >= maxStreamMessages || st.storedBytes+int64(len(r.payload)) > maxStreamBytes { + cost := streamStoredCost(r) + if st.dropped || st.stored >= maxStreamMessages || st.storedBytes+cost > maxStreamBytes { if !st.dropped { st.dropped = true addMeta = true @@ -343,7 +357,7 @@ func (t *Traffic) persistStream(st *streamState, rows []streamRow) { continue } st.stored++ - st.storedBytes += int64(len(r.payload)) + st.storedBytes += cost keep = append(keep, r) } var meta []byte @@ -356,36 +370,52 @@ func (t *Traffic) persistStream(st *streamState, rows []streamRow) { t.wmu.Lock() defer t.wmu.Unlock() + // Sequence numbers and blob writes come first, as in record(): blob writes are + // filesystem work and must not sit inside the SQLite transaction. Holding wmu + // keeps gcBlobs from collecting a blob before its reference is committed. + type preparedRow struct { + streamRow + seq int64 + body storedBody + } + prepared := make([]preparedRow, 0, len(keep)) + for _, r := range keep { + st.seq++ + prepared = append(prepared, preparedRow{streamRow: r, seq: st.seq, body: t.spillAt(r.payload, r.ctype, maxStreamInline)}) + } + var metaSeq int64 + if meta != nil { + st.seq++ + metaSeq = st.seq + } + tx, err := t.db.Begin() if err != nil { log.Printf("[traffic] failed to record stream messages of %s (beginning transaction): %v", st.id, err) return } defer tx.Rollback() //nolint:errcheck // no-op once committed - for _, r := range keep { - st.seq++ - b := t.spill(r.payload, r.ctype) - inline := b.inline + for _, p := range prepared { + inline := p.body.inline if inline == nil { inline = []byte{} } if _, err := tx.Exec(`INSERT INTO stream_messages(exchange_id,seq,ts,direction,kind,event,event_id,retry,size,payload,payload_blob,truncated) -VALUES(?,?,?,?,?,?,?,?,?,?,?,?)`, st.id, st.seq, r.ts, r.direction, r.kind, r.event, r.eventID, r.retry, r.size, - inline, nullIfEmpty(b.hash), boolInt(r.truncated)); err != nil { - log.Printf("[traffic] failed to record stream message %d of %s: %v", st.seq, st.id, err) +VALUES(?,?,?,?,?,?,?,?,?,?,?,?)`, st.id, p.seq, p.ts, p.direction, p.kind, p.event, p.eventID, p.retry, p.size, + inline, nullIfEmpty(p.body.hash), boolInt(p.truncated)); err != nil { + log.Printf("[traffic] failed to record stream message %d of %s: %v", p.seq, st.id, err) return } - if b.hash != "" { - if _, err := tx.Exec(`INSERT OR IGNORE INTO blob_refs(hash,exchange_id) VALUES(?,?)`, b.hash, st.id); err != nil { - log.Printf("[traffic] failed to record stream message %d of %s (registering blob reference): %v", st.seq, st.id, err) + if p.body.hash != "" { + if _, err := tx.Exec(`INSERT OR IGNORE INTO blob_refs(hash,exchange_id) VALUES(?,?)`, p.body.hash, st.id); err != nil { + log.Printf("[traffic] failed to record stream message %d of %s (registering blob reference): %v", p.seq, st.id, err) return } } } if meta != nil { - st.seq++ if _, err := tx.Exec(`INSERT INTO stream_messages(exchange_id,seq,ts,direction,kind,size,payload) -VALUES(?,?,?,'meta',0,?,?)`, st.id, st.seq, time.Now().UnixMilli(), len(meta), meta); err != nil { +VALUES(?,?,?,'meta',0,?,?)`, st.id, metaSeq, time.Now().Unix(), len(meta), meta); err != nil { log.Printf("[traffic] failed to record stream limit marker of %s: %v", st.id, err) return } @@ -395,6 +425,20 @@ VALUES(?,?,?,'meta',0,?,?)`, st.id, st.seq, time.Now().UnixMilli(), len(meta), m } } +// streamStoredCost is what keeping r adds to the index and blob store: the +// payload, plus the inline preview spillAt keeps when the payload spills (a text +// prefix of at most blobPreview, or a one-line tag for binary). +func streamStoredCost(r streamRow) int64 { + n := int64(len(r.payload)) + if len(r.payload) <= maxStreamInline { + return n + } + if isBinaryBody(r.ctype, r.payload) { + return n + int64(len(binaryTag(r.ctype, r.payload))) + } + return n + int64(len(truncateUTF8(r.payload, blobPreview))) +} + func streamMetaPayload(st *streamState) []byte { b, _ := json.Marshal(map[string]int64{"dropped_messages": st.droppedMsgs, "dropped_bytes": st.droppedBytes}) return b @@ -429,7 +473,7 @@ func (t *Traffic) finishStream(st *streamState) { // StreamMessage is one recorded WebSocket message or SSE event. type StreamMessage struct { Seq int64 `json:"seq"` - TS int64 `json:"ts"` // unix milliseconds + TS int64 `json:"ts"` // unix seconds, like an exchange's ts; Seq orders Direction string `json:"direction"` Kind int `json:"kind"` // Type is "text" or "binary" (WebSocket), "event" (SSE), or "meta" (the @@ -447,8 +491,9 @@ type StreamMessage struct { } // StreamMessages returns one page of an exchange's stream messages in order. -// limit is 1..200 (default 50) and offset >= 0. A payload that spilled to the -// blob store comes back as a preview of at most 4 KiB plus its hash. +// limit is 1..200 (default 50) and offset >= 0. Every payload comes back as at +// most streamPreview (4 KiB); a longer one lives in the blob store and the row +// carries its hash for the rest (traffic_blob, GET /api/traffic/blob). func (t *Traffic) StreamMessages(exchangeID string, offset, limit int) ([]StreamMessage, int, error) { if limit <= 0 { limit = 50 @@ -490,16 +535,15 @@ FROM stream_messages WHERE exchange_id=? ORDER BY seq LIMIT ? OFFSET ?`, exchang default: m.Type = "event" } - if m.Blob != "" { - payload = clipBytes(payload, streamPreview) - } if m.Type == "binary" { - m.Payload, m.Encoding = base64.StdEncoding.EncodeToString(payload), "base64" - } else { - m.Payload = string(payload) if m.Blob != "" { - m.Payload = truncateUTF8(payload, streamPreview) + // A spilled binary payload keeps only a descriptive tag inline; + // the preview is the payload's own leading bytes. + payload, _, _ = t.BlobRange(m.Blob, 0, streamPreview) } + m.Payload, m.Encoding = base64.StdEncoding.EncodeToString(clipBytes(payload, streamPreview)), "base64" + } else { + m.Payload = truncateUTF8(payload, streamPreview) } out = append(out, m) } diff --git a/traffic/stream_test.go b/traffic/stream_test.go index 8aaaf4f..96e6263 100644 --- a/traffic/stream_test.go +++ b/traffic/stream_test.go @@ -156,7 +156,7 @@ func TestWebSocketMessagesRecorded(t *testing.T) { } return got } - before := time.Now().UnixMilli() + before := time.Now().Unix() if got := exchange(websocket.TextMessage, []byte("hello")); string(got) != "echo:hello" { t.Fatalf("echo %q", got) } @@ -374,7 +374,14 @@ func TestStreamMessageLimitStoresOneMetaRow(t *testing.T) { func TestStreamByteLimitStoresOneMetaRow(t *testing.T) { tr, s, f := unitStream(t, "bytes.test") chunk := bytes.Repeat([]byte{7}, maxStreamPayload) - n := maxStreamBytes/maxStreamPayload + 1 + // Each kept 1 MiB payload spills and also keeps its inline tag, so the cap + // admits floor(maxStreamBytes / (payload + tag)) of them. + cost := streamStoredCost(streamRow{payload: chunk, ctype: "application/octet-stream"}) + if cost <= maxStreamPayload { + t.Fatalf("cost %d does not count the inline preview", cost) + } + kept := int(maxStreamBytes / cost) + n := kept + 1 for i := 0; i < n; i++ { addWS(f, false, websocket.BinaryMessage, chunk) } @@ -384,8 +391,8 @@ func TestStreamByteLimitStoresOneMetaRow(t *testing.T) { s.WebSocketEnd(f) id := onlyExchange(t, tr) msgs := allMessages(t, tr, id) - if len(msgs) != n { - t.Fatalf("%d rows, want %d stored and one meta row", len(msgs), n-1) + if len(msgs) != kept+1 { + t.Fatalf("%d rows, want %d stored and one meta row", len(msgs), kept) } meta := msgs[len(msgs)-1] if meta.Direction != "meta" { @@ -394,9 +401,10 @@ func TestStreamByteLimitStoresOneMetaRow(t *testing.T) { if dn, db := metaCounts(t, meta); dn != 2 || db != maxStreamPayload+1 { t.Fatalf("meta dropped_messages=%d dropped_bytes=%d", dn, db) } - var stored int64 - if err := tr.DB().QueryRow(`SELECT SUM(size) FROM stream_messages WHERE exchange_id=? AND direction<>'meta'`, id).Scan(&stored); err != nil || stored != maxStreamBytes { - t.Fatalf("stored %d bytes err=%v, want %d", stored, err, maxStreamBytes) + var stored, inline int64 + if err := tr.DB().QueryRow(`SELECT SUM(size), SUM(LENGTH(payload)) FROM stream_messages WHERE exchange_id=? AND direction<>'meta'`, id).Scan(&stored, &inline); err != nil || + stored != int64(kept*maxStreamPayload) || stored+inline > maxStreamBytes { + t.Fatalf("stored %d payload bytes + %d inline err=%v, want %d within %d", stored, inline, err, kept*maxStreamPayload, maxStreamBytes) } var respLen int64 if err := tr.DB().QueryRow(`SELECT resp_len FROM exchanges WHERE id=?`, id).Scan(&respLen); err != nil || respLen != int64(n*maxStreamPayload+1) { @@ -404,6 +412,81 @@ func TestStreamByteLimitStoresOneMetaRow(t *testing.T) { } } +// A payload over maxStreamInline goes to the blob store; the row returns at +// most 4 KiB and the hash, and the blob holds the whole payload. +func TestStreamPayloadSpillsAboveInlineLimit(t *testing.T) { + tr, s, f := unitStream(t, "spill.test") + bigText := []byte(strings.Repeat("0123456789", 1024)) // 10 KiB + bigBin := make([]byte, 10*1024) + for i := range bigBin { + bigBin[i] = byte(i) + } + small := []byte(strings.Repeat("s", 1024)) + addWS(f, true, websocket.TextMessage, bigText) + addWS(f, false, websocket.BinaryMessage, bigBin) + addWS(f, true, websocket.TextMessage, small) + s.WebSocketMessage(f) + msgs := allMessages(t, tr, onlyExchange(t, tr)) + if len(msgs) != 3 { + t.Fatalf("%d messages", len(msgs)) + } + text, bin, inline := msgs[0], msgs[1], msgs[2] + if text.Blob == "" || len(text.Payload) > streamPreview || text.Payload != string(bigText[:streamPreview]) || text.Size != len(bigText) || text.Truncated { + t.Fatalf("10 KiB text row: blob %q payload %d bytes size %d truncated %v", text.Blob, len(text.Payload), text.Size, text.Truncated) + } + if data, total, err := tr.BlobRange(text.Blob, 0, int64(len(bigText))); err != nil || total != int64(len(bigText)) || !bytes.Equal(data, bigText) { + t.Fatalf("text blob total=%d err=%v, want the full 10 KiB", total, err) + } + raw, err := base64.StdEncoding.DecodeString(bin.Payload) + if bin.Blob == "" || err != nil || !bytes.Equal(raw, bigBin[:streamPreview]) { + t.Fatalf("10 KiB binary row: blob %q preview %d bytes err=%v, want its first 4 KiB", bin.Blob, len(raw), err) + } + if data, total, err := tr.BlobRange(bin.Blob, 0, int64(len(bigBin))); err != nil || total != int64(len(bigBin)) || !bytes.Equal(data, bigBin) { + t.Fatalf("binary blob total=%d err=%v", total, err) + } + if inline.Blob != "" || inline.Payload != string(small) { + t.Fatalf("1 KiB row: blob %q payload %d bytes, want inline and complete", inline.Blob, len(inline.Payload)) + } +} + +// The server writes a message and closes at once; the message the client read +// must be recorded even though WebSocketEnd fires as soon as one direction ends. +func TestWebSocketFinalMessageOnClose(t *testing.T) { + tr, _, proxyURL := startProxy(t) + up := websocket.Upgrader{CheckOrigin: func(*http.Request) bool { return true }} + srv := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + c, err := up.Upgrade(w, r, nil) + if err != nil { + return + } + _ = c.WriteMessage(websocket.TextMessage, []byte("final")) + _ = c.WriteMessage(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseNormalClosure, "")) + _ = c.Close() + })) + t.Cleanup(srv.Close) + c, _, err := wsDialer(t, tr, proxyURL).Dial("wss://"+strings.TrimPrefix(localhostURL(srv.URL), "https://")+"/ws", nil) + if err != nil { + t.Fatal(err) + } + if _, got, err := c.ReadMessage(); err != nil || string(got) != "final" { + t.Fatalf("read %q err=%v", got, err) + } + _ = c.Close() + var id string + waitFor(t, "websocket end", func() bool { + exs := streamExchanges(t, tr, "websocket") + if len(exs) != 1 || exs[0].respLen == 0 { + return false + } + id = exs[0].id + return true + }) + msgs := allMessages(t, tr, id) + if len(msgs) != 1 || msgs[0].Direction != "s2c" || msgs[0].Payload != "final" { + t.Fatalf("messages %+v, want the final server message", msgs) + } +} + func TestDeleteHostRemovesStreamMessagesAndBlobs(t *testing.T) { tr, s, f := unitStream(t, "gone.test") addWS(f, false, websocket.BinaryMessage, bytes.Repeat([]byte{9}, maxInlineBody+1)) @@ -547,4 +630,8 @@ func TestLibMutexFound(t *testing.T) { if libMutex(&mproxy.WebSocketData{}) == nil || libMutex(&mproxy.SSEData{}) == nil { t.Fatal("go-mitmproxy WebSocketData/SSEData no longer have a sync.Mutex field named mu") } + // Without the lock nothing is read: no unlocked fallback. + if _, ok := lockLib(&struct{ Messages []int }{}); ok { + t.Fatal("lockLib reported a lock on a type without mu") + } } diff --git a/traffic/traffic.go b/traffic/traffic.go index 0f598d1..b6fe0f9 100644 --- a/traffic/traffic.go +++ b/traffic/traffic.go @@ -78,7 +78,7 @@ CREATE INDEX IF NOT EXISTS idx_blob_refs_ex ON blob_refs(exchange_id); CREATE TABLE IF NOT EXISTS stream_messages ( exchange_id TEXT NOT NULL, seq INTEGER NOT NULL, - ts INTEGER NOT NULL, -- unix milliseconds + ts INTEGER NOT NULL, -- unix seconds, like exchanges.ts direction TEXT NOT NULL, -- 'c2s' | 's2c' | 'meta' kind INTEGER NOT NULL, -- WebSocket opcode (1 text, 2 binary), 0 for SSE and meta event TEXT NOT NULL DEFAULT '', @@ -558,6 +558,12 @@ type storedBody struct { // are handed to the full-text index in full (up to maxIndexBody) — indexing is // independent of where the bytes end up. func (t *Traffic) spill(body []byte, contentType string) storedBody { + return t.spillAt(body, contentType, maxInlineBody) +} + +// spillAt is spill with the inline threshold as a parameter: bodies up to +// maxInline stay inline. Stream messages use a much lower one (maxStreamInline). +func (t *Traffic) spillAt(body []byte, contentType string, maxInline int) storedBody { if len(body) == 0 { return storedBody{} } @@ -568,7 +574,7 @@ func (t *Traffic) spill(body []byte, contentType string) storedBody { } return string(clipBytes(body, maxIndexBody)) } - if len(body) <= maxInlineBody { + if len(body) <= maxInline { return storedBody{inline: body, index: indexText()} }