438 lines
10 KiB
Go
438 lines
10 KiB
Go
package logger
|
|
|
|
import (
|
|
"fmt"
|
|
"io"
|
|
"os"
|
|
"sync"
|
|
"sync/atomic"
|
|
"time"
|
|
)
|
|
|
|
// ANSI color codes
|
|
const (
|
|
colorReset = "\033[0m"
|
|
colorRed = "\033[31m"
|
|
colorGreen = "\033[32m"
|
|
colorYellow = "\033[33m"
|
|
colorBlue = "\033[34m"
|
|
colorPurple = "\033[35m"
|
|
colorCyan = "\033[36m"
|
|
colorWhite = "\033[37m"
|
|
colorGray = "\033[90m"
|
|
)
|
|
|
|
// Log levels
|
|
const (
|
|
LevelDebug = iota
|
|
LevelInfo
|
|
LevelWarning
|
|
LevelError
|
|
LevelServer
|
|
LevelFatal
|
|
)
|
|
|
|
// Level names and colors
|
|
var levelProps = map[int]struct {
|
|
tag string
|
|
color string
|
|
}{
|
|
LevelDebug: {"DEBUG", colorCyan},
|
|
LevelInfo: {" INFO", colorBlue},
|
|
LevelWarning: {" WARN", colorYellow},
|
|
LevelError: {"ERROR", colorRed},
|
|
LevelServer: {" SYS", colorGreen},
|
|
LevelFatal: {"FATAL", colorPurple},
|
|
}
|
|
|
|
// Time format for log messages
|
|
const timeFormat = "15:04:05"
|
|
|
|
// Default rate limiting settings
|
|
const (
|
|
defaultMaxLogs = 1000 // Max logs per second before rate limiting
|
|
defaultRateLimitTime = 10 * time.Second // How long to pause during rate limiting
|
|
)
|
|
|
|
// Single global logger instance with mutex for safe initialization
|
|
var (
|
|
globalLogger *Logger
|
|
globalLoggerOnce sync.Once
|
|
)
|
|
|
|
// Logger handles logging operations
|
|
type Logger struct {
|
|
writer io.Writer
|
|
level int
|
|
useColors bool
|
|
timeFormat string
|
|
mu sync.Mutex // Mutex for thread-safe writing
|
|
debugMode atomic.Bool // Force debug logging regardless of level
|
|
|
|
// Simple rate limiting
|
|
logCount atomic.Int64 // Number of logs in current window
|
|
logCountStart atomic.Int64 // Start time of current counting window
|
|
rateLimited atomic.Bool // Whether we're currently rate limited
|
|
rateLimitUntil atomic.Int64 // Timestamp when rate limiting ends
|
|
maxLogsPerSec int64 // Maximum logs per second before limiting
|
|
limitDuration time.Duration // How long to pause logging when rate limited
|
|
}
|
|
|
|
// GetLogger returns the global logger instance, creating it if needed
|
|
func GetLogger() *Logger {
|
|
globalLoggerOnce.Do(func() {
|
|
globalLogger = newLogger(LevelInfo, true)
|
|
})
|
|
return globalLogger
|
|
}
|
|
|
|
// InitGlobalLogger initializes the global logger with custom settings
|
|
func InitGlobalLogger(minLevel int, useColors bool) {
|
|
globalLoggerOnce.Do(func() {
|
|
globalLogger = newLogger(minLevel, useColors)
|
|
})
|
|
}
|
|
|
|
// newLogger creates a new logger instance (internal use)
|
|
func newLogger(minLevel int, useColors bool) *Logger {
|
|
logger := &Logger{
|
|
writer: os.Stdout,
|
|
level: minLevel,
|
|
useColors: useColors,
|
|
timeFormat: timeFormat,
|
|
maxLogsPerSec: defaultMaxLogs,
|
|
limitDuration: defaultRateLimitTime,
|
|
}
|
|
|
|
// Initialize counters
|
|
logger.resetCounters()
|
|
|
|
return logger
|
|
}
|
|
|
|
// New creates a new logger (deprecated - use GetLogger() instead)
|
|
func New(minLevel int, useColors bool) *Logger {
|
|
return newLogger(minLevel, useColors)
|
|
}
|
|
|
|
// resetCounters resets the rate limiting counters
|
|
func (l *Logger) resetCounters() {
|
|
l.logCount.Store(0)
|
|
l.logCountStart.Store(time.Now().Unix())
|
|
l.rateLimited.Store(false)
|
|
l.rateLimitUntil.Store(0)
|
|
}
|
|
|
|
// SetOutput changes the output destination
|
|
func (l *Logger) SetOutput(w io.Writer) {
|
|
l.mu.Lock()
|
|
defer l.mu.Unlock()
|
|
l.writer = w
|
|
}
|
|
|
|
// TimeFormat returns the current time format
|
|
func (l *Logger) TimeFormat() string {
|
|
return l.timeFormat
|
|
}
|
|
|
|
// SetTimeFormat changes the time format string
|
|
func (l *Logger) SetTimeFormat(format string) {
|
|
l.timeFormat = format
|
|
}
|
|
|
|
// SetLevel changes the minimum log level
|
|
func (l *Logger) SetLevel(level int) {
|
|
l.level = level
|
|
}
|
|
|
|
// EnableColors enables ANSI color codes in the output
|
|
func (l *Logger) EnableColors() {
|
|
l.useColors = true
|
|
}
|
|
|
|
// DisableColors disables ANSI color codes in the output
|
|
func (l *Logger) DisableColors() {
|
|
l.useColors = false
|
|
}
|
|
|
|
// EnableDebug forces debug logs to be shown regardless of level
|
|
func (l *Logger) EnableDebug() {
|
|
l.debugMode.Store(true)
|
|
}
|
|
|
|
// DisableDebug stops forcing debug logs
|
|
func (l *Logger) DisableDebug() {
|
|
l.debugMode.Store(false)
|
|
}
|
|
|
|
// IsDebugEnabled returns true if debug mode is enabled
|
|
func (l *Logger) IsDebugEnabled() bool {
|
|
return l.debugMode.Load()
|
|
}
|
|
|
|
// writeMessage writes a formatted log message directly to the writer
|
|
func (l *Logger) writeMessage(level int, message string, rawMode bool) {
|
|
var logLine string
|
|
|
|
if rawMode {
|
|
// Raw mode - message is already formatted, just append newline
|
|
logLine = message + "\n"
|
|
} else {
|
|
// Standard format with timestamp, level tag, and message
|
|
now := time.Now().Format(l.timeFormat)
|
|
props := levelProps[level]
|
|
|
|
if l.useColors {
|
|
logLine = fmt.Sprintf("%s%s%s %s%s%s %s\n",
|
|
colorGray, now, colorReset, props.color, props.tag, colorReset, message)
|
|
} else {
|
|
logLine = fmt.Sprintf("%s %s %s\n",
|
|
now, props.tag, message)
|
|
}
|
|
}
|
|
|
|
// Synchronously write the log message
|
|
l.mu.Lock()
|
|
_, _ = fmt.Fprint(l.writer, logLine)
|
|
|
|
// For fatal errors, ensure we sync immediately
|
|
if level == LevelFatal {
|
|
if f, ok := l.writer.(*os.File); ok {
|
|
_ = f.Sync()
|
|
}
|
|
}
|
|
l.mu.Unlock()
|
|
}
|
|
|
|
// checkRateLimit checks if we should rate limit logging
|
|
// Returns true if the message should be logged, false if it should be dropped
|
|
func (l *Logger) checkRateLimit(level int) bool {
|
|
// High priority messages are never rate limited
|
|
if level >= LevelWarning {
|
|
return true
|
|
}
|
|
|
|
// Check if we're currently in a rate-limited period
|
|
if l.rateLimited.Load() {
|
|
now := time.Now().Unix()
|
|
limitUntil := l.rateLimitUntil.Load()
|
|
|
|
if now >= limitUntil {
|
|
// Rate limiting period is over
|
|
l.rateLimited.Store(false)
|
|
l.resetCounters()
|
|
} else {
|
|
// Still in rate limiting period, drop the message
|
|
return false
|
|
}
|
|
}
|
|
|
|
// If not rate limited, check if we should start rate limiting
|
|
count := l.logCount.Add(1)
|
|
|
|
// Check if we need to reset the counter for a new second
|
|
now := time.Now().Unix()
|
|
start := l.logCountStart.Load()
|
|
if now > start {
|
|
// New second, reset counter
|
|
l.logCount.Store(1) // Count this message
|
|
l.logCountStart.Store(now)
|
|
return true
|
|
}
|
|
|
|
// Check if we've exceeded our threshold
|
|
if count > l.maxLogsPerSec {
|
|
// Start rate limiting
|
|
l.rateLimited.Store(true)
|
|
l.rateLimitUntil.Store(now + int64(l.limitDuration.Seconds()))
|
|
|
|
// Log a warning about rate limiting
|
|
l.writeMessage(LevelServer,
|
|
fmt.Sprintf("Rate limiting logger temporarily due to high demand (%d logs/sec exceeded)", count),
|
|
false)
|
|
|
|
return false
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
// log handles the core logging logic with level filtering
|
|
func (l *Logger) log(level int, format string, args ...any) {
|
|
// Check if we should log this message
|
|
// Either level is high enough OR (it's a debug message AND debug mode is enabled)
|
|
if level < l.level && !(level == LevelDebug && l.debugMode.Load()) {
|
|
return
|
|
}
|
|
|
|
// Check rate limiting - always log high priority messages
|
|
if !l.checkRateLimit(level) {
|
|
return
|
|
}
|
|
|
|
// Format message
|
|
var message string
|
|
if len(args) > 0 {
|
|
message = fmt.Sprintf(format, args...)
|
|
} else {
|
|
message = format
|
|
}
|
|
|
|
l.writeMessage(level, message, false)
|
|
|
|
// Exit on fatal errors
|
|
if level == LevelFatal {
|
|
os.Exit(1)
|
|
}
|
|
}
|
|
|
|
// LogRaw logs a message with raw formatting, bypassing the standard format
|
|
func (l *Logger) LogRaw(format string, args ...any) {
|
|
// Use info level for filtering
|
|
if LevelInfo < l.level {
|
|
return
|
|
}
|
|
|
|
// Check rate limiting
|
|
if !l.checkRateLimit(LevelInfo) {
|
|
return
|
|
}
|
|
|
|
var message string
|
|
if len(args) > 0 {
|
|
message = fmt.Sprintf(format, args...)
|
|
} else {
|
|
message = format
|
|
}
|
|
|
|
// Don't apply colors if disabled
|
|
if !l.useColors {
|
|
// Strip ANSI color codes if colors are disabled
|
|
message = removeAnsiColors(message)
|
|
}
|
|
|
|
l.writeMessage(LevelInfo, message, true)
|
|
}
|
|
|
|
// Simple helper to remove ANSI color codes
|
|
func removeAnsiColors(s string) string {
|
|
result := ""
|
|
inEscape := false
|
|
|
|
for _, c := range s {
|
|
if inEscape {
|
|
if c == 'm' {
|
|
inEscape = false
|
|
}
|
|
continue
|
|
}
|
|
|
|
if c == '\033' {
|
|
inEscape = true
|
|
continue
|
|
}
|
|
|
|
result += string(c)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
// Debug logs a debug message
|
|
func (l *Logger) Debug(format string, args ...any) {
|
|
l.log(LevelDebug, format, args...)
|
|
}
|
|
|
|
// Info logs an informational message
|
|
func (l *Logger) Info(format string, args ...any) {
|
|
l.log(LevelInfo, format, args...)
|
|
}
|
|
|
|
// Warning logs a warning message
|
|
func (l *Logger) Warning(format string, args ...any) {
|
|
l.log(LevelWarning, format, args...)
|
|
}
|
|
|
|
// Error logs an error message
|
|
func (l *Logger) Error(format string, args ...any) {
|
|
l.log(LevelError, format, args...)
|
|
}
|
|
|
|
// Fatal logs a fatal error message and exits
|
|
func (l *Logger) Fatal(format string, args ...any) {
|
|
l.log(LevelFatal, format, args...)
|
|
// No need for os.Exit here as it's handled in log()
|
|
}
|
|
|
|
// Server logs a server message
|
|
func (l *Logger) Server(format string, args ...any) {
|
|
l.log(LevelServer, format, args...)
|
|
}
|
|
|
|
// Global helper functions that use the global logger
|
|
|
|
// Debug logs a debug message to the global logger
|
|
func Debug(format string, args ...any) {
|
|
GetLogger().Debug(format, args...)
|
|
}
|
|
|
|
// Info logs an informational message to the global logger
|
|
func Info(format string, args ...any) {
|
|
GetLogger().Info(format, args...)
|
|
}
|
|
|
|
// Warning logs a warning message to the global logger
|
|
func Warning(format string, args ...any) {
|
|
GetLogger().Warning(format, args...)
|
|
}
|
|
|
|
// Error logs an error message to the global logger
|
|
func Error(format string, args ...any) {
|
|
GetLogger().Error(format, args...)
|
|
}
|
|
|
|
// Fatal logs a fatal error message to the global logger and exits
|
|
func Fatal(format string, args ...any) {
|
|
GetLogger().Fatal(format, args...)
|
|
}
|
|
|
|
// Server logs a server message to the global logger
|
|
func Server(format string, args ...any) {
|
|
GetLogger().Server(format, args...)
|
|
}
|
|
|
|
// LogRaw logs a raw message to the global logger
|
|
func LogRaw(format string, args ...any) {
|
|
GetLogger().LogRaw(format, args...)
|
|
}
|
|
|
|
// SetLevel changes the minimum log level of the global logger
|
|
func SetLevel(level int) {
|
|
GetLogger().SetLevel(level)
|
|
}
|
|
|
|
// SetOutput changes the output destination of the global logger
|
|
func SetOutput(w io.Writer) {
|
|
GetLogger().SetOutput(w)
|
|
}
|
|
|
|
// TimeFormat returns the current time format of the global logger
|
|
func TimeFormat() string {
|
|
return GetLogger().TimeFormat()
|
|
}
|
|
|
|
// EnableDebug enables debug messages regardless of log level
|
|
func EnableDebug() {
|
|
GetLogger().EnableDebug()
|
|
}
|
|
|
|
// DisableDebug disables forced debug messages
|
|
func DisableDebug() {
|
|
GetLogger().DisableDebug()
|
|
}
|
|
|
|
// IsDebugEnabled returns true if debug mode is enabled
|
|
func IsDebugEnabled() bool {
|
|
return GetLogger().IsDebugEnabled()
|
|
}
|