hook.go

package logging

import (
	"time"

	"go.uber.org/zap"
	"go.uber.org/zap/zapcore"
)

// HookEntry describes a record passed to a hook. It holds no fields of the record.
type HookEntry struct {
	// Time is the record time.
	Time time.Time
	// Level is the record level.
	Level Level
	// Logger is the name of the named logger, empty for others.
	Logger string
	// Message is the record text.
	Message string
	// Caller is the record caller as file:line, empty when callers are not collected.
	Caller string
}

// HookFunc is called for every written record of the level it is registered for.
// It runs synchronously in the goroutine writing the record, so it must not block: update a counter,
// send to a channel without waiting. A panic of the function is recovered and ignored.
type HookFunc func(entry HookEntry)

type hook struct {
	min Level
	fn  HookFunc
}

// WithHook registers fn to be called for every written record having level min or above,
// f.e. to count errors for metrics. Records dropped by a logger level are not passed.
// Hooks are called in order of registration, also for Fatal records before the process exit.
// Hooks are not loaded from YAML. Nil fn is ignored.
func WithHook(minLevel Level, fn HookFunc) Option {
	return func(config *Config) {
		if fn != nil {
			config.hooks = append(config.hooks, hook{min: minLevel, fn: fn})
		}
	}
}

// makeHookOption makes zap option calling the hooks, nil if there is none.
func makeHookOption(hooks []hook) zap.Option {
	if len(hooks) == 0 {
		return nil
	}

	return zap.Hooks(func(entry zapcore.Entry) error {
		level := fromZapLevel(entry.Level)

		var info *HookEntry

		for _, h := range hooks {
			if level < h.min {
				continue
			}

			if info == nil {
				info = &HookEntry{Time: entry.Time, Level: level, Logger: entry.LoggerName, Message: entry.Message}
				if entry.Caller.Defined {
					info.Caller = entry.Caller.TrimmedPath()
				}
			}

			callHook(h.fn, *info)
		}

		return nil
	})
}

func callHook(fn HookFunc, entry HookEntry) {
	defer func() { _ = recover() }()

	fn(entry)
}