I like your idea

[lunemec]

I like your idea - try to unite or provide common logging interface with adapters for mostly used loggers. But I think the API is a bit verbose..

// log with  key-value
logger.WithField("key1", 1).Warnf("warning! %s", "message")

I think logxi nailed the api:

log.Info("message", "key", value, "key2", value2)
// without key-values
log.Info("message")

It just looks much cleaner...

[tutuming]

Thanks to your proposal! 🙏

Hmm, I think ... interface{}signature is bad idea for logging.
User must keep it 2n+1 arguments and keep 2n+1st argument to be string.

[lunemec]

Yes, I also found it strange at first, but now I think it great. It makes sense to log key-value pairs, since you can format them easily (to json) and machine-parse later. This is impossible with regular strings - where you'd have to know how it was formatted.
But the main thing is, the API is much more cleaner and less verbose than adding WithField everywhere. A best solution would be something like Python's keyword arguments:

log.Info("message", key="value", key2="value2")

But this is impossible in Go...
Still, just a suggestion :)

[tutuming]

I agree with you, WithValue(...).WithValue(...) is a little bit redundant.
But I think that log is not only for info/debug but for errors, for errors that rarely happens run-time validation is not enough.

I have some ideas to improve interface cleaner

1. WithField shorthand

for example

ulog.Logger(ctx).F("key", 1).F("key2", "value").Info("message")

2. Typed key-value arguments

ulog.Logger(ctx).Info("message", ulog.F("key", 1), ulog.F("key2", "value"))

3. multiple field as map (but break the order of fields)

(like logrus does)

ulog.Logger(ctx).WithFields(ulog.F{"key" : 1, "key2" : "value"}).Info("message") 

[tutuming]

And I'm considering Infof, Warnf... is not needed for structured logging, so should I drop those from interface?

[lunemec]

I still kind of don't understand the difference between separating fields with ulog.F{} opposed to simply accepting (can you elaborate a bit?)

log.Info(...interface{})

Why am I complaining about this - because I kinda hate that Go community is divided on logging systems since the std logging is way too basic. And you often have to stop using some library simply by its use of different logging library than in your project.

I really would like for Go community to agree on 1 system for logging - like with python logging system.

[tonglil]

What about:

log.Info(msg string, map[string]interface{})
// thus
log.Info("message", {"key": value, "key2": value2})

Or even (varying log levels like glog):

log.V(level int, msg string, map[string]interface{})
// thus
log.V(1, "message", {"key": value, "key2": value2})

[tonglil]

Actually ignore what I said above.

I am pretty keen on using ulog for it's adapter capability, but I really would like to also standardize around this interface other log libraries seem to converge on:

• https://godoc.org/github.com/op/go-logging

• https://godoc.org/github.com/inconshreveable/log15

• https://godoc.org/github.com/mgutz/logxi/v1

[lunemec]

log.V(1, "message", {"key": value, "key2": value2})

This would mean you'd have to do 1 more allocation for the map against just using:

log("key", "value", ...)

Also I discovered some time ago go-kit. It is de-facto standard set of libraries to use when building microservices. They also have a logger interface (for operating with different loggers, like logrus).

See here: log.V(1, "message", {"key": value, "key2": value2})

[kyoh86]

💭idea 1

- func Logger(context.Context) LoggerContext
+ func For(context.Context) LoggerContext
+ func Connect(Adoptor) Option
+ func Depth(depth int) Option
+ func Val(key, value string) Option
+ type Set map[string]interface{}
+ var _ Option = Set{} // NOTE: Set implements Option interface
+ 
  type LoggerContext interface {
  	context.Context
-	WithField(key string, value interface{}) LoggerContext
- 	WithAdapter(Adapter) LoggerContext
- 	WithCallDepth(depth int) LoggerContext
+	With(...Option) LoggerContext

  	Error(args ...interface{})
- 	Errorf(format string, args ...interface{})
  	Warn(args ...interface{})
- 	Warnf(format string, args ...interface{})
  	Info(args ...interface{})
- 	Infof(format string, args ...interface{})
  	Debug(args ...interface{})
- 	Debugf(format string, args ...interface{})
  }

💭idea 2

- func Logger(context.Context) LoggerContext
+ func For(context.Context) LoggerContext
+ func Connect(Adoptor) Option
+ func Depth(depth int) Option
+ func Val(key, value string) Option
+ type Set map[string]interface{}
+ var _ Option = Set{} // NOTE: Set implements Option interface
+ 
  type LoggerContext interface {
  	context.Context
-	WithField(key string, value interface{}) LoggerContext
- 	WithAdapter(Adapter) LoggerContext
- 	WithCallDepth(depth int) LoggerContext
+	With(...Option) LoggerContext

  	Error(message interface{}, ...Option)
- 	Errorf(format string, args ...interface{})
  	Warn(message interface{}, ...Option)
- 	Warnf(format string, args ...interface{})
  	Info(message interface{}, ...Option)
- 	Infof(format string, args ...interface{})
  	Debug(message interface{}, ...Option)
- 	Debugf(format string, args ...interface{})
  }