level

package
v1.0.19 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jul 18, 2022 License: MIT Imports: 7 Imported by: 0

Documentation

Index

Examples

Constants

This section is empty.

Variables

View Source 
var (
	// ErrorColor defines the color of the ERROR label
	ErrorColor = color.New(color.Bold, color.FgHiRed)
	// InfoColor defines the color of the INFO label
	InfoColor = color.New(color.Bold, color.FgHiMagenta)
	// DebugColor defines the color of the DEBUG label
	DebugColor = color.New(color.Bold, color.FgHiBlue)
	// WarningColor defines the color of the DEBUG label
	WarningColor = color.New(color.Bold, color.FgHiYellow)
	// FatalColor defines the color of the DEBUG label
	FatalColor = color.New(color.Bold, color.FgHiRed)
)

Colors

View Source 
var (
	ErrLevelerNotImplemented = errors.New("Leveler interface not implemented")
)
View Source 
var LevelColor = map[Level]string{
	UNSET:   LevelString[UNSET],
	DEBUG:   DebugColor.Sprint(LevelString[DEBUG]),
	INFO:    InfoColor.Sprint(LevelString[INFO]),
	WARNING: WarningColor.Sprint(LevelString[WARNING]),
	ERROR:   ErrorColor.Sprint(LevelString[ERROR]),
	FATAL:   FatalColor.Sprint(LevelString[FATAL]),
	OFF:     LevelString[OFF],
}
View Source 
var LevelFromString = map[string]Level{
	"unset":   UNSET,
	"debug":   DEBUG,
	"info":    INFO,
	"warning": WARNING,
	"error":   ERROR,
	"fatal":   FATAL,
	"off":     OFF,
}
View Source 
var LevelString = map[Level]string{
	UNSET:   "unset",
	DEBUG:   "debug",
	INFO:    "info",
	WARNING: "warning",
	ERROR:   "error",
	FATAL:   "fatal",
	OFF:     "off",
}

Functions

func Debug 

func Debug(logger *genelog.Logger, v ...interface{})

func Debugf 

func Debugf(logger *genelog.Logger, format string, v ...interface{})

func Debugln 

func Debugln(logger *genelog.Logger, v ...interface{})

func Error 

func Error(logger *genelog.Logger, v ...interface{})

func Errorf 

func Errorf(logger *genelog.Logger, format string, v ...interface{})

func Errorln 

func Errorln(logger *genelog.Logger, v ...interface{})

func Fatal 

func Fatal(logger *genelog.Logger, v ...interface{})

func Fatalf 

func Fatalf(logger *genelog.Logger, format string, v ...interface{})

func Fatalln 

func Fatalln(logger *genelog.Logger, v ...interface{})

func HookLevelSkip 

func HookLevelSkip(v interface{}, msg string) (interface{}, string, error)

func Info 

func Info(logger *genelog.Logger, v ...interface{})

func Infof 

func Infof(logger *genelog.Logger, format string, v ...interface{})

func Infoln 

func Infoln(logger *genelog.Logger, v ...interface{})

func IsActive 

func IsActive(ref, l Level) bool

IsActive returns true if l includes ref

func Output 

func Output(logger *genelog.Logger, level Level, output func(logger *genelog.Logger) error) error

func Warning 

func Warning(logger *genelog.Logger, v ...interface{})

func Warningf 

func Warningf(logger *genelog.Logger, format string, v ...interface{})

func Warningln 

func Warningln(logger *genelog.Logger, v ...interface{})

Types

type Level 

type Level int

Type list the available type of logger 

const (
	UNSET Level = iota
	// DEBUG is the type to log DEBUG message
	DEBUG
	// INFO is the type to log INFO message
	INFO
	// WARNING is the type to log WARNING message
	WARNING
	// ERROR is the type to log ERROR message
	ERROR
	// FATAL is the type to log FATAL message
	FATAL
	// OFF turns off logging
	OFF
)

func NewLevelFromString 

func NewLevelFromString(s string) (Level, bool)

func (Level) Color 

func (l Level) Color() string

func (Level) MarshalText 

func (l Level) MarshalText() (text []byte, err error)

func (Level) String 

func (l Level) String() string

func (*Level) UnmarshalText 

func (l *Level) UnmarshalText(text []byte) error

type LevelLogger 

type LevelLogger struct {
	*genelog.Logger
}
Example 
buf := bytes.Buffer{}

context := exampleWithLevel{
	NewWithLevel(WARNING),
}

logger := NewLevelLogger(&buf).
	WithContext(context).
	WithFormatter(json.JSON)

logger = logger.WithFormatter(func(v interface{}, msg string) (string, error) {
	context, _ := v.(exampleWithLevel)
	return fmt.Sprintf("%s: %s\n", context.Level(), msg), nil
})

logger.AddHook(func(v interface{}, msg string) (interface{}, string, error) {
	return v, msg, nil
})

logger.Print("mylog")
logger.Debug("mylog")
logger.Info("mylog")
logger.Warning("mylog")
logger.Error("mylog")
logger.Fatalf("%s", "mylog")

