restore v0.3.0

handler/logrus/logger.go

@@ -0,0 +1,90 @@
+package logrus
+
+import (
+	"context"
+
+	"github.com/sirupsen/logrus"
+	"gitoa.ru/go-4devs/log"
+	"gitoa.ru/go-4devs/log/entry"
+	"gitoa.ru/go-4devs/log/level"
+)
+
+// Option configure logger.
+type Option func(*logger)
+
+// WithLevel sets callback level to log level.
+func WithLevel(level level.Level, c func(*logrus.Entry, string)) Option {
+	return func(l *logger) {
+		l.levels[level] = c
+	}
+}
+
+// WithLogrus sets logrus logger.
+func WithLogrus(logrus *logrus.Logger) Option {
+	return func(l *logger) {
+		l.logrus = logrus
+	}
+}
+
+// New create new logrus handler.
+func New(opts ...Option) log.Logger {
+	log := logger{
+		logrus: logrus.StandardLogger(),
+		levels: map[level.Level]func(*logrus.Entry, string){
+			level.Emergency: panicLog,
+			level.Alert:     fatalLog,
+			level.Critical:  errorLog,
+			level.Error:     errorLog,
+			level.Warning:   warnLog,
+			level.Notice:    infoLog,
+			level.Info:      infoLog,
+			level.Debug:     debugLog,
+		},
+	}
+
+	for _, o := range opts {
+		o(&log)
+	}
+
+	return log.log
+}
+
+type logger struct {
+	levels map[level.Level]func(l *logrus.Entry, msg string)
+	logrus *logrus.Logger
+}
+
+func (l *logger) log(ctx context.Context, e *entry.Entry) (int, error) {
+	lrgFields := make(logrus.Fields, e.Fields().Len())
+	for _, field := range e.Fields() {
+		lrgFields[string(field.Key())] = field.AsInterface()
+	}
+
+	l.levels[e.Level()](l.logrus.WithFields(lrgFields), e.Message())
+
+	return 0, nil
+}
+
+func panicLog(e *logrus.Entry, msg string) {
+	e.Panic(msg)
+}
+
+func fatalLog(e *logrus.Entry, msg string) {
+	e.Fatal(msg)
+}
+
+func errorLog(e *logrus.Entry, msg string) {
+	e.Error(msg)
+}
+
+func warnLog(e *logrus.Entry, msg string) {
+	e.Warn(msg)
+}
+
+func infoLog(e *logrus.Entry, msg string) {
+	e.Info(msg)
+}
+
+func debugLog(e *logrus.Entry, msg string) {
+	e.Debug(msg)
+}

handler/logrus/logger_test.go

@@ -0,0 +1,36 @@
+package logrus_test
+
+import (
+	"bytes"
+	"context"
+	"strings"
+	"testing"
+
+	lgr "github.com/sirupsen/logrus"
+	"gitoa.ru/go-4devs/log/entry"
+	"gitoa.ru/go-4devs/log/handler/logrus"
+	"gitoa.ru/go-4devs/log/level"
+)
+
+func TestNew(t *testing.T) {
+	ctx := context.Background()
+	buf := &bytes.Buffer{}
+
+	lgrus := lgr.New()
+	lgrus.SetLevel(lgr.DebugLevel)
+	lgrus.SetOutput(buf)
+	lgrus.SetFormatter(&lgr.TextFormatter{
+		DisableTimestamp: true,
+	})
+
+	handler := logrus.New(logrus.WithLogrus(lgrus))
+	expect := "level=info msg=\"handle logrus message\"\n"
+
+	if _, err := handler(ctx, entry.New(entry.WithLevel(level.Info), entry.WithMessage("handle logrus message"))); err != nil {
+		t.Error(err)
+	}
+
+	if !strings.HasSuffix(buf.String(), expect) {
+		t.Errorf("invalid suffix\n got: %s\nexpect:%s\n", buf.String(), expect)
+	}
+}

handler/otel/helpers.go

