log

package
v12.120.0 Latest Latest
Warning

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

 Go to latest Published: Apr 29, 2024 License: Apache-2.0 Imports: 13 Imported by: 16

Documentation

Overview

Package log provides an improved logger

Example 
logger, err := New("/path/to/file.log", 0644)

if err != nil {
	fmt.Printf("Error: %v\n", err)
	return
}

// Enable buffered IO with 1-second flush interval
logger.EnableBufIO(time.Second)

// Set minimal log level
logger.MinLevel(INFO)

// Print message to log
logger.Print(DEBUG, "This is %s message", "debug")

// Package provides different methods for each level
logger.Debug("This is %d %s message", 2, "debug")
logger.Info("This is info message")
logger.Warn("This is warning message")
logger.Error("This is error message")
logger.Crit("This is critical message")

// Enable colors for output
logger.UseColors = true

// Encode messages to JSON
logger.UseJSON = true

// Print caller info
logger.WithCaller = true

// Use custom date & time layout
logger.TimeLayout = time.RFC3339

// Add fields to message
logger.Debug("This is %d %s message", 2, "debug", F{"user", "bob"}, F{"id", 200})

// AUX message it's unskippable message which will be printed to log file with
// any minimum level
//
// Note that all AUX messages are dropped when using JSON format
logger.Aux("This is aux message")

// Print simple divider
logger.Divider()

// For log rotation we provide method Reopen
logger.Reopen()

// If buffered IO is used, you should flush data before exit
logger.Flush()

Output:

Index

Examples

Constants

View Source 
const (
	DEBUG uint8 = 0  // DEBUG debug messages
	INFO  uint8 = 1  // INFO info messages
	WARN  uint8 = 2  // WARN warning messages
	ERROR uint8 = 3  // ERROR error messages
	CRIT  uint8 = 4  // CRIT critical error messages
	AUX   uint8 = 99 // AUX unskipable messages (separators, headers, etc...)
)
View Source 
const (
	DATE_LAYOUT_TEXT = "2006/01/02 15:04:05.000" // Datetime layout for text logs
	DATE_LAYOUT_JSON = time.RFC3339              // Datetime layout for JSON logs
)

Variables

View Source 
var (
	// ErrNilLogger is returned by Logger struct methods if struct is nil
	ErrNilLogger = errors.New("Logger is nil")

	// ErrUnexpectedLevel is returned by the MinLevel method if given level is unknown
	ErrUnexpectedLevel = errors.New("Unexpected level type")

	// ErrOutputNotSet is returned by the Reopen method if output file is not set
	ErrOutputNotSet = errors.New("Output file is not set")
)

Errors

View Source 
var Colors = map[uint8]string{
	DEBUG: "{s-}",
	INFO:  "",
	WARN:  "{y}",
	ERROR: "{#208}",
	CRIT:  "{#196}{*}",
}

Colors colors is map with fmtc color tags for every level

View Source 
var Global = &Logger{
	PrefixWarn:  true,
	PrefixError: true,
	PrefixCrit:  true,

	minLevel: INFO,
	mu:       &sync.Mutex{},
}

Global is global logger struct

View Source 
var PrefixMap = map[uint8]string{
	DEBUG: "[DEBUG]",
	INFO:  "[INFO]",
	WARN:  "[WARNING]",
	ERROR: "[ERROR]",
	CRIT:  "[CRITICAL]",
}

PrefixMap is map with messages prefixes

Functions

func Aux 

func Aux(f string, a ...any) error

Aux writes unskippable message (for separators/headers)

Example 
err := Set("/path/to/file.log", 0644)

if err != nil {
	fmt.Printf("Error: %v\n", err)
	return
}

Aux("Auxiliary message")

Output:

func Crit 

func Crit(f string, a ...any) error

Crit writes critical message to global logger output

Example 
err := Set("/path/to/file.log", 0644)

if err != nil {
	fmt.Printf("Error: %v\n", err)
	return
}

Crit("Critical error message")

Output:

func Debug 

func Debug(f string, a ...any) error

Debug writes debug message to global logger output

Example 
err := Set("/path/to/file.log", 0644)

if err != nil {
	fmt.Printf("Error: %v\n", err)
	return
}

Debug("Debug message")

