log2/logger.go at main · renderedtext/log2 · 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
package log2

import (
	log "github.com/sirupsen/logrus"
)

type logFormatter struct {
}

func (f *logFormatter) Format(entry *log.Entry) ([]byte, error) {
	return append([]byte("* "), entry.Message...), nil
}

// LogEntry ...
var LogEntry *logEntry = entry()

// Level ...
type Level uint32

// Fields ...
type Fields map[string]interface{}

const (
	//InfoLevel ...
	InfoLevel = Level(log.InfoLevel)

	// ErrorLevel ...
	ErrorLevel = Level(log.ErrorLevel)

	// WarnLevel ...
	WarnLevel = Level(log.WarnLevel)

	// DebugLevel ...
	DebugLevel = Level(log.DebugLevel)

	// TraceLevel ...
	TraceLevel = Level(log.TraceLevel)
)

// LogEntry  ...
type logEntry struct {
	logger *log.Logger
}

// entry ...
func entry() *logEntry {
	logger := log.New()
	logEntry := &logEntry{logger: logger}
	logEntry.logger.SetFormatter(&log.TextFormatter{})
	logEntry.logger.SetReportCaller(true)
	return logEntry
}

// GetLogger ...
func GetLogger() *log.Logger {
	return LogEntry.logger
}

// SetLogger ...
func SetLogger(logger *log.Logger) {
	LogEntry.logger = logger
	LogEntry.logger.SetFormatter(&logFormatter{})
}

// SetLevel ...
func SetLevel(level Level) {
	LogEntry.logger.SetLevel(log.Level(level))
}

// Error ...
func Error(s string, args ...interface{}) {
	Log(ErrorLevel, s, args...)
}

// Warn ...
func Warn(s string, args ...interface{}) {
	Log(WarnLevel, s, args...)
}

// Info ...
func Info(s string, args ...interface{}) {
	Log(InfoLevel, s, args...)
}

// Debug ...
func Debug(s string, args ...interface{}) {
	Log(DebugLevel, s, args...)
}

// Trace ...
func Trace(s string, args ...interface{}) {
	Log(TraceLevel, s, args...)
}

// Inspect ...
func Inspect(i interface{}) {
	Log(InfoLevel, "=========================================")
	Log(InfoLevel, "%+v", i)
	Log(InfoLevel, "=========================================")
}

// Log ...
func Log(level Level, s string, args ...interface{}) {
	switch level {
	case ErrorLevel:
		LogEntry.logger.Errorf(s+"\n", args...)
	case WarnLevel:
		LogEntry.logger.Warnf(s+"\n", args...)
	case InfoLevel:
		LogEntry.logger.Infof(s+"\n", args...)
	case DebugLevel:
		LogEntry.logger.Debugf(s+"\n", args...)
	case TraceLevel:
		LogEntry.logger.Tracef(s+"\n", args...)
	}
}