@@ -25,16 +25,15 @@ import (
2525// loggerPromise knows how to populate a concrete logr.Logger
2626// with options, given an actual base logger later on down the line.
2727type loggerPromise struct {
28- logger * DelegatingLogger
28+ logger * DelegatingLogSink
2929 childPromises []* loggerPromise
3030 promisesLock sync.Mutex
3131
32- name * string
33- tags []interface {}
34- level int
32+ name * string
33+ tags []interface {}
3534}
3635
37- func (p * loggerPromise ) WithName (l * DelegatingLogger , name string ) * loggerPromise {
36+ func (p * loggerPromise ) WithName (l * DelegatingLogSink , name string ) * loggerPromise {
3837 res := & loggerPromise {
3938 logger : l ,
4039 name : & name ,
@@ -48,7 +47,7 @@ func (p *loggerPromise) WithName(l *DelegatingLogger, name string) *loggerPromis
4847}
4948
5049// WithValues provides a new Logger with the tags appended.
51- func (p * loggerPromise ) WithValues (l * DelegatingLogger , tags ... interface {}) * loggerPromise {
50+ func (p * loggerPromise ) WithValues (l * DelegatingLogSink , tags ... interface {}) * loggerPromise {
5251 res := & loggerPromise {
5352 logger : l ,
5453 tags : tags ,
@@ -61,61 +60,53 @@ func (p *loggerPromise) WithValues(l *DelegatingLogger, tags ...interface{}) *lo
6160 return res
6261}
6362
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-
7763// Fulfill instantiates the Logger with the provided logger.
78- func (p * loggerPromise ) Fulfill (parentLogger logr.Logger ) {
79- logger := logr . WithCallDepth ( parentLogger , 1 )
64+ func (p * loggerPromise ) Fulfill (parentLogSink logr.LogSink ) {
65+ sink := parentLogSink
8066 if p .name != nil {
81- logger = logger .WithName (* p .name )
67+ sink = sink .WithName (* p .name )
8268 }
8369
8470 if p .tags != nil {
85- logger = logger .WithValues (p .tags ... )
86- }
87- if p .level != 0 {
88- logger = logger .V (p .level )
71+ sink = sink .WithValues (p .tags ... )
8972 }
9073
9174 p .logger .lock .Lock ()
92- p .logger .logger = logger
75+ p .logger .logger = sink
9376 p .logger .promise = nil
9477 p .logger .lock .Unlock ()
9578
9679 for _ , childPromise := range p .childPromises {
97- childPromise .Fulfill (logger )
80+ childPromise .Fulfill (sink )
9881 }
9982}
10083
101- // DelegatingLogger is a logr.Logger that delegates to another logr.Logger .
84+ // DelegatingLogSink is a logsink that delegates to another logr.LogSink .
10285// If the underlying promise is not nil, it registers calls to sub-loggers with
10386// the logging factory to be populated later, and returns a new delegating
10487// logger. It expects to have *some* logr.Logger set at all times (generally
10588// a no-op logger before the promises are fulfilled).
106- type DelegatingLogger struct {
89+ type DelegatingLogSink struct {
10790 lock sync.RWMutex
108- logger logr.Logger
91+ logger logr.LogSink
10992 promise * loggerPromise
93+ info logr.RuntimeInfo
94+ }
95+
96+ // Init implements logr.LogSink.
97+ func (l * DelegatingLogSink ) Init (info logr.RuntimeInfo ) {
98+ l .lock .Lock ()
99+ defer l .lock .Unlock ()
100+ l .info = info
110101}
111102
112103// Enabled tests whether this Logger is enabled. For example, commandline
113104// flags might be used to set the logging verbosity and disable some info
114105// logs.
115- func (l * DelegatingLogger ) Enabled () bool {
106+ func (l * DelegatingLogSink ) Enabled (level int ) bool {
116107 l .lock .RLock ()
117108 defer l .lock .RUnlock ()
118- return l .logger .Enabled ()
109+ return l .logger .Enabled (level )
119110}
120111
121112// Info logs a non-error message with the given key/value pairs as context.
@@ -124,10 +115,10 @@ func (l *DelegatingLogger) Enabled() bool {
124115// the log line. The key/value pairs can then be used to add additional
125116// variable information. The key/value pairs should alternate string
126117// keys and arbitrary values.
127- func (l * DelegatingLogger ) Info (msg string , keysAndValues ... interface {}) {
118+ func (l * DelegatingLogSink ) Info (level int , msg string , keysAndValues ... interface {}) {
128119 l .lock .RLock ()
129120 defer l .lock .RUnlock ()
130- l .logger .Info (msg , keysAndValues ... )
121+ l .logger .Info (level , msg , keysAndValues ... )
131122}
132123
133124// Error logs an error, with the given message and key/value pairs as context.
@@ -138,57 +129,38 @@ func (l *DelegatingLogger) Info(msg string, keysAndValues ...interface{}) {
138129// The msg field should be used to add context to any underlying error,
139130// while the err field should be used to attach the actual error that
140131// triggered this log line, if present.
141- func (l * DelegatingLogger ) Error (err error , msg string , keysAndValues ... interface {}) {
132+ func (l * DelegatingLogSink ) Error (err error , msg string , keysAndValues ... interface {}) {
142133 l .lock .RLock ()
143134 defer l .lock .RUnlock ()
144135 l .logger .Error (err , msg , keysAndValues ... )
145136}
146137
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-
166138// WithName provides a new Logger with the name appended.
167- func (l * DelegatingLogger ) WithName (name string ) logr.Logger {
139+ func (l * DelegatingLogSink ) WithName (name string ) logr.LogSink {
168140 l .lock .RLock ()
169141 defer l .lock .RUnlock ()
170142
171143 if l .promise == nil {
172144 return l .logger .WithName (name )
173145 }
174146
175- res := & DelegatingLogger {logger : l .logger }
147+ res := & DelegatingLogSink {logger : l .logger }
176148 promise := l .promise .WithName (res , name )
177149 res .promise = promise
178150
179151 return res
180152}
181153
182154// WithValues provides a new Logger with the tags appended.
183- func (l * DelegatingLogger ) WithValues (tags ... interface {}) logr.Logger {
155+ func (l * DelegatingLogSink ) WithValues (tags ... interface {}) logr.LogSink {
184156 l .lock .RLock ()
185157 defer l .lock .RUnlock ()
186158
187159 if l .promise == nil {
188160 return l .logger .WithValues (tags ... )
189161 }
190162
191- res := & DelegatingLogger {logger : l .logger }
163+ res := & DelegatingLogSink {logger : l .logger }
192164 promise := l .promise .WithValues (res , tags ... )
193165 res .promise = promise
194166
@@ -198,16 +170,16 @@ func (l *DelegatingLogger) WithValues(tags ...interface{}) logr.Logger {
198170// Fulfill switches the logger over to use the actual logger
199171// provided, instead of the temporary initial one, if this method
200172// has not been previously called.
201- func (l * DelegatingLogger ) Fulfill (actual logr.Logger ) {
173+ func (l * DelegatingLogSink ) Fulfill (actual logr.LogSink ) {
202174 if l .promise != nil {
203175 l .promise .Fulfill (actual )
204176 }
205177}
206178
207- // NewDelegatingLogger constructs a new DelegatingLogger which uses
179+ // NewDelegatingLogSink constructs a new DelegatingLogSink which uses
208180// the given logger before it's promise is fulfilled.
209- func NewDelegatingLogger (initial logr.Logger ) * DelegatingLogger {
210- l := & DelegatingLogger {
181+ func NewDelegatingLogSink (initial logr.LogSink ) * DelegatingLogSink {
182+ l := & DelegatingLogSink {
211183 logger : initial ,
212184 promise : & loggerPromise {promisesLock : sync.Mutex {}},
213185 }
0 commit comments