@@ -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,54 @@ 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
66+
8067 if p .name != nil {
81- logger = logger .WithName (* p .name )
68+ sink = sink .WithName (* p .name )
8269 }
8370
8471 if p .tags != nil {
85- logger = logger .WithValues (p .tags ... )
86- }
87- if p .level != 0 {
88- logger = logger .V (p .level )
72+ sink = sink .WithValues (p .tags ... )
8973 }
9074
9175 p .logger .lock .Lock ()
92- p .logger .logger = logger
76+ p .logger .logger = sink
9377 p .logger .promise = nil
9478 p .logger .lock .Unlock ()
9579
9680 for _ , childPromise := range p .childPromises {
97- childPromise .Fulfill (logger )
81+ childPromise .Fulfill (sink )
9882 }
9983}
10084
101- // DelegatingLogger is a logr.Logger that delegates to another logr.Logger .
85+ // DelegatingLogSink is a logr.LogSink that delegates to another logr.LogSink .
10286// If the underlying promise is not nil, it registers calls to sub-loggers with
10387// the logging factory to be populated later, and returns a new delegating
10488// logger. It expects to have *some* logr.Logger set at all times (generally
10589// a no-op logger before the promises are fulfilled).
106- type DelegatingLogger struct {
90+ type DelegatingLogSink struct {
10791 lock sync.RWMutex
108- logger logr.Logger
92+ logger logr.LogSink
10993 promise * loggerPromise
94+ info logr.RuntimeInfo
95+ }
96+
97+ // Init implements logr.LogSink.
98+ func (l * DelegatingLogSink ) Init (info logr.RuntimeInfo ) {
99+ l .lock .Lock ()
100+ defer l .lock .Unlock ()
101+ l .info = info
110102}
111103
112104// Enabled tests whether this Logger is enabled. For example, commandline
113105// flags might be used to set the logging verbosity and disable some info
114106// logs.
115- func (l * DelegatingLogger ) Enabled () bool {
107+ func (l * DelegatingLogSink ) Enabled (v int ) bool {
116108 l .lock .RLock ()
117109 defer l .lock .RUnlock ()
118- return l .logger .Enabled ()
110+ return l .logger .Enabled (v )
119111}
120112
121113// Info logs a non-error message with the given key/value pairs as context.
@@ -124,10 +116,10 @@ func (l *DelegatingLogger) Enabled() bool {
124116// the log line. The key/value pairs can then be used to add additional
125117// variable information. The key/value pairs should alternate string
126118// keys and arbitrary values.
127- func (l * DelegatingLogger ) Info (msg string , keysAndValues ... interface {}) {
119+ func (l * DelegatingLogSink ) Info (level int , msg string , keysAndValues ... interface {}) {
128120 l .lock .RLock ()
129121 defer l .lock .RUnlock ()
130- l .logger .Info (msg , keysAndValues ... )
122+ l .logger .Info (level , msg , keysAndValues ... )
131123}
132124
133125// Error logs an error, with the given message and key/value pairs as context.
@@ -138,57 +130,38 @@ func (l *DelegatingLogger) Info(msg string, keysAndValues ...interface{}) {
138130// The msg field should be used to add context to any underlying error,
139131// while the err field should be used to attach the actual error that
140132// triggered this log line, if present.
141- func (l * DelegatingLogger ) Error (err error , msg string , keysAndValues ... interface {}) {
133+ func (l * DelegatingLogSink ) Error (err error , msg string , keysAndValues ... interface {}) {
142134 l .lock .RLock ()
143135 defer l .lock .RUnlock ()
144136 l .logger .Error (err , msg , keysAndValues ... )
145137}
146138
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-
166139// WithName provides a new Logger with the name appended.
167- func (l * DelegatingLogger ) WithName (name string ) logr.Logger {
140+ func (l * DelegatingLogSink ) WithName (name string ) logr.LogSink {
168141 l .lock .RLock ()
169142 defer l .lock .RUnlock ()
170143
171144 if l .promise == nil {
172145 return l .logger .WithName (name )
173146 }
174147
175- res := & DelegatingLogger {logger : l .logger }
148+ res := & DelegatingLogSink {logger : l .logger }
176149 promise := l .promise .WithName (res , name )
177150 res .promise = promise
178151
179152 return res
180153}
181154
182155// WithValues provides a new Logger with the tags appended.
183- func (l * DelegatingLogger ) WithValues (tags ... interface {}) logr.Logger {
156+ func (l * DelegatingLogSink ) WithValues (tags ... interface {}) logr.LogSink {
184157 l .lock .RLock ()
185158 defer l .lock .RUnlock ()
186159
187160 if l .promise == nil {
188161 return l .logger .WithValues (tags ... )
189162 }
190163
191- res := & DelegatingLogger {logger : l .logger }
164+ res := & DelegatingLogSink {logger : l .logger }
192165 promise := l .promise .WithValues (res , tags ... )
193166 res .promise = promise
194167
@@ -198,16 +171,16 @@ func (l *DelegatingLogger) WithValues(tags ...interface{}) logr.Logger {
198171// Fulfill switches the logger over to use the actual logger
199172// provided, instead of the temporary initial one, if this method
200173// has not been previously called.
201- func (l * DelegatingLogger ) Fulfill (actual logr.Logger ) {
174+ func (l * DelegatingLogSink ) Fulfill (actual logr.LogSink ) {
202175 if l .promise != nil {
203176 l .promise .Fulfill (actual )
204177 }
205178}
206179
207- // NewDelegatingLogger constructs a new DelegatingLogger which uses
180+ // NewDelegatingLogSink constructs a new DelegatingLogSink which uses
208181// the given logger before it's promise is fulfilled.
209- func NewDelegatingLogger (initial logr.Logger ) * DelegatingLogger {
210- l := & DelegatingLogger {
182+ func NewDelegatingLogSink (initial logr.LogSink ) * DelegatingLogSink {
183+ l := & DelegatingLogSink {
211184 logger : initial ,
212185 promise : & loggerPromise {promisesLock : sync.Mutex {}},
213186 }
0 commit comments