Skip to content

Find, verify, and analyze leaked credentials

[THOG-643] Implement independent log level controls (#733)

Miccahf3367d791016
diff --git a/pkg/log/core.go b/pkg/log/core.go
new file mode 100644
index 000000000..49a961c8c
--- /dev/null
+++ b/pkg/log/core.go
@@ -0,0 +1,41 @@
+package log
+
+import (
+ "go.uber.org/zap/zapcore"
+)
+
+type levelFilterCore struct {
+ core zapcore.Core
+ level zapcore.LevelEnabler
+}
+
+// NewLevelCore creates a core that can be used to independently control the
+// level of an existing Core. This is essentially a filter that will only log
+// if both the parent and the wrapper cores are enabled.
+func NewLevelCore(core zapcore.Core, level zapcore.LevelEnabler) zapcore.Core {
+ return &levelFilterCore{core, level}
+}
+
+func (c *levelFilterCore) Enabled(lvl zapcore.Level) bool {
+ return c.level.Enabled(lvl)
+}
+
+func (c *levelFilterCore) With(fields []zapcore.Field) zapcore.Core {
+ return &levelFilterCore{c.core.With(fields), c.level}
+}
+
+func (c *levelFilterCore) Check(ent zapcore.Entry, ce *zapcore.CheckedEntry) *zapcore.CheckedEntry {
+ if !c.Enabled(ent.Level) {
+ return ce
+ }
+
+ return c.core.Check(ent, ce)
+}
+
+func (c *levelFilterCore) Write(ent zapcore.Entry, fields []zapcore.Field) error {
+ return c.core.Write(ent, fields)
+}
+
+func (c *levelFilterCore) Sync() error {
+ return c.core.Sync()
+}
diff --git a/pkg/log/level.go b/pkg/log/level.go
new file mode 100644
index 000000000..cc8f8d433
--- /dev/null
+++ b/pkg/log/level.go
@@ -0,0 +1,114 @@
+package log
+
+import (
+ "sort"
+ "sync"
+
+ "github.com/go-logr/logr"
+ "github.com/go-logr/zapr"
+ "go.uber.org/zap"
+ "go.uber.org/zap/zapcore"
+)
+
+// TODO: Use a struct to make testing easier.
+var (
+ // Global, default log level control.
+ globalLogLevel levelSetter = zap.NewAtomicLevel()
+
+ // Map of name -> level control for independently setting log levels. A new
+ // control is registered via WithNamedLevel. This map is never cleaned up
+ // and new entries will overwrite previous values. Currently, this is
+ // acceptable behavior because WithNamedLevel is used sparingly.
+ globalControls map[string]levelSetter = make(map[string]levelSetter, 16)
+ // globalControls is protected (both read and write) by a mutex to make it
+ // thread safe. Access is low frequency, so performance is not a concern.
+ globalControlsLock sync.Mutex
+)
+
+type levelSetter interface {
+ zapcore.LevelEnabler
+ SetLevel(zapcore.Level)
+ Level() zapcore.Level
+}
+
+// SetLevel sets the log level for loggers created with the default level
+// controller.
+func SetLevel(level int8) {
+ SetLevelForControl(globalLogLevel, level)
+}
+
+// SetLevelForControl sets the log level for a given control.
+func SetLevelForControl(control levelSetter, level int8) {
+ // Zap's levels get more verbose as the number gets smaller, as explained
+ // by zapr here: https://github.com/go-logr/zapr#increasing-verbosity
+ // For example setting the level to -2 below, means log.V(2) will be enabled.
+ control.SetLevel(zapcore.Level(-level))
+}
+
+// SetLevelFor sets the log level for a given named control.
+func SetLevelFor(name string, level int8) {
+ globalControlsLock.Lock()
+ defer globalControlsLock.Unlock()
+ if control, ok := globalControls[name]; ok {
+ SetLevelForControl(control, level)
+ return
+ }
+ // Create a new control so registering a control with the same name will
+ // inherit the existing level.
+ globalControls[name] = newAtomicLevelAt(level)
+}
+
+// AddLeveler adds a log level control to a logr.Logger.
+func AddLeveler(l logr.Logger, control levelSetter) (logr.Logger, error) {
+ zapLogger, err := getZapLogger(l)
+ if err != nil {
+ return l, err
+ }
+
+ zapLogger = zapLogger.WithOptions(zap.WrapCore(func(core zapcore.Core) zapcore.Core {
+ return NewLevelCore(core, control)
+ }))
+ return zapr.NewLogger(zapLogger), nil
+}
+
+// WithNamedLevel creates a child logger with a new name and independent log
+// level control (see SetLevelFor). NOTE: if name already exists, the existing
+// controller will be used, otherwise a new controller is created with level
+// matching the parent's log level.
+func WithNamedLevel(logger logr.Logger, name string) logr.Logger {
+ logger = logger.WithName(name)
+
+ globalControlsLock.Lock()
+ defer globalControlsLock.Unlock()
+
+ var leveler levelSetter
+ if currentControl, ok := globalControls[name]; ok {
+ leveler = currentControl
+ } else {
+ leveler = newAtomicLevelAt(findLevel(logger))
+ globalControls[name] = leveler
+ }
+ newLogger, err := AddLeveler(logger, leveler)
+ if err != nil {
+ return logger
+ }
+ return newLogger
+}
+
+// newAtomicLevelAt is a helper function to create a zap.AtomicLevel
+// initialized with a level. We cannot use zap.NewAtomicLevelAt here because of
+// a quirk with logr levels (see SetLevelForControl).
+func newAtomicLevelAt(level int8) zap.AtomicLevel {
+ control := zap.NewAtomicLevel()
+ SetLevelForControl(control, level)
+ return control
+}
+
+// findLevel probes a logr.Logger to figure out what level it is at via binary
+// search. We only search [0, 128), so worst case is ~7 checks.
+func findLevel(logger logr.Logger) int8 {
+ sink := logger.GetSink()
+ return int8(sort.Search(128, func(i int) bool {
+ return !sink.Enabled(i)
+ }) - 1)
+}
diff --git a/pkg/log/log.go b/pkg/log/log.go
index 93fd4e4b3..41fbcae08 100644
--- a/pkg/log/log.go
+++ b/pkg/log/log.go
@@ -2,6 +2,7 @@ package log
import (
"errors"
+ "fmt"
"io"
"time"
@@ -13,11 +14,6 @@ import (
"go.uber.org/zap/zapcore"
)
-var (
- // global log level control (see SetLevel)
- logLevel zap.AtomicLevel = zap.NewAtomicLevel()
-)
-
type logConfig struct {
core zapcore.Core
cleanup func() error
@@ -56,15 +52,6 @@ func New(service string, configs ...logConfig) (logr.Logger, func() error) {
return logger, firstErrorFunc(cleanupFuncs...)
}
-// SetLevel sets the log level for all loggers created with WithJSONSink and
-// WithConsoleSink.
-func SetLevel(level int8) {
- // Zap's levels get more verbose as the number gets smaller, as explained
- // by zapr here: https://github.com/go-logr/zapr#increasing-verbosity
- // For example setting the level to -2 below, means log.V(2) will be enabled.
- logLevel.SetLevel(zapcore.Level(-level))
-}
-
// WithSentry adds sentry integration to the logger. This configuration may
// fail, in which case, sentry will not be added and execution will continue
// normally.
@@ -95,36 +82,43 @@ func WithSentry(opts sentry.ClientOptions, tags map[string]string) logConfig {
}
}
+type sinkConfig struct {
+ encoder zapcore.Encoder
+ sink zapcore.WriteSyncer
+ level levelSetter
+}
+
// WithJSONSink adds a JSON encoded output to the logger.
-func WithJSONSink(sink io.Writer) logConfig {
- return logConfig{
- core: zapcore.NewCore(
- zapcore.NewJSONEncoder(defaultEncoderConfig()),
- zapcore.Lock(
- zapcore.AddSync(sink),
- ),
- logLevel,
- ),
- }
+func WithJSONSink(sink io.Writer, opts ...func(*sinkConfig)) logConfig {
+ return newCoreConfig(
+ zapcore.NewJSONEncoder(defaultEncoderConfig()),
+ zapcore.Lock(zapcore.AddSync(sink)),
+ globalLogLevel,
+ opts...,
+ )
}
// WithConsoleSink adds a console-style output to the logger.
-func WithConsoleSink(sink io.Writer) logConfig {
- return logConfig{
- core: zapcore.NewCore(
- zapcore.NewConsoleEncoder(defaultEncoderConfig()),
- zapcore.Lock(
- zapcore.AddSync(sink),
- ),
- logLevel,
- ),
- }
+func WithConsoleSink(sink io.Writer, opts ...func(*sinkConfig)) logConfig {
+ return newCoreConfig(
+ zapcore.NewConsoleEncoder(defaultEncoderConfig()),
+ zapcore.Lock(zapcore.AddSync(sink)),
+ globalLogLevel,
+ opts...,
+ )
}
func defaultEncoderConfig() zapcore.EncoderConfig {
conf := zap.NewProductionEncoderConfig()
// Use more human-readable time format.
conf.EncodeTime = zapcore.TimeEncoderOfLayout(time.RFC3339)
+ conf.EncodeLevel = func(level zapcore.Level, enc zapcore.PrimitiveArrayEncoder) {
+ if level == zapcore.ErrorLevel {
+ enc.AppendString("error")
+ return
+ }
+ enc.AppendString(fmt.Sprintf("info-%d", -int8(level)))
+ }
return conf
}
@@ -136,16 +130,15 @@ func WithCore(core zapcore.Core) logConfig {
// AddSentry initializes a sentry client and extends an existing
// logr.Logger with the hook.
func AddSentry(l logr.Logger, opts sentry.ClientOptions, tags map[string]string) (logr.Logger, func() error, error) {
- conf := WithSentry(opts, tags)
- if conf.err != nil {
- return l, nil, conf.err
- }
- return AddSink(l, conf)
+ return AddSink(l, WithSentry(opts, tags))
}
// AddSink extends an existing logr.Logger with a new sink. It returns the new
// logr.Logger, a cleanup function, and an error.
func AddSink(l logr.Logger, sink logConfig) (logr.Logger, func() error, error) {
+ if sink.err != nil {
+ return l, nil, sink.err
+ }
zapLogger, err := getZapLogger(l)
if err != nil {
return l, nil, errors.New("unsupported logr implementation")
@@ -165,6 +158,24 @@ func getZapLogger(l logr.Logger) (*zap.Logger, error) {
return nil, errors.New("not a zapr logger")
}
+// WithLevel sets the sink's level to a static level. This option prevents
+// changing the log level for this sink later on.
+func WithLevel(level int8) func(*sinkConfig) {
+ return WithLeveler(
+ // Zap's levels get more verbose as the number gets smaller, as explained
+ // by zapr here: https://github.com/go-logr/zapr#increasing-verbosity
+ // For example setting the level to -2 below, means log.V(2) will be enabled.
+ zap.NewAtomicLevelAt(zapcore.Level(-level)),
+ )
+}
+
+// WithLeveler sets the sink's level enabler to leveler.
+func WithLeveler(leveler levelSetter) func(*sinkConfig) {
+ return func(conf *sinkConfig) {
+ conf.level = leveler
+ }
+}
+
// firstErrorFunc is a helper function that returns a function that executes
// all provided args and returns the first error, if any.
func firstErrorFunc(fs ...func() error) func() error {
@@ -181,3 +192,28 @@ func firstErrorFunc(fs ...func() error) func() error {
return firstErr
}
}
+
+// newCoreConfig is a helper function that creates a default sinkConfig,
+// applies the options, then creates a zapcore.Core.
+func newCoreConfig(
+ defaultEncoder zapcore.Encoder,
+ defaultSink zapcore.WriteSyncer,
+ defaultLevel levelSetter,
+ opts ...func(*sinkConfig),
+) logConfig {
+ conf := sinkConfig{
+ encoder: defaultEncoder,
+ sink: defaultSink,
+ level: defaultLevel,
+ }
+ for _, f := range opts {
+ f(&conf)
+ }
+ return logConfig{
+ core: zapcore.NewCore(
+ conf.encoder,
+ conf.sink,
+ conf.level,
+ ),
+ }
+}
diff --git a/pkg/log/log_test.go b/pkg/log/log_test.go
index f5a356314..65593b789 100644
--- a/pkg/log/log_test.go
+++ b/pkg/log/log_test.go
@@ -2,33 +2,52 @@ package log
import (
"bytes"
+ "encoding/json"
+ "fmt"
+ "io"
+ "sort"
"strings"
+ "sync"
"testing"
"time"
"github.com/getsentry/sentry-go"
+ "github.com/go-logr/logr"
"github.com/stretchr/testify/assert"
+ "go.uber.org/zap"
)
func TestNew(t *testing.T) {
var jsonBuffer, consoleBuffer bytes.Buffer
- logger, sync := New("service-name",
+ logger, flush := New("service-name",
WithJSONSink(&jsonBuffer),
WithConsoleSink(&consoleBuffer),
)
logger.Info("yay")
- assert.Nil(t, sync())
+ assert.Nil(t, flush())
- assert.Contains(t, jsonBuffer.String(), `"logger":"service-name"`)
- assert.Contains(t, jsonBuffer.String(), `"msg":"yay"`)
- assert.Contains(t, consoleBuffer.String(), "info\tservice-name\tyay")
+ var parsedJSON map[string]any
+ assert.Nil(t, json.Unmarshal(jsonBuffer.Bytes(), &parsedJSON))
+ assert.NotEmpty(t, parsedJSON["ts"])
+ delete(parsedJSON, "ts")
+ assert.Equal(t,
+ map[string]any{
+ "level": "info-0",
+ "logger": "service-name",
+ "msg": "yay",
+ },
+ parsedJSON,
+ )
+ assert.Equal(t,
+ []string{"info-0\tservice-name\tyay"},
+ splitLines(consoleBuffer.String()),
+ )
}
func TestSetLevel(t *testing.T) {
var buffer bytes.Buffer
- logger, _ := New("service-name",
- WithConsoleSink(&buffer),
- )
+ defer SetLevel(0)
+ logger, _ := New("service-name", WithConsoleSink(&buffer))
assert.Equal(t, true, logger.GetSink().Enabled(0))
assert.Equal(t, false, logger.GetSink().Enabled(1))
@@ -47,12 +66,12 @@ func TestSetLevel(t *testing.T) {
func TestWithSentryFailure(t *testing.T) {
var buffer bytes.Buffer
- logger, sync := New("service-name",
+ logger, flush := New("service-name",
WithSentry(sentry.ClientOptions{Dsn: "fail"}, nil),
WithConsoleSink(&buffer),
)
logger.Info("yay")
- assert.Nil(t, sync())
+ assert.Nil(t, flush())
assert.Contains(t, buffer.String(), "error configuring logger")
assert.Contains(t, buffer.String(), "yay")
@@ -60,15 +79,13 @@ func TestWithSentryFailure(t *testing.T) {
func TestAddSentryFailure(t *testing.T) {
var buffer bytes.Buffer
- logger, sync := New("service-name",
- WithConsoleSink(&buffer),
- )
+ logger, flush := New("service-name", WithConsoleSink(&buffer))
logger, _, err := AddSentry(logger, sentry.ClientOptions{Dsn: "fail"}, nil)
assert.NotNil(t, err)
assert.NotContains(t, err.Error(), "unsupported")
logger.Info("yay")
- assert.Nil(t, sync())
+ assert.Nil(t, flush())
assert.Contains(t, buffer.String(), "yay")
}
@@ -76,10 +93,8 @@ func TestAddSentryFailure(t *testing.T) {
func TestAddSentry(t *testing.T) {
var buffer bytes.Buffer
var sentryMessage string
- logger, _ := New("service-name",
- WithConsoleSink(&buffer),
- )
- logger, sync, err := AddSentry(logger, sentry.ClientOptions{
+ logger, _ := New("service-name", WithConsoleSink(&buffer))
+ logger, flush, err := AddSentry(logger, sentry.ClientOptions{
BeforeSend: func(event *sentry.Event, hint *sentry.EventHint) *sentry.Event {
sentryMessage = event.Message
return nil
@@ -87,19 +102,19 @@ func TestAddSentry(t *testing.T) {
}, nil)
assert.Nil(t, err)
- logger.Info("yay")
logger.Error(nil, "oops")
- assert.Nil(t, sync())
+ logger.Info("yay")
+ assert.Nil(t, flush())
- assert.Contains(t, buffer.String(), "yay")
assert.Contains(t, buffer.String(), "oops")
+ assert.Contains(t, buffer.String(), "yay")
assert.Equal(t, "oops", sentryMessage)
}
func TestWithSentry(t *testing.T) {
var buffer bytes.Buffer
var sentryMessage string
- logger, sync := New("service-name",
+ logger, flush := New("service-name",
WithConsoleSink(&buffer),
WithSentry(sentry.ClientOptions{
BeforeSend: func(event *sentry.Event, hint *sentry.EventHint) *sentry.Event {
@@ -110,7 +125,7 @@ func TestWithSentry(t *testing.T) {
)
logger.Info("yay")
logger.Error(nil, "oops")
- assert.Nil(t, sync())
+ assert.Nil(t, flush())
assert.Contains(t, buffer.String(), "yay")
assert.Contains(t, buffer.String(), "oops")
@@ -119,11 +134,11 @@ func TestWithSentry(t *testing.T) {
func TestHumanReadableTimestamp(t *testing.T) {
var buffer bytes.Buffer
- logger, sync := New("service-name",
+ logger, flush := New("service-name",
WithConsoleSink(&buffer),
)
logger.Info("yay")
- assert.Nil(t, sync())
+ assert.Nil(t, flush())
ts := strings.Split(buffer.String(), "\t")[0]
assert.NotContains(t, ts, "e+09")
@@ -139,10 +154,10 @@ func TestAddSink(t *testing.T) {
WithConsoleSink(&buf1),
)
logger.Info("line 1")
- logger, sync, err := AddSink(logger, WithConsoleSink(&buf2))
+ logger, flush, err := AddSink(logger, WithConsoleSink(&buf2))
assert.Nil(t, err)
logger.Info("line 2")
- assert.Nil(t, sync())
+ assert.Nil(t, flush())
assert.Contains(t, buf1.String(), "line 1")
assert.Contains(t, buf1.String(), "line 2")
@@ -150,3 +165,384 @@ func TestAddSink(t *testing.T) {
assert.NotContains(t, buf2.String(), "line 1")
assert.Contains(t, buf2.String(), "line 2")
}
+
+func TestStaticLevelSink(t *testing.T) {
+ var buf1, buf2 bytes.Buffer
+ l1 := zap.NewAtomicLevel()
+ logger, flush := New(
+ "service-name",
+ WithConsoleSink(&buf1, WithLeveler(l1)),
+ WithConsoleSink(&buf2, WithLevel(0)),
+ )
+
+ logger.Info("line 1")
+ SetLevelForControl(l1, 1)
+ logger.V(1).Info("line 2")
+ assert.Nil(t, flush())
+
+ // buf1 should have both lines
+ assert.Contains(t, buf1.String(), "line 1")
+ assert.Contains(t, buf1.String(), "line 2")
+
+ // buf2 should only have "line 1"
+ assert.Contains(t, buf2.String(), "line 1")
+ assert.NotContains(t, buf2.String(), "line 2")
+}
+
+func TestWithLeveler(t *testing.T) {
+ var buf1, buf2 bytes.Buffer
+ l1, l2 := zap.NewAtomicLevel(), zap.NewAtomicLevel()
+ logger, flush := New(
+ "service-name",
+ WithConsoleSink(&buf1, WithLeveler(l1)),
+ WithConsoleSink(&buf2, WithLeveler(l2)),
+ )
+
+ SetLevelForControl(l1, 1)
+ SetLevelForControl(l2, 2)
+
+ logger.V(0).Info("line 1")
+ logger.V(1).Info("line 2")
+ logger.V(2).Info("line 3")
+ assert.Nil(t, flush())
+
+ // buf1 should have lines 1 and 2
+ assert.Contains(t, buf1.String(), "line 1")
+ assert.Contains(t, buf1.String(), "line 2")
+ assert.NotContains(t, buf1.String(), "line 3")
+
+ // buf2 should have all lines
+ assert.Contains(t, buf2.String(), "line 1")
+ assert.Contains(t, buf2.String(), "line 2")
+ assert.Contains(t, buf2.String(), "line 3")
+}
+
+func TestWithNamedLevelMoreVerbose(t *testing.T) {
+ var buf bytes.Buffer
+ globalControls = make(map[string]levelSetter, 16)
+
+ l1 := zap.NewAtomicLevel()
+ logger, flush := New(
+ "service-name",
+ WithConsoleSink(&buf, WithLeveler(l1)),
+ )
+
+ childLogger := WithNamedLevel(logger, "child")
+
+ SetLevelForControl(l1, 1)
+ SetLevelFor("child", 2)
+
+ logger.V(0).Info("line 1")
+ logger.V(1).Info("line 2")
+ logger.V(2).Info("line 3")
+ childLogger.V(0).Info("line A")
+ childLogger.V(1).Info("line B")
+ childLogger.V(2).Info("line C")
+ assert.Nil(t, flush())
+
+ // output should contain up to verbosity 1
+ assert.Equal(t, []string{
+ "info-0\tservice-name\tline 1",
+ "info-1\tservice-name\tline 2",
+ "info-0\tservice-name.child\tline A",
+ "info-1\tservice-name.child\tline B",
+ }, splitLines(buf.String()))
+}
+
+func TestWithNamedLevelLessVerbose(t *testing.T) {
+ var buf bytes.Buffer
+ globalControls = make(map[string]levelSetter, 16)
+
+ l1 := zap.NewAtomicLevel()
+ logger, flush := New(
+ "service-name",
+ WithConsoleSink(&buf, WithLeveler(l1)),
+ )
+
+ childLogger := WithNamedLevel(logger, "child")
+
+ SetLevelForControl(l1, 1)
+ SetLevelFor("child", 0)
+
+ logger.V(0).Info("line 1")
+ logger.V(1).Info("line 2")
+ logger.V(2).Info("line 3")
+ childLogger.V(0).Info("line A")
+ childLogger.V(1).Info("line B")
+ childLogger.V(2).Info("line C")
+ assert.Nil(t, flush())
+
+ // output should contain up to verbosity 1 for parent
+ // and verbosity 0 for child
+ assert.Equal(t, []string{
+ "info-0\tservice-name\tline 1",
+ "info-1\tservice-name\tline 2",
+ "info-0\tservice-name.child\tline A",
+ }, splitLines(buf.String()))
+}
+
+func TestNestedWithNamedLevel(t *testing.T) {
+ var buf bytes.Buffer
+ globalControls = make(map[string]levelSetter, 16)
+
+ grandParent, flush := New("grandParent", WithConsoleSink(&buf, WithLevel(1)))
+ parent := WithNamedLevel(grandParent, "parent")
+ child := WithNamedLevel(parent, "child")
+
+ SetLevelFor("parent", 0)
+ SetLevelFor("child", 2)
+
+ grandParent.V(0).Info("line 1")
+ parent.V(0).Info("line 2")
+ child.V(0).Info("line 3")
+
+ grandParent.V(1).Info("line 4")
+ parent.V(1).Info("line 5")
+ child.V(1).Info("line 6")
+
+ grandParent.V(2).Info("line 7")
+ parent.V(2).Info("line 8")
+ child.V(2).Info("line 9")
+
+ assert.Nil(t, flush())
+
+ lines := splitLines(buf.String())
+ assert.Equal(t, 4, len(lines))
+
+ assert.Equal(t, `info-0 grandParent line 1`, lines[0])
+ assert.Equal(t, `info-0 grandParent.parent line 2`, lines[1])
+ assert.Equal(t, `info-0 grandParent.parent.child line 3`, lines[2])
+ assert.Equal(t, `info-1 grandParent line 4`, lines[3])
+}
+
+func TestSiblingsWithNamedLevel(t *testing.T) {
+ var buf bytes.Buffer
+ globalControls = make(map[string]levelSetter, 16)
+
+ parent, flush := New("parent", WithConsoleSink(&buf, WithLevel(1)))
+ alice := WithNamedLevel(parent, "alice")
+ bob := WithNamedLevel(parent, "bob")
+
+ SetLevelFor("alice", 0)
+ SetLevelFor("bob", 2)
+
+ parent.V(0).Info("line 1")
+ alice.V(0).Info("line 2")
+ bob.V(0).Info("line 3")
+
+ parent.V(1).Info("line 4")
+ alice.V(1).Info("line 5")
+ bob.V(1).Info("line 6")
+
+ parent.V(2).Info("line 7")
+ alice.V(2).Info("line 8")
+ bob.V(2).Info("line 9")
+
+ assert.Nil(t, flush())
+ lines := splitLines(buf.String())
+ assert.Equal(t, 5, len(lines))
+
+ assert.Equal(t, `info-0 parent line 1`, lines[0])
+ assert.Equal(t, `info-0 parent.alice line 2`, lines[1])
+ assert.Equal(t, `info-0 parent.bob line 3`, lines[2])
+ assert.Equal(t, `info-1 parent line 4`, lines[3])
+ assert.Equal(t, `info-1 parent.bob line 6`, lines[4])
+}
+
+func TestWithNamedLevelConcurrency(t *testing.T) {
+ var buf bytes.Buffer
+ globalControls = make(map[string]levelSetter, 16)
+
+ parent, flush := New("parent", WithConsoleSink(&buf))
+
+ alice := WithNamedLevel(parent, "alice")
+ bob := WithNamedLevel(parent, "bob")
+
+ var wg sync.WaitGroup
+ f := func(logger logr.Logger) {
+ defer wg.Done()
+ for i := 0; i < 100_000; i++ {
+ logger.Info(fmt.Sprintf("%06d", i))
+ }
+ }
+ wg.Add(3)
+ go f(parent)
+ go f(alice)
+ go f(bob)
+ wg.Wait()
+
+ assert.Nil(t, flush())
+ logLines := splitLines(buf.String())
+ assert.Equal(t, 300_000, len(logLines))
+ sort.Slice(logLines, func(i, j int) bool {
+ return logLines[i] < logLines[j]
+ })
+
+ for i := 0; i < 100_000; i++ {
+ assert.Equal(t, fmt.Sprintf("info-0\tparent\t%06d", i), logLines[i])
+ assert.Equal(t, fmt.Sprintf("info-0\tparent.alice\t%06d", i), logLines[i+100_000])
+ assert.Equal(t, fmt.Sprintf("info-0\tparent.bob\t%06d", i), logLines[i+200_000])
+ }
+}
+
+func TestWithNamedLevelInheritance(t *testing.T) {
+ t.Run("child inherits parent level", func(t *testing.T) {
+ var buf bytes.Buffer
+ globalControls = make(map[string]levelSetter, 16)
+
+ parent, flush := New("parent", WithConsoleSink(&buf, WithLevel(2)))
+ parent = parent.WithValues("key", "value")
+ // child will inherit parent's log level 2
+ child := WithNamedLevel(parent, "child")
+
+ parent.V(2).Info("yay")
+ child.V(2).Info("yay again")
+ assert.Nil(t, flush())
+
+ logLines := splitLines(buf.String())
+ assert.Equal(t, []string{
+ `info-2 parent yay {"key": "value"}`,
+ `info-2 parent.child yay again {"key": "value"}`,
+ }, logLines)
+ })
+
+ t.Run("child inherits existing named level", func(t *testing.T) {
+ var buf bytes.Buffer
+ globalControls = make(map[string]levelSetter, 16)
+
+ parent, flush := New("parent", WithConsoleSink(&buf, WithLevel(2)))
+ parent = parent.WithValues("key", "value")
+ SetLevelFor("child", 0)
+ // child will inherit existing named level 0
+ child := WithNamedLevel(parent, "child")
+
+ parent.V(2).Info("yay")
+ child.V(2).Info("yay again")
+ assert.Nil(t, flush())
+
+ logLines := splitLines(buf.String())
+ assert.Equal(t, []string{`info-2 parent yay {"key": "value"}`}, logLines)
+ })
+}
+
+func TestExistingChildLevel(t *testing.T) {
+ var buf bytes.Buffer
+ globalControls = make(map[string]levelSetter, 16)
+
+ parent, flush := New("parent", WithConsoleSink(&buf, WithLevel(2)))
+
+ SetLevelFor("child", 2)
+ // child should start with a level of 2 due to SetLevelFor above
+ child := WithNamedLevel(parent, "child")
+
+ parent.V(2).Info("yay")
+ child.V(2).Info("yay again")
+ assert.Nil(t, flush())
+
+ assert.Contains(t, buf.String(), "info-2\tparent\tyay")
+ assert.Contains(t, buf.String(), "info-2\tparent.child\tyay again")
+}
+
+func TestSinkWithNamedLevel(t *testing.T) {
+ var buf1, buf2 bytes.Buffer
+ globalControls = make(map[string]levelSetter, 16)
+
+ parent, flush := New(
+ "parent",
+ WithConsoleSink(&buf1, WithLevel(0)),
+ WithConsoleSink(&buf2, WithLevel(2)),
+ )
+ child := WithNamedLevel(parent, "child")
+
+ for level := 0; level < 3; level++ {
+ SetLevelFor("child", int8(level))
+ child.Info("")
+ child.V(1).Info("")
+ child.V(2).Info("")
+ }
+ assert.Nil(t, flush())
+
+ // buf1 should get only level 0 logs
+ assert.Equal(t, []string{
+ "info-0\tparent.child",
+ "info-0\tparent.child",
+ "info-0\tparent.child",
+ }, splitLines(buf1.String()))
+
+ assert.Equal(t, []string{
+ // child level 0
+ "info-0\tparent.child",
+ // child level 1
+ "info-0\tparent.child",
+ "info-1\tparent.child",
+ // child level 2
+ "info-0\tparent.child",
+ "info-1\tparent.child",
+ "info-2\tparent.child",
+ }, splitLines(buf2.String()))
+}
+
+func TestAddLeveler(t *testing.T) {
+ l1, l2 := zap.NewAtomicLevel(), zap.NewAtomicLevel()
+ logger, _ := New("parent", WithConsoleSink(io.Discard, WithLeveler(l1)))
+
+ t.Run("child level more verbose", func(t *testing.T) {
+ l1.SetLevel(0)
+ l2.SetLevel(1)
+ _, err := AddLeveler(logger, l2)
+ assert.Nil(t, err)
+ })
+
+ t.Run("child level less verbose", func(t *testing.T) {
+ l1.SetLevel(1)
+ l2.SetLevel(0)
+ _, err := AddLeveler(logger, l2)
+ assert.Nil(t, err)
+ })
+}
+
+func splitLines(s string) []string {
+ lines := strings.Split(strings.TrimSpace(s), "\n")
+ logLines := make([]string, len(lines))
+ for i, logLine := range lines {
+ // remove timestamp
+ logLines[i] = strings.TrimSpace(logLine[strings.Index(logLine, "\t")+1:])
+ }
+ return logLines
+}
+
+func TestFindLevel(t *testing.T) {
+ lvl := zap.NewAtomicLevel()
+ logger, _ := New("parent", WithConsoleSink(io.Discard, WithLeveler(lvl)))
+
+ for i := 0; i < 128; i++ {
+ i8 := int8(i)
+ SetLevelForControl(lvl, i8)
+ assert.Equal(t, i8, findLevel(logger))
+ }
+}
+
+func TestOverwriteWithNamedLevel(t *testing.T) {
+ var buf bytes.Buffer
+ globalControls = make(map[string]levelSetter, 16)
+
+ parent, flush := New(
+ "parent",
+ WithConsoleSink(&buf, WithLevel(2)),
+ )
+ SetLevelFor("child", 0)
+ child1 := WithNamedLevel(parent, "child")
+ child2 := WithNamedLevel(parent, "child")
+ SetLevelFor("child", 2)
+
+ child1.V(2).Info("")
+ child2.V(2).Info("")
+
+ assert.Nil(t, flush())
+
+ // buf1 should get only level 0 logs
+ assert.Equal(t, []string{
+ "info-2\tparent.child",
+ "info-2\tparent.child",
+ }, splitLines(buf.String()))
+}