This repository has been archived by the owner on Aug 27, 2019. It is now read-only.
-
Notifications
You must be signed in to change notification settings - Fork 8
/
glog_logger.go
164 lines (138 loc) · 4.72 KB
/
glog_logger.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
/*
Copyright (c) 2018 Red Hat, Inc.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
// This file contains a logger that uses the `glog` package.
package sdk
import (
"context"
"fmt"
"github.com/golang/glog"
)
// GlogLoggerBuilder contains the configuration and logic needed to build a logger that uses the
// glog V mechanism. Don't create instances of this type directly, use the NewGlogLoggerBuilder
// function instead.
type GlogLoggerBuilder struct {
debugV glog.Level
infoV glog.Level
warnV glog.Level
errorV glog.Level
}
// GlogLogger is a logger that uses the glog V mechanism.
type GlogLogger struct {
debugV glog.Level
infoV glog.Level
warnV glog.Level
errorV glog.Level
}
// NewGlogLoggerBuilder creates a builder that uses the glog V mechanism. By default errors,
// warnings and information messages will be written to the log if the level is 0 or greater, and
// debug messages will be written if the level is 1 or greater. This can be changed using the
// ErrorV, WarnV, InfoV and DebugV methods of the builder. For example, to write errors and warnings
// for level 0, information messages for level 1, and debug messages for level 2, you can create the
// logger like this:
//
// logger, err := client.NewGlobLoggerBuilder().
// ErrorV(0).
// WarnV(0).
// InfoV(1).
// DebugV(2).
// Build()
//
// Once the logger is created these settings can't be changed.
func NewGlogLoggerBuilder() *GlogLoggerBuilder {
// Allocate the object:
builder := new(GlogLoggerBuilder)
// Set default values:
builder.debugV = 1
builder.infoV = 0
builder.warnV = 0
builder.errorV = 0
return builder
}
// DebugV sets the V value that will be used for debug messages.
func (b *GlogLoggerBuilder) DebugV(v glog.Level) *GlogLoggerBuilder {
b.debugV = v
return b
}
// InfoV sets the V value that will be used for info messages.
func (b *GlogLoggerBuilder) InfoV(v glog.Level) *GlogLoggerBuilder {
b.infoV = v
return b
}
// WarnV sets the V value that will be used for warn messages.
func (b *GlogLoggerBuilder) WarnV(v glog.Level) *GlogLoggerBuilder {
b.warnV = v
return b
}
// ErrorV sets the V value that will be used for error messages.
func (b *GlogLoggerBuilder) ErrorV(v glog.Level) *GlogLoggerBuilder {
b.errorV = v
return b
}
// Build creates a new logger using the configuration stored in the builder.
func (b *GlogLoggerBuilder) Build() (logger *GlogLogger, err error) {
// Allocate and populate the object:
logger = new(GlogLogger)
logger.debugV = b.debugV
logger.infoV = b.infoV
logger.warnV = b.warnV
logger.errorV = b.errorV
return
}
// DebugEnabled returns true iff the debug level is enabled.
func (l *GlogLogger) DebugEnabled() bool {
return bool(glog.V(l.debugV))
}
// InfoEnabled returns true iff the information level is enabled.
func (l *GlogLogger) InfoEnabled() bool {
return bool(glog.V(l.infoV))
}
// WarnEnabled returns true iff the warning level is enabled.
func (l *GlogLogger) WarnEnabled() bool {
return bool(glog.V(l.warnV))
}
// ErrorEnabled returns true iff the error level is enabled.
func (l *GlogLogger) ErrorEnabled() bool {
return bool(glog.V(l.errorV))
}
// Debug sends to the log a debug message formatted using the fmt.Sprintf function and the given
// format and arguments.
func (l *GlogLogger) Debug(ctx context.Context, format string, args ...interface{}) {
if glog.V(l.debugV) {
msg := fmt.Sprintf(format, args...)
glog.InfoDepth(1, msg)
}
}
// Info sends to the log an information message formatted using the fmt.Sprintf function and the
// given format and arguments.
func (l *GlogLogger) Info(ctx context.Context, format string, args ...interface{}) {
if glog.V(l.infoV) {
msg := fmt.Sprintf(format, args...)
glog.InfoDepth(1, msg)
}
}
// Warn sends to the log a warning message formatted using the fmt.Sprintf function and the given
// format and arguments.
func (l *GlogLogger) Warn(ctx context.Context, format string, args ...interface{}) {
if glog.V(l.warnV) {
msg := fmt.Sprintf(format, args...)
glog.WarningDepth(1, msg)
}
}
// Error sends to the log an error message formatted using the fmt.Sprintf function and the given
// format and arguments.
func (l *GlogLogger) Error(ctx context.Context, format string, args ...interface{}) {
if glog.V(l.errorV) {
msg := fmt.Sprintf(format, args...)
glog.ErrorDepth(1, msg)
}
}