forked from mirrors/homebox
121 lines
3 KiB
Go
121 lines
3 KiB
Go
package logger
|
|
|
|
import (
|
|
"encoding/json"
|
|
"io"
|
|
"os"
|
|
"runtime/debug"
|
|
"sync"
|
|
"time"
|
|
)
|
|
|
|
type Level int8
|
|
|
|
const (
|
|
LevelDebug Level = iota
|
|
LevelInfo
|
|
LevelError
|
|
LevelFatal
|
|
LevelOff
|
|
)
|
|
|
|
func (l Level) String() string {
|
|
switch l {
|
|
case LevelDebug:
|
|
return "DEBUG"
|
|
case LevelInfo:
|
|
return "INFO"
|
|
case LevelError:
|
|
return "ERROR"
|
|
case LevelFatal:
|
|
return "FATAL"
|
|
default:
|
|
return ""
|
|
}
|
|
}
|
|
|
|
type Props map[string]string
|
|
|
|
type Logger struct {
|
|
out io.Writer
|
|
minLevel Level
|
|
mu sync.Mutex
|
|
}
|
|
|
|
func New(out io.Writer, minLevel Level) *Logger {
|
|
return &Logger{
|
|
out: out,
|
|
minLevel: minLevel,
|
|
}
|
|
}
|
|
|
|
func (l *Logger) Debug(message string, properties map[string]string) {
|
|
l.print(LevelDebug, message, properties)
|
|
}
|
|
|
|
func (l *Logger) Info(message string, properties map[string]string) {
|
|
l.print(LevelInfo, message, properties)
|
|
}
|
|
|
|
func (l *Logger) Error(err error, properties map[string]string) {
|
|
l.print(LevelError, err.Error(), properties)
|
|
}
|
|
|
|
func (l *Logger) Fatal(err error, properties map[string]string) {
|
|
l.print(LevelFatal, err.Error(), properties)
|
|
os.Exit(1) // For entries at the FATAL level, we also terminate the application.
|
|
}
|
|
|
|
func (l *Logger) print(level Level, message string, properties map[string]string) (int, error) {
|
|
// If the severity level of the log entry is below the minimum severity for the
|
|
// logger, then return with no further action.
|
|
if level < l.minLevel {
|
|
return 0, nil
|
|
}
|
|
|
|
// Declare an anonymous struct holding the data for the log entry.
|
|
aux := struct {
|
|
Level string `json:"level"`
|
|
Time string `json:"time"`
|
|
Message string `json:"message"`
|
|
Properties map[string]string `json:"properties,omitempty"`
|
|
Trace string `json:"trace,omitempty"`
|
|
}{
|
|
Level: level.String(),
|
|
Time: time.Now().UTC().Format(time.RFC3339),
|
|
Message: message,
|
|
Properties: properties,
|
|
}
|
|
|
|
// Include a stack trace for entries at the ERROR and FATAL levels.
|
|
if level >= LevelError {
|
|
aux.Trace = string(debug.Stack())
|
|
}
|
|
|
|
// Declare a line variable for holding the actual log entry text.
|
|
var line []byte
|
|
|
|
// Marshal the anonymous struct to JSON and store it in the line variable. If there
|
|
// was a problem creating the JSON, set the contents of the log entry to be that
|
|
// plain-text error message instead.”
|
|
line, err := json.Marshal(aux)
|
|
if err != nil {
|
|
line = []byte(LevelError.String() + ": unable to marshal log message:" + err.Error())
|
|
}
|
|
|
|
// Lock the mutex so that no two writes to the output destination cannot happen
|
|
// concurrently. If we don't do this, it's possible that the text for two or more
|
|
// log entries will be intermingled in the output.
|
|
l.mu.Lock()
|
|
defer l.mu.Unlock()
|
|
|
|
// Write the log entry followed by a newline.
|
|
return l.out.Write(append(line, '\n'))
|
|
}
|
|
|
|
// We also implement a Write() method on our Logger type so that it satisfies the
|
|
// io.Writer interface. This writes a log entry at the ERROR level with no additional
|
|
// properties.
|
|
func (l *Logger) Write(message []byte) (n int, err error) {
|
|
return l.print(LevelError, string(message), nil)
|
|
}
|