CODEWITHSUNDEEP
gologginggo-zap
Efim Efim
Efim Efim

Reputation: 65

How to configure a custom zap logger that writes to output only at error level?

I’m trying to build a customized logger that keeps log messages below Error level in a buffer and flushes the buffer only after encountering an Error.

The problem is that I don’t know how to trigger the flushing of the logs to the output (Sync method) when encountering an Error.

The below code is an attempt to do so:

func CustomLogger() {
   // First, define our level-handling logic.
   lowPriority := zap.LevelEnablerFunc(func(lvl zapcore.Level) bool {
      return lvl < activationLevel
   })
   //define the output of the logs
   customWriteSyncer := Buffer(os.Stdout)

   consoleEncoder := zapcore.NewConsoleEncoder(zap.NewDevelopmentEncoderConfig())
   zapcore.NewJSONEncoder(zap.NewProductionEncoderConfig())

   //creates a Core that writes logs to a WriteSyncer
   core := zapcore.NewCore(consoleEncoder, customWriteSyncer, lowPriority)

   logger := zap.New(core)

   defer logger.Sync()
  
   Logger = logger
}

type BufferWriterSync struct {
   buf *bufio.Writer
}

func Buffer(ws zapcore.WriteSyncer) zapcore.WriteSyncer {
   bw := &BufferWriterSync{
      buf: bufio.NewWriter(ws),
   }
   ws = zapcore.Lock(bw)
   return ws
}
// Sync syncs data to output
func (w BufferWriterSync) Sync() error {
   return w.buf.Flush()
}
// Write writes data to buffer
func (w BufferWriterSync) Write(p []byte) (int, error) {
   return w.buf.Write(p)
}

Example, when performing:

Expected output:

some Info message
some Info message2
some Error message

NOTE: The functionality that I am trying to achieve is similar to fingers_crossed feature that is present in Php Symfony framework.

Upvotes: 5

Views: 6658

Answers (1)

blackgreen
blackgreen

Reputation: 45220

I don't think this is a good idea, in general. If your application never has errors, your buffer in theory could grow unbounded. This is the reason why Zap's own BufferedWriteSyncer has a size-based or timer-based flush: you must deterministically clear the buffer. However:

Print logs only at error level

To print logs only at a certain level, you can easily create a custom core with zap.NewAtomicLevelAt():

core := zapcore.NewCore(
        zapcore.NewJSONEncoder(zap.NewProductionEncoderConfig()),
        os.Stdout,
        zap.LevelEnablerFunc(func(level zapcore.Level) bool {
            return level == zapcore.ErrorLevel
        }),
    )
logger := zap.New(core)

logger.Info("bar")  // not logged
logger.Error("baz") // logged

Of course that will work similarly for other log levels.

Buffer and flush only at error level

As I said above, you should favor deterministic flush logic. Anyway if you can prove that your buffer will eventually clear, for completeness' sake, the following is a working solution. It's a bit awkward, because AFAIK there's no (sane) way to access the log entry details, as the log level, from the zapcore.WriteSyncer.

You have to create a custom core and implement buffering. The idea is to embed a zapcore.Encoder in your custom struct and implement Encoder.EncodeEntry with the buffering logic. The following is a demonstrative program (it is not meant to be thread-safe, memory-efficient, etc...):

// struct to "remember" buffered entries
type log struct {
    entry zapcore.Entry
    fields []zapcore.Field
}

// custom encoder
type bufferEncoder struct {
    // embeds a zapcore encoder
    zapcore.Encoder

    // the entry buffer itself
    buffer []*log

    // the buffer pool, to return encoded entries
    pool buffer.Pool
}

func (b *bufferEncoder) EncodeEntry(entry zapcore.Entry, fields []zapcore.Field) (*buffer.Buffer, error) {
    // buffer entries
    b.buffer = append(b.buffer, &log{entry, fields})

    // return an empty buffer if the level is not error
    if entry.Level != zap.ErrorLevel {
        return b.pool.Get(), nil
    }
    
    // new buffer
    buf := b.pool.Get()
    for _, log := range b.buffer {
        // encode buffered entries and append them to buf
        encoded, err := b.Encoder.EncodeEntry(log.entry, log.fields)
        if err != nil {
            return nil, err
        }
        buf.AppendString(encoded.String())
    }
    // reset the buffer before returning
    b.buffer = nil
    return buf, nil
}


func main() {
    enc := &bufferEncoder{
        Encoder: zapcore.NewJSONEncoder(zap.NewProductionEncoderConfig()),
        pool: buffer.NewPool(),
    }

    core := zapcore.NewCore(enc, os.Stdout, zap.NewAtomicLevelAt(zap.InfoLevel))
    logger := zap.New(core)

    logger.Info("info")
    fmt.Println("buffered info")
    time.Sleep(500 * time.Millisecond)

    logger.Warn("warn")
    fmt.Println("buffered warn")
    time.Sleep(500 * time.Millisecond)

    logger.Error("error")
    fmt.Println("flushed")
}

Upvotes: 3

Related Questions