@@ -29,11 +29,11 @@ type loggerPromise struct {
29
29
childPromises []* loggerPromise
30
30
promisesLock sync.Mutex
31
31
32
- name * string
33
- tags []interface {}
32
+ name * string
33
+ tags []interface {}
34
+ level int
34
35
}
35
36
36
- // WithName provides a new Logger with the name appended
37
37
func (p * loggerPromise ) WithName (l * DelegatingLogger , name string ) * loggerPromise {
38
38
res := & loggerPromise {
39
39
logger : l ,
@@ -61,6 +61,19 @@ func (p *loggerPromise) WithValues(l *DelegatingLogger, tags ...interface{}) *lo
61
61
return res
62
62
}
63
63
64
+ func (p * loggerPromise ) V (l * DelegatingLogger , level int ) * loggerPromise {
65
+ res := & loggerPromise {
66
+ logger : l ,
67
+ level : level ,
68
+ promisesLock : sync.Mutex {},
69
+ }
70
+
71
+ p .promisesLock .Lock ()
72
+ defer p .promisesLock .Unlock ()
73
+ p .childPromises = append (p .childPromises , res )
74
+ return res
75
+ }
76
+
64
77
// Fulfill instantiates the Logger with the provided logger
65
78
func (p * loggerPromise ) Fulfill (parentLogger logr.Logger ) {
66
79
var logger = parentLogger
@@ -71,9 +84,12 @@ func (p *loggerPromise) Fulfill(parentLogger logr.Logger) {
71
84
if p .tags != nil {
72
85
logger = logger .WithValues (p .tags ... )
73
86
}
87
+ if p .level != 0 {
88
+ logger = logger .V (p .level )
89
+ }
74
90
75
91
p .logger .lock .Lock ()
76
- p .logger .Logger = logger
92
+ p .logger .logger = logger
77
93
p .logger .promise = nil
78
94
p .logger .lock .Unlock ()
79
95
@@ -88,21 +104,75 @@ func (p *loggerPromise) Fulfill(parentLogger logr.Logger) {
88
104
// logger. It expects to have *some* logr.Logger set at all times (generally
89
105
// a no-op logger before the promises are fulfilled).
90
106
type DelegatingLogger struct {
91
- lock sync.Mutex
92
- logr.Logger
107
+ lock sync.RWMutex
108
+ logger logr.Logger
93
109
promise * loggerPromise
94
110
}
95
111
112
+ // Enabled tests whether this Logger is enabled. For example, commandline
113
+ // flags might be used to set the logging verbosity and disable some info
114
+ // logs.
115
+ func (l * DelegatingLogger ) Enabled () bool {
116
+ l .lock .RLock ()
117
+ defer l .lock .RUnlock ()
118
+ return l .logger .Enabled ()
119
+ }
120
+
121
+ // Info logs a non-error message with the given key/value pairs as context.
122
+ //
123
+ // The msg argument should be used to add some constant description to
124
+ // the log line. The key/value pairs can then be used to add additional
125
+ // variable information. The key/value pairs should alternate string
126
+ // keys and arbitrary values.
127
+ func (l * DelegatingLogger ) Info (msg string , keysAndValues ... interface {}) {
128
+ l .lock .RLock ()
129
+ defer l .lock .RUnlock ()
130
+ l .logger .Info (msg , keysAndValues ... )
131
+ }
132
+
133
+ // Error logs an error, with the given message and key/value pairs as context.
134
+ // It functions similarly to calling Info with the "error" named value, but may
135
+ // have unique behavior, and should be preferred for logging errors (see the
136
+ // package documentations for more information).
137
+ //
138
+ // The msg field should be used to add context to any underlying error,
139
+ // while the err field should be used to attach the actual error that
140
+ // triggered this log line, if present.
141
+ func (l * DelegatingLogger ) Error (err error , msg string , keysAndValues ... interface {}) {
142
+ l .lock .RLock ()
143
+ defer l .lock .RUnlock ()
144
+ l .logger .Error (err , msg , keysAndValues ... )
145
+ }
146
+
147
+ // V returns an Logger value for a specific verbosity level, relative to
148
+ // this Logger. In other words, V values are additive. V higher verbosity
149
+ // level means a log message is less important. It's illegal to pass a log
150
+ // level less than zero.
151
+ func (l * DelegatingLogger ) V (level int ) logr.Logger {
152
+ l .lock .RLock ()
153
+ defer l .lock .RUnlock ()
154
+
155
+ if l .promise == nil {
156
+ return l .logger .V (level )
157
+ }
158
+
159
+ res := & DelegatingLogger {logger : l .logger }
160
+ promise := l .promise .V (res , level )
161
+ res .promise = promise
162
+
163
+ return res
164
+ }
165
+
96
166
// WithName provides a new Logger with the name appended
97
167
func (l * DelegatingLogger ) WithName (name string ) logr.Logger {
98
- l .lock .Lock ()
99
- defer l .lock .Unlock ()
168
+ l .lock .RLock ()
169
+ defer l .lock .RUnlock ()
100
170
101
171
if l .promise == nil {
102
- return l .Logger .WithName (name )
172
+ return l .logger .WithName (name )
103
173
}
104
174
105
- res := & DelegatingLogger {Logger : l .Logger }
175
+ res := & DelegatingLogger {logger : l .logger }
106
176
promise := l .promise .WithName (res , name )
107
177
res .promise = promise
108
178
@@ -111,14 +181,14 @@ func (l *DelegatingLogger) WithName(name string) logr.Logger {
111
181
112
182
// WithValues provides a new Logger with the tags appended
113
183
func (l * DelegatingLogger ) WithValues (tags ... interface {}) logr.Logger {
114
- l .lock .Lock ()
115
- defer l .lock .Unlock ()
184
+ l .lock .RLock ()
185
+ defer l .lock .RUnlock ()
116
186
117
187
if l .promise == nil {
118
- return l .Logger .WithValues (tags ... )
188
+ return l .logger .WithValues (tags ... )
119
189
}
120
190
121
- res := & DelegatingLogger {Logger : l .Logger }
191
+ res := & DelegatingLogger {logger : l .logger }
122
192
promise := l .promise .WithValues (res , tags ... )
123
193
res .promise = promise
124
194
@@ -138,7 +208,7 @@ func (l *DelegatingLogger) Fulfill(actual logr.Logger) {
138
208
// the given logger before it's promise is fulfilled.
139
209
func NewDelegatingLogger (initial logr.Logger ) * DelegatingLogger {
140
210
l := & DelegatingLogger {
141
- Logger : initial ,
211
+ logger : initial ,
142
212
promise : & loggerPromise {promisesLock : sync.Mutex {}},
143
213
}
144
214
l .promise .logger = l
0 commit comments