/
logger.go
164 lines (137 loc) · 3.9 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
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
// Copyright (c) 2021 - 2024, Ludvig Lundgren and the autobrr contributors.
// SPDX-License-Identifier: GPL-2.0-or-later
package logger
import (
"io"
"os"
"time"
"github.com/autobrr/autobrr/internal/domain"
"github.com/r3labs/sse/v2"
"github.com/rs/zerolog"
"github.com/rs/zerolog/pkgerrors"
"gopkg.in/natefinch/lumberjack.v2"
)
// Logger interface
type Logger interface {
Log() *zerolog.Event
Fatal() *zerolog.Event
Err(err error) *zerolog.Event
Error() *zerolog.Event
Warn() *zerolog.Event
Info() *zerolog.Event
Trace() *zerolog.Event
Debug() *zerolog.Event
With() zerolog.Context
RegisterSSEWriter(sse *sse.Server)
SetLogLevel(level string)
Printf(format string, v ...interface{})
Print(v ...interface{})
}
// DefaultLogger default logging controller
type DefaultLogger struct {
log zerolog.Logger
level zerolog.Level
writers []io.Writer
}
func New(cfg *domain.Config) Logger {
l := &DefaultLogger{
writers: make([]io.Writer, 0),
level: zerolog.DebugLevel,
}
// set log level
l.SetLogLevel(cfg.LogLevel)
// use pretty logging for dev only
if cfg.Version == "dev" {
// setup console writer
consoleWriter := zerolog.ConsoleWriter{Out: os.Stderr, TimeFormat: time.RFC3339}
l.writers = append(l.writers, consoleWriter)
} else {
// default to stderr
l.writers = append(l.writers, os.Stderr)
}
if cfg.LogPath != "" {
l.writers = append(l.writers,
&lumberjack.Logger{
Filename: cfg.LogPath,
MaxSize: cfg.LogMaxSize, // megabytes
MaxBackups: cfg.LogMaxBackups,
},
)
}
// set some defaults
zerolog.TimeFieldFormat = time.RFC3339
zerolog.ErrorStackMarshaler = pkgerrors.MarshalStack
// init new logger
l.log = zerolog.New(io.MultiWriter(l.writers...)).With().Stack().Logger()
return l
}
func (l *DefaultLogger) RegisterSSEWriter(sse *sse.Server) {
w := NewSSEWriter(sse)
l.writers = append(l.writers, w)
l.log = zerolog.New(io.MultiWriter(l.writers...)).With().Stack().Logger()
}
func (l *DefaultLogger) SetLogLevel(level string) {
switch level {
case "INFO":
l.level = zerolog.InfoLevel
zerolog.SetGlobalLevel(zerolog.InfoLevel)
case "DEBUG":
l.level = zerolog.DebugLevel
zerolog.SetGlobalLevel(zerolog.DebugLevel)
case "ERROR":
l.level = zerolog.ErrorLevel
case "WARN":
l.level = zerolog.WarnLevel
case "TRACE":
l.level = zerolog.TraceLevel
zerolog.SetGlobalLevel(zerolog.TraceLevel)
default:
l.level = zerolog.Disabled
}
}
// Log log something at fatal level.
func (l *DefaultLogger) Log() *zerolog.Event {
return l.log.Log().Timestamp()
}
// Fatal log something at fatal level. This will panic!
func (l *DefaultLogger) Fatal() *zerolog.Event {
return l.log.Fatal().Timestamp()
}
// Error log something at Error level
func (l *DefaultLogger) Error() *zerolog.Event {
return l.log.Error().Timestamp()
}
// Err log something at Err level
func (l *DefaultLogger) Err(err error) *zerolog.Event {
return l.log.Err(err).Timestamp()
}
// Warn log something at warning level.
func (l *DefaultLogger) Warn() *zerolog.Event {
return l.log.Warn().Timestamp()
}
// Info log something at fatal level.
func (l *DefaultLogger) Info() *zerolog.Event {
return l.log.Info().Timestamp()
}
// Debug log something at debug level.
func (l *DefaultLogger) Debug() *zerolog.Event {
return l.log.Debug().Timestamp()
}
// Trace log something at fatal level. This will panic!
func (l *DefaultLogger) Trace() *zerolog.Event {
return l.log.Trace().Timestamp()
}
// Print sends a log event using debug level and no extra field.
// Arguments are handled in the manner of fmt.Print.
func (l *DefaultLogger) Print(v ...interface{}) {
l.log.Print(v...)
}
// Printf sends a log event using debug level and no extra field.
// Arguments are handled in the manner of fmt.Printf.
func (l *DefaultLogger) Printf(format string, v ...interface{}) {
l.log.Printf(format, v...)
}
// With log with context
func (l *DefaultLogger) With() zerolog.Context {
return l.log.With().Timestamp()
}