New logger for the Traefik logs

pkg/logs/aws.go

@@ -0,0 +1,16 @@
+package logs
+
+import (
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/rs/zerolog"
+)
+
+func NewAWSWrapper(logger zerolog.Logger) aws.LoggerFunc {
+	if logger.GetLevel() > zerolog.DebugLevel {
+		return func(args ...interface{}) {}
+	}
+
+	return func(args ...interface{}) {
+		logger.Debug().CallerSkipFrame(2).MsgFunc(msgFunc(args...))
+	}
+}

pkg/logs/aws_test.go

@@ -0,0 +1,17 @@
+package logs
+
+import (
+	"os"
+	"testing"
+	"time"
+
+	"github.com/rs/zerolog"
+)
+
+func TestNewAWSWrapper(t *testing.T) {
+	out := zerolog.ConsoleWriter{Out: os.Stderr, TimeFormat: time.RFC3339}
+
+	logger := NewAWSWrapper(zerolog.New(out).With().Caller().Logger())
+
+	logger.Log("foo")
+}

pkg/logs/datadog.go

@@ -0,0 +1,15 @@
+package logs
+
+import "github.com/rs/zerolog"
+
+type DatadogLogger struct {
+	logger zerolog.Logger
+}
+
+func NewDatadogLogger(logger zerolog.Logger) *DatadogLogger {
+	return &DatadogLogger{logger: logger}
+}
+
+func (d DatadogLogger) Log(msg string) {
+	d.logger.Debug().CallerSkipFrame(1).Msg(msg)
+}

pkg/logs/datadog_test.go

@@ -0,0 +1,17 @@
+package logs
+
+import (
+	"os"
+	"testing"
+	"time"
+
+	"github.com/rs/zerolog"
+)
+
+func TestNewDatadogLogger(t *testing.T) {
+	out := zerolog.ConsoleWriter{Out: os.Stderr, TimeFormat: time.RFC3339}
+
+	logger := NewDatadogLogger(zerolog.New(out).With().Caller().Logger())
+
+	logger.Log("foo")
+}

pkg/logs/elastic.go

@@ -0,0 +1,19 @@
+package logs
+
+import "github.com/rs/zerolog"
+
+type ElasticLogger struct {
+	logger zerolog.Logger
+}
+
+func NewElasticLogger(logger zerolog.Logger) *ElasticLogger {
+	return &ElasticLogger{logger: logger}
+}
+
+func (l ElasticLogger) Debugf(format string, args ...interface{}) {
+	l.logger.Debug().CallerSkipFrame(1).Msgf(format, args...)
+}
+
+func (l ElasticLogger) Errorf(format string, args ...interface{}) {
+	l.logger.Error().CallerSkipFrame(1).Msgf(format, args...)
+}

pkg/logs/elastic_test.go

@@ -0,0 +1,17 @@
+package logs
+
+import (
+	"os"
+	"testing"
+	"time"
+
+	"github.com/rs/zerolog"
+)
+
+func TestNewElasticLogger(t *testing.T) {
+	out := zerolog.ConsoleWriter{Out: os.Stderr, TimeFormat: time.RFC3339}
+
+	logger := NewElasticLogger(zerolog.New(out).With().Caller().Logger())
+
+	logger.Errorf("foo")
+}

pkg/logs/fields.go

@@ -0,0 +1,18 @@
+package logs
+
+// Log entry names.
+const (
+	EntryPointName       = "entryPointName"
+	RouterName           = "routerName"
+	Rule                 = "rule"
+	MiddlewareName       = "middlewareName"
+	MiddlewareType       = "middlewareType"
+	ProviderName         = "providerName"
+	ServiceName          = "serviceName"
+	MetricsProviderName  = "metricsProviderName"
+	TracingProviderName  = "tracingProviderName"
+	ServerName           = "serverName"
+	ServerIndex          = "serverIndex"
+	TLSStoreName         = "tlsStoreName"
+	ServersTransportName = "serversTransport"
+)

pkg/logs/gokit.go

@@ -0,0 +1,17 @@
+package logs
+
+import (
+	kitlog "github.com/go-kit/kit/log"
+	"github.com/rs/zerolog"
+)
+
+func NewGoKitWrapper(logger zerolog.Logger) kitlog.LoggerFunc {
+	if logger.GetLevel() > zerolog.DebugLevel {
+		return func(args ...interface{}) error { return nil }
+	}
+
+	return func(args ...interface{}) error {
+		logger.Debug().CallerSkipFrame(2).MsgFunc(msgFunc(args...))
+		return nil
+	}
+}

pkg/logs/gokit_test.go

@@ -0,0 +1,17 @@
+package logs
+
+import (
+	"os"
+	"testing"
+	"time"
+
+	"github.com/rs/zerolog"
+)
+
+func TestNewGoKitWrapper(t *testing.T) {
+	out := zerolog.ConsoleWriter{Out: os.Stderr, TimeFormat: time.RFC3339}
+
+	logger := NewGoKitWrapper(zerolog.New(out).With().Caller().Logger())
+
+	_ = logger.Log("foo")
+}

