logger

package
v1.43.2 Latest Latest
Warning

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

 Go to latest Published: Oct 30, 2025 License: Apache-2.0 Imports: 32 Imported by: 200

Documentation

Overview

Package logger provides a flexible logging interface with support for multiple backends (logrus, slog) and various output formats.

The package offers a global logger instance that can be configured with different log levels, output formats, and additional context values.

Basic Usage: 

logger.Infof("Server started on port %d", 8080)
logger.Debugf("Processing request: %s", requestID)
logger.Errorf("Failed to connect to database: %v", err)

With Context Values: 

log := logger.GetLogger().WithValues("user", userID, "request", requestID)
log.Infof("Processing user request")

Named Loggers: 

dbLogger := logger.GetLogger().Named("database")
apiLogger := logger.GetLogger().Named("api")

Log Levels: 

logger.SetLogLevel(logger.Debug)  // Enable debug logging
logger.SetLogLevel(logger.Trace)  // Enable trace logging

The package supports standard log levels (Info, Debug, Error, etc.) plus extended trace levels (Trace, Trace1-4) for fine-grained debugging.

Index

Constants

View Source 
const (
	Cyan = cyan + Normal

	Magenta   = magenta + Normal
	DarkWhite = "\x1b[38;5;244m"
	Normal    = "m"
	Reset     = "\x1b[0m"
)

Variables

View Source 
var CommonRedactedHeaders = []string{
	"Authorization*", "Bearer*", "Session*", "*Cookie", "*Token", "*-Secret", "*-Key",
	"Password", "Passwd", "Pwd",
}
View Source 
var SensitiveHeaders = []string{
	"Authorization",
	"Set-Cookie",
	"Cookie",
	"Proxy-Authorization",
	"Cookie",
}
View Source 
var SensitiveKeys = []string{"user", "pass", "key", "token", "username", "password"}
View Source 
var SkipFrameContains = []string{
	"gorm.io",
	"golang.org/toolchain",
}
View Source 
var SkipFrameSuffixes = []string{
	"logger/slog.go",
	"logger/default.go",
	"logger/caller.go",
	"gorm/logger.go",
	"golang.org/toolchain",
}
View Source 
var SlogFatal = slog.LevelError + 1
View Source 
var SlogTraceLevel slog.Level = slog.LevelDebug - 1

Functions

func BindFlags added in v1.4.0 

func BindFlags(flags *pflag.FlagSet)

BindFlags add flags to an existing flag set, note that this is not an actual binding which occurs later during initialization

func BrightF added in v1.26.0 

func BrightF(msg string, args ...interface{}) string

func Caller added in v1.26.0 

func Caller(skip ...int) string

Caller return the file name and line number of the current file

func CallerPC added in v1.26.0 

func CallerPC(skip ...int) uintptr

func Configure added in v1.41.1 

func Configure(flags Flags)

func Debugf 

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

Debugf logs a debug message with formatting support. These messages are only shown when debug logging is enabled.

func Errorf 

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

Errorf logs an error message with formatting support. Use this for errors that need attention but don't terminate the program.

func Fatalf 

func Fatalf(format string, args ...interface{})

Fatalf logs a fatal error message and terminates the program. Use this for unrecoverable errors.

func GetCaller added in v1.27.0 

func GetCaller(pc ...uintptr) string

func GetNamedLoggingLevels added in v1.26.2 

func GetNamedLoggingLevels() (levels map[string]string)

func Infof 

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

Infof logs an informational message with formatting support. These are general informational messages about normal operations.

func IsDebugEnabled 

func IsDebugEnabled() bool

IsDebugEnabled returns true if debug level logging is enabled.

func IsJsonLogs added in v1.20.1 

func IsJsonLogs() bool

func IsLevelEnabled added in v1.20.1 

func IsLevelEnabled(level int) bool

IsLevelEnabled returns true if the specified verbosity level is enabled.

Example: 

if logger.IsLevelEnabled(3) {
    // Perform expensive operation only if logging at level 3
}

func IsSensitiveKey added in v1.30.0 

func IsSensitiveKey(v string) bool

func IsTraceEnabled 

func IsTraceEnabled() bool

IsTraceEnabled returns true if trace level logging is enabled.

func NewHttpLogger added in v1.29.0 

