forked from mirrors/gotosocial
153 lines
4.5 KiB
Go
153 lines
4.5 KiB
Go
package logger
|
|
|
|
import (
|
|
"context"
|
|
"io"
|
|
"os"
|
|
"sync"
|
|
"sync/atomic"
|
|
|
|
"codeberg.org/gruf/go-bytes"
|
|
)
|
|
|
|
type Logger struct {
|
|
// Hooks defines a list of hooks which are called before an entry
|
|
// is written. This should NOT be modified while the Logger is in use
|
|
Hooks []Hook
|
|
|
|
// Level is the current log LEVEL, entries at level below the
|
|
// currently set level will not be output. This should NOT
|
|
// be modified while the Logger is in use
|
|
Level LEVEL
|
|
|
|
// Timestamp defines whether to automatically append timestamps
|
|
// to entries written via Logger convience methods and specifically
|
|
// Entry.TimestampIf(). This should NOT be modified while Logger in use
|
|
Timestamp bool
|
|
|
|
// Format is the log entry LogFormat to use. This should NOT
|
|
// be modified while the Logger is in use
|
|
Format LogFormat
|
|
|
|
// BufferSize is the Entry buffer size to use when allocating
|
|
// new Entry objects. This should be modified atomically
|
|
BufSize int64
|
|
|
|
// Output is the log's output writer. This should NOT be
|
|
// modified while the Logger is in use
|
|
Output io.Writer
|
|
|
|
// entry pool
|
|
pool sync.Pool
|
|
}
|
|
|
|
// New returns a new Logger instance with defaults
|
|
func New(out io.Writer) *Logger {
|
|
return NewWith(0 /* all */, true, DefaultTextFormat, 512, out)
|
|
}
|
|
|
|
// NewWith returns a new Logger instance with supplied configuration
|
|
func NewWith(lvl LEVEL, timestamp bool, fmt LogFormat, bufsize int64, out io.Writer) *Logger {
|
|
// Create new logger object
|
|
log := &Logger{
|
|
Level: lvl,
|
|
Timestamp: timestamp,
|
|
Format: fmt,
|
|
BufSize: bufsize,
|
|
Output: out,
|
|
pool: sync.Pool{},
|
|
}
|
|
|
|
// Ensure clock running
|
|
startClock()
|
|
|
|
// Set-up logger Entry pool
|
|
log.pool.New = func() interface{} {
|
|
return &Entry{
|
|
lvl: unset,
|
|
buf: &bytes.Buffer{B: make([]byte, 0, atomic.LoadInt64(&log.BufSize))},
|
|
log: log,
|
|
}
|
|
}
|
|
|
|
return log
|
|
}
|
|
|
|
// Entry returns a new Entry from the Logger's pool with background context
|
|
func (l *Logger) Entry() *Entry {
|
|
return l.pool.Get().(*Entry).WithContext(context.Background())
|
|
}
|
|
|
|
// Debug prints the provided arguments with the debug prefix
|
|
func (l *Logger) Debug(a ...interface{}) {
|
|
l.Entry().TimestampIf().Level(DEBUG).Hooks().Msg(a...)
|
|
}
|
|
|
|
// Debugf prints the provided format string and arguments with the debug prefix
|
|
func (l *Logger) Debugf(s string, a ...interface{}) {
|
|
l.Entry().TimestampIf().Level(DEBUG).Hooks().Msgf(s, a...)
|
|
}
|
|
|
|
// Info prints the provided arguments with the info prefix
|
|
func (l *Logger) Info(a ...interface{}) {
|
|
l.Entry().TimestampIf().Level(INFO).Hooks().Msg(a...)
|
|
}
|
|
|
|
// Infof prints the provided format string and arguments with the info prefix
|
|
func (l *Logger) Infof(s string, a ...interface{}) {
|
|
l.Entry().TimestampIf().Level(INFO).Hooks().Msgf(s, a...)
|
|
}
|
|
|
|
// Warn prints the provided arguments with the warn prefix
|
|
func (l *Logger) Warn(a ...interface{}) {
|
|
l.Entry().TimestampIf().Level(WARN).Hooks().Msg(a...)
|
|
}
|
|
|
|
// Warnf prints the provided format string and arguments with the warn prefix
|
|
func (l *Logger) Warnf(s string, a ...interface{}) {
|
|
l.Entry().TimestampIf().Level(WARN).Hooks().Msgf(s, a...)
|
|
}
|
|
|
|
// Error prints the provided arguments with the error prefix
|
|
func (l *Logger) Error(a ...interface{}) {
|
|
l.Entry().TimestampIf().Level(ERROR).Hooks().Msg(a...)
|
|
}
|
|
|
|
// Errorf prints the provided format string and arguments with the error prefix
|
|
func (l *Logger) Errorf(s string, a ...interface{}) {
|
|
l.Entry().TimestampIf().Level(ERROR).Hooks().Msgf(s, a...)
|
|
}
|
|
|
|
// Fatal prints provided arguments with the fatal prefix before exiting the program
|
|
// with os.Exit(1)
|
|
func (l *Logger) Fatal(a ...interface{}) {
|
|
defer os.Exit(1)
|
|
l.Entry().TimestampIf().Level(FATAL).Hooks().Msg(a...)
|
|
}
|
|
|
|
// Fatalf prints provided the provided format string and arguments with the fatal prefix
|
|
// before exiting the program with os.Exit(1)
|
|
func (l *Logger) Fatalf(s string, a ...interface{}) {
|
|
defer os.Exit(1)
|
|
l.Entry().TimestampIf().Level(FATAL).Hooks().Msgf(s, a...)
|
|
}
|
|
|
|
// Log prints the provided arguments with the supplied log level
|
|
func (l *Logger) Log(lvl LEVEL, a ...interface{}) {
|
|
l.Entry().TimestampIf().Hooks().Msg(a...)
|
|
}
|
|
|
|
// Logf prints the provided format string and arguments with the supplied log level
|
|
func (l *Logger) Logf(lvl LEVEL, s string, a ...interface{}) {
|
|
l.Entry().TimestampIf().Hooks().Msgf(s, a...)
|
|
}
|
|
|
|
// Print simply prints provided arguments
|
|
func (l *Logger) Print(a ...interface{}) {
|
|
l.Entry().Hooks().Msg(a...)
|
|
}
|
|
|
|
// Printf simply prints provided the provided format string and arguments
|
|
func (l *Logger) Printf(s string, a ...interface{}) {
|
|
l.Entry().Hooks().Msgf(s, a...)
|
|
}
|