-
Notifications
You must be signed in to change notification settings - Fork 1
/
stream-file.go
136 lines (124 loc) · 3.39 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
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
FilterLevel Level
Unbuffered bool
file *os.File
output *bufio.Writer
flushFrequency time.Duration
mutex sync.Mutex
}
// SetFilterLevel sets the filter level
func (stream *FileStream) SetFilterLevel(level Level) Streamer {
stream.mutex.Lock()
defer stream.mutex.Unlock()
stream.FilterLevel = level
return stream
}
// SetFilterLevelIfUnset sets the filter level if not set already
func (stream *FileStream) SetFilterLevelIfUnset(level Level) Streamer {
stream.mutex.Lock()
defer stream.mutex.Unlock()
if stream.FilterLevel == UNSET {
stream.FilterLevel = level
}
return stream
}
// Write writes the given Record
// implements logger.Stream
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.FilterLevel == UNSET {
stream.FilterLevel = GetLevelFromEnvironment()
}
if stream.Converter == nil {
stream.Converter = GetConverterFromEnvironment()
}
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)); 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
func (stream *FileStream) ShouldWrite(level Level) bool {
// implements logger.Stream
return level.ShouldWrite(stream.FilterLevel)
}
// Flush flushes the stream (makes sure records are actually written)
func (stream *FileStream) Flush() {
// implements logger.Stream
if stream.output != nil {
stream.mutex.Lock()
defer stream.mutex.Unlock()
stream.output.Flush()
}
}
// Close closes the stream
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
func (stream *FileStream) String() string {
// implements the fmt.Stringer interface
var format strings.Builder
if stream.Unbuffered {
format.WriteString("Unbuffered ")
}
format.WriteString("Stream to %s")
if stream.FilterLevel == UNSET {
return fmt.Sprintf(format.String(), stream.Path)
}
format.WriteString(", Filter: %s")
return fmt.Sprintf(format.String(), stream.Path, stream.FilterLevel)
}
func (stream *FileStream) flushJob() {
for range time.Tick(stream.flushFrequency) {
stream.Flush()
}
}