logger

package
v1.7.4 Latest Latest
Warning

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

Go to latest
Published: Jul 8, 2026 License: GPL-2.0 Imports: 11 Imported by: 15

Documentation

Index

Constants

View Source
const (
	CMD_Green  = "\033[32m"
	CMD_Cyan   = "\033[36m"
	CMD_Yellow = "\033[33m"
	CMD_Red    = "\033[31m"
	CMD_Bold   = "\033[1m"
	CMD_Reset  = "\033[0m"
)

Variables

View Source
var (
	Writer    = func(level LogLevel) io.Writer { return os.Stdout }
	PWriter   = func(label string, level LogLevel) io.Writer { return prefixerwriter{label, level, os.Stdout} }
	NameSpace = func(label string) Log { return nil }

	SetOutput func(level LogLevel, w io.Writer) = func(level LogLevel, w io.Writer) {}
	SetLevel  func(level LogLevel)              = func(level LogLevel) { defaultLogLevel = level }
	GetLevel  func() (level LogLevel)           = func() (level LogLevel) { return defaultLogLevel }

	Debug  = func(args ...interface{}) { printArgs("DEBUG", "", args...) }
	Info   = func(args ...interface{}) { printArgs("INFO", "", args...) }
	Warn   = func(args ...interface{}) { printArgs("WARN", "", args...) }
	Error  = func(args ...interface{}) { printArgs("ERROR", "", args...) }
	Fatal  = func(errorcode int, args ...interface{}) { printArgs("FATAL", "", args...) }
	Debugf = func(format string, args ...interface{}) { printArgs("DEBUG", format, args...) }
	Infof  = func(format string, args ...interface{}) { printArgs("INFO", format, args...) }
	Warnf  = func(format string, args ...interface{}) { printArgs("WARN", format, args...) }
	Errorf = func(format string, args ...interface{}) { printArgs("ERROR", format, args...) }
	Fatalf = func(errorcode int, format string, args ...interface{}) { printArgs("FATAL", format, args...) }
	Logf   = func(level LogLevel, format string, args ...interface{}) {
		printArgs(level.String(), format, args...)
	}
)
View Source
var (
	ErrOutputInvalid = errors.New("output is invalid")
)
View Source
var SUPPORTS_COLORS_DEFAULT = true

Functions

func ColoredLogWrapper

func ColoredLogWrapper(ctx context.Context, l LogLevel, s string) string

func Colorize

func Colorize(ctx context.Context, color, s any) string

func FColorize

func FColorize(ctx context.Context, w io.Writer, color, s any) (n int, err error)

func Setup

func Setup(logger Log)

func SupportsColors added in v1.7.2

func SupportsColors(ctx context.Context) bool

func WithSupportsColors added in v1.7.2

func WithSupportsColors(ctx context.Context, supports bool) context.Context

Types

type Log

type Log interface {

	// Writer returns a new io.Writer that writes to the log output for the given log level.
	Writer(level LogLevel) io.Writer

	// PWriter returns a new io.Writer that writes to the log output for the given log level with a prefix.
	PWriter(label string, level LogLevel) io.Writer

	// NameSpace returns a new Log with the given label as the prefix.
	NameSpace(label string) Log

	// GetLevel retrieves the loglevel for the current logger
	GetLevel() LogLevel

	// SetOutput sets the output for the given log level.
	SetOutput(level LogLevel, w io.Writer)

	// SetLevel sets the current log level.
	//
	// Log messages with a log level lower than the current log level will not be written.
	SetLevel(level LogLevel)

	// Log a debug message.
	Debug(args ...interface{})

	// Log an info message.
	Info(args ...interface{})

	// Log a warning message.
	Warn(args ...interface{})

	// Log an error message.
	Error(args ...interface{})

	// Log a message and exit the program with the given error code.
	Fatal(errorcode int, args ...interface{})

	// Log a format- and args-based debug message.
	Debugf(format string, args ...interface{})

	// Log a format- and args-based info message.
	Infof(format string, args ...interface{})

	// Log a format- and args-based warning message.
	Warnf(format string, args ...interface{})

	// Log a format- and args-based error message.
	Errorf(format string, args ...interface{})

	// Log a format- and args-based message and exit the program with the given error code.
	Fatalf(errorcode int, format string, args ...interface{})

	// Log a message at the given log level.
	Log(level LogLevel, args ...interface{})

	// Log a format string at the given log level.
	Logf(level LogLevel, format string, args ...interface{})

	// WriteString writes a string to the log output.
	WriteString(s string) (n int, err error)
}

