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
|
package logging
import (
"context"
"crypto/sha256"
"encoding/hex"
"errors"
"io"
"time"
sr "tildegit.org/tjp/sliderule"
)
func LogRequests(logger Logger) sr.Middleware {
return func(inner sr.Handler) sr.Handler {
return sr.HandlerFunc(func(ctx context.Context, request *sr.Request) *sr.Response {
start := time.Now()
response := inner.Handle(ctx, request)
if response != nil {
response.Body = loggingBody(logger, request, response, start)
} else {
end := time.Now()
params := []any{
"msg", "request",
"ts", end.UTC(),
"dur", end.Sub(start),
"url", request.URL,
"status", "(not found)",
}
if fingerprint, ok := clientFingerprint(request); ok {
params = append(params, "client_ident", fingerprint)
}
_ = logger.Log(params...)
}
return response
})
}
}
func clientFingerprint(request *sr.Request) (string, bool) {
if request.TLSState == nil || len(request.TLSState.PeerCertificates) == 0 {
return "", false
}
digest := sha256.Sum256(request.TLSState.PeerCertificates[0].Raw)
return hex.EncodeToString(digest[:]), true
}
type loggedResponseBody struct {
request *sr.Request
response *sr.Response
body io.Reader
start time.Time
written int
logger Logger
}
func (lr *loggedResponseBody) log() {
end := time.Now()
params := []any{
"msg", "request",
"ts", end.UTC(),
"dur", end.Sub(lr.start),
"url", lr.request.URL,
"status", lr.response.Status,
"bodylen", lr.written,
}
if fingerprint, ok := clientFingerprint(lr.request); ok {
params = append(params, "client_ident", fingerprint)
}
_ = lr.logger.Log(params...)
}
func (lr *loggedResponseBody) Read(b []byte) (int, error) {
if lr.body == nil {
lr.log()
return 0, io.EOF
}
wr, err := lr.body.Read(b)
lr.written += wr
if errors.Is(err, io.EOF) {
lr.log()
}
return wr, err
}
func (lr *loggedResponseBody) Close() error {
if cl, ok := lr.body.(io.Closer); ok {
return cl.Close()
}
return nil
}
type loggedWriteToResponseBody struct {
*loggedResponseBody
}
func (lwtr loggedWriteToResponseBody) WriteTo(dst io.Writer) (int64, error) {
n, err := lwtr.body.(io.WriterTo).WriteTo(dst)
if err == nil {
lwtr.written += int(n)
lwtr.log()
}
return n, err
}
func loggingBody(logger Logger, request *sr.Request, response *sr.Response, start time.Time) io.Reader {
body := &loggedResponseBody{
request: request,
response: response,
body: response.Body,
start: start,
written: 0,
logger: logger,
}
if _, ok := response.Body.(io.WriterTo); ok {
return loggedWriteToResponseBody{body}
}
return body
}
|
