logger/logger.go at master · ThingiverseIO/logger · 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 logger

import (
	"fmt"
	"html/template"
	"os"
	"sync/atomic"
)

var (
	defaultBackend  Backend
	defaultTemplate *template.Template
)


func init() {
	defaultTemplate, _ = template.New("tvio_logger_default").Parse(
		"{{.FormattedTime}} \u2771\u2771 {{.Prefix}} \u2771\u2771 {{.Level.Name}} \u2771\u2771\t%s")
	defaultBackend = NewWriterBackend(os.Stdout)
}

type Logger struct {
	Prefix string

	backend  Backend
	debug    bool
	levels   map[string]Level
	logNr    uint64
	template *template.Template
}

func New(prefix string) (logger *Logger) {

	logger = &Logger{
		Prefix:   prefix,
		backend:  defaultBackend,
		template: defaultTemplate,
		levels:   DefaultLevels,
	}
	return

}

func (l *Logger) SetBackend(backend Backend) *Logger {
	l.backend = backend
	return l
}

func (l *Logger) SetDebug(debug bool) *Logger {
	l.debug = debug
	return l
}

func (l *Logger) SetTemplate(tmpl string) *Logger {
	l.template, _ = template.New("tvio_logger_default").Parse(tmpl)
	return l
}

func (l *Logger) Init(message ...interface{}) {
	msg := fmt.Sprint(message...)
	l.print(INIT, msg)
}

func (l *Logger) Initf(format string, val ...interface{}) {
	l.print(INIT, format, val...)
}

func (l *Logger) Info(message ...interface{}) {
	msg := fmt.Sprint(message...)
	l.print(INFO, msg)
}

func (l *Logger) Infof(format string, val ...interface{}) {
	l.print(INFO, format, val...)
}

func (l *Logger) Debug(message ...interface{}) {
	if !l.debug {
		return
	}
	msg := fmt.Sprint(message...)
	l.print(DEBUG, msg)
}

func (l *Logger) Debugf(format string, val ...interface{}) {
	if !l.debug {
		return
	}
	l.print(DEBUG, format, val...)
}

func (l *Logger) Error(message ...interface{}) {
	msg := fmt.Sprint(message...)
	l.print(ERROR, msg)
}

func (l *Logger) Errorf(format string, val ...interface{}) {
	l.print(ERROR, format, val...)
}

func (l *Logger) Success(message ...interface{}) {
	msg := fmt.Sprint(message...)
	l.print(SUCCESS, msg)
}

func (l *Logger) Successf(format string, val ...interface{}) {
	l.print(SUCCESS, format, val...)
}

func (l *Logger) PrintSuccess() {
	l.Success("Success")
}

func (l *Logger) print(level, format string, val ...interface{}) {
	lvl, ok := l.levels[level]
	if !ok {
		lvl = l.levels[INFO]
	}
	message := NewMessage(atomic.AddUint64(&l.logNr, 1), l.Prefix, lvl, l.template, format, val...)
	l.backend.Write(message)
}