Implement BlockSelectors for level debug

This commit implements a block list of selectors for debug logging on
`logp`.

Author: belimawr

logp/config.go

@@ -24,9 +24,10 @@ import (
 // Config contains the configuration options for the logger. To create a Config
 // from a common.Config use logp/config.Build.
 type Config struct {
-	Beat      string   `config:",ignore"`   // Name of the Beat (for default file name).
-	Level     Level    `config:"level"`     // Logging level (error, warning, info, debug).
-	Selectors []string `config:"selectors"` // Selectors for debug level logging.
+	Beat      string   `config:",ignore"`    // Name of the Beat (for default file name).
+	Level     Level    `config:"level"`      // Logging level (error, warning, info, debug).
+	Selectors []string `config:"selectors"`  // Selectors for debug level logging.
+	BlockList []string `config:"block_list"` // Block list of selectors for debug logging.
 
 	toObserver  bool
 	toIODiscard bool

logp/core.go

@@ -57,6 +57,7 @@ func init() {
 
 type coreLogger struct {
 	selectors    map[string]struct{}    // Set of enabled debug selectors.
+	blockList    map[string]struct{}    // Set of blocked debug selectors.
 	rootLogger   *zap.Logger            // Root logger without any options configured.
 	globalLogger *zap.Logger            // Logger used by legacy global functions (e.g. logp.Info).
 	logger       *Logger                // Logger that is the basis for all logp.Loggers.
@@ -97,7 +98,12 @@ func ConfigureWithOutputs(cfg Config, outputs ...zapcore.Core) error {
 
 	// Enabled selectors when debug is enabled.
 	selectors := make(map[string]struct{}, len(cfg.Selectors))
-	if cfg.Level.Enabled(DebugLevel) && len(cfg.Selectors) > 0 {
+	blockList := make(map[string]struct{}, len(cfg.BlockList))
+	if cfg.Level.Enabled(DebugLevel) && (len(cfg.Selectors) > 0 || len(cfg.BlockList) > 0) {
+		for _, sel := range cfg.BlockList {
+			blockList[strings.TrimSpace(sel)] = struct{}{}
+		}
+
 		for _, sel := range cfg.Selectors {
 			selectors[strings.TrimSpace(sel)] = struct{}{}
 		}
@@ -115,13 +121,14 @@ func ConfigureWithOutputs(cfg Config, outputs ...zapcore.Core) error {
 			golog.SetOutput(_defaultGoLog)
 		}
 
-		sink = selectiveWrapper(sink, selectors)
+		sink = selectiveWrapper(sink, selectors, blockList)
 	}
 
 	sink = newMultiCore(append(outputs, sink)...)
 	root := zap.New(sink, makeOptions(cfg)...)
 	storeLogger(&coreLogger{
 		selectors:    selectors,
+		blockList:    blockList,
 		rootLogger:   root,
 		globalLogger: root.WithOptions(zap.AddCallerSkip(1)),
 		logger:       newLogger(root, ""),

logp/options.go

@@ -35,6 +35,14 @@ func WithSelectors(selectors ...string) Option {
 	}
 }
 
+// WithBlockList specifies what debug selectors are disabled. If no selectors
+// are specified, then nothing is blocked
+func WithBlockList(blockList ...string) Option {
+	return func(cfg *Config) {
+		cfg.BlockList = append(cfg.BlockList, blockList...)
+	}
+}
+
 // ToObserverOutput specifies that the output should be collected in memory so
 // that they can be read by an observer by calling ObserverLogs().
 func ToObserverOutput() Option {

logp/selective.go

@@ -24,6 +24,7 @@ import (
 type selectiveCore struct {
 	allSelectors bool
 	selectors    map[string]struct{}
+	blockList    map[string]struct{}
 	core         zapcore.Core
 }
 
@@ -33,12 +34,24 @@ func HasSelector(selector string) bool {
 	return found
 }
 
-func selectiveWrapper(core zapcore.Core, selectors map[string]struct{}) zapcore.Core {
+// IsBlocked returns true if the given selector was explicitly set.
+func IsBlocked(selector string) bool {
+	l := loadLogger()
+	_, found := l.blockList[selector]
+	return found
+}
+
+func selectiveWrapper(core zapcore.Core, selectors, blockList map[string]struct{}) zapcore.Core {
 	if len(selectors) == 0 {
 		return core
 	}
 	_, allSelectors := selectors["*"]
-	return &selectiveCore{selectors: selectors, core: core, allSelectors: allSelectors}
+	return &selectiveCore{
+		selectors:    selectors,
+		core:         core,
+		allSelectors: allSelectors,
+		blockList:    blockList,
+	}
 }
 
 // Enabled returns whether a given logging level is enabled when logging a
@@ -49,7 +62,7 @@ func (c *selectiveCore) Enabled(level zapcore.Level) bool {
 
 // With adds structured context to the Core.
 func (c *selectiveCore) With(fields []zapcore.Field) zapcore.Core {
-	return selectiveWrapper(c.core.With(fields), c.selectors)
+	return selectiveWrapper(c.core.With(fields), c.selectors, c.blockList)
 }
 
 // Check determines whether the supplied Entry should be logged (using the
@@ -61,6 +74,9 @@ func (c *selectiveCore) With(fields []zapcore.Field) zapcore.Core {
 func (c *selectiveCore) Check(ent zapcore.Entry, ce *zapcore.CheckedEntry) *zapcore.CheckedEntry {
 	if c.Enabled(ent.Level) {
 		if ent.Level == zapcore.DebugLevel {
+			if _, blocked := c.blockList[ent.LoggerName]; blocked {
+				return ce
+			}
 			if c.allSelectors {
 				return ce.AddCore(ent, c)
 			} else if _, enabled := c.selectors[ent.LoggerName]; enabled {

logp/selective_test.go

@@ -54,3 +54,33 @@ func TestLoggerSelectors(t *testing.T) {
 	logs = ObserverLogs().TakeAll()
 	assert.Len(t, logs, 1)
 }
+
+func TestLoggerBlockList(t *testing.T) {
+	if err := DevelopmentSetup(WithBlockList("tooVerbose", " sensitiveInformation "), ToObserverOutput()); err != nil {
+		t.Fatal(err)
+	}
+
+	require.True(t, IsBlocked("tooVerbose"))
+	require.True(t, IsBlocked("sensitiveInformation"))
+
+	doesNotLog := NewLogger("tooVerbose")
+	doesNotLog2 := NewLogger("sensitiveInformation")
+	willLog := NewLogger("notVerbose")
+
+	doesNotLog.Debug("is not logged")
+	logs := ObserverLogs().TakeAll()
+	assert.Len(t, logs, 0)
+
+	doesNotLog2.Debug("is not logged")
+	logs = ObserverLogs().TakeAll()
+	assert.Len(t, logs, 0)
+
+	// Selectors only apply to debug level logs.
+	willLog.Debug("is logged")
+	logs = ObserverLogs().TakeAll()
+	assert.Len(t, logs, 1)
+
+	willLog.Info("is also logged")
+	logs = ObserverLogs().TakeAll()
+	assert.Len(t, logs, 1)
+}