Output:

func Divider added in v12.102.0 

func Divider() error

Divider writes simple divider to logger output

Example 
err := Set("/path/to/file.log", 0644)

if err != nil {
	fmt.Printf("Error: %v\n", err)
	return
}

Divider()

Output:

func EnableBufIO 

func EnableBufIO(interval time.Duration)

EnableBufIO enables buffered I/O

Example 
err := Set("/path/to/file.log", 0644)

if err != nil {
	fmt.Printf("Error: %v\n", err)
	return
}

// Enable buffered IO with 1-second flush interval
EnableBufIO(time.Second)

Info("Info message")

Flush()

Output:

func Error 

func Error(f string, a ...any) error

Error writes error message to global logger output

Example 
err := Set("/path/to/file.log", 0644)

if err != nil {
	fmt.Printf("Error: %v\n", err)
	return
}

Error("Error message")

Output:

func Flush 

func Flush() error

Flush writes buffered data to file

Example 
err := Set("/path/to/file.log", 0644)

if err != nil {
	fmt.Printf("Error: %v\n", err)
	return
}

// Enable buffered IO with 1-second flush interval
EnableBufIO(time.Second)

Info("Info message")

Flush()

Output:

func Info 

func Info(f string, a ...any) error

Info writes info message to global logger output

Example 
err := Set("/path/to/file.log", 0644)

if err != nil {
	fmt.Printf("Error: %v\n", err)
	return
}

Info("Info message")

Output:

func Is added in v12.85.0 

func Is(level uint8) bool

Is returns true if current minimal logging level is equal or greater than given

Example 
err := Set("/path/to/file.log", 0644)

if err != nil {
	fmt.Printf("Error: %v\n", err)
	return
}

if Is(INFO) {
	Info("Info message")
}

Output:

func MinLevel 

func MinLevel(level any) error

MinLevel defines minimal logging level

Example 
err := Set("/path/to/file.log", 0644)

if err != nil {
	fmt.Printf("Error: %v\n", err)
	return
}

// Set minimal log level to error
MinLevel(ERROR)

Info("This message is not displayed")
Error("This message is displayed")

Output:

func Print 

func Print(level uint8, f string, a ...any) error

Print writes message to global logger output

Example 
err := Set("/path/to/file.log", 0644)

if err != nil {
	fmt.Printf("Error: %v\n", err)
	return
}

Print(INFO, "Info message")
Print(ERROR, "Error message")

Output:

func Reopen 

func Reopen() error

Reopen close file descriptor for global logger and open it again Useful for log rotation

Example 
err := Set("/path/to/file.log", 0644)

if err != nil {
	fmt.Printf("Error: %v\n", err)
	return
}

// For log rotation we provide method Reopen
Reopen()

Output:

func Set 

func Set(file string, perms os.FileMode) error

Set changes global logger output target

Example 
err := Set("/path/to/file.log", 0644)

if err != nil {
	fmt.Printf("Error: %v\n", err)
	return
}

err = Set("/path/to/file2.log", 0640)

if err != nil {
	fmt.Printf("Error: %v\n", err)
	return
}

Info("Message will go to file2.log")

Output:

func Warn 

func Warn(f string, a ...any) error

Warn writes warning message to global logger output

Example 
err := Set("/path/to/file.log", 0644)

if err != nil {
	fmt.Printf("Error: %v\n", err)
	return
}

Warn("Warning message")

Output:

Types

type F added in v12.105.0 

type F = Field

F is a shortcut for Field struct

type Field added in v12.105.0 

type Field struct {
	Key   string
	Value any
}

Field contains key and value for JSON log

func (Field) String added in v12.105.0 

func (f Field) String() string

String returns string representation of field

type ILogger added in v12.57.0 

type ILogger interface {
	Aux(f string, a ...any) error
	Debug(f string, a ...any) error
	Info(f string, a ...any) error
	Warn(f string, a ...any) error
	Error(f string, a ...any) error
	Crit(f string, a ...any) error
	Print(level uint8, f string, a ...any) error
}

ILogger is interface for compatible loggers

type Logger 

