feat: Waku v2 bridge

Issue #12610

vendor/github.com/status-im/status-go/logutils/logger.go

@@ -0,0 +1,27 @@
+package logutils
+
+import (
+	"sync"
+
+	"go.uber.org/zap"
+
+	"github.com/ethereum/go-ethereum/log"
+)
+
+var (
+	_zapLogger     *zap.Logger
+	_initZapLogger sync.Once
+)
+
+// ZapLogger creates a custom zap.Logger which will forward logs
+// to status-go logger.
+func ZapLogger() *zap.Logger {
+	_initZapLogger.Do(func() {
+		var err error
+		_zapLogger, err = NewZapLoggerWithAdapter(log.Root())
+		if err != nil {
+			panic(err)
+		}
+	})
+	return _zapLogger
+}

vendor/github.com/status-im/status-go/logutils/logrotation.go

@@ -0,0 +1,30 @@
+package logutils
+
+import (
+	"gopkg.in/natefinch/lumberjack.v2"
+
+	"github.com/ethereum/go-ethereum/log"
+)
+
+// FileOptions are all options supported by internal rotation module.
+type FileOptions struct {
+	// Base name for log file.
+	Filename string
+	// Size in megabytes.
+	MaxSize int
+	// Number of rotated log files.
+	MaxBackups int
+	// If true rotated log files will be gzipped.
+	Compress bool
+}
+
+// FileHandlerWithRotation instantiates log.Handler with a configured rotation
+func FileHandlerWithRotation(opts FileOptions, format log.Format) log.Handler {
+	logger := &lumberjack.Logger{
+		Filename:   opts.Filename,
+		MaxSize:    opts.MaxSize,
+		MaxBackups: opts.MaxBackups,
+		Compress:   opts.Compress,
+	}
+	return log.StreamHandler(logger, format)
+}

vendor/github.com/status-im/status-go/logutils/override.go

@@ -0,0 +1,100 @@
+package logutils
+
+import (
+	"os"
+	"strings"
+
+	logging "github.com/ipfs/go-log/v2"
+
+	"github.com/ethereum/go-ethereum/log"
+)
+
+type LogSettings struct {
+	Enabled         bool
+	MobileSystem    bool
+	Level           string
+	File            string
+	MaxSize         int
+	MaxBackups      int
+	CompressRotated bool
+}
+
+// OverrideWithStdLogger overwrites ethereum's root logger with a logger from golang std lib.
+func OverrideWithStdLogger(logLevel string) error {
+	return enableRootLog(logLevel, NewStdHandler(log.TerminalFormat(false)))
+}
+
+// OverrideRootLogWithConfig derives all configuration from params.NodeConfig and configures logger using it.
+func OverrideRootLogWithConfig(settings LogSettings, colors bool) error {
+	if !settings.Enabled {
+		return nil
+	}
+	if settings.MobileSystem {
+		return OverrideWithStdLogger(settings.Level)
+	}
+	return OverrideRootLog(settings.Enabled, settings.Level, FileOptions{
+		Filename:   settings.File,
+		MaxSize:    settings.MaxSize,
+		MaxBackups: settings.MaxBackups,
+		Compress:   settings.CompressRotated,
+	}, colors)
+
+}
+
+// OverrideRootLog overrides root logger with file handler, if defined,
+// and log level (defaults to INFO).
+func OverrideRootLog(enabled bool, levelStr string, fileOpts FileOptions, terminal bool) error {
+	if !enabled {
+		disableRootLog()
+		return nil
+	}
+	if os.Getenv("CI") == "true" {
+		terminal = false
+	}
+	var (
+		handler log.Handler
+	)
+	if fileOpts.Filename != "" {
+		if fileOpts.MaxBackups == 0 {
+			// Setting MaxBackups to 0 causes all log files to be kept. Even setting MaxAge to > 0 doesn't fix it
+			// Docs: https://pkg.go.dev/gopkg.in/natefinch/lumberjack.v2@v2.0.0#readme-cleaning-up-old-log-files
+			fileOpts.MaxBackups = 1
+		}
+		handler = FileHandlerWithRotation(fileOpts, log.TerminalFormat(terminal))
+	} else {
+		handler = log.StreamHandler(os.Stderr, log.TerminalFormat(terminal))
+	}
+
+	return enableRootLog(levelStr, handler)
+}
+
+func disableRootLog() {
+	log.Root().SetHandler(log.DiscardHandler())
+}
+
+func enableRootLog(levelStr string, handler log.Handler) error {
+	if levelStr == "" {
+		levelStr = "INFO"
+	}
+
+	levelStr = strings.ToLower(levelStr)
+
+	level, err := log.LvlFromString(levelStr)
+	if err != nil {
+		return err
+	}
+
+	filteredHandler := log.LvlFilterHandler(level, handler)
+	log.Root().SetHandler(filteredHandler)
+	log.PrintOrigins(true)
+
+	// go-libp2p logger
+	lvl, err := logging.LevelFromString(levelStr)
+	if err != nil {
+		return err
+	}
+
+	logging.SetAllLoggers(lvl)
+
+	return nil
+}

vendor/github.com/status-im/status-go/logutils/stdhandler.go

@@ -0,0 +1,17 @@
+package logutils
+
+import (
+	stdlog "log"
+
+	"github.com/ethereum/go-ethereum/log"
+)
+
+// NewStdHandler returns handler that uses logger from golang std lib.
+func NewStdHandler(fmtr log.Format) log.Handler {
+	return log.FuncHandler(func(r *log.Record) error {
+		line := fmtr.Format(r)
+		// 8 is a number of frames that will be skipped when log is printed.
+		// this is needed to show the file (with line number) where call to a logger was made
+		return stdlog.Output(8, string(line))
+	})
+}

vendor/github.com/status-im/status-go/logutils/zap_adapter.go

@@ -0,0 +1,152 @@
+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 {
+	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))
+		}
+	}
+
+	// set callDepth to 3 for `Output` to skip the calls to zap.Logger
+	// and get the correct caller in the log
+	callDepth := 3
+	switch ent.Level {
+	case zapcore.DebugLevel:
+		c.logger.Output(ent.Message, log.LvlDebug, callDepth, args...)
+	case zapcore.InfoLevel:
+		c.logger.Output(ent.Message, log.LvlInfo, callDepth, args...)
+	case zapcore.WarnLevel:
+		c.logger.Output(ent.Message, log.LvlWarn, callDepth, args...)
+	case zapcore.ErrorLevel:
+		c.logger.Output(ent.Message, log.LvlError, callDepth, args...)
+	case zapcore.DPanicLevel, zapcore.PanicLevel, zapcore.FatalLevel:
+		c.logger.Output(ent.Message, log.LvlCrit, callDepth, 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)
+		},
+	)
+	log.PrintOrigins(true)
+	return cfg.Build(adapter)
+}