somewhat working ebpf bpftrace

internal/logging/logger.go

@@ -5,11 +5,39 @@ import (
 	"log"
 	"log/syslog"
 	"os"
+	"strings"
 )
 
+// LogLevel defines the logging level
+type LogLevel int
+
+const (
+	LevelDebug LogLevel = iota
+	LevelInfo
+	LevelWarning
+	LevelError
+)
+
+func (l LogLevel) String() string {
+	switch l {
+	case LevelDebug:
+		return "DEBUG"
+	case LevelInfo:
+		return "INFO"
+	case LevelWarning:
+		return "WARN"
+	case LevelError:
+		return "ERROR"
+	default:
+		return "INFO"
+	}
+}
+
+// Logger provides structured logging with configurable levels
 type Logger struct {
 	syslogWriter *syslog.Writer
-	debugMode    bool
+	level        LogLevel
+	showEmoji    bool
 }
 
 var defaultLogger *Logger
@@ -18,9 +46,16 @@ func init() {
 	defaultLogger = NewLogger()
 }
 
+// NewLogger creates a new logger with default configuration
 func NewLogger() *Logger {
+	return NewLoggerWithLevel(getLogLevelFromEnv())
+}
+
+// NewLoggerWithLevel creates a logger with specified level
+func NewLoggerWithLevel(level LogLevel) *Logger {
 	l := &Logger{
-		debugMode: os.Getenv("DEBUG") == "true",
+		level:     level,
+		showEmoji: os.Getenv("LOG_NO_EMOJI") != "true",
 	}
 
 	// Try to connect to syslog
@@ -31,39 +66,87 @@ func NewLogger() *Logger {
 	return l
 }
 
-func (l *Logger) Info(format string, args ...interface{}) {
-	msg := fmt.Sprintf(format, args...)
-	if l.syslogWriter != nil {
-		l.syslogWriter.Info(msg)
+// getLogLevelFromEnv parses log level from environment variable
+func getLogLevelFromEnv() LogLevel {
+	level := strings.ToUpper(os.Getenv("LOG_LEVEL"))
+	switch level {
+	case "DEBUG":
+		return LevelDebug
+	case "INFO", "":
+		return LevelInfo
+	case "WARN", "WARNING":
+		return LevelWarning
+	case "ERROR":
+		return LevelError
+	default:
+		return LevelInfo
 	}
-	log.Printf("[INFO] %s", msg)
+}
+
+// logMessage handles the actual logging
+func (l *Logger) logMessage(level LogLevel, format string, args ...interface{}) {
+	if level < l.level {
+		return
+	}
+
+	msg := fmt.Sprintf(format, args...)
+	prefix := fmt.Sprintf("[%s]", level.String())
+
+	// Add emoji prefix if enabled
+	if l.showEmoji {
+		switch level {
+		case LevelDebug:
+			prefix = "🔍 " + prefix
+		case LevelInfo:
+			prefix = "ℹ️  " + prefix
+		case LevelWarning:
+			prefix = "⚠️  " + prefix
+		case LevelError:
+			prefix = "❌ " + prefix
+		}
+	}
+
+	// Log to syslog if available
+	if l.syslogWriter != nil {
+		switch level {
+		case LevelDebug:
+			l.syslogWriter.Debug(msg)
+		case LevelInfo:
+			l.syslogWriter.Info(msg)
+		case LevelWarning:
+			l.syslogWriter.Warning(msg)
+		case LevelError:
+			l.syslogWriter.Err(msg)
+		}
+	}
+
+	log.Printf("%s %s", prefix, msg)
 }
 
 func (l *Logger) Debug(format string, args ...interface{}) {
-	if !l.debugMode {
-		return
-	}
-	msg := fmt.Sprintf(format, args...)
-	if l.syslogWriter != nil {
-		l.syslogWriter.Debug(msg)
-	}
-	log.Printf("[DEBUG] %s", msg)
+	l.logMessage(LevelDebug, format, args...)
+}
+
+func (l *Logger) Info(format string, args ...interface{}) {
+	l.logMessage(LevelInfo, format, args...)
 }
 
 func (l *Logger) Warning(format string, args ...interface{}) {
-	msg := fmt.Sprintf(format, args...)
-	if l.syslogWriter != nil {
-		l.syslogWriter.Warning(msg)
-	}
-	log.Printf("[WARNING] %s", msg)
+	l.logMessage(LevelWarning, format, args...)
 }
 
 func (l *Logger) Error(format string, args ...interface{}) {
-	msg := fmt.Sprintf(format, args...)
-	if l.syslogWriter != nil {
-		l.syslogWriter.Err(msg)
-	}
-	log.Printf("[ERROR] %s", msg)
+	l.logMessage(LevelError, format, args...)
+}
+
+// SetLevel changes the logging level
+func (l *Logger) SetLevel(level LogLevel) {
+	l.level = level
+}
+
+// GetLevel returns current logging level
+func (l *Logger) GetLevel() LogLevel {
+	return l.level
 }
 
 func (l *Logger) Close() {
@@ -73,14 +156,14 @@ func (l *Logger) Close() {
 }
 
 // Global logging functions
-func Info(format string, args ...interface{}) {
-	defaultLogger.Info(format, args...)
-}
-
 func Debug(format string, args ...interface{}) {
 	defaultLogger.Debug(format, args...)
 }
 
+func Info(format string, args ...interface{}) {
+	defaultLogger.Info(format, args...)
+}
+
 func Warning(format string, args ...interface{}) {
 	defaultLogger.Warning(format, args...)
 }
@@ -88,3 +171,13 @@ func Warning(format string, args ...interface{}) {
 func Error(format string, args ...interface{}) {
 	defaultLogger.Error(format, args...)
 }
+
+// SetLevel sets the global logger level
+func SetLevel(level LogLevel) {
+	defaultLogger.SetLevel(level)
+}
+
+// GetLevel gets the global logger level
+func GetLevel() LogLevel {
+	return defaultLogger.GetLevel()
+}