Move code to pkg

pkg/log/deprecated.go

@@ -0,0 +1,139 @@
+package log
+
+import (
+	"bufio"
+	"io"
+	"runtime"
+
+	"github.com/sirupsen/logrus"
+)
+
+// Debug logs a message at level Debug on the standard logger.
+// Deprecated
+func Debug(args ...interface{}) {
+	mainLogger.Debug(args...)
+}
+
+// Debugf logs a message at level Debug on the standard logger.
+// Deprecated
+func Debugf(format string, args ...interface{}) {
+	mainLogger.Debugf(format, args...)
+}
+
+// Info logs a message at level Info on the standard logger.
+// Deprecated
+func Info(args ...interface{}) {
+	mainLogger.Info(args...)
+}
+
+// Infof logs a message at level Info on the standard logger.
+// Deprecated
+func Infof(format string, args ...interface{}) {
+	mainLogger.Infof(format, args...)
+}
+
+// Warn logs a message at level Warn on the standard logger.
+// Deprecated
+func Warn(args ...interface{}) {
+	mainLogger.Warn(args...)
+}
+
+// Warnf logs a message at level Warn on the standard logger.
+// Deprecated
+func Warnf(format string, args ...interface{}) {
+	mainLogger.Warnf(format, args...)
+}
+
+// Error logs a message at level Error on the standard logger.
+// Deprecated
+func Error(args ...interface{}) {
+	mainLogger.Error(args...)
+}
+
+// Errorf logs a message at level Error on the standard logger.
+// Deprecated
+func Errorf(format string, args ...interface{}) {
+	mainLogger.Errorf(format, args...)
+}
+
+// Panic logs a message at level Panic on the standard logger.
+// Deprecated
+func Panic(args ...interface{}) {
+	mainLogger.Panic(args...)
+}
+
+// Panicf logs a message at level Panic on the standard logger.
+// Deprecated
+func Panicf(format string, args ...interface{}) {
+	mainLogger.Panicf(format, args...)
+}
+
+// Fatal logs a message at level Fatal on the standard logger.
+// Deprecated
+func Fatal(args ...interface{}) {
+	mainLogger.Fatal(args...)
+}
+
+// Fatalf logs a message at level Fatal on the standard logger.
+// Deprecated
+func Fatalf(format string, args ...interface{}) {
+	mainLogger.Fatalf(format, args...)
+}
+
+// AddHook adds a hook to the standard logger hooks.
+func AddHook(hook logrus.Hook) {
+	logrus.AddHook(hook)
+}
+
+// CustomWriterLevel logs writer for a specific level. (with a custom scanner buffer size.)
+// adapted from github.com/Sirupsen/logrus/writer.go
+func CustomWriterLevel(level logrus.Level, maxScanTokenSize int) *io.PipeWriter {
+	reader, writer := io.Pipe()
+
+	var printFunc func(args ...interface{})
+
+	switch level {
+	case logrus.DebugLevel:
+		printFunc = Debug
+	case logrus.InfoLevel:
+		printFunc = Info
+	case logrus.WarnLevel:
+		printFunc = Warn
+	case logrus.ErrorLevel:
+		printFunc = Error
+	case logrus.FatalLevel:
+		printFunc = Fatal
+	case logrus.PanicLevel:
+		printFunc = Panic
+	default:
+		printFunc = mainLogger.Print
+	}
+
+	go writerScanner(reader, maxScanTokenSize, printFunc)
+	runtime.SetFinalizer(writer, writerFinalizer)
+
+	return writer
+}
+
+// extract from github.com/Sirupsen/logrus/writer.go
+// Hack the buffer size
+func writerScanner(reader io.ReadCloser, scanTokenSize int, printFunc func(args ...interface{})) {
+	scanner := bufio.NewScanner(reader)
+
+	if scanTokenSize > bufio.MaxScanTokenSize {
+		buf := make([]byte, bufio.MaxScanTokenSize)
+		scanner.Buffer(buf, scanTokenSize)
+	}
+
+	for scanner.Scan() {
+		printFunc(scanner.Text())
+	}
+	if err := scanner.Err(); err != nil {
+		Errorf("Error while reading from Writer: %s", err)
+	}
+	reader.Close()
+}
+
+func writerFinalizer(writer *io.PipeWriter) {
+	writer.Close()
+}

pkg/log/fields.go

@@ -0,0 +1,15 @@
+package log
+
+// Log entry name
+const (
+	EntryPointName      = "entryPointName"
+	RouterName          = "routerName"
+	Rule                = "rule"
+	MiddlewareName      = "middlewareName"
+	MiddlewareType      = "middlewareType"
+	ProviderName        = "providerName"
+	ServiceName         = "serviceName"
+	MetricsProviderName = "metricsProviderName"
+	TracingProviderName = "tracingProviderName"
+	ServerName          = "serverName"
+)

