plogr

package module
v0.7.0 Latest Latest
Warning

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

Go to latest
Published: Dec 27, 2022 License: Apache-2.0 Imports: 5 Imported by: 2

README

plogr

Go version Version Go Report Card Codecov

go-logr implementation with pterm

Usage

See examples

Add more colors and levels

By default, only level 0 (info) and level 1 (debug) are configured.

While go-logr doesn't have names for logging levels ("info", "warning", etc), pterm does. Both libraries agree that verbosity is increased with higher numeric logging level. For pterm however, one could argue that their "Warning" and "Success" levels have lower verbosity than "Info". If you like to customize the levels or styling, you could do something like this:

func main() {
	sink := plogr.NewPtermSink().
	    SetLevelPrinter(3, pterm.Debug).
        SetLevelPrinter(2, plogr.DefaultLevelPrinters[0]).
        SetLevelPrinter(1, pterm.Success).
        SetLevelPrinter(0, pterm.Warning)

	logger := logr.New(sink)
	logger.V(0).WithName("main").Info("Warning message")
	logger.V(1).WithName("app").Info("Success message")
	logger.V(2).WithName("database").Info("Info message", "key", "value")
	logger.V(3).WithName("controller").Info("Debug message")
}

example output

That means whenever you want to show informational messages, you'd have to set the logging level to 2 in your code base. Alternatively, without breaking the code base, append levels like success to the LevelPrinters to your desired level, disregarding the verbosity increase though. For a logging library, it remains questionable though if you'd like to maintain warnings and success levels via plogr or whether they're better explicitly invoked in pterm.

The error printer can be customized as well, but it has its own field.

Documentation

Index

Constants

This section is empty.

Variables

View Source
var DefaultErrorPrinter = *pterm.Error.WithPrefix(pterm.Prefix{Text: "  ERROR ", Style: pterm.Error.Prefix.Style}).WithShowLineNumber(true).WithLineNumberOffset(4)

DefaultErrorPrinter is the default pterm.PrefixPrinter for the error level.

View Source
var DefaultFormatter = func(msg string, keysAndValues map[string]interface{}) string {
	if len(keysAndValues) <= 0 {
		return msg
	}
	pairs := make([]string, 0)
	for k, v := range keysAndValues {
		pairs = append(pairs, fmt.Sprintf("%s=\"%+v\"", k, v))
	}
	msg = fmt.Sprintf("%s %s", msg, pterm.FgGray.Sprint("(", strings.Join(pairs, " "), ")"))
	return msg
}

DefaultFormatter returns a string that looks as following (with colored key/values):

  • message
  • message (key="value" foo="bar")
View Source
var DefaultLevelPrinters = map[int]pterm.PrefixPrinter{
	0: *pterm.Info.WithPrefix(pterm.Prefix{Text: DefaultPrefixFormatter(0), Style: pterm.Info.Prefix.Style}),
	1: NewDefaultDebugPrinter(1),
}

DefaultLevelPrinters contains the default pterm.PrefixPrinter for a specific log levels.

View Source
var DefaultPrefixFormatter = func(level int) string {
	if level == 0 {
		return "  INFO  "
	}
	return fmt.Sprintf(" DBUG/%d ", level)
}

DefaultPrefixFormatter returns the prefix text for the given log level for all Info messages.

View Source
var ScopeSeparator = ":"

ScopeSeparator delimits logger names.

Functions

func NewDefaultDebugPrinter added in v0.7.0

func NewDefaultDebugPrinter(level int) pterm.PrefixPrinter

NewDefaultDebugPrinter returns a new pterm.PrefixPrinter with a pterm.Prefix that contains the log level.

Types

type PtermSink

type PtermSink struct {
	// LevelPrinters maps a pterm.PrefixPrinter to each supported log level.
	LevelPrinters map[int]pterm.PrefixPrinter
	// LevelEnabled enables or disables logging for the supported log levels.
	LevelEnabled map[int]bool

	// ErrorPrinter is the instance that formats and styles error messages.
	ErrorPrinter pterm.PrefixPrinter
	// contains filtered or unexported fields
}

PtermSink implements logr.LogSink.

func NewPtermSink

func NewPtermSink() PtermSink

NewPtermSink returns a new logr.LogSink instance where messages are being printed with pterm.PrefixPrinter. PtermSink.LevelPrinters and PtermSink.ErrorPrinter are initialized with DefaultLevelPrinters resp. pterm.Error.

func (PtermSink) Enabled

func (s PtermSink) Enabled(level int) bool

Enabled implements logr.LogSink. It will return true if LevelEnabled has a key with the level and a value "true"

func (PtermSink) Error

func (s PtermSink) Error(err error, msg string, kvs ...interface{})

Error implements logr.LogSink. The given err is appended to the keys and values array with the "error" key, but only if err is non-nil.

func (PtermSink) Info

func (s PtermSink) Info(level int, msg string, kvs ...interface{})

Info implements logr.LogSink.

func (PtermSink) Init

func (s PtermSink) Init(_ logr.RuntimeInfo)

Init implements logr.LogSink.

func (PtermSink) Name added in v0.4.0

func (s PtermSink) Name() string

Name returns the currently configured scope name

func (*PtermSink) SetLevelEnabled added in v0.5.0

func (s *PtermSink) SetLevelEnabled(level int, enabled bool) *PtermSink

SetLevelEnabled explicitly enables or disables a logging level.

func (*PtermSink) SetLevelPrinter added in v0.7.0

func (s *PtermSink) SetLevelPrinter(level int, printer pterm.PrefixPrinter) *PtermSink

SetLevelPrinter sets the printer for the given logging level. Does not enable the given log level though.

func (*PtermSink) SetOutput added in v0.3.0

func (s *PtermSink) SetOutput(output io.Writer) *PtermSink

SetOutput is a convenience func that sets the new writer directly in pterm.PrefixPrinter. The difference to WithOutput is that setting the output on this instance also affects other log sinks that were created on the current state of s.

func (PtermSink) WithName

func (s PtermSink) WithName(name string) logr.LogSink

WithName implements logr.LogSink. It returns a new logr.Logger instance that copies the pterm.PrefixPrinter from previous instance, but modifies the Scope property of the prefix printer. The value of the name is joined with the existing name, delimited by ScopeSeparator.

func (PtermSink) WithOutput added in v0.3.0

func (s PtermSink) WithOutput(output io.Writer) *PtermSink

WithOutput returns a new sink that writes log messages to the given output. The difference to SetOutput is that this method doesn't alter the existing sink.

func (PtermSink) WithValues

func (s PtermSink) WithValues(kvs ...interface{}) logr.LogSink

WithValues implements logr.LogSink. It returns a new logr.Logger instance that is pre-configured with given keys and values.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL