go-4devs/log
1
0
Fork 0
Code Issues Pull Requests Actions Projects Releases Wiki Activity

update zap/logrus hanler (#1)

Browse Source 
Co-authored-by: andrey1s <andrey_simfi@list.ru>
Reviewed-on: #1
Co-authored-by: andrey <andrey@4devs.io>
Co-committed-by: andrey <andrey@4devs.io>
This commit was merged in pull request #1.
This commit is contained in:
andrey
2022-01-02 14:32:19 +03:00
parent deb67b0008
commit b56ca08811
22 changed files with 426 additions and 379 deletions
Download Patch File Download Diff File Expand all files Collapse all files

102
handler/logrus/logger.go
View File

@@ -9,82 +9,36 @@ import (
"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
}
// Standard create new standart logrus handler.
func Standard() log.Logger {
return New(logrus.StandardLogger())
}
// 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,
},
func New(log *logrus.Logger) log.Logger {
return func(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()
}
entry := log.WithContext(ctx).WithFields(lrgFields)
switch e.Level() {
case level.Emergency:
entry.Panic(e.Message())
case level.Alert:
entry.Fatal(e.Message())
case level.Critical, level.Error:
entry.Error(e.Message())
case level.Warning:
entry.Warn(e.Message())
case level.Notice, level.Info:
entry.Info(e.Message())
case level.Debug:
entry.Debug(e.Message())
}
return 0, nil
}
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)
}

4
handler/logrus/logger_test.go
View File

@@ -13,6 +13,8 @@ import (
)
func TestNew(t *testing.T) {
t.Parallel()
ctx := context.Background()
buf := &bytes.Buffer{}
@@ -23,7 +25,7 @@ func TestNew(t *testing.T) {
DisableTimestamp: true,
})
handler := logrus.New(logrus.WithLogrus(lgrus))
handler := logrus.New(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 {

14
handler/otel/helpers.go
View File

@@ -5,8 +5,8 @@ import (
"gitoa.ru/go-4devs/log/entry"
"gitoa.ru/go-4devs/log/level"
"go.opentelemetry.io/otel/api/trace"
"go.opentelemetry.io/otel/label"
"go.opentelemetry.io/otel/attribute"
"go.opentelemetry.io/otel/trace"
)
const (
@@ -40,17 +40,17 @@ func levels(lvl level.Level) Level {
func addEvent(ctx context.Context, e *entry.Entry) {
span := trace.SpanFromContext(ctx)
attrs := make([]label.KeyValue, 0, e.Fields().Len()+levelFields)
attrs := make([]attribute.KeyValue, 0, e.Fields().Len()+levelFields)
lvl := levels(e.Level())
attrs = append(attrs,
label.String(fieldSeverityText, lvl.String()),
label.Int(fieldSeverityNumber, int(lvl)),
attribute.String(fieldSeverityText, lvl.String()),
attribute.Int(fieldSeverityNumber, int(lvl)),
)
for _, field := range e.Fields() {
attrs = append(attrs, label.String(string(field.Key()), field.Value().String()))
attrs = append(attrs, attribute.String(string(field.Key()), field.Value().String()))
}
span.AddEvent(ctx, e.Message(), attrs...)
span.AddEvent(e.Message(), trace.WithAttributes(attrs...))
}

112
handler/zap/logger.go
View File

@@ -9,87 +9,55 @@ import (
"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
}
func Nop() log.Logger {
return New(zap.NewNop())
}
// WithZap sets zap logger.
func WithZap(z *zap.Logger) Option {
return func(l *logger) {
l.zap = z
}
func Example(options ...zap.Option) log.Logger {
return New(zap.NewExample(options...))
}
// New create handler by zap logger.
func New(opts ...Option) log.Logger {
z, err := zap.NewDevelopment()
func Production(options ...zap.Option) log.Logger {
z, err := zap.NewProduction(options...)
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,
},
return New(z)
}
func Development(options ...zap.Option) log.Logger {
z, err := zap.NewDevelopment(options...)
if err != nil {
panic(err)
}
for _, opt := range opts {
opt(&log)
return New(z)
}
// New create handler by zap logger.
func New(z *zap.Logger) log.Logger {
return func(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())
}
switch e.Level() {
case level.Emergency:
z.Fatal(e.Message(), zf...)
case level.Alert:
z.Panic(e.Message(), zf...)
case level.Critical, level.Error:
z.Error(e.Message(), zf...)
case level.Warning:
z.Warn(e.Message(), zf...)
case level.Notice, level.Info:
z.Info(e.Message(), zf...)
case level.Debug:
z.Debug(e.Message(), zf...)
}
return 0, nil
}
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...)
}

4
handler/zap/logger_test.go
View File

@@ -14,6 +14,8 @@ import (
)
func TestNew(t *testing.T) {
t.Parallel()
ctx := context.Background()
buf := &bytes.Buffer{}
core := zapcore.NewCore(zapcore.NewJSONEncoder(zapcore.EncoderConfig{
@@ -24,7 +26,7 @@ func TestNew(t *testing.T) {
EncodeTime: zapcore.ISO8601TimeEncoder,
EncodeDuration: zapcore.StringDurationEncoder,
}), zapcore.AddSync(buf), zapcore.DebugLevel)
logger := zlog.New(zlog.WithZap(zap.New(core)))
logger := zlog.New(zap.New(core))
expect := `{"level":"info","msg":"handle zap message","env":"test"}` + "\n"
if _, err := logger(ctx, entry.New(