log

package module
v0.2.7 Latest Latest
Warning

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

 Go to latest Published: Mar 21, 2026 License: Apache-2.0 Imports: 17 Imported by: 0

README

// made with <3

About

This logger aims to be performant and async out of the gate.

Features
  • Log rotations
  • Async logging
  • File logging
Usage Install into your project 
go get -u github.com/LatteSec/log@latest
Use it 
import "github.com/LatteSec/log"

func main() {
  defer log.Sync()

  // Use it straight away with a default logger
  log.Info().Msg("Hello, World!").Send()
  log.Log(log.INFO).Msg("Hello, World!").Send()

  // or create a logger
  logger, _ := log.NewLogger().
              Name("my-logger").
              Level(log.INFO).
              Build()

  _ = logger.Start()
  logger.Info().Msg("Hello from custom logger!").Send()
  logger.Log(log.INFO).Msg("Hello from custom logger!").Send()

  // and you can register it to the global logger too!
  log.Register(logger)
}
Development 
# For all the commands you will need
make help
Special Thanks
  • Waku - For the project templating
  • Img Shields - For the awesome README badges
  • Hyprland - For showing how to make beautiful READMEs
  • Hyprdots - For showing how to make beautiful READMEs

stars-graph

Documentation

Overview

Package log is an extensible logging library

We use the concept of "loggers sharing handlers" to enable more efficient use of resources for complex asynchronous logging needs.

Usage: 

import "github.com/LatteSec/log"

