Initial commit

internal/logger/logger.go

@@ -0,0 +1,170 @@
+// @tag logging
+// @tag core
+package logger
+
+import (
+	"fmt"
+	"log"
+	"os"
+	"sync"
+	"time"
+)
+
+// Level represents the minimum severity for log messages.
+type Level int
+
+// Log severity levels from most verbose to most critical.
+const (
+	LevelDebug Level = iota // Debug logs everything including diagnostic messages
+	LevelInfo               // Info logs informational messages and above (default)
+	LevelWarn               // Warn logs warnings, errors, and critical messages
+	LevelError              // LevelError logs only errors and critical messages
+)
+
+var (
+	currentLevel = LevelInfo
+	logger       = log.New(os.Stdout, "", 0)
+	logFile      *os.File
+	logPath      string
+	pid          int
+	mu           sync.Once
+	loggerMu     sync.Mutex // Protects logger and logFile
+)
+
+// initPID gets the process ID for log messages
+func initPID() {
+	pid = os.Getpid()
+}
+
+// formatLog formats a message with timestamp, log level, and pid.
+// Format: timestamp level pekoe[pid]: message
+func formatLog(level string, message string) string {
+	mu.Do(initPID)
+
+	// Timestamp format: "YYYY Mmm dd hh:mm:ss"
+	// e.g., "2024 Apr  2 14:30:15"
+	now := time.Now()
+	timestamp := now.Format("2006 Jan _2 15:04:05")
+
+	// Format: timestamp level pekoe[pid]: message
+	// e.g., "2024 Apr  2 14:30:15 INFO pekoe[12345]: event=startup"
+	return fmt.Sprintf("%s %s pekoe[%d]: %s", timestamp, level, pid, message)
+}
+
+// SetOutput configures the logger to write to the specified file.
+// An empty path resets to stdout.
+// Returns an error if the file cannot be opened/created.
+// nolint: gosec
+func SetOutput(path string) error {
+	loggerMu.Lock()
+	defer loggerMu.Unlock()
+
+	// Close existing log file if any
+	if logFile != nil {
+		_ = logFile.Close()
+		logFile = nil
+	}
+
+	if path == "" {
+		logPath = ""
+		logger = log.New(os.Stdout, "", 0)
+		return nil
+	}
+
+	file, err := os.OpenFile(path, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
+	if err != nil {
+		return err
+	}
+
+	logPath = path
+	logFile = file
+	logger = log.New(file, "", 0)
+	return nil
+}
+
+// Reopen reopens the log file.
+// This is useful for log rotation - after the log file is moved/renamed,
+// sending SIGUSR1 will cause the server to reopen the log file.
+// Returns an error if the log file cannot be opened.
+func Reopen() error {
+	loggerMu.Lock()
+	defer loggerMu.Unlock()
+
+	// If logging to stdout, nothing to reopen
+	if logPath == "" {
+		return nil
+	}
+
+	// Close existing file
+	if logFile != nil {
+		_ = logFile.Close()
+		logFile = nil
+	}
+
+	// Open the file again (create if doesn't exist)
+	//nolint: gosec // logPath is configured by admin, not user input
+	file, err := os.OpenFile(logPath, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
+	if err != nil {
+		// Fall back to stdout if we can't reopen
+		logger = log.New(os.Stdout, "", 0)
+		return fmt.Errorf("failed to reopen log file %s: %w", logPath, err)
+	}
+
+	logFile = file
+	logger = log.New(file, "", 0)
+	return nil
+}
+
+// SetLevel configures the minimum log level from a string name.
+// Accepted values: "debug", "info", "warn", "error".
+func SetLevel(level string) {
+	switch level {
+	case "debug":
+		currentLevel = LevelDebug
+	case "info":
+		currentLevel = LevelInfo
+	case "warn":
+		currentLevel = LevelWarn
+	case "error":
+		currentLevel = LevelError
+	}
+}
+
+// Debug logs a message at debug level. Uses fmt.Sprintf formatting.
+func Debug(format string, v ...any) {
+	if currentLevel <= LevelDebug {
+		msg := fmt.Sprintf(format, v...)
+		logger.Println(formatLog("DEBUG", msg))
+	}
+}
+
+// Info logs a message at info level. Uses fmt.Sprintf formatting.
+func Info(format string, v ...any) {
+	if currentLevel <= LevelInfo {
+		msg := fmt.Sprintf(format, v...)
+		logger.Println(formatLog("INFO", msg))
+	}
+}
+
+// Warn logs a message at warning level. Uses fmt.Sprintf formatting.
+func Warn(format string, v ...any) {
+	if currentLevel <= LevelWarn {
+		msg := fmt.Sprintf(format, v...)
+		logger.Println(formatLog("WARN", msg))
+	}
+}
+
+// Error logs a message at error level. Uses fmt.Sprintf formatting.
+func Error(format string, v ...any) {
+	if currentLevel <= LevelError {
+		msg := fmt.Sprintf(format, v...)
+		logger.Println(formatLog("ERROR", msg))
+	}
+}
+
+// Fatal logs a message at critical level and terminates the process with exit code 1.
+func Fatal(format string, v ...any) {
+	msg := fmt.Sprintf(format, v...)
+	logger.Println(formatLog("CRITICAL", msg))
+	os.Exit(1)
+}