log

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
  • func Ctx(ps ...any) ContextLogger
• type Level
  • func (level Level) String() string
• type LevelLogger
  • func (logger *LevelLogger) Debug(msg string, keysAndValues ...interface{})
  • func (logger *LevelLogger) Error(msg string, keysAndValues ...interface{})
  • func (logger *LevelLogger) Info(msg string, keysAndValues ...interface{})
• type LevelLoggerOption
  • func WithLevel(level Level) LevelLoggerOption
  • func WithLogger(std *log.Logger) LevelLoggerOption
• type Logger
• type LoggerInterface
  • func GetLogger(loggerName LoggerName) LoggerInterface
  • func NewLevelLogger(opts ...LevelLoggerOption) LoggerInterface
• type LoggerName
• type NopLogger
  • func (NopLogger) Debug(msg string, keysAndValues ...interface{})
  • func (NopLogger) Error(msg string, keysAndValues ...interface{})
  • func (NopLogger) Info(msg string, keysAndValues ...interface{})

Constants

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

var (
	// D is alias of DebugLevel
	D = DebugLevel
	// I is alias of InfoLevel
	I = InfoLevel
	// E is alias of ErrorLevel
	E = ErrorLevel
)

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

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 Debug

func Debug(msg string, keysAndValues ...interface{})

func Error

func Error(msg string, keysAndValues ...interface{})

func Info

func Info(msg string, keysAndValues ...interface{})

func Log

func Log(logger LoggerInterface, level Level, msg string, keysAndValues ...interface{})

Log utility function to log by level

func RegisterLevelName

func RegisterLevelName(level Level, name string)

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
)

func (Level) String

func (level Level) String() string

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 Logger

type Logger = log.Logger

re-export

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.

type LoggerName

type LoggerName string

LoggerName logger name

type NopLogger

type NopLogger struct{}

NopLogger is a logger which discards all logs.

func (NopLogger) Debug

func (NopLogger) Debug(msg string, keysAndValues ...interface{})

func (NopLogger) Error

func (NopLogger) Error(msg string, keysAndValues ...interface{})

func (NopLogger) Info

func (NopLogger) Info(msg string, keysAndValues ...interface{})