1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
|
// Package store persists proxy history to SQLite in WAL mode. Request
// and response bytes are stored as-received where possible (see the
// Exact fields) rather than re-serialized from a parsed representation.
package store
import (
"database/sql"
"fmt"
"time"
_ "modernc.org/sqlite"
)
const schema = `
CREATE TABLE IF NOT EXISTS history (
id INTEGER PRIMARY KEY AUTOINCREMENT,
started_at INTEGER NOT NULL,
duration_ms INTEGER NOT NULL,
method TEXT NOT NULL,
scheme TEXT NOT NULL,
host TEXT NOT NULL,
path TEXT NOT NULL,
status_code INTEGER,
request_raw BLOB NOT NULL,
response_raw BLOB,
request_exact INTEGER NOT NULL,
response_exact INTEGER NOT NULL,
error TEXT NOT NULL DEFAULT ''
);
`
// Store is a handle to the history database. Safe for concurrent use.
type Store struct {
db *sql.DB
}
// Open opens (creating if needed) the SQLite database at path in WAL mode.
func Open(path string) (*Store, error) {
db, err := sql.Open("sqlite", path)
if err != nil {
return nil, fmt.Errorf("open db: %w", err)
}
// modernc.org/sqlite has no real connection pooling benefit here and
// SQLite only supports one writer at a time; serializing access
// through a single connection avoids SQLITE_BUSY entirely.
db.SetMaxOpenConns(1)
for _, pragma := range []string{
"PRAGMA journal_mode = WAL",
"PRAGMA synchronous = NORMAL",
"PRAGMA foreign_keys = ON",
} {
if _, err := db.Exec(pragma); err != nil {
db.Close()
return nil, fmt.Errorf("%s: %w", pragma, err)
}
}
if _, err := db.Exec(schema); err != nil {
db.Close()
return nil, fmt.Errorf("create schema: %w", err)
}
return &Store{db: db}, nil
}
// Close closes the underlying database.
func (s *Store) Close() error {
return s.db.Close()
}
// Entry is one captured request/response pair.
type Entry struct {
ID int64
StartedAt time.Time
Duration time.Duration
Method string
Scheme string
Host string
Path string
StatusCode int // 0 if no response was received
RequestRaw []byte
ResponseRaw []byte // nil if no response was received
RequestExact bool // true if RequestRaw is wire-exact, false if reconstructed (e.g. HTTP/2)
ResponseExact bool
Error string // network/transport error, if the request never got a response
}
// Summary is the lightweight metadata used for the history list view -
// no request/response bodies.
type Summary struct {
ID int64
StartedAt time.Time
Duration time.Duration
Method string
Scheme string
Host string
Path string
StatusCode int
ReqSize int
RespSize int
Error string
}
// Insert stores e and returns its assigned ID.
func (s *Store) Insert(e *Entry) (int64, error) {
var statusCode any
if e.StatusCode != 0 {
statusCode = e.StatusCode
}
res, err := s.db.Exec(
`INSERT INTO history
(started_at, duration_ms, method, scheme, host, path, status_code,
request_raw, response_raw, request_exact, response_exact, error)
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
e.StartedAt.UnixMilli(), e.Duration.Milliseconds(), e.Method, e.Scheme, e.Host, e.Path,
statusCode, e.RequestRaw, e.ResponseRaw, boolToInt(e.RequestExact), boolToInt(e.ResponseExact), e.Error,
)
if err != nil {
return 0, fmt.Errorf("insert history entry: %w", err)
}
return res.LastInsertId()
}
// List returns up to limit history summaries older than beforeID (or the
// most recent if beforeID is 0), newest first.
func (s *Store) List(limit int, beforeID int64) ([]Summary, error) {
if limit <= 0 || limit > 1000 {
limit = 200
}
if beforeID <= 0 {
beforeID = 1<<63 - 1
}
rows, err := s.db.Query(
`SELECT id, started_at, duration_ms, method, scheme, host, path,
COALESCE(status_code, 0), length(request_raw), COALESCE(length(response_raw), 0), error
FROM history WHERE id < ? ORDER BY id DESC LIMIT ?`,
beforeID, limit,
)
if err != nil {
return nil, fmt.Errorf("list history: %w", err)
}
defer rows.Close()
var out []Summary
for rows.Next() {
var sum Summary
var startedAt, durationMs int64
if err := rows.Scan(&sum.ID, &startedAt, &durationMs, &sum.Method, &sum.Scheme, &sum.Host, &sum.Path,
&sum.StatusCode, &sum.ReqSize, &sum.RespSize, &sum.Error); err != nil {
return nil, fmt.Errorf("scan history row: %w", err)
}
sum.StartedAt = time.UnixMilli(startedAt)
sum.Duration = time.Duration(durationMs) * time.Millisecond
out = append(out, sum)
}
return out, rows.Err()
}
// Get returns the full entry (including raw bytes) for id.
func (s *Store) Get(id int64) (*Entry, error) {
row := s.db.QueryRow(
`SELECT id, started_at, duration_ms, method, scheme, host, path,
COALESCE(status_code, 0), request_raw, response_raw,
request_exact, response_exact, error
FROM history WHERE id = ?`,
id,
)
var e Entry
var startedAt, durationMs int64
var reqExact, respExact int
if err := row.Scan(&e.ID, &startedAt, &durationMs, &e.Method, &e.Scheme, &e.Host, &e.Path,
&e.StatusCode, &e.RequestRaw, &e.ResponseRaw, &reqExact, &respExact, &e.Error); err != nil {
return nil, fmt.Errorf("get history entry %d: %w", id, err)
}
e.StartedAt = time.UnixMilli(startedAt)
e.Duration = time.Duration(durationMs) * time.Millisecond
e.RequestExact = reqExact != 0
e.ResponseExact = respExact != 0
return &e, nil
}
func boolToInt(b bool) int {
if b {
return 1
}
return 0
}
|