# README
logger
package logger contains LoggerWrapper, BasicLogger and logging interfaces.
LoggerWrapper
In order not to extort any specific logging package, a logger wraper has been created. LoggerWrapper wraps around third-party loggers that implement one of the logging-interfaces:
- StdLogger - standard library logger interface
- LeveledLogger - basic leveled logger interface
- DebugLeveledLogger - LeveledLogger with the debug2 and debug3 support
- ShortLeveledLogger - basic leveled logger interfaces with shortened method names
- ExtendedLeveledLogger - a fully leveled logger interface
This solution allows to use ExtendedLeveledLogger interface methods for most of the third-party logging packages.
Wrapping third-party logger
import (
"github.com/neuronlabs/uni-logger"
"some/loggingpkg"
)
func main(){
// Having a third-party logger that implements any of the package interfaces
var myLogger *logginpkg.Logger = loggingpkg.New()
// If 'myLogger' doesn't implement 'ExtendedLeveledLogger' but any generic function
// uses logs of that interface, it can be wrapped using LoggerWrapper.
// if 'myLogger' doesn't implement any of the listed interfaces MustGetLoggingWrapper would panic.
var wrappedLoggerMust *unilogger.LoggerWrapper = unilogger.MustGetLoggerWrapped(myLogger)
// The other function to get a logging wrapper is NewLoggingWrapper(myLogger) which returns
// new *LoggerWrapper or an error if it doesn't implement listed interfaces.
var wrappedLoggerNew *unilogger.LoggerWrapper
var err error
wrappedLoggerNew, err = unilogger.NewLoggingWrapper(myLogger)
if err != nil {
...
}
wrappedLoggerNew.Infoln("It works!")
}
BasicLogger
The package contains also BasicLogger that implements 'LeveledLogger' interface. It is very simple and lightweight implementation of leveled logger.
import (
"log"
"os"
"github.com/neuronlabs/uni-logger"
)
func main(){
// BasicLogger is simple leveled logger that implements LeveledLogger interface.
var basicLogger *logger.BasicLogger
// In order to get new basic logger use NewBasicLogger() function
basicLogger = logger.NewBasicLogger(os.Stderr, "", log.Ltime)
// BasicLogger implements LeveledLogger interface
basicLogger.Error("This should log an error.")
}
Log Levels
The package uses 8 basic log levels.
// Level defines a logging level used in BasicLogger
type Level int
// Following levels are supported in BasicLogger
const (
DEBUG3 Level = iota
DEBUG2
DEBUG
INFO
WARNING
ERROR
CRITICAL
PRINT
)
The BasicLogger allows to set a logging level so that no lower level logs would be printed. This allows to control the logging output just for specified level (or higher).
# Functions
CurrentLevel returns current logger Level.
Debug writes the LevelDebug level log.
Debug2 writes the LevelDebug2 level logs.
Debug2f writes the formatted LevelDebug2 level log.
Debug3 writes the LevelDebug3 level logs.
Debug3f writes the formatted LevelDebug2 level log.
Debugf writes the formatted LevelDebug level log.
Error writes the LevelError level log.
Errorf writes the formatted LevelError level log.
Fatal writes the fatal - LevelCritical level log.
Fatalf writes the formatted fatal - LevelCritical level log.
Info writes the LevelInfo level log.
Infof writes the formatted LevelInfo level log.
Logger returns default logger.
MustGetLoggerWrapper creates a Wrapper wrapper over provided 'logger' argument.
New creates new basic logger that writes to provided 'out' io.Writer with specific 'prefix' and provided 'flags'.
NewBasicLogger creates new BasicLogger that shares common sequence id.
NewDefault creates new basic logger without prefix with standard flags.
NewLoggerWrapper creates a Wrapper wrapper over provided 'logger' argument By default the function checks if provided logger implements logging interfaces in a following hierarchy: # ExtendedLeveledLogger # ShortLeveledLogger # LeveledLogger # StdLogger if logger doesn't implement an interface it tries to check the next in hierarchy.
NewModuleLogger creates new module logger for given 'name' of the module and an optional 'logger'.
Panic writes and panics the log.
Panicf writes and panics formatted log.
ParseLevel parses level from string.
SetLevel sets the level if possible for the logger file.
SetLogger sets the 'log' as the current logger.
SetModulesLevel sets the 'level' for all modules.
Warning writes the warning level log.
Warningf writes the formatted warning level log.
# Constants
Following levels are supported in BasicLogger.
Following levels are supported in BasicLogger.
Following levels are supported in BasicLogger.
Following levels are supported in BasicLogger.
Following levels are supported in BasicLogger.
Following levels are supported in BasicLogger.
Following levels are supported in BasicLogger.
Following levels are supported in BasicLogger.
# Variables
ErrInvalidLogger is the classification for the invalid logger.
ErrLogger is the major logger error classification.
# Structs
BasicLogger is simple leveled logger that implements DebugLeveledLogger interface.
Message is a basic logging record structure used in BasicLogger.
ModuleLogger is the logger used for getting the specific modules.
Wrapper is wrapper around any third-party logger that implements any of the following interfaces: # ExtendedLeveledLogger # ShortLeveledLogger # LeveledLogger # StdLogger By wrapping the logger it implements ExtendedLeveledLogger.
# Interfaces
DebugLeveledLogger is Leveled Logger with the debug2 and debug3 levels.
ExtendedLeveledLogger adds distinction between Leveled methods that starts new or not.
LeveledLogger is a logger that uses basic logging levels.
LevelGetter is the interface used to get current logger level.
LevelSetter is the interface that allows to set the logging level.
OutputDepthGetter is the interface that gets the output get.
OutputDepthSetter is the interface that sets the output depth for the logging interface.
ShortLeveledLogger is a logger that uses basic logging levels.
StdLogger is the logger interface for standard log library.
SubLogger interface that creates and returns new sub logger.
# Type aliases
Level defines a logging level used in BasicLogger.