fmt.Print(buf.String())

Output:

warning: mylog
error: mylog
fatal: mylog

func NewLevelLogger 

func NewLevelLogger(w io.Writer) LevelLogger

func (LevelLogger) AddHook added in v1.0.8 

func (l LevelLogger) AddHook(h genelog.Hook) LevelLogger

func (LevelLogger) Debug 

func (l LevelLogger) Debug(v ...interface{})

func (LevelLogger) Debugf 

func (l LevelLogger) Debugf(format string, v ...interface{})

func (LevelLogger) Debugln 

func (l LevelLogger) Debugln(v ...interface{})

func (LevelLogger) Error 

func (l LevelLogger) Error(v ...interface{})

func (LevelLogger) Errorf 

func (l LevelLogger) Errorf(format string, v ...interface{})

func (LevelLogger) Errorln 

func (l LevelLogger) Errorln(v ...interface{})

func (LevelLogger) Fatal 

func (l LevelLogger) Fatal(v ...interface{})

func (LevelLogger) Fatalf 

func (l LevelLogger) Fatalf(format string, v ...interface{})

func (LevelLogger) Fatalln 

func (l LevelLogger) Fatalln(v ...interface{})

func (LevelLogger) Info 

func (l LevelLogger) Info(v ...interface{})

func (LevelLogger) Infof 

func (l LevelLogger) Infof(format string, v ...interface{})

func (LevelLogger) Infoln 

func (l LevelLogger) Infoln(v ...interface{})

func (LevelLogger) Warning 

func (l LevelLogger) Warning(v ...interface{})

func (LevelLogger) Warningf 

func (l LevelLogger) Warningf(format string, v ...interface{})

func (LevelLogger) Warningln 

func (l LevelLogger) Warningln(v ...interface{})

func (LevelLogger) WithContext added in v1.0.8 

func (l LevelLogger) WithContext(v interface{}) LevelLogger

func (LevelLogger) WithFormatter added in v1.0.8 

func (l LevelLogger) WithFormatter(f genelog.Format) LevelLogger

func (LevelLogger) Writer added in v1.0.9 

func (l LevelLogger) Writer(level Level) io.Writer

Writer returns a Writer set to level

Multiple writers can't be made because another writer will overwrite the level of the first one by updating the logger context.

In order to have multiple writers, deep copy the context for each of them to not share the WithLevel pointer, then inject the context into the logger:

w := logger.WithContext(context).Writer(level)

Example 
buf := bytes.Buffer{}

var context = struct {
	*WithLevel
}{
	NewWithLevel(INFO),
}

logger := NewLevelLogger(&buf).
	WithContext(context).
	WithFormatter(json.JSON)

w1 := logger.Writer(WARNING)
_, _ = io.WriteString(w1, "w1")
_, _ = io.WriteString(w1, "w1")

fmt.Print(buf.String())

Output:

{"context":{"level":"warning"},"message":"w1"}
{"context":{"level":"warning"},"message":"w1"}

type Leveler 

type Leveler interface {
	// LevelMin returns the minimum level to print
	LevelMin() Level
	// Level returns the current level
	Level() Level
	// LevelSet changes the level
	LevelSet(Level)
}

Leveler is the interface to access the level field

func GetLeveler added in v1.0.9 

func GetLeveler(v interface{}) (Leveler, bool)

GetLeveler converts v into Leveler. Returns false if not possible.

type WithLevel 

type WithLevel struct {
	// contains filtered or unexported fields
}
Example 
// output buffer
buf := bytes.Buffer{}

// simply converts v into exampleWithLevel
getContext := func(v interface{}) (exampleWithLevel, error) {
	exampleWithLevel, ok := v.(exampleWithLevel)
	if !ok {
		return exampleWithLevel, fmt.Errorf("%T: not exampleWithLevel type", v)
	}
	return exampleWithLevel, nil
}

context := exampleWithLevel{
	NewWithLevel(INFO),
}

logger := genelog.New(&buf).
	WithContext(context).
	WithFormatter(json.JSON).
	AddHook(HookLevelSkip)

context, _ = getContext(logger.Context())
context.LevelSet(ERROR)
logger = logger.WithContext(context)

logger.Println("mylog")

// not displayed because min level set to info
context, _ = getContext(logger.Context())
context.LevelSet(DEBUG)
logger = logger.WithContext(context)

logger.Println("mylog")

fmt.Println(&buf)

Output:

{"context":{"level":"error"},"message":"mylog"}

func NewWithLevel 

func NewWithLevel(min Level) *WithLevel

func (WithLevel) Level 

func (w WithLevel) Level() Level

func (WithLevel) LevelMin 

func (w WithLevel) LevelMin() Level

func (*WithLevel) LevelSet 

func (w *WithLevel) LevelSet(level Level)

func (WithLevel) MarshalJSON 

func (w WithLevel) MarshalJSON() ([]byte, error)

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.