-
Notifications
You must be signed in to change notification settings - Fork 1
/
stream-file.go
181 lines (167 loc) · 4.71 KB
/
stream-file.go
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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
package logger
import (
"bufio"
"encoding/json"
"fmt"
"os"
"path"
"strings"
"sync"
"time"
"github.com/gildas/go-errors"
)
// FileStream is the Stream that writes to a file
// Any record with a level < FilterLevel will be written
type FileStream struct {
*json.Encoder
Path string
Converter Converter
FilterLevels LevelSet
Unbuffered bool
SourceInfo bool
file *os.File
output *bufio.Writer
flushFrequency time.Duration
mutex sync.Mutex
}
// SetFilterLevel sets the filter level
//
// If present, the first parameter is the topic.
//
// If present, the second parameter is the scope.
//
// implements logger.FilterSetter
func (stream *FileStream) SetFilterLevel(level Level, parameters ...string) {
stream.mutex.Lock()
defer stream.mutex.Unlock()
if len(parameters) == 0 {
stream.FilterLevels.SetDefault(level)
} else if len(parameters) == 1 {
stream.FilterLevels.Set(level, parameters[0], "")
} else {
stream.FilterLevels.Set(level, parameters[0], parameters[1])
}
}
// FilterMore tells the stream to filter more
//
// The stream will filter more if it is not already at the highest level.
// Which means less log messages will be written to the stream
//
// Example: if the stream is at DEBUG, it will be filtering at INFO
//
// implements logger.FilterModifier
func (stream *FileStream) FilterMore() {
stream.mutex.Lock()
defer stream.mutex.Unlock()
stream.FilterLevels.SetDefault(stream.FilterLevels.GetDefault().Next())
}
// FilterLess tells the stream to filter less
//
// The stream will filter less if it is not already at the lowest level.
// Which means more log messages will be written to the stream
//
// Example: if the stream is at INFO, it will be filtering at DEBUG
//
// implements logger.FilterModifier
func (stream *FileStream) FilterLess() {
stream.mutex.Lock()
defer stream.mutex.Unlock()
stream.FilterLevels.SetDefault(stream.FilterLevels.GetDefault().Previous())
}
// Write writes the given Record
//
// implements logger.Streamer
func (stream *FileStream) Write(record Record) (err error) {
stream.mutex.Lock()
defer stream.mutex.Unlock()
if stream.file == nil {
const flags = os.O_CREATE | os.O_APPEND | os.O_WRONLY
const perms = 0644
err = os.MkdirAll(path.Dir(stream.Path), os.ModePerm)
if err != nil {
return errors.WithStack(err)
}
if stream.file, err = os.OpenFile(stream.Path, flags, perms); err != nil {
return errors.WithStack(err)
}
if stream.Converter == nil {
stream.Converter = GetConverterFromEnvironment()
}
if len(stream.FilterLevels) == 0 {
stream.FilterLevels = ParseLevelsFromEnvironment()
}
if stream.Unbuffered {
stream.output = nil
stream.Encoder = json.NewEncoder(stream.file)
} else {
stream.output = bufio.NewWriter(stream.file)
stream.Encoder = json.NewEncoder(stream.output)
stream.flushFrequency = GetFlushFrequencyFromEnvironment()
go stream.flushJob()
}
}
if err := stream.Encoder.Encode(stream.Converter.Convert(record)); errors.Is(err, errors.JSONMarshalError) {
return err
} else if err != nil {
return errors.JSONMarshalError.Wrap(err)
}
if GetLevelFromRecord(record) >= ERROR && stream.output != nil {
stream.output.Flush() // calling stream.Flush would Lock the mutex again and end up with a dead-lock
}
return nil
}
// ShouldWrite tells if the given level should be written to this stream
//
// implements logger.Streamer
func (stream *FileStream) ShouldWrite(level Level, topic, scope string) bool {
return level.ShouldWrite(stream.FilterLevels.Get(topic, scope))
}
// ShouldLogSourceInfo tells if the source info should be logged
//
// implements logger.Streamer
func (stream *FileStream) ShouldLogSourceInfo() bool {
return stream.SourceInfo
}
// Flush flushes the stream (makes sure records are actually written)
//
// implements logger.Streamer
func (stream *FileStream) Flush() {
if stream.output != nil {
stream.mutex.Lock()
defer stream.mutex.Unlock()
stream.output.Flush()
}
}
// Close closes the stream
//
// implements logger.Streamer
func (stream *FileStream) Close() {
stream.mutex.Lock()
defer stream.mutex.Unlock()
if stream.output != nil {
stream.output.Flush()
}
if stream.file != nil {
stream.file.Close()
}
}
// String gets a string version
//
// implements fmt.Stringer
func (stream *FileStream) String() string {
var format strings.Builder
if stream.Unbuffered {
format.WriteString("Unbuffered ")
}
format.WriteString("Stream to %s")
if len(stream.FilterLevels) > 0 {
format.WriteString(", Filter: %s")
return fmt.Sprintf(format.String(), stream.Path, stream.FilterLevels)
}
return fmt.Sprintf(format.String(), stream.Path)
}
func (stream *FileStream) flushJob() {
for range time.Tick(stream.flushFrequency) {
stream.Flush()
}
}