pkg/logs/haystack.go

@@ -0,0 +1,28 @@
+package logs
+
+import (
+	"github.com/rs/zerolog"
+)
+
+type HaystackLogger struct {
+	logger zerolog.Logger
+}
+
+func NewHaystackLogger(logger zerolog.Logger) *HaystackLogger {
+	return &HaystackLogger{logger: logger}
+}
+
+// Error prints the error message.
+func (l HaystackLogger) Error(format string, v ...interface{}) {
+	l.logger.Error().CallerSkipFrame(1).Msgf(format, v...)
+}
+
+// Info prints the info message.
+func (l HaystackLogger) Info(format string, v ...interface{}) {
+	l.logger.Info().CallerSkipFrame(1).Msgf(format, v...)
+}
+
+// Debug prints the info message.
+func (l HaystackLogger) Debug(format string, v ...interface{}) {
+	l.logger.Debug().CallerSkipFrame(1).Msgf(format, v...)
+}

pkg/logs/haystack_test.go

@@ -0,0 +1,17 @@
+package logs
+
+import (
+	"os"
+	"testing"
+	"time"
+
+	"github.com/rs/zerolog"
+)
+
+func TestNewHaystackLogger(t *testing.T) {
+	out := zerolog.ConsoleWriter{Out: os.Stderr, TimeFormat: time.RFC3339}
+
+	logger := NewHaystackLogger(zerolog.New(out).With().Caller().Logger())
+
+	logger.Info("foo")
+}

pkg/logs/instana.go

@@ -0,0 +1,29 @@
+package logs
+
+import (
+	"github.com/rs/zerolog"
+)
+
+type InstanaLogger struct {
+	logger zerolog.Logger
+}
+
+func NewInstanaLogger(logger zerolog.Logger) *InstanaLogger {
+	return &InstanaLogger{logger: logger}
+}
+
+func (l InstanaLogger) Debug(args ...interface{}) {
+	l.logger.Debug().CallerSkipFrame(1).MsgFunc(msgFunc(args...))
+}
+
+func (l InstanaLogger) Info(args ...interface{}) {
+	l.logger.Info().CallerSkipFrame(1).MsgFunc(msgFunc(args...))
+}
+
+func (l InstanaLogger) Warn(args ...interface{}) {
+	l.logger.Warn().CallerSkipFrame(1).MsgFunc(msgFunc(args...))
+}
+
+func (l InstanaLogger) Error(args ...interface{}) {
+	l.logger.Error().CallerSkipFrame(1).MsgFunc(msgFunc(args...))
+}

pkg/logs/instana_test.go

@@ -0,0 +1,17 @@
+package logs
+
+import (
+	"os"
+	"testing"
+	"time"
+
+	"github.com/rs/zerolog"
+)
+
+func TestNewInstanaLogger(t *testing.T) {
+	out := zerolog.ConsoleWriter{Out: os.Stderr, TimeFormat: time.RFC3339}
+
+	logger := NewInstanaLogger(zerolog.New(out).With().Caller().Logger())
+
+	logger.Info("foo")
+}

pkg/logs/jaeger.go

@@ -0,0 +1,23 @@
+package logs
+
+import (
+	"github.com/rs/zerolog"
+)
+
+// JaegerLogger is an implementation of the Logger interface that delegates to traefik log.
+type JaegerLogger struct {
+	logger zerolog.Logger
+}
+
+func NewJaegerLogger(logger zerolog.Logger) *JaegerLogger {
+	return &JaegerLogger{logger: logger}
+}
+
+func (l *JaegerLogger) Error(msg string) {
+	l.logger.Error().CallerSkipFrame(1).Msg(msg)
+}
+
+// Infof logs a message at debug priority.
+func (l *JaegerLogger) Infof(msg string, args ...interface{}) {
+	l.logger.Debug().CallerSkipFrame(1).Msgf(msg, args...)
+}

pkg/logs/jaeger_test.go

@@ -0,0 +1,17 @@
+package logs
+
+import (
+	"os"
+	"testing"
+	"time"
+
+	"github.com/rs/zerolog"
+)
+
+func TestNewJaegerLogger(t *testing.T) {
+	out := zerolog.ConsoleWriter{Out: os.Stderr, TimeFormat: time.RFC3339}
+
+	logger := NewJaegerLogger(zerolog.New(out).With().Caller().Logger())
+
+	logger.Infof("foo")
+}

pkg/logs/log.go

@@ -0,0 +1,35 @@
+package logs
+
+import (
+	"fmt"
+
+	"github.com/rs/zerolog"
+)
+
+func NoLevel(logger zerolog.Logger, level zerolog.Level) zerolog.Logger {
+	return logger.Hook(NewNoLevelHook(logger.GetLevel(), level))
+}
+
+type NoLevelHook struct {
+	minLevel zerolog.Level
+	level    zerolog.Level
+}
+
+func NewNoLevelHook(minLevel zerolog.Level, level zerolog.Level) *NoLevelHook {
+	return &NoLevelHook{minLevel: minLevel, level: level}
+}
+
+func (n NoLevelHook) Run(e *zerolog.Event, level zerolog.Level, _ string) {
+	if n.minLevel > n.level {
+		e.Discard()
+		return
+	}
+
+	if level == zerolog.NoLevel {
+		e.Str("level", n.level.String())
+	}
+}
+
+func msgFunc(i ...any) func() string {
+	return func() string { return fmt.Sprint(i...) }
+}

