status-go/logutils/zap_adapter.go

package logutils

import (
	"fmt"
	"math"
	"sync"
	"time"

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

	"github.com/ethereum/go-ethereum/log"

	"github.com/status-im/status-go/protocol/zaputil"
)

type gethLoggerCore struct {
	zapcore.LevelEnabler
	fields []zapcore.Field
	logger log.Logger
}

func (c gethLoggerCore) With(fields []zapcore.Field) zapcore.Core {
	clone := c.clone()
	clone.fields = append(clone.fields, fields...)
	return clone
}

func (c gethLoggerCore) Check(ent zapcore.Entry, ce *zapcore.CheckedEntry) *zapcore.CheckedEntry {
	if c.Enabled(ent.Level) {
		return ce.AddCore(ent, c)
	}
	return ce
}
func (c gethLoggerCore) Write(ent zapcore.Entry, fields []zapcore.Field) error { // nolint: gocyclo
	fields = append(c.fields[:], fields...)

	var args []interface{}
	for _, f := range fields {
		switch f.Type {
		case zapcore.ArrayMarshalerType,
			zapcore.ObjectMarshalerType,
			zapcore.BinaryType,
			zapcore.ByteStringType,
			zapcore.Complex128Type,
			zapcore.ReflectType,
			zapcore.StringerType,
			zapcore.ErrorType:
			args = append(args, f.Key, f.Interface)
		case zapcore.BoolType:
			args = append(args, f.Key, f.Integer == 1)
		case zapcore.DurationType:
			args = append(args, f.Key, time.Duration(f.Integer))
		case zapcore.Float64Type:
			args = append(args, f.Key, math.Float64frombits(uint64(f.Integer)))
		case zapcore.Float32Type:
			args = append(args, f.Key, math.Float32frombits(uint32(f.Integer)))
		case zapcore.Int64Type,
			zapcore.Int32Type,
			zapcore.Int16Type,
			zapcore.Int8Type,
			zapcore.Uint64Type,
			zapcore.Uint32Type,
			zapcore.Uint16Type,
			zapcore.Uint8Type:
			args = append(args, f.Key, f.Integer)
		case zapcore.UintptrType:
			args = append(args, f.Key, uintptr(f.Integer))
		case zapcore.StringType:
			args = append(args, f.Key, f.String)
		case zapcore.TimeType:
			if f.Interface != nil {
				args = append(args, f.Key, time.Unix(0, f.Integer).In(f.Interface.(*time.Location)))
			} else {
				// Fall back to UTC if location is nil.
				args = append(args, f.Key, time.Unix(0, f.Integer))
			}
		case zapcore.NamespaceType:
			args = append(args, "namespace", f.Key)
		case zapcore.SkipType:
			break
		default:
			panic(fmt.Sprintf("unknown field type: %v", f))
		}
	}

	switch ent.Level {
	case zapcore.DebugLevel:
		c.logger.Debug(ent.Message, args...)
	case zapcore.InfoLevel:
		c.logger.Info(ent.Message, args...)
	case zapcore.WarnLevel:
		c.logger.Warn(ent.Message, args...)
	case zapcore.ErrorLevel:
		c.logger.Error(ent.Message, args...)
	case zapcore.DPanicLevel, zapcore.PanicLevel, zapcore.FatalLevel:
		c.logger.Crit(ent.Message, args...)
	}

	return nil
}

func (gethLoggerCore) Sync() error {
	return nil
}

func (c *gethLoggerCore) clone() *gethLoggerCore {
	return &gethLoggerCore{
		LevelEnabler: c.LevelEnabler,
		fields:       c.fields,
		logger:       c.logger,
	}
}

// NewZapAdapter returns a new zapcore.Core interface which forwards logs to log.Logger.
func NewZapAdapter(logger log.Logger, enab zapcore.LevelEnabler) zapcore.Core {
	return &gethLoggerCore{
		LevelEnabler: enab,
		logger:       logger,
	}
}

var registerOnce sync.Once

// NewZapLoggerWithAdapter returns a logger forwarding all logs with level info and above.
func NewZapLoggerWithAdapter(logger log.Logger) (*zap.Logger, error) {
	registerOnce.Do(func() {
		if err := zaputil.RegisterJSONHexEncoder(); err != nil {
			panic(err)
		}
	})

	cfg := zap.Config{
		Level:            zap.NewAtomicLevelAt(zapcore.DebugLevel),
		Development:      false,
		Sampling:         nil,
		Encoding:         "json-hex",
		EncoderConfig:    zap.NewProductionEncoderConfig(),
		OutputPaths:      []string{"stderr"},
		ErrorOutputPaths: []string{"stderr"},
	}
	adapter := zap.WrapCore(
		func(zapcore.Core) zapcore.Core {
			return NewZapAdapter(logger, cfg.Level)
		},
	)
	return cfg.Build(adapter)
}