dogger

1
package dogger
2

3
import (
4
	"bytes"
5
	"context"
6
	"fmt"
7
	logCtx "github.com/nikwo/dogger/context"
8
	"github.com/nikwo/dogger/format"
9
	"github.com/nikwo/dogger/level"
10
	"github.com/nikwo/dogger/utility"
11
	"io"
12
	"sync"
13
)
14

15
type Logger interface {
16
	WithContext(ctx context.Context) Logger
17
	WithFields(entry string, value interface{}) Logger
18
	Trace(input interface{})
19
	Debug(input interface{})
20
	Info(input interface{})
21
	Warn(input interface{})
22
	Error(input interface{})
23
}
24

25
type logger struct {
26
	lock      sync.Mutex
27
	lvl       level.Level
28
	ctx       logCtx.LogContext
29
	buffer    *bytes.Buffer
30
	formatter format.Format
31
	fields    map[string]interface{}
32
}
33

34
func newChildLogger() *logger {
35
	l := new(logger)
36
	lockIO()
37
	defer unlockIO()
38
	l.lvl = log.lvl
39
	l.buffer = bytes.NewBuffer([]byte{})
40
	l.formatter = log.formatter
41
	return l
42
}
43

44
func (l *logger) acceptedLevel(lvl level.Level) bool {
45
	return l.lvl <= lvl
46
}
47

48
func createChildLogger(ctx context.Context, lvl level.Level) *logger {
49
	l := newChildLogger()
50
	l.ctx = logCtx.NewLogContext(ctx, lvl, 1)
51

52
	return l
53
}
54

55
func (l *logger) WithContext(ctx context.Context) Logger {
56
	l.ctx = logCtx.NewLogContext(ctx, level.TRACE)
57
	return l
58
}
59

60
func (l *logger) WithFields(entry string, value interface{}) Logger {
61
	l.fields = make(map[string]interface{})
62
	l.fields[entry] = value
63
	return l
64
}
65

66
func (l *logger) Trace(input interface{}) {
67
	l.ctx.SetLevel(level.TRACE)
68
	if !l.acceptedLevel(level.TRACE) {
69
		return
70
	}
71

72
	l.formOutput(input)
73
	l.flush()
74
}
75

76
func (l *logger) Debug(input interface{}) {
77
	l.ctx.SetLevel(level.DEBUG)
78
	if !l.acceptedLevel(level.DEBUG) {
79
		return
80
	}
81

82
	l.formOutput(input)
83
	l.flush()
84
}
85

86
func (l *logger) Info(input interface{}) {
87
	l.ctx.SetLevel(level.INFO)
88
	if !l.acceptedLevel(level.INFO) {
89
		return
90
	}
91

92
	l.formOutput(input)
93
	l.flush()
94
}
95

96
func (l *logger) Warn(input interface{}) {
97
	l.ctx.SetLevel(level.WARN)
98
	if !l.acceptedLevel(level.WARN) {
99
		return
100
	}
101

102
	l.formOutput(input)
103
	l.flush()
104
}
105

106
func (l *logger) Error(input interface{}) {
107
	l.ctx.SetLevel(level.ERROR)
108

109
	if !l.acceptedLevel(level.ERROR) {
110
		return
111
	}
112

113
	l.formOutput(input)
114
	l.flush()
115
}
116

117
func (l *logger) formOutput(input interface{}) {
118
	inlineBuffer := make([]byte, 0, 100)
119
	inlineBuffer = append(inlineBuffer, utility.Bytes(l.formatter.FormatString(l.ctx))...)
120
	for entry, field := range l.fields {
121
		inlineBuffer = append(inlineBuffer, utility.Bytes(fmt.Sprintf(" entry=\"%s\" value=\"%+v\"", entry, field))...)
122
	}
123
	inlineBuffer = append(inlineBuffer, utility.Bytes(fmt.Sprintf(" message=\"%+v\"\n", input))...)
124
	_, _ = l.buffer.Write(inlineBuffer)
125
}
126

127
func (l *logger) flush() {
128
	lockIO()
129
	defer unlockIO()
130
	_, _ = writer.Write(l.buffer.Bytes())
131
}
132

133
var (
134
	log    *logger
135
	writer io.Writer
136
)
137

138
func lockIO() {
139
	log.lock.Lock()
140
}
141

142
func unlockIO() {
143
	log.lock.Unlock()
144
}
145