func main() {
  defer log.Sync()

  // Use it straight away with a default logger
  log.Info().Msg("Hello, World!").Send()
  log.Log(log.INFO).Msg("Hello, World!").Send()

  // or create a logger
  logger, _ := log.NewLogger().
              Name("my-logger").
              Level(log.INFO).
              Build()

  _ = logger.Start()
  logger.Info().Msg("Hello from custom logger!").Send()
  logger.Log(log.INFO).Msg("Hello from custom logger!").Send()

  // and you can register it to the global logger too!
  log.Register(logger)
}
```

Index

Constants

This section is empty.

Variables

View Source 
var (
	DefaultStdoutHandler atomic.Pointer[WriterHandler]
	DefaultStderrHandler atomic.Pointer[WriterHandler]

	ErrNotStarted                = errors.New("not started")
	ErrAlreadyStarted            = errors.New("already started")
	ErrInvalidLogHandler         = errors.New("invalid log handler")
	ErrInvalidLogLevel           = errors.New("invalid log level")
	ErrInvalidMaxFileSize        = errors.New("invalid max file size")
	ErrInvalidMaxFileArchives    = errors.New("invalid max file archives")
	ErrMissingLogFilename        = errors.New("missing log filename")
	ErrNoLogFileConfigured       = errors.New("no log file configured")
	ErrFoundDirWhenExpectingFile = errors.New("found directory when expecting file")
)
View Source 
var ErrSkipClose = errors.New("skip running closing")

Functions

func Register 

func Register(l *Logger)

func RegisterStderrHandler added in v0.2.2 

func RegisterStderrHandler(handler *WriterHandler) error

func RegisterStdoutHandler added in v0.2.2 

func RegisterStdoutHandler(handler *WriterHandler) error

func SetInterruptHandler added in v0.2.7 

func SetInterruptHandler(enabled bool)

SetInterruptHandler enables or disables the SIGINT/TERM handler

Please only disable this if you plan to implement your own handler. You can use Sync to handle cleanup on interrupt.

func Sync added in v0.2.3 

func Sync()

Types

type BaseHandler 

type BaseHandler struct {
	LogHandler

	HandleFunc func(context.Context, *LogMessage) error

	StartFunc      func(context.Context, LogHandler) error
	CancelPreFunc  func(context.Context, LogHandler) error // runs before ctx.cancel is executed, return ErrSkipClose to skip
	CancelPostFunc func(context.Context, LogHandler) error
	CloseFunc      func(context.Context, LogHandler) error
	Subprocesses   []func(context.Context) error // processes must terminate when ctx is done
	// contains filtered or unexported fields
}

Start() -> StartFunc() -> Subprocess -> CancelPreFunc() -> CancelPostFunc() -> OnSigint() -> CloseFunc()

func (*BaseHandler) Close added in v0.2.0 

func (b *BaseHandler) Close() error

func (*BaseHandler) Handle added in v0.2.0 

func (b *BaseHandler) Handle(loggerName string, msg *LogMessage)

func (*BaseHandler) IsRunning added in v0.2.0 

func (b *BaseHandler) IsRunning() bool

func (*BaseHandler) Start added in v0.2.0 

func (b *BaseHandler) Start() error

type FileHandler 

type FileHandler struct {
	BaseHandler
	// contains filtered or unexported fields
}

func NewFileHandler 

func NewFileHandler(path string) (*FileHandler, error)

NewFileHandler creates a new FileHandler and starts it.

func (*FileHandler) GetLogfileLocation 

func (f *FileHandler) GetLogfileLocation() (dir, base string)

func (*FileHandler) GetMaxFileSize added in v0.2.0 

func (f *FileHandler) GetMaxFileSize() int64

func (*FileHandler) GetMaxFilesArchived added in v0.2.5 

func (f *FileHandler) GetMaxFilesArchived() int

func (*FileHandler) SetLogfileLocation 

func (f *FileHandler) SetLogfileLocation(dir, base string) error

func (*FileHandler) SetMaxFileArchives added in v0.2.5 

func (f *FileHandler) SetMaxFileArchives(amt int)

func (*FileHandler) SetMaxFileSize added in v0.2.0 

func (f *FileHandler) SetMaxFileSize(size int64)

type ILogger 

type ILogger interface {
	Start() error
	Close() error

	GetName() string
	SetName(name string)

	GetLevel() Level
	SetLevel(level Level) error

	IsRunning() bool
	Stdout(on bool)
	Stderr(on bool)

	SendLog(msg *LogMessage)

	Log() *LogMessage
	Debug() *LogMessage
	Info() *LogMessage
	Warn() *LogMessage
	Error() *LogMessage
	Fatal() *LogMessage
}

type Level 

type Level int

Log Level 

const (
	TRACE Level = iota
	DEBUG
	INFO
	WARN
	ERROR
	QUIET
)

Log Levels

Arranged from most to least verbose

type LogHandler 

type LogHandler interface {
	Handle(loggerName string, msg *LogMessage) // handles the log message

	Start() error    // starts the handler
	Close() error    // closes the handler
	IsRunning() bool // returns true if the handler is running
}

Loggers use LogHandlers under the hood to handle log messages

type LogMessage 

type LogMessage struct {
	Timestamp time.Time          // timestamp
	Level     Level              // log level
	Message   string             // log message
	Meta      []LogMessageMetaKV // log metadata
	// contains filtered or unexported fields
}

func Debug 

func Debug() *LogMessage

func Error 

func Error() *LogMessage

func Fatal 

func Fatal() *LogMessage

func Info 

func Info() *LogMessage

func Log 

func Log(level Level) *LogMessage

func NewLogMessage 

func NewLogMessage() *LogMessage

NewLogMessage

Creates a new LogMessage

func Warn 

func Warn() *LogMessage

func (*LogMessage) Debug 

func (lm *LogMessage) Debug() *LogMessage

func (*LogMessage) Error 

func (lm *LogMessage) Error() *LogMessage

func (*LogMessage) Fatal 

func (lm *LogMessage) Fatal() *LogMessage

func (*LogMessage) Info 

func (lm *LogMessage) Info() *LogMessage

func (*LogMessage) LevelString added in v0.2.3 

func (lm *LogMessage) LevelString() string

func (*LogMessage) Msg 

func (lm *LogMessage) Msg(msg ...any) *LogMessage

func (*LogMessage) Msgf 

func (lm *LogMessage) Msgf(format string, v ...any) *LogMessage

func (*LogMessage) Send 

func (lm *LogMessage) Send()

func (*LogMessage) SendE added in v0.2.1 

func (lm *LogMessage) SendE() error

func (*LogMessage) String 

func (lm *LogMessage) String(loggerName string) string

func (*LogMessage) Warn 

func (lm *LogMessage) Warn() *LogMessage

func (*LogMessage) WithCaller 

func (lm *LogMessage) WithCaller() *LogMessage

func (*LogMessage) WithLevel 

func (lm *LogMessage) WithLevel(level Level) *LogMessage

func (*LogMessage) WithMeta 

func (lm *LogMessage) WithMeta(key string, value any) *LogMessage

func (*LogMessage) WithMetaf 

func (lm *LogMessage) WithMetaf(key, format string, v ...any) *LogMessage

func (*LogMessage) WithSend 

func (lm *LogMessage) WithSend(send func(*LogMessage)) *LogMessage

func (*LogMessage) WithTraceStack 

func (lm *LogMessage) WithTraceStack() *LogMessage

type LogMessageMetaKV 

type LogMessageMetaKV struct {
	K, V string
}

type Logger 

type Logger struct {
	LoggerMeta
	// contains filtered or unexported fields
}

func DefaultLogger 

func DefaultLogger() *Logger

func (*Logger) Close 

func (l *Logger) Close() error

func (*Logger) Debug 

func (l *Logger) Debug() *LogMessage

func (*Logger) Error 

func (l *Logger) Error() *LogMessage

func (*Logger) Fatal 

func (l *Logger) Fatal() *LogMessage

func (*Logger) GetLevel 

func (l *Logger) GetLevel() Level

func (*Logger) GetName 

func (l *Logger) GetName() string

func (*Logger) Info 

func (l *Logger) Info() *LogMessage

func (*Logger) IsRunning 

func (l *Logger) IsRunning() bool

func (*Logger) Log 

func (l *Logger) Log(level Level) *LogMessage

func (*Logger) SendLog 

func (l *Logger) SendLog(msg *LogMessage)

func (*Logger) SetLevel 

func (l *Logger) SetLevel(level Level) error

func (*Logger) SetName 

func (l *Logger) SetName(name string)

func (*Logger) Start 

func (l *Logger) Start() error

func (*Logger) Stderr 

func (l *Logger) Stderr(on bool)

func (*Logger) Stdout 

func (l *Logger) Stdout(on bool)

func (*Logger) Warn 

func (l *Logger) Warn() *LogMessage

type LoggerBuilder 

type LoggerBuilder struct {
	LoggerMeta
	// contains filtered or unexported fields
}

func NewLogger 

func NewLogger() *LoggerBuilder

func (*LoggerBuilder) Build 

func (lb *LoggerBuilder) Build() (*Logger, error)

func (*LoggerBuilder) Debug 

func (lb *LoggerBuilder) Debug() *LoggerBuilder

func (*LoggerBuilder) Error 

func (lb *LoggerBuilder) Error() *LoggerBuilder

func (*LoggerBuilder) Info 

func (lb *LoggerBuilder) Info() *LoggerBuilder

func (*LoggerBuilder) Name 

func (lb *LoggerBuilder) Name(name string) *LoggerBuilder

func (*LoggerBuilder) Trace 

func (lb *LoggerBuilder) Trace() *LoggerBuilder

func (*LoggerBuilder) Warn 

func (lb *LoggerBuilder) Warn() *LoggerBuilder

func (*LoggerBuilder) WithCleanup 

func (lb *LoggerBuilder) WithCleanup(fns ...func()) *LoggerBuilder

func (*LoggerBuilder) WithFile 

func (lb *LoggerBuilder) WithFile(path string, maxLogFileSize int64, maxArchives int) *LoggerBuilder

path is the path to the log file maxLogFileSize is the maximum size of the log file in bytes before it is rotated (set to -1 to disable rotations) maxArchives is the maximum number of log files to keep (set to -1 to disable rotations)

func (*LoggerBuilder) WithHandlers 

func (lb *LoggerBuilder) WithHandlers(hs ...LogHandler) *LoggerBuilder

func (*LoggerBuilder) WithLevel 

func (lb *LoggerBuilder) WithLevel(level Level) *LoggerBuilder

func (*LoggerBuilder) WithStderr 

func (lb *LoggerBuilder) WithStderr(on bool) *LoggerBuilder

func (*LoggerBuilder) WithStdout 

func (lb *LoggerBuilder) WithStdout(on bool) *LoggerBuilder

func (*LoggerBuilder) WithWriter added in v0.2.0 

func (lb *LoggerBuilder) WithWriter(wr io.Writer) *LoggerBuilder

type LoggerMeta 

type LoggerMeta struct {
	// contains filtered or unexported fields
}

type WriterHandler 

type WriterHandler struct {
	BaseHandler
	// contains filtered or unexported fields
}

func NewWriterHandler added in v0.2.0 

func NewWriterHandler(writer io.Writer) *WriterHandler

func (*WriterHandler) SetWriter added in v0.2.3 

func (wh *WriterHandler) SetWriter(writer io.Writer)

func (*WriterHandler) Writer added in v0.2.3 

func (wh *WriterHandler) Writer() io.Writer

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.