Visitar URL original
logging: fix -v=<n> output (#23910) · pulumi/pulumi@93f6e51 · GitHub
Skip to content

Commit 93f6e51

Browse files
tgummereriwahbe
andauthored
logging: fix -v=<n> output (#23910)
With the introduction of automatic logging, we introduce a bug, where the log levels with -v would not be respected correctly anymore. Introduce a verbosityHandler, that does that filtering for us in a more granular manner than slog can (as people seeem to be relying on that). --------- Co-authored-by: Ian Wahbe <me@iwahbe.com>
1 parent d8e98e7 commit 93f6e51

3 files changed

Lines changed: 196 additions & 2 deletions

File tree

Lines changed: 6 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,6 @@
1+
component: cli
2+
kind: fix
3+
body: Respect the -v log level again so that without -v only warnings and errors are written to stderr
4+
time: 2026-07-13T00:00:00+00:00
5+
custom:
6+
PR: "23910"

‎sdk/go/common/util/logging/log.go‎

Lines changed: 40 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -75,7 +75,7 @@ func init() {
7575
// handlerMu held for writing. slog.SetDefault is safe for concurrent use
7676
// with readers, so no additional synchronisation is needed.
7777
func rebuildLogger() {
78-
var p slog.Handler = formattingHandler{inner: primary}
78+
var p slog.Handler = verbosityHandler{inner: formattingHandler{inner: primary}}
7979
var h slog.Handler = filteringHandler{inner: &teeHandler{
8080
primary: p,
8181
sink: sinkHandler,
@@ -120,8 +120,10 @@ func verbosityLevel(verbose int) slog.Level {
120120
return LevelTrace
121121
case verbose >= 10:
122122
return slog.LevelDebug
123-
default:
123+
case verbose >= 1:
124124
return slog.LevelInfo
125+
default:
126+
return slog.LevelWarn
125127
}
126128
}
127129

@@ -453,6 +455,42 @@ func FilterString(msg string) string {
453455
return msg
454456
}
455457

458+
// verbosityHandler drops records whose "v" attribute exceeds the requested -v level before they
459+
// reach the primary log output. Records carry their original pulumi verbosity in the "v"
460+
// attribute, while their slog levels are bucketed too coarsely (V(1)-V(9) all map to Info) for
461+
// level-based filtering alone. Only the primary output filters by verbosity; the sink and export
462+
// handlers receive every record.
463+
type verbosityHandler struct {
464+
inner slog.Handler
465+
}
466+
467+
func (h verbosityHandler) Enabled(ctx context.Context, level slog.Level) bool {
468+
return h.inner.Enabled(ctx, level)
469+
}
470+
471+
func (h verbosityHandler) Handle(ctx context.Context, r slog.Record) error {
472+
drop := false
473+
r.Attrs(func(a slog.Attr) bool {
474+
if a.Key == "v" && a.Value.Kind() == slog.KindInt64 {
475+
drop = a.Value.Int64() > int64(Verbose)
476+
return false
477+
}
478+
return true
479+
})
480+
if drop {
481+
return nil
482+
}
483+
return h.inner.Handle(ctx, r)
484+
}
485+
486+
func (h verbosityHandler) WithAttrs(attrs []slog.Attr) slog.Handler {
487+
return verbosityHandler{inner: h.inner.WithAttrs(attrs)}
488+
}
489+
490+
func (h verbosityHandler) WithGroup(name string) slog.Handler {
491+
return verbosityHandler{inner: h.inner.WithGroup(name)}
492+
}
493+
456494
type discardHandler struct{}
457495

458496
func (discardHandler) Enabled(context.Context, slog.Level) bool { return false }

‎sdk/go/common/util/logging/log_test.go‎

Lines changed: 150 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -15,9 +15,14 @@
1515
package logging
1616

1717
import (
18+
"context"
19+
"io"
20+
"log/slog"
1821
"os"
1922
"os/exec"
2023
"path/filepath"
24+
"slices"
25+
"sync"
2126
"testing"
2227

2328
"github.com/stretchr/testify/assert"
@@ -144,3 +149,148 @@ func TestLoggingDoesNotConflictWithGlog(t *testing.T) {
144149
output, err := cmd.CombinedOutput()
145150
require.NoError(t, err, string(output))
146151
}
152+
153+
// TestInitLoggingFiltersVerbosity verifies that the stderr handler filters records logged directly
154+
// through slog by the -v level: without -v only warnings and errors pass.
155+
//
156+
//nolint:paralleltest // mutates global logging state
157+
func TestInitLoggingFiltersVerbosity(t *testing.T) {
158+
prevLog, prevV, prevFlow := LogToStderr, Verbose, LogFlow
159+
t.Cleanup(func() {
160+
handlerMu.Lock()
161+
primary = discardHandler{}
162+
rebuildLogger()
163+
handlerMu.Unlock()
164+
LogToStderr, Verbose, LogFlow = prevLog, prevV, prevFlow
165+
})
166+
167+
enabled := func(level slog.Level) bool {
168+
handlerMu.RLock()
169+
defer handlerMu.RUnlock()
170+
return primary.Enabled(t.Context(), level)
171+
}
172+
173+
InitLogging(true, 0, false)
174+
assert.False(t, enabled(slog.LevelInfo))
175+
assert.False(t, enabled(slog.LevelDebug))
176+
assert.True(t, enabled(slog.LevelWarn))
177+
assert.True(t, enabled(slog.LevelError))
178+
179+
InitLogging(true, 1, false)
180+
assert.True(t, enabled(slog.LevelInfo))
181+
assert.False(t, enabled(slog.LevelDebug))
182+
183+
InitLogging(true, 10, false)
184+
assert.True(t, enabled(slog.LevelDebug))
185+
assert.False(t, enabled(LevelTrace))
186+
187+
InitLogging(true, 11, false)
188+
assert.True(t, enabled(LevelTrace))
189+
}
190+
191+
// TestLogToStderrRespectsVerbosity verifies that with --logtostderr and no -v, neither V-guarded
192+
// nor direct slog info records reach stderr — even while a sink handler (as installed for
193+
// encrypted logs) keeps them flowing — and warnings still show.
194+
//
195+
//nolint:paralleltest // mutates global logging state and os.Stderr
196+
func TestLogToStderrRespectsVerbosity(t *testing.T) {
197+
prevLog, prevV, prevFlow := LogToStderr, Verbose, LogFlow
198+
t.Cleanup(func() {
199+
SetSinkHandler(nil)
200+
handlerMu.Lock()
201+
primary = discardHandler{}
202+
rebuildLogger()
203+
handlerMu.Unlock()
204+
LogToStderr, Verbose, LogFlow = prevLog, prevV, prevFlow
205+
})
206+
207+
r, w, err := os.Pipe()
208+
require.NoError(t, err)
209+
oldStderr := os.Stderr
210+
os.Stderr = w
211+
InitLogging(true, 0, false)
212+
os.Stderr = oldStderr
213+
214+
sink := &recordingHandler{}
215+
SetSinkHandler(sink)
216+
217+
V(9).Infof("guarded info %d", 42)
218+
Infof("unguarded info")
219+
slog.Info("direct info")
220+
Warningf("warning shows")
221+
222+
require.NoError(t, w.Close())
223+
out, err := io.ReadAll(r)
224+
require.NoError(t, err)
225+
226+
assert.NotContains(t, string(out), "guarded info")
227+
assert.NotContains(t, string(out), "unguarded info")
228+
assert.NotContains(t, string(out), "direct info")
229+
assert.Contains(t, string(out), "warning shows")
230+
assert.True(t, sink.saw("guarded info %d"))
231+
}
232+
233+
type recordingHandler struct {
234+
mu sync.Mutex
235+
msgs []string
236+
}
237+
238+
func (h *recordingHandler) Enabled(context.Context, slog.Level) bool { return true }
239+
240+
func (h *recordingHandler) Handle(_ context.Context, r slog.Record) error {
241+
h.mu.Lock()
242+
defer h.mu.Unlock()
243+
h.msgs = append(h.msgs, r.Message)
244+
return nil
245+
}
246+
247+
func (h *recordingHandler) WithAttrs([]slog.Attr) slog.Handler { return h }
248+
func (h *recordingHandler) WithGroup(string) slog.Handler { return h }
249+
250+
func (h *recordingHandler) saw(msg string) bool {
251+
h.mu.Lock()
252+
defer h.mu.Unlock()
253+
return slices.Contains(h.msgs, msg)
254+
}
255+
256+
// TestLogToStderrFiltersHigherVerbosity reproduces `pulumi up --logtostderr -v=1` showing v=5
257+
// records: the primary handler must drop records whose "v" attribute exceeds the requested level,
258+
// for both the V() wrapper and direct slog calls that carry the attribute.
259+
//
260+
//nolint:paralleltest // mutates global logging state and os.Stderr
261+
func TestLogToStderrFiltersHigherVerbosity(t *testing.T) {
262+
prevLog, prevV, prevFlow := LogToStderr, Verbose, LogFlow
263+
t.Cleanup(func() {
264+
SetSinkHandler(nil)
265+
handlerMu.Lock()
266+
primary = discardHandler{}
267+
rebuildLogger()
268+
handlerMu.Unlock()
269+
LogToStderr, Verbose, LogFlow = prevLog, prevV, prevFlow
270+
})
271+
272+
r, w, err := os.Pipe()
273+
require.NoError(t, err)
274+
oldStderr := os.Stderr
275+
os.Stderr = w
276+
InitLogging(true, 1, false)
277+
os.Stderr = oldStderr
278+
279+
sink := &recordingHandler{}
280+
SetSinkHandler(sink)
281+
282+
V(1).Infof("v1 shows")
283+
V(5).Infof("v5 hidden")
284+
slog.Info("direct v5 hidden", "v", 5)
285+
slog.Info("unleveled info shows")
286+
287+
require.NoError(t, w.Close())
288+
out, err := io.ReadAll(r)
289+
require.NoError(t, err)
290+
291+
assert.Contains(t, string(out), "v1 shows")
292+
assert.NotContains(t, string(out), "v5 hidden")
293+
assert.NotContains(t, string(out), "direct v5 hidden")
294+
assert.Contains(t, string(out), "unleveled info shows")
295+
assert.True(t, sink.saw("v5 hidden"))
296+
}

0 commit comments

Comments
 (0)