@@ -0,0 +1,56 @@
+package otel
+
+import (
+	"context"
+
+	"gitoa.ru/go-4devs/log/entry"
+	"gitoa.ru/go-4devs/log/level"
+	"go.opentelemetry.io/otel/api/trace"
+	"go.opentelemetry.io/otel/label"
+)
+
+const (
+	fieldSeverityNumber = "SeverityNumber"
+	fieldSeverityText   = "SeverityText"
+	levelFields         = 2
+)
+
+func levels(lvl level.Level) Level {
+	switch lvl {
+	case level.Emergency:
+		return levelError3
+	case level.Alert:
+		return levelFatal
+	case level.Critical:
+		return levelError2
+	case level.Error:
+		return levelError
+	case level.Warning:
+		return levelWarn
+	case level.Notice:
+		return levelInfo2
+	case level.Info:
+		return levelInfo
+	case level.Debug:
+		return levelDebug
+	}
+
+	return 0
+}
+
+func addEvent(ctx context.Context, e *entry.Entry) {
+	span := trace.SpanFromContext(ctx)
+	attrs := make([]label.KeyValue, 0, e.Fields().Len()+levelFields)
+
+	lvl := levels(e.Level())
+	attrs = append(attrs,
+		label.String(fieldSeverityText, lvl.String()),
+		label.Int(fieldSeverityNumber, int(lvl)),
+	)
+
+	for _, field := range e.Fields() {
+		attrs = append(attrs, label.String(string(field.Key()), field.Value().String()))
+	}
+
+	span.AddEvent(ctx, e.Message(), attrs...)
+}

handler/otel/level.go

@@ -0,0 +1,16 @@
+package otel
+
+//go:generate stringer -type=Level -linecomment -output=level_string.go
+
+type Level int
+
+const (
+	levelDebug  Level = 5  // DEBUG
+	levelInfo   Level = 9  // INFO
+	levelInfo2  Level = 10 // INFO2
+	levelWarn   Level = 13 // WARN
+	levelError  Level = 17 // ERROR
+	levelError2 Level = 18 // ERROR2
+	levelError3 Level = 19 // ERROR3
+	levelFatal  Level = 21 // FATAL
+)

handler/otel/level_string.go

@@ -0,0 +1,51 @@
+// Code generated by "stringer -type=Level -linecomment -output=level_string.go"; DO NOT EDIT.
+
+package otel
+
+import "strconv"
+
+func _() {
+	// An "invalid array index" compiler error signifies that the constant values have changed.
+	// Re-run the stringer command to generate them again.
+	var x [1]struct{}
+	_ = x[levelDebug-5]
+	_ = x[levelInfo-9]
+	_ = x[levelInfo2-10]
+	_ = x[levelWarn-13]
+	_ = x[levelError-17]
+	_ = x[levelError2-18]
+	_ = x[levelError3-19]
+	_ = x[levelFatal-21]
+}
+
+const (
+	_Level_name_0 = "DEBUG"
+	_Level_name_1 = "INFOINFO2"
+	_Level_name_2 = "WARN"
+	_Level_name_3 = "ERRORERROR2ERROR3"
+	_Level_name_4 = "FATAL"
+)
+
+var (
+	_Level_index_1 = [...]uint8{0, 4, 9}
+	_Level_index_3 = [...]uint8{0, 5, 11, 17}
+)
+
+func (i Level) String() string {
+	switch {
+	case i == 5:
+		return _Level_name_0
+	case 9 <= i && i <= 10:
+		i -= 9
+		return _Level_name_1[_Level_index_1[i]:_Level_index_1[i+1]]
+	case i == 13:
+		return _Level_name_2
+	case 17 <= i && i <= 19:
+		i -= 17
+		return _Level_name_3[_Level_index_3[i]:_Level_index_3[i+1]]
+	case i == 21:
+		return _Level_name_4
+	default:
+		return "Level(" + strconv.FormatInt(int64(i), 10) + ")"
+	}
+}

handler/otel/logger.go

@@ -0,0 +1,16 @@
+package otel
+
+import (
+	"context"
+
+	"gitoa.ru/go-4devs/log"
+	"gitoa.ru/go-4devs/log/entry"
+)
+
+func New() log.Logger {
+	return func(ctx context.Context, e *entry.Entry) (int, error) {
+		addEvent(ctx, e)
+
+		return 0, nil
+	}
+}

handler/otel/middleware.go

@@ -0,0 +1,16 @@
+package otel
+
+import (
+	"context"
+
+	"gitoa.ru/go-4devs/log"
+	"gitoa.ru/go-4devs/log/entry"
+)
+
+func Middleware() log.Middleware {
+	return func(ctx context.Context, e *entry.Entry, handler log.Logger) (int, error) {
+		addEvent(ctx, e)
+
+		return handler(ctx, e)
+	}
+}

handler/zap/logger.go

