136 lines
2.7 KiB
Go
136 lines
2.7 KiB
Go
package logging
|
|
|
|
import (
|
|
"fmt"
|
|
"io"
|
|
"sync"
|
|
"time"
|
|
)
|
|
|
|
type Logger interface {
|
|
// Error logs an error message.
|
|
Error(msg ...any)
|
|
// Errorf logs a formatted error message.
|
|
Errorf(format string, args ...any)
|
|
// Warn logs a warning message.
|
|
Warn(msg ...any)
|
|
// Warnf logs a formatted warning message.
|
|
Warnf(format string, args ...any)
|
|
// Info logs an info message.
|
|
Info(msg ...any)
|
|
// Infof logs a formatted info message.
|
|
Infof(format string, args ...any)
|
|
// Log prints a line to the output writer with a header.
|
|
Log(msg ...any)
|
|
// Logf prints a formatted line to the output writer with a header.
|
|
Logf(format string, args ...any)
|
|
|
|
// Verbose returns the logger instance if verbose logging is enabled, and otherwise returns nil.
|
|
// A nil logger created with `logging.NewLogger` is safe to call methods on.
|
|
Verbose() Logger
|
|
// IsVerbose returns true if verbose logging is enabled, and false otherwise.
|
|
IsVerbose() bool
|
|
// SetVerbose sets the verbose logging flag.
|
|
SetVerbose(verbose bool)
|
|
}
|
|
|
|
var _ Logger = (*logger)(nil)
|
|
|
|
type logger struct {
|
|
mu sync.Mutex
|
|
verbose bool
|
|
writer io.Writer
|
|
prefix func() string
|
|
}
|
|
|
|
func (l *logger) Log(msg ...any) {
|
|
if l == nil {
|
|
return
|
|
}
|
|
l.mu.Lock()
|
|
defer l.mu.Unlock()
|
|
fmt.Fprintln(l.writer, l.prefix(), fmt.Sprint(msg...))
|
|
}
|
|
|
|
func (l *logger) Logf(format string, args ...any) {
|
|
if l == nil {
|
|
return
|
|
}
|
|
l.mu.Lock()
|
|
defer l.mu.Unlock()
|
|
fmt.Fprintf(l.writer, "%s %s\n", l.prefix(), fmt.Sprintf(format, args...))
|
|
}
|
|
|
|
func (l *logger) Verbose() Logger {
|
|
if l == nil {
|
|
return nil
|
|
}
|
|
l.mu.Lock()
|
|
defer l.mu.Unlock()
|
|
if !l.verbose {
|
|
return nil
|
|
}
|
|
return l
|
|
}
|
|
|
|
func (l *logger) IsVerbose() bool {
|
|
if l == nil {
|
|
return false
|
|
}
|
|
l.mu.Lock()
|
|
defer l.mu.Unlock()
|
|
return l.verbose
|
|
}
|
|
|
|
func (l *logger) SetVerbose(verbose bool) {
|
|
if l == nil {
|
|
return
|
|
}
|
|
l.mu.Lock()
|
|
defer l.mu.Unlock()
|
|
l.verbose = verbose
|
|
}
|
|
|
|
func (l *logger) Error(msg ...any) {
|
|
l.Log(msg...)
|
|
}
|
|
|
|
func (l *logger) Errorf(format string, args ...any) {
|
|
l.Logf(format, args...)
|
|
}
|
|
|
|
func (l *logger) Warn(msg ...any) {
|
|
l.Log(msg...)
|
|
}
|
|
|
|
func (l *logger) Warnf(format string, args ...any) {
|
|
l.Logf(format, args...)
|
|
}
|
|
|
|
func (l *logger) Info(msg ...any) {
|
|
l.Log(msg...)
|
|
}
|
|
|
|
func (l *logger) Infof(format string, args ...any) {
|
|
l.Logf(format, args...)
|
|
}
|
|
|
|
func NewLogger(output io.Writer) Logger {
|
|
return &logger{
|
|
writer: output,
|
|
prefix: func() string {
|
|
return formatTime(time.Now())
|
|
},
|
|
}
|
|
}
|
|
|
|
// NewNopLogger returns a no-op Logger that discards all log messages.
|
|
// It is safe to call any method on the returned Logger.
|
|
func NewNopLogger() Logger {
|
|
return (*logger)(nil)
|
|
}
|
|
|
|
func formatTime(t time.Time) string {
|
|
return fmt.Sprintf("[%s]", t.Format("15:04:05.000"))
|
|
}
|