type Logger struct {
	PrefixDebug bool // Show prefix for debug messages
	PrefixInfo  bool // Show prefix for info messages
	PrefixWarn  bool // Show prefix for warning messages
	PrefixError bool // Show prefix for error messages
	PrefixCrit  bool // Show prefix for critical/fatal messages

	TimeLayout string // Date and time layout used for rendering dates
	UseColors  bool   // Enable ANSI escape codes for colors in output
	UseJSON    bool   // Encode messages to JSON
	WithCaller bool   // Show caller info
	// contains filtered or unexported fields
}

Logger is a basic logger struct

func New 

func New(file string, perms os.FileMode) (*Logger, error)

New creates new logger struct

Example 
logger, err := New("/path/to/file.log", 0644)

if err != nil {
	fmt.Printf("Error: %v\n", err)
	return
}

// Package provides different methods for each level
logger.Debug("This is %d %s message", 2, "debug")
logger.Info("This is info message")
logger.Warn("This is warning message")
logger.Error("This is error message")
logger.Crit("This is critical message")

// If buffered IO is used, you should flush data before exit
logger.Flush()

Output:

func (*Logger) Aux 

func (l *Logger) Aux(f string, a ...any) error

Aux writes unfiltered message (for separators/headers) to logger output

Example 
logger, err := New("/path/to/file.log", 0644)

if err != nil {
	fmt.Printf("Error: %v\n", err)
	return
}

logger.Aux("Auxiliary message")

Output:

func (*Logger) Crit 

func (l *Logger) Crit(f string, a ...any) error

Crit writes critical message to logger output

Example 
logger, err := New("/path/to/file.log", 0644)

if err != nil {
	fmt.Printf("Error: %v\n", err)
	return
}

logger.Crit("Critical error message")

Output:

func (*Logger) Debug 

func (l *Logger) Debug(f string, a ...any) error

Debug writes debug message to logger output

Example 
logger, err := New("/path/to/file.log", 0644)

if err != nil {
	fmt.Printf("Error: %v\n", err)
	return
}

logger.Debug("Debug message")

Output:

func (*Logger) Divider added in v12.102.0 

func (l *Logger) Divider() error

Divider writes simple divider to logger output

Example 
logger, err := New("/path/to/file.log", 0644)

if err != nil {
	fmt.Printf("Error: %v\n", err)
	return
}

logger.Divider()

Output:

func (*Logger) EnableBufIO 

func (l *Logger) EnableBufIO(flushInterval time.Duration)

EnableBufIO enables buffered I/O support

Example 
logger, err := New("/path/to/file.log", 0644)

if err != nil {
	fmt.Printf("Error: %v\n", err)
	return
}

// Enable buffered IO with 1-second flush interval
logger.EnableBufIO(time.Second)

logger.Info("Info message")

logger.Flush()

Output:

func (*Logger) Error 

func (l *Logger) Error(f string, a ...any) error

Error writes error message to logger output

Example 
logger, err := New("/path/to/file.log", 0644)

if err != nil {
	fmt.Printf("Error: %v\n", err)
	return
}

logger.Error("Error message")

Output:

func (*Logger) Flush 

func (l *Logger) Flush() error

Flush writes buffered data to file

Example 
logger, err := New("/path/to/file.log", 0644)

if err != nil {
	fmt.Printf("Error: %v\n", err)
	return
}

// Enable buffered IO with 1-second flush interval
logger.EnableBufIO(time.Second)

logger.Info("Info message")

logger.Flush()

Output:

func (*Logger) Info 

func (l *Logger) Info(f string, a ...any) error

Info writes info message to logger output

Example 
logger, err := New("/path/to/file.log", 0644)

if err != nil {
	fmt.Printf("Error: %v\n", err)
	return
}

logger.Info("Info message")

Output:

func (*Logger) Is added in v12.85.0 

func (l *Logger) Is(level uint8) bool

Is returns true if current minimal logging level is equal or greater than given

Example 
logger, err := New("/path/to/file.log", 0644)

if err != nil {
	fmt.Printf("Error: %v\n", err)
	return
}

if logger.Is(INFO) {
	logger.Info("Info message")
}

Output:

func (*Logger) MinLevel 

func (l *Logger) MinLevel(level any) error

MinLevel defines minimal logging level

Example 
logger, err := New("/path/to/file.log", 0644)