func NewHttpLogger(logger Logger, rt http.RoundTripper) http.RoundTripper

NewHttpLogger creates an HTTP logger that logs at predefined levels. Deprecated: Use NewHttpLoggerWithLevels for more control over logging levels.

Default behavior:

  • Headers and timing: Requires log level 5 (Trace3)
  • Request body: Requires log level 6 (Trace4)
  • Response body: Requires log level 7

func NewHttpLoggerWithLevels added in v1.40.2 

func NewHttpLoggerWithLevels(logger Logger, rt http.RoundTripper, headerLevel, bodyLevel LogLevel) http.RoundTripper

NewHttpLoggerWithLevels creates an HTTP logger with configurable log levels for headers and body.

Parameters:

  • logger: The logger instance to use
  • rt: The underlying RoundTripper to wrap
  • headerLevel: Minimum log level required to log headers, timing, and TLS info
  • bodyLevel: Minimum log level required to log request/response bodies

Example: 

// Log headers at debug level (-v) and bodies at trace level (-vv)
transport := NewHttpLoggerWithLevels(logger, http.DefaultTransport, logger.Debug, logger.Trace)

func Pretty added in v1.26.0 

func Pretty(v any) string

func PrettyYAML added in v1.30.5 

func PrettyYAML(s string) string

func Prettyf added in v1.3.0 

func Prettyf(msg string, obj interface{})

Prettyf logs a trace message with a pretty-printed representation of the given object. Useful for debugging complex data structures.

Example: 

logger.Prettyf("User data:", userStruct) // Logs formatted struct

func PrintableSecret added in v1.26.3 

func PrintableSecret(secret string) string

PrintableSecret returns an approximation of a secret, so that it is possible to compare the secrets rudimentally e.g. for "john-doe-jane" it will return ***e Secrets smaller than 10 characters will always return *** These secrets

func SanitizeHeaders added in v1.29.0 

func SanitizeHeaders(headers http.Header, redactedHeaders ...string) http.Header

func Secretf added in v1.3.0 

func Secretf(format string, args ...interface{})

Secretf logs a trace message after attempting to strip any secrets from the text. It automatically redacts common secret patterns like passwords, tokens, and API keys.

Example: 

logger.Secretf("Connecting with password=%s", password) // password will be redacted

func SetLogger added in v1.20.0 

func SetLogger(logger Logger)

SetLogger replaces the global logger instance. Use this to configure a custom logger implementation.

func Stacktrace added in v1.26.0 

func Stacktrace() string

func StripSecrets added in v1.26.3 

func StripSecrets(text string) string

StripSecrets takes a URL, YAML or INI formatted text and removes any potentially secret data as denoted by keys containing "pass" or "secret" or exact matches for "key" the last character of the secret is kept to aid in troubleshooting

func StripSecretsFromMap added in v1.30.5 

func StripSecretsFromMap[V comparable](m map[string]V) map[string]any

func Tracef 

func Tracef(format string, args ...interface{})

Tracef logs a trace message with formatting support. These are very detailed messages for troubleshooting, only shown at trace level.

func Use added in v1.42.2 

func Use(writer io.Writer)

Use configures the logger to write to the specified writer. This replaces the current logger with one that outputs to the given writer. Useful for integrating with test frameworks like Ginkgo.

Example: 

logger.Use(GinkgoWriter) // Route logger output to Ginkgo's test writer

func UseCobraFlags added in v1.40.2 

func UseCobraFlags(flags *pflag.FlagSet)

UseCobraFlags initializes the logger using values from parsed cobra flags. This should be called after cobra has parsed the command line arguments.

func UseSlog added in v1.26.0 

func UseSlog()

func Warnf 

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

Warnf logs a warning message with formatting support. These are messages about potentially harmful situations.

Types

type BufferedLogEntry added in v1.42.0 

type BufferedLogEntry struct {
	Message string
	Time    time.Time
	Level   LogLevel
}

BufferedLogEntry represents a single buffered log message

type BufferedLogger added in v1.42.0 

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

BufferedLogger implements Logger interface with in-memory log storage

func NewBufferedLogger added in v1.42.0 

func NewBufferedLogger(maxLogs int) *BufferedLogger

NewBufferedLogger creates a new BufferedLogger with default retention strategy