pkg/logs/log_test.go

@@ -0,0 +1,17 @@
+package logs
+
+import (
+	"os"
+	"testing"
+	"time"
+
+	"github.com/rs/zerolog"
+)
+
+func TestNoLevel(t *testing.T) {
+	out := zerolog.ConsoleWriter{Out: os.Stderr, TimeFormat: time.RFC3339}
+
+	logger := NoLevel(zerolog.New(out).With().Caller().Logger(), zerolog.DebugLevel)
+
+	logger.Info().Msg("foo")
+}

pkg/logs/logrus.go

@@ -0,0 +1,49 @@
+package logs
+
+import (
+	"github.com/rs/zerolog"
+)
+
+type LogrusStdWrapper struct {
+	logger zerolog.Logger
+}
+
+func NewLogrusWrapper(logger zerolog.Logger) *LogrusStdWrapper {
+	return &LogrusStdWrapper{logger: logger}
+}
+
+func (l LogrusStdWrapper) Print(args ...interface{}) {
+	l.logger.Debug().CallerSkipFrame(1).MsgFunc(msgFunc(args...))
+}
+
+func (l LogrusStdWrapper) Printf(s string, args ...interface{}) {
+	l.logger.Debug().CallerSkipFrame(1).Msgf(s, args...)
+}
+
+func (l LogrusStdWrapper) Println(args ...interface{}) {
+	l.logger.Debug().CallerSkipFrame(1).MsgFunc(msgFunc(args...))
+}
+
+func (l LogrusStdWrapper) Fatal(args ...interface{}) {
+	l.logger.Fatal().CallerSkipFrame(1).MsgFunc(msgFunc(args...))
+}
+
+func (l LogrusStdWrapper) Fatalf(s string, args ...interface{}) {
+	l.logger.Fatal().CallerSkipFrame(1).Msgf(s, args...)
+}
+
+func (l LogrusStdWrapper) Fatalln(args ...interface{}) {
+	l.logger.Fatal().CallerSkipFrame(1).MsgFunc(msgFunc(args...))
+}
+
+func (l LogrusStdWrapper) Panic(args ...interface{}) {
+	l.logger.Panic().CallerSkipFrame(1).MsgFunc(msgFunc(args...))
+}
+
+func (l LogrusStdWrapper) Panicf(s string, args ...interface{}) {
+	l.logger.Panic().CallerSkipFrame(1).Msgf(s, args...)
+}
+
+func (l LogrusStdWrapper) Panicln(args ...interface{}) {
+	l.logger.Panic().CallerSkipFrame(1).MsgFunc(msgFunc(args...))
+}

pkg/logs/logrus_test.go

@@ -0,0 +1,17 @@
+package logs
+
+import (
+	"os"
+	"testing"
+	"time"
+
+	"github.com/rs/zerolog"
+)
+
+func TestNewLogrusStdWrapper(t *testing.T) {
+	out := zerolog.ConsoleWriter{Out: os.Stderr, TimeFormat: time.RFC3339}
+
+	logger := NewLogrusWrapper(zerolog.New(out).With().Caller().Logger())
+
+	logger.Println("foo")
+}

pkg/logs/oxy.go

@@ -0,0 +1,27 @@
+package logs
+
+import "github.com/rs/zerolog"
+
+type OxyWrapper struct {
+	logger zerolog.Logger
+}
+
+func NewOxyWrapper(logger zerolog.Logger) *OxyWrapper {
+	return &OxyWrapper{logger: logger}
+}
+
+func (l OxyWrapper) Debug(s string, i ...interface{}) {
+	l.logger.Debug().CallerSkipFrame(1).Msgf(s, i...)
+}
+
+func (l OxyWrapper) Info(s string, i ...interface{}) {
+	l.logger.Info().CallerSkipFrame(1).Msgf(s, i...)
+}
+
+func (l OxyWrapper) Warn(s string, i ...interface{}) {
+	l.logger.Warn().CallerSkipFrame(1).Msgf(s, i...)
+}
+
+func (l OxyWrapper) Error(s string, i ...interface{}) {
+	l.logger.Error().CallerSkipFrame(1).Msgf(s, i...)
+}

pkg/logs/oxy_test.go

@@ -0,0 +1,17 @@
+package logs
+
+import (
+	"os"
+	"testing"
+	"time"
+
+	"github.com/rs/zerolog"
+)
+
+func TestNewOxyWrapper(t *testing.T) {
+	out := zerolog.ConsoleWriter{Out: os.Stderr, TimeFormat: time.RFC3339}
+
+	logger := NewOxyWrapper(zerolog.New(out).With().Caller().Logger())
+
+	logger.Info("foo")
+}