pkg/log/log.go

@@ -0,0 +1,145 @@
+package log
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"os"
+
+	"github.com/sirupsen/logrus"
+)
+
+type contextKey int
+
+const (
+	loggerKey contextKey = iota
+)
+
+// Logger the Traefik logger
+type Logger interface {
+	logrus.FieldLogger
+	WriterLevel(logrus.Level) *io.PipeWriter
+}
+
+var (
+	mainLogger  Logger
+	logFilePath string
+	logFile     *os.File
+)
+
+func init() {
+	mainLogger = logrus.StandardLogger()
+	logrus.SetOutput(os.Stdout)
+}
+
+// SetLogger sets the logger.
+func SetLogger(l Logger) {
+	mainLogger = l
+}
+
+// SetOutput sets the standard logger output.
+func SetOutput(out io.Writer) {
+	logrus.SetOutput(out)
+}
+
+// SetFormatter sets the standard logger formatter.
+func SetFormatter(formatter logrus.Formatter) {
+	logrus.SetFormatter(formatter)
+}
+
+// SetLevel sets the standard logger level.
+func SetLevel(level logrus.Level) {
+	logrus.SetLevel(level)
+}
+
+// GetLevel returns the standard logger level.
+func GetLevel() logrus.Level {
+	return logrus.GetLevel()
+}
+
+// Str adds a string field
+func Str(key, value string) func(logrus.Fields) {
+	return func(fields logrus.Fields) {
+		fields[key] = value
+	}
+}
+
+// With Adds fields
+func With(ctx context.Context, opts ...func(logrus.Fields)) context.Context {
+	logger := FromContext(ctx)
+
+	fields := make(logrus.Fields)
+	for _, opt := range opts {
+		opt(fields)
+	}
+	logger = logger.WithFields(fields)
+
+	return context.WithValue(ctx, loggerKey, logger)
+}
+
+// FromContext Gets the logger from context
+func FromContext(ctx context.Context) Logger {
+	if ctx == nil {
+		panic("nil context")
+	}
+
+	logger, ok := ctx.Value(loggerKey).(Logger)
+	if !ok {
+		logger = mainLogger
+	}
+
+	return logger
+}
+
+// WithoutContext Gets the main logger
+func WithoutContext() Logger {
+	return mainLogger
+}
+
+// OpenFile opens the log file using the specified path
+func OpenFile(path string) error {
+	logFilePath = path
+
+	var err error
+	logFile, err = os.OpenFile(logFilePath, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0666)
+	if err != nil {
+		return err
+	}
+
+	SetOutput(logFile)
+	return nil
+}
+
+// CloseFile closes the log and sets the Output to stdout
+func CloseFile() error {
+	logrus.SetOutput(os.Stdout)
+
+	if logFile != nil {
+		return logFile.Close()
+	}
+	return nil
+}
+
+// RotateFile closes and reopens the log file to allow for rotation
+// by an external source.  If the log isn't backed by a file then
+// it does nothing.
+func RotateFile() error {
+	logger := FromContext(context.Background())
+
+	if logFile == nil && logFilePath == "" {
+		logger.Debug("Traefik log is not writing to a file, ignoring rotate request")
+		return nil
+	}
+
+	if logFile != nil {
+		defer func(f *os.File) {
+			_ = f.Close()
+		}(logFile)
+	}
+
+	if err := OpenFile(logFilePath); err != nil {
+		return fmt.Errorf("error opening log file: %s", err)
+	}
+
+	return nil
+}

pkg/log/log_test.go

@@ -0,0 +1,58 @@
+package log
+
+import (
+	"bytes"
+	"context"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestLog(t *testing.T) {
+	testCases := []struct {
+		desc     string
+		fields   map[string]string
+		expected string
+	}{
+		{
+			desc: "Log with one field",
+			fields: map[string]string{
+				"foo": "bar",
+			},
+			expected: ` level=error msg="message test" foo=bar$`,
+		},
+		{
+			desc: "Log with two fields",
+			fields: map[string]string{
+				"foo": "bar",
+				"oof": "rab",
+			},
+			expected: ` level=error msg="message test" foo=bar oof=rab$`,
+		},
+		{
+			desc:     "Log without field",
+			fields:   map[string]string{},
+			expected: ` level=error msg="message test"$`,
+		},
+	}
+
+	for _, test := range testCases {
+		test := test
+		t.Run(test.desc, func(t *testing.T) {
+
+			var buffer bytes.Buffer
+			SetOutput(&buffer)
+
+			ctx := context.Background()
+
+			for key, value := range test.fields {
+				ctx = With(ctx, Str(key, value))
+			}
+
+			FromContext(ctx).Error("message test")
+
+			assert.Regexp(t, test.expected, strings.TrimSpace(buffer.String()))
+		})
+	}
+}