func NewBufferedLoggerWithRetention added in v1.42.0 

func NewBufferedLoggerWithRetention(config RetentionConfig) *BufferedLogger

NewBufferedLoggerWithRetention creates a new BufferedLogger with custom retention config

func (*BufferedLogger) ClearLogs added in v1.42.0 

func (b *BufferedLogger) ClearLogs()

ClearLogs clears all buffered log entries

func (*BufferedLogger) Debugf added in v1.42.0 

func (b *BufferedLogger) Debugf(format string, args ...interface{})

Debugf logs a debug message

func (*BufferedLogger) Errorf added in v1.42.0 

func (b *BufferedLogger) Errorf(format string, args ...interface{})

Errorf logs an error message

func (*BufferedLogger) Fatalf added in v1.42.0 

func (b *BufferedLogger) Fatalf(format string, args ...interface{})

Fatalf logs a fatal message and panics

func (*BufferedLogger) GetLevel added in v1.42.0 

func (b *BufferedLogger) GetLevel() LogLevel

GetLevel returns the current log level

func (*BufferedLogger) GetLogs added in v1.42.0 

func (b *BufferedLogger) GetLogs() []BufferedLogEntry

GetLogs returns a copy of all buffered log entries, sorted by timestamp

func (*BufferedLogger) GetLogsByLevel added in v1.42.0 

func (b *BufferedLogger) GetLogsByLevel(level LogLevel) []BufferedLogEntry

GetLogsByLevel returns buffered log entries for a specific level

func (*BufferedLogger) GetRetentionPolicy added in v1.42.0 

func (b *BufferedLogger) GetRetentionPolicy() RetentionConfig

GetRetentionPolicy returns current retention limits

func (*BufferedLogger) GetSlogLogger added in v1.42.0 

func (b *BufferedLogger) GetSlogLogger() *slog.Logger

GetSlogLogger returns nil (unsupported as requested)

func (*BufferedLogger) Infof added in v1.42.0 

func (b *BufferedLogger) Infof(format string, args ...interface{})

Infof logs an info message

func (*BufferedLogger) IsDebugEnabled added in v1.42.0 

func (b *BufferedLogger) IsDebugEnabled() bool

IsDebugEnabled checks if debug level is enabled

func (*BufferedLogger) IsLevelEnabled added in v1.42.0 

func (b *BufferedLogger) IsLevelEnabled(level LogLevel) bool

IsLevelEnabled checks if a specific level is enabled

func (*BufferedLogger) IsTraceEnabled added in v1.42.0 

func (b *BufferedLogger) IsTraceEnabled() bool

IsTraceEnabled checks if trace level is enabled

func (*BufferedLogger) Named added in v1.42.0 

func (b *BufferedLogger) Named(name string) Logger

Named returns the same logger (noop as requested)

func (*BufferedLogger) ScaleRetentionByLogLevel added in v1.42.0 

func (b *BufferedLogger) ScaleRetentionByLogLevel()

ScaleRetentionByLogLevel adjusts retention based on current log level Higher verbosity = more retention for all levels

func (*BufferedLogger) SetLogLevel added in v1.42.0 

func (b *BufferedLogger) SetLogLevel(level any)

SetLogLevel sets the log level and automatically scales retention

func (*BufferedLogger) SetMinLogLevel added in v1.42.0 

func (b *BufferedLogger) SetMinLogLevel(level any)

SetMinLogLevel sets the minimum log level (same as SetLogLevel for BufferedLogger)

func (*BufferedLogger) SetRetentionPolicy added in v1.42.0 

func (b *BufferedLogger) SetRetentionPolicy(config RetentionConfig)

SetRetentionPolicy updates the retention limits for log levels

func (*BufferedLogger) Tracef added in v1.42.0 

func (b *BufferedLogger) Tracef(format string, args ...interface{})

Tracef logs a trace message

func (*BufferedLogger) V added in v1.42.0 

func (b *BufferedLogger) V(level any) Verbose

V returns a verbose logger

func (*BufferedLogger) Warnf added in v1.42.0 

func (b *BufferedLogger) Warnf(format string, args ...interface{})

Warnf logs a warning message

func (*BufferedLogger) WithSkipReportLevel added in v1.42.0 

