appender.go

package logging

import (
	"fmt"
	"io"
	"os"
	"sync"
	"sync/atomic"
)

//LogAppender is used to push log records to a destination like a file
type LogAppender interface {
	//Log takes a record and should append it
	Log(record *LogRecord) error
	//SetLevel should remember the level assigned to this appender and check
	//it to filter incoming records
	SetLevel(l LogLevel)
	//SetFormatter should remember the formatting function that this
	//appender should use to generate strings from LogRecords
	SetFormatter(formatter LogFormatter)
}

//ClosableAppender defines an optional single method for appenders that
//need to be closed when they will not be used anymore. An example
//is a file appender.
type ClosableAppender interface {
	LogAppender
	io.Closer
}

//BaseLogAppender provides a simple struct for building log appenders.
type BaseLogAppender struct {
	m         sync.RWMutex
	level     LogLevel
	formatter LogFormatter
}

//SetLevel stores the level in the BaseLogAppender struct
func (appender *BaseLogAppender) SetLevel(l LogLevel) {
	appender.m.Lock()
	appender.level = l
	appender.m.Unlock()
}

func (appender *BaseLogAppender) checkLevel(l LogLevel) bool {
	// caller is responsible for obtaining lock
	return appender.level <= l
}

//CheckLevel tests the level in the BaseLogAppender struct
func (appender *BaseLogAppender) CheckLevel(l LogLevel) bool {
	appender.m.RLock()
	defer appender.m.RUnlock()

	return appender.checkLevel(l)
}

//SetFormatter stores the formatting function in the BaseLogAppender struct
func (appender *BaseLogAppender) SetFormatter(formatter LogFormatter) {
	appender.m.Lock()
	appender.formatter = formatter
	appender.m.Unlock()
}

func (appender *BaseLogAppender) format(record *LogRecord) string {
	// caller is responsible for obtaining lock
	formatter := appender.formatter

	if formatter == nil {
		formatter = defaultFormatter
	}

	return formatter(record.Level, record.Tags, record.Message, record.Time, record.Original)
}

//NullAppender is a simple log appender that just counts the number of log messages
type NullAppender struct {
	BaseLogAppender
	count int64
}

//NewNullAppender creates a null appender
func NewNullAppender() *NullAppender {
	return &NullAppender{}
}

//Log adds 1 to the count
func (appender *NullAppender) Log(record *LogRecord) error {
	atomic.AddInt64(&(appender.count), 1)
	return nil
}

//Count returns the count of messages logged
func (appender *NullAppender) Count() int64 {
	return atomic.LoadInt64(&(appender.count))
}

//ErrorAppender is provided for testing and will generate an error
//when asked to log a message, it will also maintain a count
type ErrorAppender struct {
	NullAppender
}

//NewErrorAppender creates an ErrorAppender
func NewErrorAppender() *ErrorAppender {
	return &ErrorAppender{}
}

//Log adds to the count and returns an error
func (appender *ErrorAppender) Log(record *LogRecord) error {
	atomic.AddInt64(&(appender.count), 1)
	return fmt.Errorf("error: %s", record.Message)
}

//ConsoleAppender can be used to write log records to standard
//err or standard out.
type ConsoleAppender struct {
	useStdout bool
	BaseLogAppender
}

//NewStdErrAppender creates a console appender configured to write to
//standard err.
func NewStdErrAppender() *ConsoleAppender {
	return &ConsoleAppender{}
}

//NewStdOutAppender creates a console appender configured to write to
//standard out.
func NewStdOutAppender() *ConsoleAppender {
	return &ConsoleAppender{useStdout: true}
}

//Log writes the record, if its level passes the appenders level
//to stderr or stdout
func (appender *ConsoleAppender) Log(record *LogRecord) error {
	appender.m.Lock()
	defer appender.m.Unlock()

	if !appender.checkLevel(record.Level) {
		return nil
	}

	if appender.useStdout {
		fmt.Fprintln(os.Stdout, appender.format(record))
	} else {
		fmt.Fprintln(os.Stderr, appender.format(record))
	}
	return nil
}

//MemoryAppender is useful for testing and keeps a list of logged messages
type MemoryAppender struct {
	BaseLogAppender
	//LoggedMesssages is the list of messages that have been logged to this appender
	LoggedMessages []string
}

//NewMemoryAppender creates a new empty memory appender
func NewMemoryAppender() *MemoryAppender {
	appender := new(MemoryAppender)
	appender.LoggedMessages = make([]string, 0, 100)
	return appender
}

//Log checks the log records level and if it passes appends the record to the list
func (appender *MemoryAppender) Log(record *LogRecord) error {
	appender.m.Lock()
	defer appender.m.Unlock()

	if !appender.checkLevel(record.Level) {
		return nil
	}

	appender.LoggedMessages = append(appender.LoggedMessages, appender.format(record))
	return nil
}

//GetLoggedMessages returns the list of logged messages as strings.
func (appender *MemoryAppender) GetLoggedMessages() []string {
	appender.m.RLock()
	defer appender.m.RUnlock()

	return appender.LoggedMessages
}

//WriterAppender is a simple appender that pushes messages as bytes to a writer
type WriterAppender struct {
	BaseLogAppender
	writer io.Writer
}

//NewWriterAppender creates an appender from the specified writer.
func NewWriterAppender(writer io.Writer) *WriterAppender {
	return &WriterAppender{writer: writer}
}

//Log checks the log record's level and then writes the formatted record
//to the writer, followed by the bytes for "\n"
func (appender *WriterAppender) Log(record *LogRecord) error {
	appender.m.Lock()
	defer appender.m.Unlock()

	if !appender.checkLevel(record.Level) {
		return nil
	}

	if appender.writer != nil {
		_, err := appender.writer.Write([]byte(appender.format(record)))
		_, err = appender.writer.Write([]byte("\n"))
		return err
	}

	return nil
}