logfrog-go/logger.go

package logfrog

import (
	"fmt"
	"time"
)

type Logger struct {
    name            string
    level           LogLevel

    processors      []LogProcessor
    processorFuncs  []LogProcessorFn

    handlers        []LogHandler
}

// --------------------------------------------------------------------------------

func NewLogger(name string, level LogLevel) *Logger {
    return &Logger{
        name: name,
        level: level,
    }
}

// --------------------------------------------------------------------------------

func (l *Logger) GetName() string {
    return l.name
}

func (l *Logger) GetLevel() LogLevel {
    return l.level
}

// --------------------------------------------------------------------------------

func (l *Logger) IsTrace() bool {
    return l.level <= TRACE
}

func (l *Logger) IsDebug() bool {
    return l.level <= DEBUG
}

func (l *Logger) IsInfo() bool {
    return l.level <= INFO
}

func (l *Logger) IsError() bool {
    return l.level <= ERROR
}

func (l *Logger) IsCritical() bool {
    return l.level <= CRITICAL
}

func (l *Logger) IsFatal() bool {
    return l.level <= FATAL
}

// --------------------------------------------------------------------------------

// Adds an processor to modify/enhance log-entries before they are send to each handler
func (l *Logger) AddProcessorFn(fn LogProcessorFn) {
    l.processorFuncs = append(l.processorFuncs, fn)
}

// Removes an processor function previously added by AddProcessorFn
func (l *Logger) RemoveProcessorFn(fn LogProcessorFn) {
    l.processorFuncs = deleteFrom(l.processorFuncs, fn)
}

func (l *Logger) AddProcessor(p LogProcessor) {
    p.Ref()
    l.processors = append(l.processors, p)
    l.processorFuncs = append(l.processorFuncs, p.Process)
}

func (l *Logger) RemoveProcessor(p LogProcessor) error {
    l.processors = deleteFrom(l.processors, p)
    l.processorFuncs = deleteFrom(l.processorFuncs, p.Process)
    return p.Unref()
}

// --------------------------------------------------------------------------------

func (l *Logger) AddHandler(handler LogHandler) {
    handler.Ref();
    l.handlers = append(l.handlers, handler)
}

func (l *Logger) RemoveHandler(handler LogHandler) error {
    l.handlers = deleteFrom(l.handlers, handler)
    return handler.Unref()
}

func (l *Logger) handle(r *LogRecord) {
    for _, process := range l.processorFuncs {
        lr := process(r)
        if lr != nil {
            r = lr
        }
    }

    for _, handler := range l.handlers {
        handled, err := handler.Handle(r.Clone())

        if err != nil {
            panic(err)
        }

        if handled {
            break
        }
    }
}

// --------------------------------------------------------------------------------

func (l *Logger) Log(skip int, level LogLevel, format string, v ...interface{}) {
    created_at := time.Now()
    if l.level <= level {
        msg := fmt.Sprintf(format, v...)
        l.handle(newLogRecordFromSource(l, skip + 1, created_at, level, msg, nil))
    }
}

func (l *Logger) Trace(format string, v ...interface{}) {
    l.Log(1, TRACE, format, v...)
}

func (l *Logger) Debug(format string, v ...interface{}) {
    l.Log(1, DEBUG, format, v...)
}

func (l *Logger) Info(format string, v ...interface{}) {
    l.Log(1, INFO, format, v...)
}

func (l *Logger) Warn(format string, v ...interface{}) {
    l.Log(1, WARN, format, v...)
}

func (l *Logger) Error(format string, v ...interface{}) {
    l.Log(1, ERROR, format, v...)
}

func (l *Logger) Critical(format string, v ...interface{}) {
    l.Log(1, CRITICAL, format, v...)
}

func (l *Logger) Fatal(format string, v ...interface{}) {
    l.Log(1, FATAL, format, v...)
}

// --------------------------------------------------------------------------------

func (l *Logger) LogFields(skip int, level LogLevel, fields Fields, format string, v ...interface{}) {
    created_at := time.Now()
    if l.level <= level {
        msg := fmt.Sprintf(format, v...)
        l.handle(newLogRecordFromSource(l, skip + 1, created_at, level, msg, nil))
    }
}

func (l *Logger) TraceFields(fields Fields, format string, v ...interface{}) {
    l.LogFields(1, TRACE, fields, format, v...)
}

func (l *Logger) DebugFields(fields Fields, format string, v ...interface{}) {
    l.LogFields(1, DEBUG, fields, format, v...)
}

func (l *Logger) InfoFields(fields Fields, format string, v ...interface{}) {
    l.LogFields(1, INFO, fields, format, v...)
}

func (l *Logger) WarnFields(fields Fields, format string, v ...interface{}) {
    l.LogFields(1, WARN, fields, format, v...)
}

func (l *Logger) ErrorFields(fields Fields, format string, v ...interface{}) {
    l.LogFields(1, ERROR, fields, format, v...)
}

func (l *Logger) CriticalFields(fields Fields, format string, v ...interface{}) {
    l.LogFields(1, CRITICAL, fields, format, v...)
}

func (l *Logger) FatalFields(fields Fields, format string, v ...interface{}) {
    l.LogFields(1, FATAL, fields, format, v...)
}

// --------------------------------------------------------------------------------

// Closing a logger means we unref all handlers
func (l *Logger) Close() error {
    lerr := &ErrLoggerCloseFailure{}

    for _, processor := range l.processors {
        err := processor.Unref()
        if err != nil {
            lerr.addProcessorError(processor, err)
        }
    }

    for _, handler := range l.handlers {
        err := handler.Unref()
        if err != nil {
            lerr.addHandlerError(handler, err)
        }
    }

    if (lerr.containsErrors()) {
        return lerr
    }
    return nil
}