if err != nil {
	fmt.Printf("Error: %v\n", err)
	return
}

// Set minimal log level to error
logger.MinLevel(ERROR)

logger.Info("This message is not displayed")
logger.Error("This message is displayed")

Output:

func (*Logger) Print 

func (l *Logger) Print(level uint8, f string, a ...any) error

Print writes message to logger output

Example 
logger, err := New("/path/to/file.log", 0644)

if err != nil {
	fmt.Printf("Error: %v\n", err)
	return
}

logger.Print(INFO, "Info message")
logger.Print(ERROR, "Error message")

Output:

func (*Logger) Reopen 

func (l *Logger) Reopen() error

Reopen closes file descriptor and opens it again Useful for log rotation

Example 
logger, err := New("/path/to/file.log", 0644)

if err != nil {
	fmt.Printf("Error: %v\n", err)
	return
}

// For log rotation we provide method Reopen
logger.Reopen()

Output:

func (*Logger) Set 

func (l *Logger) Set(file string, perms os.FileMode) error

Set changes logger output target

Example 
logger, err := New("/path/to/file.log", 0644)

if err != nil {
	fmt.Printf("Error: %v\n", err)
	return
}

err = logger.Set("/path/to/file2.log", 0640)

if err != nil {
	fmt.Printf("Error: %v\n", err)
	return
}

logger.Info("Message will go to file2.log")

Output:

func (*Logger) Warn 

func (l *Logger) Warn(f string, a ...any) error

Warn writes warning message to logger output

Example 
logger, err := New("/path/to/file.log", 0644)

if err != nil {
	fmt.Printf("Error: %v\n", err)
	return
}

logger.Warn("Warning message")

Output:

type NilLogger added in v12.100.0 

type NilLogger struct{}

NilLogger is Logger (ILogger) compatible logger that doesn't print anything

func (*NilLogger) Aux added in v12.100.0 

func (l *NilLogger) Aux(f string, a ...any) error

Aux do nothing

func (*NilLogger) Crit added in v12.100.0 

func (l *NilLogger) Crit(f string, a ...any) error

Crit do nothing

func (*NilLogger) Debug added in v12.100.0 

func (l *NilLogger) Debug(f string, a ...any) error

Debug do nothing

func (*NilLogger) Error added in v12.100.0 

func (l *NilLogger) Error(f string, a ...any) error

Error do nothing

func (*NilLogger) Info added in v12.100.0 

func (l *NilLogger) Info(f string, a ...any) error

Info do nothing

func (*NilLogger) Print added in v12.100.0 

func (l *NilLogger) Print(level uint8, f string, a ...any) error

Print do nothing

func (*NilLogger) Warn added in v12.100.0 

func (l *NilLogger) Warn(f string, a ...any) error

Warn do nothing

type StdLogger 

type StdLogger struct {
	Logger *Logger
}

StdLogger is logger wrapper compatible with stdlib logger

func (*StdLogger) Fatal 

func (l *StdLogger) Fatal(v ...any)

Fatal is analog of Fatal from stdlib

func (*StdLogger) Fatalf 

func (l *StdLogger) Fatalf(format string, v ...any)

Fatalf is analog of Fatalf from stdlib

func (*StdLogger) Fatalln 

func (l *StdLogger) Fatalln(v ...any)

Fatalln is analog of Fatalln from stdlib

func (*StdLogger) Output 

func (l *StdLogger) Output(calldepth int, s string) error

Output is analog of Output from stdlib

func (*StdLogger) Panic 

func (l *StdLogger) Panic(v ...any)

Panic is analog of Panic from stdlib

func (*StdLogger) Panicf 

func (l *StdLogger) Panicf(format string, v ...any)

Panicf is analog of Panicf from stdlib

func (*StdLogger) Panicln 

func (l *StdLogger) Panicln(v ...any)

Panicln is analog of Panicln from stdlib

func (*StdLogger) Print 

func (l *StdLogger) Print(v ...any)

Print is analog of Print from stdlib

func (*StdLogger) Printf 

func (l *StdLogger) Printf(format string, v ...any)

Printf is analog of Printf from stdlib

func (*StdLogger) Println 

func (l *StdLogger) Println(v ...any)

Println is analog of Println from stdlib

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.