log

Documentation

Index

• Variables
• func Init(logFormat Format, logLevel Level)
• type Format
• type Level
• type Log
• type Logf
• type Logger

Variables

var LevelMap = map[Level]logrus.Level{
	LevelTrace: logrus.TraceLevel,
	LevelDebug: logrus.DebugLevel,
	LevelInfo:  logrus.InfoLevel,
	LevelWarn:  logrus.WarnLevel,
	LevelError: logrus.ErrorLevel,
}

var ValidFormatStrings = []string{
	string(FormatJSON),
	string(FormatText),
}

var ValidLevelStrings = []string{
	string(LevelTrace),
	string(LevelDebug),
	string(LevelInfo),
	string(LevelWarn),
	string(LevelError),
}

var WithField,
	WithFields = logger.WithField,
	logger.WithFields

Functions

func Init

func Init(
	logFormat Format,
	logLevel Level,
)

Types

type Format

type Format string

const (
	FormatJSON Format = "json"
	FormatText Format = "text"
)

type Level

type Level string

const (
	LevelTrace Level = "trace"
	LevelDebug Level = "debug"
	LevelInfo  Level = "info"
	LevelWarn  Level = "warn"
	LevelError Level = "error"
)

type Log

type Log func(l ...interface{})

Log defines the function signature of the logger

var Trace,

	Debug,

	Info,

	Warn,

	Error,
	Print Log = logger.Trace,
	logger.Debug,
	logger.Info,
	logger.Warn,
	logger.Error,
	func(l ...interface{}) {
		fmt.Println(l...)
	}

Trace logs at the Trace level

type Logf

type Logf func(s string, l ...interface{})

Log defines the function signature of the logger when called with format parameters

var Tracef,

	Debugf,

	Infof,

	Warnf,

	Errorf,
	Printf Logf = logger.Tracef,
	logger.Debugf,
	logger.Infof,
	logger.Warnf,
	logger.Errorf,
	func(s string, l ...interface{}) {
		fmt.Printf(s, l...)
		fmt.Printf("\n")
	}

Tracef logs at the trace level with formatting

type Logger

type Logger interface {
	Trace(...interface{})
	Tracef(string, ...interface{})
	Debug(...interface{})
	Debugf(string, ...interface{})
	Info(...interface{})
	Infof(string, ...interface{})
	Warn(...interface{})
	Warnf(string, ...interface{})
	Error(...interface{})
	Errorf(string, ...interface{})
}