main.go
4.07 KB
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
package gologger
import (
"fmt"
"os"
"path/filepath"
"runtime"
"sync"
"time"
)
var muEv = &sync.Mutex{}
var muEr = &sync.Mutex{}
const MaxLogFileSize5MB int64 = 5 * 1024 * 1024
const MaxLogFileSize1MB int64 = 1 * 1024 * 1024
const MaxLogFileSize500KB int64 = 500 * 1024
const MaxLogFileSize100KB int64 = 100 * 1024
const MaxLogFileSize512B int64 = 512
const ErrDirName = "error-logs"
const EvtDirName = "event-logs"
type Logger struct {
eventf *os.File
eventFileName string
errorf *os.File
errorFileName string
}
var logger Logger
func Init(eventFileName, errorFileName string) error {
timestamp := "_" + time.Now().Format(time.RFC3339)
// create directories to keep log files
err := os.Mkdir(EvtDirName, os.ModePerm)
if err != nil {
if !os.IsExist(err) {
fmt.Printf("logger: mkdir: couldn't create event log directory\n")
return err
}
}
err = os.Mkdir(ErrDirName, os.ModePerm)
if err != nil {
if !os.IsExist(err) {
fmt.Printf("logger: new: couldn't create error log directory\n")
return err
}
}
// create files
logger.eventFileName = eventFileName
logger.errorFileName = errorFileName
path := filepath.Join(EvtDirName, eventFileName+timestamp+".txt")
logger.eventf, err = os.Create(path)
if err != nil {
fmt.Printf("logger: new: couldn't create event log file\n")
return err
}
path = filepath.Join(ErrDirName, errorFileName+timestamp+".txt")
logger.errorf, err = os.Create(path)
if err != nil {
fmt.Printf("logger: new: couldn't create error log file\n")
return err
}
return nil
}
func Print(s string) {
fmt.Printf(time.Now().Format(time.RFC3339) + ": " + s + "\n")
}
func LogEvent(event string) {
muEv.Lock()
defer muEv.Unlock()
logger.eventf.WriteString(time.Now().Format(time.RFC3339) + ": " + event + "\n")
logger.splitEventLog()
}
func LogError(comment string, err error) {
muEr.Lock()
defer muEr.Unlock()
logger.errorf.WriteString(time.Now().Format(time.RFC3339) + ": " + comment + ": " + err.Error() + "\n")
logger.splitErrorLog()
}
func TraceEvent(event string) {
muEv.Lock()
defer muEv.Unlock()
_, file, line, ok := runtime.Caller(1)
var s string
if ok {
s = fmt.Sprintf("%s: %s %d: %s\n", time.Now().Format(time.RFC3339), file, line, event)
} else {
s = fmt.Sprintf(time.Now().Format(time.RFC3339) + ": [can't retreive stack details]:" + event + "\n")
}
logger.eventf.WriteString(s)
logger.splitEventLog()
}
func TraceError(err error) {
muEr.Lock()
defer muEr.Unlock()
_, file, line, ok := runtime.Caller(1)
var s string
if ok {
s = fmt.Sprintf("%s %s %d: %s\n", time.Now().Format(time.RFC3339), file, line, err.Error())
} else {
s = fmt.Sprintf(time.Now().Format(time.RFC3339) + ": [can't retreive stack details]:" + err.Error() + "\n")
}
logger.errorf.WriteString(s)
logger.splitErrorLog()
}
func Close() {
// close files
err := logger.eventf.Close()
if err != nil {
fmt.Printf("logger: on exit: couldn't close event log file\n")
}
err = logger.errorf.Close()
if err != nil {
fmt.Printf("logger: on exit: couldn't close error log file\n")
}
}
func (l *Logger) splitEventLog() {
timestamp := "_" + time.Now().Format(time.RFC3339)
evfstats, _ := l.eventf.Stat()
if evfstats.Size() >= MaxLogFileSize100KB {
// close old file
err := l.eventf.Close()
if err != nil {
fmt.Printf("logger: split: couldn't close event file\n")
return
}
// open new file
var errnew error
path := filepath.Join(EvtDirName, l.eventFileName+timestamp)
l.eventf, errnew = os.Create(path)
if errnew != nil {
fmt.Printf("logger: split: couldn't create event log file\n")
}
}
}
func (l *Logger) splitErrorLog() {
timestamp := "_" + time.Now().Format(time.RFC3339)
erfstats, _ := l.errorf.Stat()
if erfstats.Size() >= MaxLogFileSize100KB {
// close old file
err := l.errorf.Close()
if err != nil {
fmt.Printf("logger: split: couldn't close error file\n")
return
}
// open new file
var errnew error
path := filepath.Join(ErrDirName, l.errorFileName+timestamp)
l.errorf, errnew = os.Create(path)
if errnew != nil {
fmt.Printf("logger: split: couldn't create error log file\n")
}
}
}