type LogLevel

type LogLevel int8
const (
	// DBG is the lowest log level.
	DBG LogLevel = iota

	// INF is the default log level.
	INF

	// WRN is used for warnings.
	WRN

	// ERR is used for errors.
	ERR

	// CRIT is used for critical errors that should not be ignored.
	CRIT LogLevel = 100

	// OutputAll is used to output all log levels in the SetOutput function.
	OutputAll LogLevel = -1
)

func ParseLogLevel added in v1.6.7

func ParseLogLevel(s string) (LogLevel, error)

func (LogLevel) LT added in v1.7.2

func (l LogLevel) LT(other LogLevel) bool

func (*LogLevel) Scan added in v1.7.2

func (l *LogLevel) Scan(value interface{}) error

func (LogLevel) String

func (l LogLevel) String() string

func (LogLevel) Value added in v1.7.2

func (l LogLevel) Value() (driver.Value, error)

type LogWriter

type LogWriter struct {
	Logger *Logger
	Level  LogLevel
}

func (*LogWriter) Write

func (lw *LogWriter) Write(p []byte) (n int, err error)

type Logger

type Logger struct {
	// Level is the log level.
	Level LogLevel

	// Prefix is the prefix for each log message.
	Prefix string

	// Suffix is the suffix for each log message.
	Suffix string

	// Display a timestamp alongside the log message.
	OutputTime bool

	// Outputs for the log messages.
	OutputDebug io.Writer
	OutputInfo  io.Writer
	OutputWarn  io.Writer
	OutputError io.Writer

	// WrapPrefix determines how the prefix should be wrapped
	// based on the LogLevel.
	WrapPrefix func(context.Context, LogLevel, string) string
	Context    context.Context
}

The Logger type is used to log messages at different log levels.

It is possible to set the log level, prefix, suffix, and outputs for the log messages.

When a log message is written, the prefix, log level, and suffix are written to the output provided for that specific loglevel.

func (*Logger) Copy

func (l *Logger) Copy() *Logger

Copy returns a copy of the logger.

func (*Logger) Debug

func (l *Logger) Debug(args ...interface{})

func (*Logger) Debugf

func (l *Logger) Debugf(format string, args ...interface{})

func (*Logger) Error

func (l *Logger) Error(args ...interface{})

func (*Logger) Errorf

func (l *Logger) Errorf(format string, args ...interface{})

func (*Logger) Fatal

func (l *Logger) Fatal(errorcode int, args ...interface{})

func (*Logger) Fatalf

func (l *Logger) Fatalf(errorcode int, format string, args ...interface{})

Fatal is a convenience function for logging an error and exiting the program.

func (*Logger) GetLevel added in v1.7.2

func (l *Logger) GetLevel() LogLevel

GetLevel retrieves the log level for the current logger.

func (*Logger) Info

func (l *Logger) Info(args ...interface{})

func (*Logger) Infof

func (l *Logger) Infof(format string, args ...interface{})

func (*Logger) Log

func (l *Logger) Log(level LogLevel, args ...interface{})

func (*Logger) Logf

func (l *Logger) Logf(level LogLevel, format string, args ...interface{})

func (*Logger) NameSpace

func (l *Logger) NameSpace(label string) Log

NameSpace returns a new Log with the given label as the prefix.

func (*Logger) Output

func (l *Logger) Output(level LogLevel) io.Writer

Returns the output for the given log level.

func (*Logger) PWriter

func (l *Logger) PWriter(label string, level LogLevel) io.Writer

PWriter returns a new io.Writer that writes to the log output for the given log level with a prefix.

func (*Logger) SetLevel

func (l *Logger) SetLevel(level LogLevel)

SetLevel sets the current log level.

func (*Logger) SetOutput

func (l *Logger) SetOutput(level LogLevel, w io.Writer)

SetOutput sets the output for the given log level.

func (*Logger) Warn

func (l *Logger) Warn(args ...interface{})

func (*Logger) Warnf

func (l *Logger) Warnf(format string, args ...interface{})

func (*Logger) WriteString

func (l *Logger) WriteString(s string) (n int, err error)

func (*Logger) Writer

func (l *Logger) Writer(level LogLevel) io.Writer

Writer returns a new io.Writer that writes to the log output for the given log level.

Jump to

Keyboard shortcuts

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