/
log.go
130 lines (109 loc) · 3.18 KB
/
log.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
package goutils
import (
"encoding/json"
"errors"
"fmt"
"log"
"os"
"reflect"
"runtime"
"strings"
"github.com/hoveychen/go-utils/flags"
)
var (
debug = flags.Bool("debug", false, "True to turn into debug mode.")
infoLog, debugLog, errLog, fatalLog *log.Logger
)
func init() {
infoLog = log.New(os.Stdout, "[INFO]", log.LstdFlags)
debugLog = log.New(os.Stdout, "[DEBUG]", log.LstdFlags|log.Lshortfile)
errLog = log.New(os.Stderr, "[ERROR]", log.LstdFlags|log.Llongfile)
fatalLog = log.New(os.Stderr, "[FATAL]", log.LstdFlags|log.Llongfile)
}
// Check provide a quick way to check unexpected errors that should never happen.
// It's basically an assertion that once err != nil, fatal panic is thrown.
func Check(err error) {
if err != nil {
LogError(err)
panic(err)
}
}
// Check provide a quick way to check unexpected errors that should never happen.
// It's almost the same as Check(), except only in debug mode will throw panic.
func DCheck(err error) {
if err != nil {
LogError(err)
if IsDebuging() {
panic(err)
}
}
}
// LogError prints error to error output with [ERROR] prefix.
func LogError(v ...interface{}) {
errLog.Output(2, fmt.Sprintln(v...))
}
func LogErrorDetail(v ...interface{}) {
var msgs []string
for _, i := range v {
msgs = append(msgs, fmt.Sprintf("%+v", i))
}
errLog.Output(2, strings.Join(msgs, " "))
}
// LogInfo prints info to standard output with [INFO] prefix.
func LogInfo(v ...interface{}) {
infoLog.Output(2, fmt.Sprintln(v...))
}
// LogDebug prints info to standard output with [DEBUG] prefix in debug mode.
func LogDebug(v ...interface{}) {
if IsDebuging() {
debugLog.Output(2, fmt.Sprintln(v...))
}
}
// LogFatal prints error to error output with [FATAL] prefix, and terminate the
// application.
func LogFatal(v ...interface{}) {
var msgs []string
for _, i := range v {
msgs = append(msgs, fmt.Sprintf("%+v", i))
}
fatalLog.Output(2, strings.Join(msgs, " "))
os.Exit(1)
}
// Same as LogInfo, except accepting formating info.
func LogInfof(msg string, v ...interface{}) {
LogInfo(fmt.Sprintf(msg, v...))
}
// Same as LogError, except accepting formating info.
func LogErrorf(msg string, v ...interface{}) {
LogError(fmt.Sprintf(msg, v...))
}
// Same as LogDebug, except accepting formating info.
func LogDebugf(msg string, v ...interface{}) {
LogDebug(fmt.Sprintf(msg, v...))
}
// Same as LogFatal, except accepting formating info.
func LogFatalf(msg string, v ...interface{}) {
LogFatal(fmt.Sprintf(msg, v...))
}
// PrintJson outputs any varible in Json format to console. Useful for debuging.
func PrintJson(v interface{}) {
fmt.Println(Jsonify(v))
}
// Jsonify provides shortcut to return an json format string of any varible.
func Jsonify(v interface{}) string {
d, err := json.MarshalIndent(v, "", " ")
DCheck(err)
return string(d)
}
// GetFuncName provides shortcut to print the name of any function.
func GetFuncName(i interface{}) string {
return runtime.FuncForPC(reflect.ValueOf(i).Pointer()).Name()
}
// NewError returns an error composed like fmt.Sprintf().
func NewError(v ...interface{}) error {
return errors.New(fmt.Sprintln(v...))
}
// IsDebuging returns whether it's in debug mode.
func IsDebuging() bool {
return *debug
}