netramesh

1
package log
2

3
import (
4
	"fmt"
5
	"io"
6
	"log"
7
	"os"
8
	"strings"
9
	"sync"
10
)
11

12
var (
13
	logLock       sync.Mutex
14
	defaultLogger *Logger
15
)
16

17
type Level int
18

19
const (
20
	initText                  = "Logger Init wasn't called"
21
	flags                     = log.Ldate | log.Lmicroseconds | log.Lshortfile
22
	EnvNetraLoggerLevel       = "NETRA_LOGGER_LEVEL"
23
	FatalLevel          Level = iota
24
	ErrorLevel
25
	WarnLevel
26
	InfoLevel
27
	DebugLevel
28
)
29

30
type Logger struct {
31
	outputLevel Level
32
	inner       *log.Logger
33
	closer      io.Closer
34
	initialized bool
35
}
36

37
func init() {
38
	defaultLogger = &Logger{
39
		outputLevel: DebugLevel,
40
		inner:       log.New(os.Stderr, initText, flags),
41
	}
42
}
43

44
func Init(name string, errorLevel string, logFile io.Writer) (*Logger, error) {
45
	level := InfoLevel
46
	if errorLevel != "" {
47
		errorLevel = strings.ToLower(errorLevel)
48
		switch errorLevel {
49
		case "fatal":
50
			level = FatalLevel
51
		case "error":
52
			level = ErrorLevel
53
		case "warning":
54
			level = WarnLevel
55
		case "warn":
56
			level = WarnLevel
57
		case "info":
58
			level = InfoLevel
59
		case "debug":
60
			level = DebugLevel
61
		default:
62
			return nil, fmt.Errorf("invalid logger level %s", errorLevel)
63
		}
64
	}
65
	var il io.Writer
66

67
	iLogs := []io.Writer{logFile}
68
	if il != nil {
69
		iLogs = append(iLogs, il)
70
	}
71

72
	l := Logger{
73
		outputLevel: level,
74
		inner:       log.New(io.MultiWriter(iLogs...), name, flags),
75
	}
76
	l.closer = logFile.(io.Closer)
77
	l.initialized = true
78

79
	logLock.Lock()
80
	defer logLock.Unlock()
81
	if !defaultLogger.initialized {
82
		defaultLogger = &l
83
	}
84

85
	return &l, nil
86
}
87

88
func (l *Logger) Close() {
89
	logLock.Lock()
90
	defer logLock.Unlock()
91
	if err := l.closer.Close(); err != nil {
92
		fmt.Fprintf(os.Stderr, "Error on log %v closing %v\n", l.closer, err)
93
	}
94
}
95

96
func (l *Logger) Debug(v ...interface{}) {
97
	if l.outputLevel < DebugLevel {
98
		return
99
	}
100
	l.output(DebugLevel, 0, fmt.Sprint(v...))
101
}
102

103
func (l *Logger) DebugDepth(depth int, v ...interface{}) {
104
	if l.outputLevel < DebugLevel {
105
		return
106
	}
107
	l.output(DebugLevel, depth, fmt.Sprint(v...))
108
}
109

110
func (l *Logger) Debugln(v ...interface{}) {
111
	if l.outputLevel < DebugLevel {
112
		return
113
	}
114
	l.output(DebugLevel, 0, fmt.Sprintln(v...))
115
}
116

117
func (l *Logger) Debugf(format string, v ...interface{}) {
118
	if l.outputLevel < DebugLevel {
119
		return
120
	}
121
	l.output(DebugLevel, 0, fmt.Sprintf(format, v...))
122
}
123

124
func (l *Logger) Info(v ...interface{}) {
125
	if l.outputLevel < InfoLevel {
126
		return
127
	}
128
	l.output(InfoLevel, 0, fmt.Sprint(v...))
129
}
130

131
func (l *Logger) InfoDepth(depth int, v ...interface{}) {
132
	if l.outputLevel < InfoLevel {
133
		return
134
	}
135
	l.output(InfoLevel, depth, fmt.Sprint(v...))
136
}
137

138
func (l *Logger) Infoln(v ...interface{}) {
139
	if l.outputLevel < InfoLevel {
140
		return
141
	}
142
	l.output(InfoLevel, 0, fmt.Sprintln(v...))
143
}
144

145
func (l *Logger) Infof(format string, v ...interface{}) {
146
	if l.outputLevel < InfoLevel {
147
		return
148
	}
149
	l.output(InfoLevel, 0, fmt.Sprintf(format, v...))
150
}
151

152
func (l *Logger) Warning(v ...interface{}) {
153
	if l.outputLevel < WarnLevel {
154
		return
155
	}
156
	l.output(WarnLevel, 0, fmt.Sprint(v...))
157
}
158

159
func (l *Logger) WarningDepth(depth int, v ...interface{}) {
160
	if l.outputLevel < WarnLevel {
161
		return
162
	}
163
	l.output(WarnLevel, depth, fmt.Sprint(v...))
164
}
165

166
func (l *Logger) Warningln(v ...interface{}) {
167
	if l.outputLevel < WarnLevel {
168
		return
169
	}
170
	l.output(WarnLevel, 0, fmt.Sprintln(v...))
171
}
172

173
func (l *Logger) Warningf(format string, v ...interface{}) {
174
	if l.outputLevel < WarnLevel {
175
		return
176
	}
177
	l.output(WarnLevel, 0, fmt.Sprintf(format, v...))
178
}
179

