README
¶
log
log interface and default implementation for ccmonky.
Usage
inject logger
you can inject logger with the following interface(e.g. zap.SugaredLogger):
type LoggerInterface interface {
Debug(msg string, keysAndValues ...interface{})
Info(msg string, keysAndValues ...interface{})
Error(msg string, keysAndValues ...interface{})
}
inject logger like this:
log.SetLogger("xxx", zap.S())
log levels
ccmonky/log support these log levels by default:
- ErrorLevel: error level, also can use short alias
E - InfoLevel: error level, also can use short alias
I - DebugLevel: error level, also can use short alias
D
std log adapter
ccmonky/log has std log adapter support, you can use it like this:
- first, replace your std log import to
github.com/ccmonky/log
that's all for existing libs, and then in app, replace the default logger like this:
// NOTE:
// 1. default logger name is ""
// 2. appLogger is your app logger, which should implement `log.LoggerInterface`
log.SetLogger("", appLogger)
then all your logs of libs will be recorded by appLogger, but note that, all the logs can only be recorded by appLogger in info level.
- second, if you are develop new libs, you can also support logger and levels like this:
log.Println(log.Ctx("xxx", log.E), ...)
log.Printf("%v %d %s", log.Ctx("yyy", log.D), code, msg)
Documentation
¶
Index ¶
- Constants
- Variables
- func Debug(msg string, keysAndValues ...interface{})
- func Error(msg string, keysAndValues ...interface{})
- func Info(msg string, keysAndValues ...interface{})
- func Log(logger LoggerInterface, level Level, msg string, keysAndValues ...interface{})
- func RegisterLevelName(level Level, name string)
- func SetLogger(loggerName LoggerName, logger LoggerInterface)
- func WithContextArgs(args []interface{}) contextLoggerOption
- func WithContextLevel(level int8) contextLoggerOption
- func WithContextLoggerName(name string) contextLoggerOption
- type ContextLogger
- type Level
- type LevelLogger
- type LevelLoggerOption
- type Logger
- type LoggerInterface
- type LoggerName
- type NopLogger
Constants ¶
View Source
const ( Ldate = 1 << iota // the date in the local time zone: 2009/01/23 Ltime // the time in the local time zone: 01:23:23 Lmicroseconds // microsecond resolution: 01:23:23.123123. assumes Ltime. Llongfile // full file name and line number: /a/b/c/d.go:23 Lshortfile // final file name element and line number: d.go:23. overrides Llongfile LUTC // if Ldate or Ltime is set, use UTC rather than the local time zone Lmsgprefix // move the "prefix" from the beginning of the line to before the message LstdFlags = Ldate | Ltime // initial values for the standard logger )
re-export
Variables ¶
View Source
var ( // D is alias of DebugLevel D = DebugLevel // I is alias of InfoLevel I = InfoLevel // E is alias of ErrorLevel E = ErrorLevel )
View Source
var ( New = log.New Default = log.Default Output = log.Output SetOutput = log.SetOutput Flags = log.Flags SetFlags = log.SetFlags Prefix = log.Prefix SetPrefix = log.SetPrefix Writer = log.Writer )
re-export
View Source
var ( // Print enhence std log.Printf to accept ContextLogger parameter // NOTE: ContextLogger parameter will be removed when print // // usage cases: // // - log.Print(log.Ctx("xxx", log.E), ...): loggerXXX.Error("", ...) // - log.Print(log.Ctx("xxx"), ...): loggerXXX.Info("", ...) // - log.Print(log.Ctx(log.E), ...): defaultLogger.Error("", ...) // - log.Print(...): defaultLogger.Info("", ...) Print = convert(false, false) Panic = convert(true, false) Fatal = convert(false, true) // XXXln same as `XXX` Println = convert(false, false) Panicln = convert(true, false) Fatalln = convert(false, true) // Printf enhence stdlog.Printf to accept ContextLogger parameter // NOTE: format contains the format directive for ContextLogger, e.g. // // `log.Printf("%v: %d: %s", log.Ctx("xxx", log.E), code, "this is a error")` // // usage cases: // // - log.Printf(format, log.Ctx("xxx", log.E), ...): loggerXXX.Error(fmt.Sprintf(format, log.Ctx("xxx", log.E), ...)) // - log.Printf(format, log.Ctx("xxx"), ...): loggerXXX.Info(fmt.Sprintf(format, log.Ctx("xxx"), ...)) // - log.Printf(format, log.Ctx(log.E), ...): defaultLogger.Error(fmt.Sprintf(format, log.Ctx(log.E), ...)) // - log.Printf(...): defaultLogger.Info(fmt.Sprintf(format, ...)) Printf = convertf(false, false) Panicf = convertf(true, false) Fatalf = convertf(false, true) )
- rewrite these functions to use the LoggerInterface(default LevelLogger)!!!
Functions ¶
func Log ¶
func Log(logger LoggerInterface, level Level, msg string, keysAndValues ...interface{})
Log utility function to log by level
func RegisterLevelName ¶
RegisterLevelName register level name TBD: support extend level?
func SetLogger ¶
func SetLogger(loggerName LoggerName, logger LoggerInterface)
SetLogger set logger into internal registry
func WithContextArgs ¶
func WithContextArgs(args []interface{}) contextLoggerOption
WithContextArgs specify logger level
func WithContextLevel ¶
func WithContextLevel(level int8) contextLoggerOption
WithContextLevel specify logger level
func WithContextLoggerName ¶
func WithContextLoggerName(name string) contextLoggerOption
WithContextLoggerName specify logger name
Types ¶
type ContextLogger ¶
type ContextLogger interface {
LoggerInterface
Level() Level
Args() []interface{}
}
func Ctx ¶
func Ctx(ps ...any) ContextLogger
Ctx returna a conetxt logger usage: - log.Ctx("xxx", log.ErrorLevel): use xxx logger in error level - log.Ctx("xxx"): use xxx logger in info level - log.Ctx(log.DebugLevel): use default logger in debug level
type Level ¶
type Level int8
Level logger level
const ( // DebugLevel logs are typically voluminous, and are usually disabled in production. DebugLevel Level = -1 // InfoLevel is the default logging priority. InfoLevel Level = 0 // ErrorLevel logs are high-priority. If an application is running smoothly, // it shouldn't generate any error-level logs. ErrorLevel Level = 2 )
type LevelLogger ¶
type LevelLogger struct {
*Logger
// contains filtered or unexported fields
}
LevelLogger is a logger implementation, which sends al logs to provided standard output.
func (*LevelLogger) Debug ¶
func (logger *LevelLogger) Debug(msg string, keysAndValues ...interface{})
func (*LevelLogger) Error ¶
func (logger *LevelLogger) Error(msg string, keysAndValues ...interface{})
func (*LevelLogger) Info ¶
func (logger *LevelLogger) Info(msg string, keysAndValues ...interface{})
type LevelLoggerOption ¶
type LevelLoggerOption func(*LevelLogger)
func WithLevel ¶
func WithLevel(level Level) LevelLoggerOption
func WithLogger ¶
func WithLogger(std *log.Logger) LevelLoggerOption
type LoggerInterface ¶
type LoggerInterface interface {
Debug(msg string, keysAndValues ...interface{})
Info(msg string, keysAndValues ...interface{})
Error(msg string, keysAndValues ...interface{})
}
LoggerInterface log interface
func GetLogger ¶
func GetLogger(loggerName LoggerName) LoggerInterface
GetLogger get logger from internal registry
func NewLevelLogger ¶
func NewLevelLogger(opts ...LevelLoggerOption) LoggerInterface
NewLevelLogger creates LevelLogger which sends all logs to specified stdlog logger.
Source Files
Click to show internal directories.
Click to hide internal directories.