clusterkit/logger.go at main · skshohagmiah/clusterkit · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
package clusterkit

import (
	"fmt"
	"log"
	"os"
)

// Logger interface for structured logging
type Logger interface {
	Info(msg string, args ...interface{})
	Warn(msg string, args ...interface{})
	Error(msg string, args ...interface{})
	Debug(msg string, args ...interface{})
}

// DefaultLogger implements Logger using standard library
type DefaultLogger struct {
	logger *log.Logger
	level  LogLevel
}

// LogLevel represents logging levels
type LogLevel int

const (
	LogLevelDebug LogLevel = iota
	LogLevelInfo
	LogLevelWarn
	LogLevelError
)

// NewDefaultLogger creates a new default logger
func NewDefaultLogger(level LogLevel) *DefaultLogger {
	return &DefaultLogger{
		logger: log.New(os.Stdout, "[ClusterKit] ", log.LstdFlags|log.Lmsgprefix),
		level:  level,
	}
}

func (l *DefaultLogger) Info(msg string, args ...interface{}) {
	if l.level <= LogLevelInfo {
		if len(args) > 0 {
			l.logger.Printf("[INFO] %s %s", msg, formatKeyValues(args...))
		} else {
			l.logger.Printf("[INFO] %s", msg)
		}
	}
}

func (l *DefaultLogger) Warn(msg string, args ...interface{}) {
	if l.level <= LogLevelWarn {
		if len(args) > 0 {
			l.logger.Printf("[WARN] %s %s", msg, formatKeyValues(args...))
		} else {
			l.logger.Printf("[WARN] %s", msg)
		}
	}
}

func (l *DefaultLogger) Error(msg string, args ...interface{}) {
	if l.level <= LogLevelError {
		if len(args) > 0 {
			l.logger.Printf("[ERROR] %s %s", msg, formatKeyValues(args...))
		} else {
			l.logger.Printf("[ERROR] %s", msg)
		}
	}
}

func (l *DefaultLogger) Debug(msg string, args ...interface{}) {
	if l.level <= LogLevelDebug {
		if len(args) > 0 {
			l.logger.Printf("[DEBUG] %s %s", msg, formatKeyValues(args...))
		} else {
			l.logger.Printf("[DEBUG] %s", msg)
		}
	}
}

// formatKeyValues formats key-value pairs for structured logging
// Expects alternating key-value pairs: key1, value1, key2, value2, ...
func formatKeyValues(args ...interface{}) string {
	if len(args) == 0 {
		return ""
	}

	// If odd number of args, last one is just appended
	pairs := make([]string, 0, (len(args)+1)/2)

	for i := 0; i < len(args); i += 2 {
		if i+1 < len(args) {
			pairs = append(pairs, fmt.Sprintf("%v=%v", args[i], args[i+1]))
		} else {
			// Odd arg at the end
			pairs = append(pairs, fmt.Sprintf("%v", args[i]))
		}
	}

	return fmt.Sprintf("(%s)", joinStrings(pairs, ", "))
}

// joinStrings joins strings with a separator
func joinStrings(strs []string, sep string) string {
	if len(strs) == 0 {
		return ""
	}
	result := strs[0]
	for i := 1; i < len(strs); i++ {
		result += sep + strs[i]
	}
	return result
}

// NoOpLogger is a logger that does nothing (for testing)
type NoOpLogger struct{}

func (l *NoOpLogger) Info(msg string, args ...interface{})  {}
func (l *NoOpLogger) Warn(msg string, args ...interface{})  {}
func (l *NoOpLogger) Error(msg string, args ...interface{}) {}
func (l *NoOpLogger) Debug(msg string, args ...interface{}) {}