File size: 2,960 Bytes
cf4a594 | 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 log
import (
"bytes"
"context"
"encoding/json"
"io"
"log/slog"
"net/http"
"strings"
"time"
)
// NewHTTPClient creates an HTTP client with debug logging enabled when debug mode is on.
func NewHTTPClient() *http.Client {
if !slog.Default().Enabled(context.TODO(), slog.LevelDebug) {
return http.DefaultClient
}
return &http.Client{
Transport: &HTTPRoundTripLogger{
Transport: http.DefaultTransport,
},
}
}
// HTTPRoundTripLogger is an http.RoundTripper that logs requests and responses.
type HTTPRoundTripLogger struct {
Transport http.RoundTripper
}
// RoundTrip implements http.RoundTripper interface with logging.
func (h *HTTPRoundTripLogger) RoundTrip(req *http.Request) (*http.Response, error) {
var err error
var save io.ReadCloser
save, req.Body, err = drainBody(req.Body)
if err != nil {
slog.Error(
"HTTP request failed",
"method", req.Method,
"url", req.URL,
"error", err,
)
return nil, err
}
slog.Debug(
"HTTP Request",
"method", req.Method,
"url", req.URL,
"body", bodyToString(save),
)
start := time.Now()
resp, err := h.Transport.RoundTrip(req)
duration := time.Since(start)
if err != nil {
slog.Error(
"HTTP request failed",
"method", req.Method,
"url", req.URL,
"duration_ms", duration.Milliseconds(),
"error", err,
)
return resp, err
}
save, resp.Body, err = drainBody(resp.Body)
slog.Debug(
"HTTP Response",
"status_code", resp.StatusCode,
"status", resp.Status,
"headers", formatHeaders(resp.Header),
"body", bodyToString(save),
"content_length", resp.ContentLength,
"duration_ms", duration.Milliseconds(),
"error", err,
)
return resp, err
}
func bodyToString(body io.ReadCloser) string {
if body == nil {
return ""
}
src, err := io.ReadAll(body)
if err != nil {
slog.Error("Failed to read body", "error", err)
return ""
}
var b bytes.Buffer
if json.Compact(&b, bytes.TrimSpace(src)) != nil {
// not json probably
return string(src)
}
return b.String()
}
// formatHeaders formats HTTP headers for logging, filtering out sensitive information.
func formatHeaders(headers http.Header) map[string][]string {
filtered := make(map[string][]string)
for key, values := range headers {
lowerKey := strings.ToLower(key)
// Filter out sensitive headers
if strings.Contains(lowerKey, "authorization") ||
strings.Contains(lowerKey, "api-key") ||
strings.Contains(lowerKey, "token") ||
strings.Contains(lowerKey, "secret") {
filtered[key] = []string{"[REDACTED]"}
} else {
filtered[key] = values
}
}
return filtered
}
func drainBody(b io.ReadCloser) (r1, r2 io.ReadCloser, err error) {
if b == nil || b == http.NoBody {
return http.NoBody, http.NoBody, nil
}
var buf bytes.Buffer
if _, err = buf.ReadFrom(b); err != nil {
return nil, b, err
}
if err = b.Close(); err != nil {
return nil, b, err
}
return io.NopCloser(&buf), io.NopCloser(bytes.NewReader(buf.Bytes())), nil
}
|