package log import ( "context" "errors" "fmt" "io" "os" "gitoa.ru/go-4devs/log/entry" "gitoa.ru/go-4devs/log/field" "gitoa.ru/go-4devs/log/level" ) var _ io.Writer = (Logger)(nil) var ( ErrIgnoredKey = errors.New("ignored key without a value") ErrNonStringKeys = errors.New("ignored key-value pairs with non-string keys") ) func writeOutput(_ int, err error) { if err != nil { fmt.Fprint(os.Stderr, err) } } // Logger logged message. type Logger func(ctx context.Context, entry *entry.Entry) (int, error) func (l Logger) log(ctx context.Context, level level.Level, args ...interface{}) { writeOutput(l.write(ctx, level, fmt.Sprint(args...))) } func (l Logger) Write(in []byte) (int, error) { return l.write(context.Background(), level.Info, string(in)) } func (l Logger) write(ctx context.Context, level level.Level, msg string, fields ...field.Field) (int, error) { writeEntry := entry.Get() defer func() { entry.Put(writeEntry) }() return l(ctx, writeEntry.SetLevel(level).SetMessage(msg).Add(fields...)) } func (l Logger) logKVs(ctx context.Context, level level.Level, msg string, args ...interface{}) { writeOutput(l.write(ctx, level, msg, l.kv(ctx, args...)...)) } func (l Logger) logKV(ctx context.Context, level level.Level, msg string, fields ...field.Field) { writeOutput(l.write(ctx, level, msg, fields...)) } func (l Logger) logf(ctx context.Context, level level.Level, format string, args ...interface{}) { writeOutput(l.write(ctx, level, fmt.Sprintf(format, args...))) } func (l Logger) logln(ctx context.Context, level level.Level, args ...interface{}) { writeOutput(l.write(ctx, level, fmt.Sprintln(args...))) } func (l Logger) kv(ctx context.Context, args ...interface{}) field.Fields { kvEntry := entry.Get() defer func() { entry.Put(kvEntry) }() for i := 0; i < len(args); i++ { if f, ok := args[i].(field.Field); ok { kvEntry = kvEntry.Add(f) continue } if i == len(args)-1 { l.logKV(ctx, level.Critical, fmt.Sprint("Ignored key without a value.", args[i]), kvEntry.Fields()...) break } i++ key, val := args[i-1], args[i] if keyStr, ok := key.(string); ok { kvEntry = kvEntry.AddAny(keyStr, val) continue } l.logKV(ctx, level.Critical, fmt.Sprint("Ignored key-value pairs with non-string keys.", key, val), kvEntry.Fields()...) } return kvEntry.Fields() } // With adds middlewares to logger. func (l Logger) With(mw ...Middleware) Logger { return With(l, mw...) } // Emerg log by emergency level. func (l Logger) Emerg(ctx context.Context, args ...interface{}) { l.log(ctx, level.Emergency, args...) } // Alert log by alert level. func (l Logger) Alert(ctx context.Context, args ...interface{}) { l.log(ctx, level.Alert, args...) } // Crit log by critical level. func (l Logger) Crit(ctx context.Context, args ...interface{}) { l.log(ctx, level.Critical, args...) } // Err log by error level. func (l Logger) Err(ctx context.Context, args ...interface{}) { l.log(ctx, level.Error, args...) } // Warn log by warning level. func (l Logger) Warn(ctx context.Context, args ...interface{}) { l.log(ctx, level.Warning, args...) } // Notice log by notice level. func (l Logger) Notice(ctx context.Context, args ...interface{}) { l.log(ctx, level.Notice, args...) } // Info log by info level. func (l Logger) Info(ctx context.Context, args ...interface{}) { l.log(ctx, level.Info, args...) } // Debug log by debug level. func (l Logger) Debug(ctx context.Context, args ...interface{}) { l.log(ctx, level.Debug, args...) } // Print log by info level and arguments. func (l Logger) Print(args ...interface{}) { l.log(context.Background(), level.Info, args...) } // Fatal log by alert level and arguments. func (l Logger) Fatal(args ...interface{}) { l.log(context.Background(), level.Alert, args...) } // Panic log by emergency level and arguments. func (l Logger) Panic(args ...interface{}) { l.log(context.Background(), level.Emergency, args...) } // Println log by info level and arguments. func (l Logger) Println(args ...interface{}) { l.logln(context.Background(), level.Info, args...) } // Fatalln log by alert level and arguments. func (l Logger) Fatalln(args ...interface{}) { l.logln(context.Background(), level.Alert, args...) } // Panicln log by emergency level and arguments. func (l Logger) Panicln(args ...interface{}) { l.logln(context.Background(), level.Emergency, args...) } // EmergKVs sugared log by emergency level and key-values. func (l Logger) EmergKVs(ctx context.Context, msg string, args ...interface{}) { l.logKVs(ctx, level.Emergency, msg, args...) } // AlertKVs sugared log by alert level and key-values. func (l Logger) AlertKVs(ctx context.Context, msg string, args ...interface{}) { l.logKVs(ctx, level.Alert, msg, args...) } // CritKVs sugared log by critcal level and key-values. func (l Logger) CritKVs(ctx context.Context, msg string, args ...interface{}) { l.logKVs(ctx, level.Critical, msg, args...) } // ErrKVs sugared log by error level and key-values. func (l Logger) ErrKVs(ctx context.Context, msg string, args ...interface{}) { l.logKVs(ctx, level.Error, msg, args...) } // WarnKVs sugared log by warning level and key-values. func (l Logger) WarnKVs(ctx context.Context, msg string, args ...interface{}) { l.logKVs(ctx, level.Warning, msg, args...) } // NoticeKVs sugared log by notice level and key-values. func (l Logger) NoticeKVs(ctx context.Context, msg string, args ...interface{}) { l.logKVs(ctx, level.Notice, msg, args...) } // InfoKVs sugared log by info level and key-values. func (l Logger) InfoKVs(ctx context.Context, msg string, args ...interface{}) { l.logKVs(ctx, level.Info, msg, args...) } // DebugKVs sugared log by debug level and key-values. func (l Logger) DebugKVs(ctx context.Context, msg string, args ...interface{}) { l.logKVs(ctx, level.Debug, msg, args...) } // EmergKV log by emergency level and key-values. func (l Logger) EmergKV(ctx context.Context, msg string, args ...field.Field) { l.logKV(ctx, level.Emergency, msg, args...) } // AlertKV log by alert level and key-values. func (l Logger) AlertKV(ctx context.Context, msg string, args ...field.Field) { l.logKV(ctx, level.Alert, msg, args...) } // CritKV log by critcal level and key-values. func (l Logger) CritKV(ctx context.Context, msg string, args ...field.Field) { l.logKV(ctx, level.Critical, msg, args...) } // ErrKV log by error level and key-values. func (l Logger) ErrKV(ctx context.Context, msg string, args ...field.Field) { l.logKV(ctx, level.Error, msg, args...) } // WarnKV log by warning level and key-values. func (l Logger) WarnKV(ctx context.Context, msg string, args ...field.Field) { l.logKV(ctx, level.Warning, msg, args...) } // NoticeKV log by notice level and key-values. func (l Logger) NoticeKV(ctx context.Context, msg string, args ...field.Field) { l.logKV(ctx, level.Notice, msg, args...) } // InfoKV log by info level and key-values. func (l Logger) InfoKV(ctx context.Context, msg string, args ...field.Field) { l.logKV(ctx, level.Info, msg, args...) } // DebugKV log by debug level and key-values. func (l Logger) DebugKV(ctx context.Context, msg string, args ...field.Field) { l.logKV(ctx, level.Debug, msg, args...) } // Emergf log by emergency level by format and arguments. func (l Logger) Emergf(ctx context.Context, format string, args ...interface{}) { l.logf(ctx, level.Emergency, format, args...) } // Alertf log by alert level by format and arguments. func (l Logger) Alertf(ctx context.Context, format string, args ...interface{}) { l.logf(ctx, level.Alert, format, args...) } // Critf log by critical level by format and arguments. func (l Logger) Critf(ctx context.Context, format string, args ...interface{}) { l.logf(ctx, level.Critical, format, args...) } // Errf log by error level by format and arguments. func (l Logger) Errf(ctx context.Context, format string, args ...interface{}) { l.logf(ctx, level.Error, format, args...) } // Warnf log by warning level by format and arguments. func (l Logger) Warnf(ctx context.Context, format string, args ...interface{}) { l.logf(ctx, level.Warning, format, args...) } // Noticef log by notice level by format and arguments. func (l Logger) Noticef(ctx context.Context, format string, args ...interface{}) { l.logf(ctx, level.Notice, format, args...) } // Infof log by info level by format and arguments. func (l Logger) Infof(ctx context.Context, format string, args ...interface{}) { l.logf(ctx, level.Info, format, args...) } // Debugf log by debug level by format and arguments. func (l Logger) Debugf(ctx context.Context, format string, args ...interface{}) { l.logf(ctx, level.Debug, format, args...) } // Printf log by info level by format and arguments without context. func (l Logger) Printf(format string, args ...interface{}) { l.logf(context.Background(), level.Info, format, args...) } // Fatalf log by alert level by format and arguments without context. func (l Logger) Fatalf(format string, args ...interface{}) { l.logf(context.Background(), level.Alert, format, args...) } // Panicf log by emergency level and arguments without context. func (l Logger) Panicf(format string, args ...interface{}) { l.logf(context.Background(), level.Emergency, format, args...) } func (l Logger) Writer(ctx context.Context, level level.Level, fields ...field.Field) io.Writer { return writer{ ctx: ctx, level: level, Logger: l, fields: fields, } } //nolint: containedctx type writer struct { ctx context.Context level level.Level fields []field.Field Logger } func (w writer) WithLevel(level level.Level) writer { return writer{ level: level, Logger: w.Logger, ctx: w.ctx, fields: w.fields, } } func (w writer) WithContext(ctx context.Context) writer { return writer{ level: w.level, Logger: w.Logger, ctx: ctx, fields: w.fields, } } func (w writer) WithFields(fields ...field.Field) writer { return writer{ level: w.level, Logger: w.Logger, ctx: w.ctx, fields: fields, } } func (w writer) Write(in []byte) (int, error) { return w.write(w.ctx, w.level, string(in), w.fields...) }