180
func (l *Logger) Error(v ...interface{}) {
181
	if l.outputLevel < ErrorLevel {
182
		return
183
	}
184
	l.output(ErrorLevel, 0, fmt.Sprint(v...))
185
}
186

187
func (l *Logger) ErrorDepth(depth int, v ...interface{}) {
188
	if l.outputLevel < ErrorLevel {
189
		return
190
	}
191
	l.output(ErrorLevel, depth, fmt.Sprint(v...))
192
}
193

194
func (l *Logger) Errorln(v ...interface{}) {
195
	if l.outputLevel < ErrorLevel {
196
		return
197
	}
198
	l.output(ErrorLevel, 0, fmt.Sprintln(v...))
199
}
200

201
func (l *Logger) Errorf(format string, v ...interface{}) {
202
	if l.outputLevel < ErrorLevel {
203
		return
204
	}
205
	l.output(ErrorLevel, 0, fmt.Sprintf(format, v...))
206
}
207

208
func (l *Logger) Fatal(v ...interface{}) {
209
	l.output(FatalLevel, 0, fmt.Sprint(v...))
210
	l.Close()
211
	os.Exit(1)
212
}
213

214
func (l *Logger) FatalDepth(depth int, v ...interface{}) {
215
	l.output(FatalLevel, depth, fmt.Sprint(v...))
216
	l.Close()
217
	os.Exit(1)
218
}
219

220
func (l *Logger) Fatalln(v ...interface{}) {
221
	l.output(FatalLevel, 0, fmt.Sprintln(v...))
222
	l.Close()
223
	os.Exit(1)
224
}
225

226
func (l *Logger) Fatalf(format string, v ...interface{}) {
227
	l.output(FatalLevel, 0, fmt.Sprintf(format, v...))
228
	l.Close()
229
	os.Exit(1)
230
}
231

232
func Info(v ...interface{}) {
233
	defaultLogger.output(InfoLevel, 0, fmt.Sprint(v...))
234
}
235

236
func InfoDepth(depth int, v ...interface{}) {
237
	defaultLogger.output(InfoLevel, depth, fmt.Sprint(v...))
238
}
239

240
func Infoln(v ...interface{}) {
241
	defaultLogger.output(InfoLevel, 0, fmt.Sprintln(v...))
242
}
243

244
func Infof(format string, v ...interface{}) {
245
	defaultLogger.output(InfoLevel, 0, fmt.Sprintf(format, v...))
246
}
247

248
func Warning(v ...interface{}) {
249
	defaultLogger.output(WarnLevel, 0, fmt.Sprint(v...))
250
}
251

252
func WarningDepth(depth int, v ...interface{}) {
253
	defaultLogger.output(WarnLevel, depth, fmt.Sprint(v...))
254
}
255

256
func Warningln(v ...interface{}) {
257
	defaultLogger.output(WarnLevel, 0, fmt.Sprintln(v...))
258
}
259

260
func Warningf(format string, v ...interface{}) {
261
	defaultLogger.output(WarnLevel, 0, fmt.Sprintf(format, v...))
262
}
263

264
func Error(v ...interface{}) {
265
	defaultLogger.output(ErrorLevel, 0, fmt.Sprint(v...))
266
}
267

268
func ErrorDepth(depth int, v ...interface{}) {
269
	defaultLogger.output(ErrorLevel, depth, fmt.Sprint(v...))
270
}
271

272
func Errorln(v ...interface{}) {
273
	defaultLogger.output(ErrorLevel, 0, fmt.Sprintln(v...))
274
}
275

276
func Errorf(format string, v ...interface{}) {
277
	defaultLogger.output(ErrorLevel, 0, fmt.Sprintf(format, v...))
278
}
279

280
func Fatal(v ...interface{}) {
281
	defaultLogger.output(FatalLevel, 0, fmt.Sprint(v...))
282
	defaultLogger.Close()
283
	os.Exit(1)
284
}
285

286
func FatalDepth(depth int, v ...interface{}) {
287
	defaultLogger.output(FatalLevel, depth, fmt.Sprint(v...))
288
	defaultLogger.Close()
289
	os.Exit(1)
290
}
291

292
func Fatalln(v ...interface{}) {
293
	defaultLogger.output(FatalLevel, 0, fmt.Sprintln(v...))
294
	defaultLogger.Close()
295
	os.Exit(1)
296
}
297

298
func Fatalf(format string, v ...interface{}) {
299
	defaultLogger.output(FatalLevel, 0, fmt.Sprintf(format, v...))
300
	defaultLogger.Close()
301
	os.Exit(1)
302
}
303

304
func (l *Logger) output(s Level, depth int, txt string) {
305
	logLock.Lock()
306
	var switchFrameLvl = 3
307
	switch {
308
	case s == FatalLevel && l.outputLevel >= FatalLevel:
309
		l.inner.Output(switchFrameLvl+depth, "FATAL: "+txt)
310
	case s == ErrorLevel && l.outputLevel >= ErrorLevel:
311
		l.inner.Output(switchFrameLvl+depth, "ERROR: "+txt)
312
	case s == WarnLevel && l.outputLevel >= WarnLevel:
313
		l.inner.Output(switchFrameLvl+depth, "WARN: "+txt)
314
	case s == InfoLevel && l.outputLevel >= InfoLevel:
315
		l.inner.Output(switchFrameLvl+depth, "INFO: "+txt)
316
	case s == DebugLevel && l.outputLevel >= DebugLevel:
317
		l.inner.Output(switchFrameLvl+depth, "DEBUG: "+txt)
318
	}
319
	logLock.Unlock()
320
}
321