The highest tagged major version is
Documentation
¶
Overview ¶
Package log provides logging mechanism including replaceable Logger interface and its default implementation. Developers may replace default implementation and output level with her desired Logger implementation in a thread-safe manner as below:
type MyLogger struct {}
var _ Logger = (*MyLogger)(nil)
func (*MyLogger) Debug(args ...interface{}) {}
func (*MyLogger) Debugf(format string, args ...interface{}) {}
func (*MyLogger) Info(args ...interface{}) {}
func (*MyLogger) Infof(format string, args ...interface{}) {}
func (*MyLogger) Warn(args ...interface{}) {}
func (*MyLogger) Warnf(format string, args ...interface{}) {}
func (*MyLogger) Error(args ...interface{}) {}
func (*MyLogger) Errorf(format string, args ...interface{}) {}
l := &MyLogger{}
// These methods are thread-safe
log.SetLogger(l)
log.SetOutputLevel(log.InfoLevel)
log.Info("Output via new Logger impl.")
Index ¶
- func Debug(args ...interface{})
- func Debugf(format string, args ...interface{})
- func Error(args ...interface{})
- func Errorf(format string, args ...interface{})
- func Info(args ...interface{})
- func Infof(format string, args ...interface{})
- func SetLogger(l Logger)
- func SetOutputLevel(level Level)
- func Warn(args ...interface{})
- func Warnf(format string, args ...interface{})
- type Level
- type Logger
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
func Debug ¶
func Debug(args ...interface{})
Debug outputs given arguments via pre-set Logger implementation. Logging level must be left with the default setting or be set to DebugLevel via SetOutputLevel().
func Debugf ¶
func Debugf(format string, args ...interface{})
Debugf outputs given arguments with format via pre-set Logger implementation. Logging level must be left with the default setting or be set to DebugLevel via SetOutputLevel().
func Error ¶
func Error(args ...interface{})
Error outputs given arguments via pre-set Logger implementation.
func Errorf ¶
func Errorf(format string, args ...interface{})
Errorf outputs given arguments with format via pre-set Logger implementation.
func Info ¶
func Info(args ...interface{})
Info outputs given arguments via pre-set Logger implementation. Logging level must be set to DebugLevel or InfoLevel via SetOutputLevel().
func Infof ¶
func Infof(format string, args ...interface{})
Infof outputs given arguments with format via pre-set Logger implementation. Logging level must be set to DebugLevel or InfoLevel via SetOutputLevel().
func SetLogger ¶
func SetLogger(l Logger)
SetLogger receives struct that satisfies Logger interface, and sets this as logger. From this call forward, any call to logging method proxies arguments to corresponding logging method of given Logger. e.g. call to log.Info points to Logger.Info.
This method is "thread-safe."
func SetOutputLevel ¶
func SetOutputLevel(level Level)
SetOutputLevel sets what logging level to output. Application may call logging method any time, but Logger only outputs if the corresponding log level is equal to or higher than the level set here. e.g. When InfoLevel is set, output with Debug() and Debugf() are ignored.
This method is "thread-safe."
DebugLevel is set by default, so this should be explicitly overridden with higher logging level on production environment to avoid printing undesired sensitive data.
Types ¶
type Level ¶
type Level uint
Level indicates what logging level the output is representing. This typically indicates the severity of a particular logging event.
const ( // ErrorLevel indicates the error state of events. This must be noted and be fixed. // In practical situation, fix may include lowering the corresponding event's log level. ErrorLevel Level = iota // WarnLevel represents those events that are not critical, but deserves to note. // Event with this level may not necessarily be considered as an error; // however frequent occurrence deserves developer's attention and may be subject to bug-fix. WarnLevel // InfoLevel is used to inform what is happening inside the application. InfoLevel // DebugLevel indicates the output is logged for debugging purpose. // This level is not suitable for production usage. DebugLevel )
type Logger ¶
type Logger interface {
Debug(args ...interface{})
Debugf(format string, args ...interface{})
Info(args ...interface{})
Infof(format string, args ...interface{})
Warn(args ...interface{})
Warnf(format string, args ...interface{})
Error(args ...interface{})
Errorf(format string, args ...interface{})
}
Logger defines the interface that can be used as logging tool in this application. Developer may provide a customized logger via SetLogger() to modify behavior. By default, instance of defaultLogger is set as default Logger just like http's DefaultClient.
func GetLogger ¶ added in v1.5.0
func GetLogger() Logger
GetLogger returns currently set Logger. Once a preferred Logger implementation is set via log.SetLogger, developer may use its method by calling this package's function: log.Debug, log.Debugf and others.
However when developer wishes to retrieve the Logger instance, this function helps. This is particularly useful in such situation where Logger implementation must be temporarily switched but must be switched back when a task is done. Example follows.
import (
"github.com/oklahomer/go-sarah/log"
"io/ioutil"
stdLogger "log"
"os"
"testing"
)
func TestMain(m *testing.M) {
oldLogger := log.GetLogger()
defer log.SetLogger(oldLogger)
l := stdLogger.New(ioutil.Discard, "dummyLog", 0)
logger := log.NewWithStandardLogger(l)
log.SetLogger(logger)
code := m.Run()
os.Exit(code)
}
func NewWithStandardLogger ¶
NewWithStandardLogger creates an instance of defaultLogger with Go's standard log.Logger. This can be used when implementing Logger interface is too much of a task, but still a bit of modification to defaultLogger is required.
Returning Logger can be fed to SetLogger() to replace old defaultLogger.
Source Files