@@ -0,0 +1,95 @@
+package zap
+
+import (
+	"context"
+
+	"gitoa.ru/go-4devs/log"
+	"gitoa.ru/go-4devs/log/entry"
+	"gitoa.ru/go-4devs/log/level"
+	"go.uber.org/zap"
+)
+
+// Option configure logger.
+type Option func(*logger)
+
+// WithLevel sets level logged message.
+func WithLevel(level level.Level, f func(z *zap.Logger, msg string, fields ...zap.Field)) Option {
+	return func(l *logger) {
+		l.levels[level] = f
+	}
+}
+
+// WithZap sets zap logger.
+func WithZap(z *zap.Logger) Option {
+	return func(l *logger) {
+		l.zap = z
+	}
+}
+
+// New create handler by zap logger.
+func New(opts ...Option) log.Logger {
+	z, err := zap.NewDevelopment()
+	if err != nil {
+		panic(err)
+	}
+
+	log := logger{
+		zap: z,
+		levels: map[level.Level]func(z *zap.Logger, msg string, fields ...zap.Field){
+			level.Emergency: fatalLog,
+			level.Alert:     panicLog,
+			level.Critical:  errorLog,
+			level.Error:     errorLog,
+			level.Warning:   warnLog,
+			level.Notice:    infoLog,
+			level.Info:      infoLog,
+			level.Debug:     debugLog,
+		},
+	}
+
+	for _, opt := range opts {
+		opt(&log)
+	}
+
+	return log.log
+}
+
+type logger struct {
+	zap    *zap.Logger
+	levels map[level.Level]func(z *zap.Logger, msg string, fields ...zap.Field)
+}
+
+func (l *logger) log(ctx context.Context, e *entry.Entry) (int, error) {
+	zf := make([]zap.Field, e.Fields().Len())
+	for i, field := range e.Fields() {
+		zf[i] = zap.Any(string(field.Key()), field.AsInterface())
+	}
+
+	l.levels[e.Level()](l.zap, e.Message(), zf...)
+
+	return 0, nil
+}
+
+func panicLog(z *zap.Logger, msg string, fields ...zap.Field) {
+	z.Panic(msg, fields...)
+}
+
+func fatalLog(z *zap.Logger, msg string, fields ...zap.Field) {
+	z.Fatal(msg, fields...)
+}
+
+func errorLog(z *zap.Logger, msg string, fields ...zap.Field) {
+	z.Error(msg, fields...)
+}
+
+func warnLog(z *zap.Logger, msg string, fields ...zap.Field) {
+	z.Warn(msg, fields...)
+}
+
+func infoLog(z *zap.Logger, msg string, fields ...zap.Field) {
+	z.Info(msg, fields...)
+}
+
+func debugLog(z *zap.Logger, msg string, fields ...zap.Field) {
+	z.Debug(msg, fields...)
+}

handler/zap/logger_test.go

@@ -0,0 +1,41 @@
+package zap_test
+
+import (
+	"bytes"
+	"context"
+	"testing"
+
+	"gitoa.ru/go-4devs/log/entry"
+	"gitoa.ru/go-4devs/log/field"
+	zlog "gitoa.ru/go-4devs/log/handler/zap"
+	"gitoa.ru/go-4devs/log/level"
+	"go.uber.org/zap"
+	"go.uber.org/zap/zapcore"
+)
+
+func TestNew(t *testing.T) {
+	ctx := context.Background()
+	buf := &bytes.Buffer{}
+	core := zapcore.NewCore(zapcore.NewJSONEncoder(zapcore.EncoderConfig{
+		MessageKey:     "msg",
+		LevelKey:       "level",
+		NameKey:        "logger",
+		EncodeLevel:    zapcore.LowercaseLevelEncoder,
+		EncodeTime:     zapcore.ISO8601TimeEncoder,
+		EncodeDuration: zapcore.StringDurationEncoder,
+	}), zapcore.AddSync(buf), zapcore.DebugLevel)
+	logger := zlog.New(zlog.WithZap(zap.New(core)))
+	expect := `{"level":"info","msg":"handle zap message","env":"test"}` + "\n"
+
+	if _, err := logger(ctx, entry.New(
+		entry.WithFields(field.String("env", "test")),
+		entry.WithLevel(level.Notice),
+		entry.WithMessage("handle zap message"),
+	)); err != nil {
+		t.Error(err)
+	}
+
+	if buf.String() != expect {
+		t.Errorf("invalid message\n got: %s\nexpect:%s\n", buf.String(), expect)
+	}
+}