func (b *BufferedLogger) WithSkipReportLevel(i int) Logger

WithSkipReportLevel returns the same logger (noop as requested)

func (*BufferedLogger) WithV added in v1.42.0 

func (b *BufferedLogger) WithV(level any) Logger

WithV returns the same logger (for simplicity)

func (*BufferedLogger) WithValues added in v1.42.0 

func (b *BufferedLogger) WithValues(keysAndValues ...interface{}) Logger

WithValues returns the same logger (noop as requested)

func (*BufferedLogger) WithoutName added in v1.42.0 

func (b *BufferedLogger) WithoutName() Logger

WithoutName returns the same logger (noop as requested)

type Flags added in v1.41.1 

type Flags struct {
	Color, ReportCaller, JsonLogs, LogToStderr bool
	Level                                      string
	LevelCount                                 int
}

type LogLevel added in v1.26.0 

type LogLevel int

LogLevel represents the severity of a log message. Higher values indicate more verbose logging. 

const (
	Debug  LogLevel = 1
	Trace  LogLevel = 2
	Trace1 LogLevel = 3
	Trace2 LogLevel = 4
	Trace3 LogLevel = 5
	Trace4 LogLevel = 6
	Info   LogLevel = 0
	Warn   LogLevel = -1
	Error  LogLevel = -2
	Fatal  LogLevel = -3
	Silent LogLevel = 10
)

func FromSlogLevel added in v1.26.0 

func FromSlogLevel(level slog.Level) LogLevel

func ParseLevel added in v1.26.0 

func ParseLevel(logger Logger, level any) LogLevel

func (LogLevel) Slog added in v1.26.0 

func (level LogLevel) Slog() slog.Level

func (LogLevel) String added in v1.27.0 

func (l LogLevel) String() string

type Logger 

type Logger interface {
	Warnf(format string, args ...interface{})
	Infof(format string, args ...interface{})
	Errorf(format string, args ...interface{})
	Debugf(format string, args ...interface{})
	Tracef(format string, args ...interface{})
	Fatalf(format string, args ...interface{})
	// WithValues returns a new Logger with additional key-value pairs
	// that will be included in all subsequent log messages.
	//
	// Example:
	//   log := logger.WithValues("component", "auth", "version", "1.0")
	//   log.Infof("User logged in") // Will include component=auth version=1.0
	WithValues(keysAndValues ...interface{}) Logger
	IsTraceEnabled() bool
	IsDebugEnabled() bool
	IsLevelEnabled(level LogLevel) bool
	GetLevel() LogLevel
	SetLogLevel(level any)
	SetMinLogLevel(level any)
	// V returns a Verbose logger that only logs if the specified level is enabled.
	// Level can be an integer or a named level (Debug, Trace, etc.).
	//
	// Example:
	//   logger.V(2).Infof("This only logs at verbosity 2+")
	//   logger.V(logger.Trace).Infof("This only logs at trace level")
	V(level any) Verbose
	WithV(level any) Logger
	// Named returns a new Logger with the specified name added to the logging context.
	// This helps identify which component or subsystem generated the log.
	//
	// Example:
	//   dbLogger := logger.Named("database")
	//   dbLogger.Infof("Connected to database") // Logs with name="database"
	Named(name string) Logger
	WithoutName() Logger
	WithSkipReportLevel(i int) Logger
	GetSlogLogger() *slog.Logger
}

Logger is the main interface for logging operations. It provides methods for different log levels and supports structured logging with key-value pairs.

func StandardLogger 

func StandardLogger() Logger

StandardLogger returns the current global logger instance. This is equivalent to GetLogger().

func WithValues added in v1.4.2 

func WithValues(keysAndValues ...interface{}) Logger

WithValues returns a new logger with additional key-value pairs. These values will be included in all log messages from the returned logger.

Example: 

userLogger := logger.WithValues("user_id", 123, "session", "abc")
userLogger.Infof("User action") // Logs with user_id=123 session=abc

type RetentionConfig added in v1.42.0 

type RetentionConfig map[LogLevel]int

RetentionConfig defines retention limits for each log level

type SlogLogger added in v1.26.0 

type SlogLogger struct {
	*slog.Logger
	Prefix string
	Level  *slog.LevelVar
	Parent *SlogLogger
	// contains filtered or unexported fields
}

