-
Notifications
You must be signed in to change notification settings - Fork 6
/
logger.go
127 lines (104 loc) · 3.84 KB
/
logger.go
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
package slogctx
import (
"context"
"fmt"
"log/slog"
"runtime"
"time"
)
// Logger implements a wrapper around [slog.Logger] that adds formatter functions (e.g. Infof, Errorf)
type Logger struct {
slog.Logger
}
// DefaultLogger returns a new logger that uses the default [slog.Logger].
func DefaultLogger() *Logger {
return NewLogger(slog.Default())
}
// NewLogger returns a new logger that wraps the given [slog.Logger].
func NewLogger(l *slog.Logger) *Logger {
if l == nil {
l = slog.Default()
}
return &Logger{Logger: *l}
}
// New returns a new logger that wraps the given [slog.Handler].
func New(h slog.Handler) *Logger {
return NewLogger(slog.New(h))
}
// With calls [Logger.With] on the default logger.
func With(args ...any) *Logger {
return DefaultLogger().With(args...)
}
// With calls [Logger.With] on the logger.
func (l *Logger) With(args ...any) *Logger {
return NewLogger(l.Logger.With(args...))
}
// WithGroup calls [Logger.WithGroup] on the default logger.
func (l *Logger) WithGroup(name string) *Logger {
return NewLogger(l.Logger.WithGroup(name))
}
// Infof logs at LevelInfo with the given format and arguments.
func (l *Logger) Infof(format string, args ...any) {
wrapf(context.Background(), l, slog.LevelInfo, format, args...)
}
// InfoContextf logs at LevelInfo with the given context, format and arguments.
func (l *Logger) InfoContextf(ctx context.Context, format string, args ...any) {
wrapf(ctx, l, slog.LevelInfo, format, args...)
}
// Warnf logs at LevelWarn with the given format and arguments.
func (l *Logger) Warnf(format string, args ...any) {
wrapf(context.Background(), l, slog.LevelWarn, format, args...)
}
// WarnContextf logs at LevelWarn with the given context, format and arguments.
func (l *Logger) WarnContextf(ctx context.Context, format string, args ...any) {
wrapf(ctx, l, slog.LevelWarn, format, args...)
}
// Errorf logs at LevelError with the given format and arguments.
func (l *Logger) Errorf(format string, args ...any) {
wrapf(context.Background(), l, slog.LevelError, format, args...)
}
// ErrorContextf logs at LevelError with the given context, format and arguments.
func (l *Logger) ErrorContextf(ctx context.Context, format string, args ...any) {
wrapf(ctx, l, slog.LevelError, format, args...)
}
// Debugf logs at LevelDebug with the given format and arguments.
func (l *Logger) Debugf(format string, args ...any) {
wrapf(context.Background(), l, slog.LevelDebug, format, args...)
}
// DebugContextf logs at LevelDebug with the given context, format and arguments.
func (l *Logger) DebugContextf(ctx context.Context, format string, args ...any) {
wrapf(ctx, l, slog.LevelDebug, format, args...)
}
// Base returns the underlying [slog.Logger].
func (l *Logger) Base() *slog.Logger {
return &l.Logger
}
// Handler returns the underlying [slog.Handler].
func (l *Logger) Handler() slog.Handler {
return l.Logger.Handler()
}
func wrap(ctx context.Context, logger *Logger, level slog.Level, msg string, args ...any) {
var pcs [1]uintptr
runtime.Callers(3, pcs[:]) // skip [Callers, Infof, wrapf]
r := slog.NewRecord(time.Now(), level, msg, pcs[0])
r.Add(args...)
_ = logger.Handler().Handle(ctx, r)
}
// wrapf is like wrap, but uses fmt.Sprintf to format the message.
// NOTE: args are passed to fmt.Sprintf, not as [slog.Attr].
func wrapf(ctx context.Context, logger *Logger, level slog.Level, format string, args ...any) {
var pcs [1]uintptr
runtime.Callers(3, pcs[:]) // skip [Callers, Infof, wrapf]
r := slog.NewRecord(time.Now(), level, fmt.Sprintf(format, args...), pcs[0])
_ = logger.Handler().Handle(ctx, r)
}
type loggerKey struct{}
func WithLogger(ctx context.Context, logger *Logger) context.Context {
return context.WithValue(ctx, loggerKey{}, logger)
}
func FromContext(ctx context.Context) *Logger {
if logger, ok := ctx.Value(loggerKey{}).(*Logger); ok {
return logger
}
return DefaultLogger()
}