func GetLogger added in v1.26.0 

func GetLogger(names ...string) *SlogLogger

GetLogger returns a logger instance, optionally with the specified names. If no names are provided, returns the root logger. Multiple names create a hierarchical logger (e.g., GetLogger("app", "db") creates "app.db").

Example: 

dbLogger := logger.GetLogger("database")
apiLogger := logger.GetLogger("api", "v1")

func GetSlogLogger added in v1.26.0 

func GetSlogLogger() SlogLogger

func New added in v1.26.0 

func New(prefix string) *SlogLogger

func NewWithWriter added in v1.42.2 

func NewWithWriter(writer io.Writer) *SlogLogger

NewWithWriter creates a new SlogLogger that writes to the specified writer. This is useful for integrating with test frameworks or custom output destinations.

func (SlogLogger) DebugLevels added in v1.28.0 

func (s SlogLogger) DebugLevels()

func (SlogLogger) Debugf added in v1.26.0 

func (s SlogLogger) Debugf(format string, args ...interface{})

func (SlogLogger) Errorf added in v1.26.0 

func (s SlogLogger) Errorf(format string, args ...interface{})

func (SlogLogger) Fatalf added in v1.26.0 

func (s SlogLogger) Fatalf(format string, args ...interface{})

func (SlogLogger) GetLevel added in v1.26.0 

func (s SlogLogger) GetLevel() LogLevel

func (SlogLogger) GetSlogLogger added in v1.26.0 

func (s SlogLogger) GetSlogLogger() *slog.Logger

func (SlogLogger) Infof added in v1.26.0 

func (s SlogLogger) Infof(format string, args ...interface{})

func (SlogLogger) IsDebugEnabled added in v1.26.0 

func (s SlogLogger) IsDebugEnabled() bool

func (SlogLogger) IsLevelEnabled added in v1.26.0 

func (s SlogLogger) IsLevelEnabled(level LogLevel) bool

func (SlogLogger) IsTraceEnabled added in v1.26.0 

func (s SlogLogger) IsTraceEnabled() bool

func (SlogLogger) Named added in v1.26.0 

func (s SlogLogger) Named(name string) Logger

func (SlogLogger) Prettyf added in v1.26.0 

func (s SlogLogger) Prettyf(msg string, obj interface{})

func (SlogLogger) Secretf added in v1.26.0 

func (s SlogLogger) Secretf(format string, args ...interface{})

func (SlogLogger) SetLogLevel added in v1.26.0 

func (s SlogLogger) SetLogLevel(level any)

func (SlogLogger) SetMinLogLevel added in v1.26.0 

func (s SlogLogger) SetMinLogLevel(level any)

func (SlogLogger) Tracef added in v1.26.0 

func (s SlogLogger) Tracef(format string, args ...interface{})

func (SlogLogger) V added in v1.26.0 

func (s SlogLogger) V(level any) Verbose

func (SlogLogger) Warnf added in v1.26.0 

func (s SlogLogger) Warnf(format string, args ...interface{})

func (SlogLogger) WithSkipReportLevel added in v1.26.0 

func (s SlogLogger) WithSkipReportLevel(i int) Logger

func (SlogLogger) WithV added in v1.26.0 

func (s SlogLogger) WithV(level any) Logger

func (SlogLogger) WithValues added in v1.26.0 

func (s SlogLogger) WithValues(keysAndValues ...interface{}) Logger

func (SlogLogger) WithoutName added in v1.26.0 

func (s SlogLogger) WithoutName() Logger

type Verbose added in v1.5.1 

type Verbose interface {
	io.Writer
	Infof(format string, args ...interface{})
	WithFilter(filters ...string) Verbose
	Enabled() bool
}

Verbose provides conditional logging based on verbosity levels. It's returned by Logger.V() and only logs if the specified level is enabled.

Example: 

// Only logs if verbosity is 2 or higher
logger.V(2).Infof("Detailed debug information: %v", data)

func V added in v1.5.1 

func V(level any) Verbose

V returns a verbose logger for conditional logging at the specified level. The level can be an integer or a LogLevel constant.

Example: 

logger.V(2).Infof("Detailed info") // Only logs at verbosity 2+

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.