log.With does not compose well with log.Levels about kit HOT 8 CLOSED

The obvious way is to canonize some levels into the interface definition, but I'd like to avoid that...

from kit.

We could define a new interface with canonized levels, with constructors that can wrap a logger...

from kit.

How would log.With compose with the new interface you propose?

from kit.

Not well :) Could probably dream up a special-case solution, like

type Foo interface {
    Info(keyvals ...interface{})
    Warn(keyvals ...interface{})
    Error(keyvals ...interface{})

    With(keyvals ...interface{}) Foo
}

But that feels awkward, opposite of the existing API.

from kit.

In general I'm struggling to embrace and extend log.With semantics...

from kit.

@ChrisHines, what do you think about the approach described in this README?

from kit.

@peterbourgon What do you think of this?

func With(keyvals ...interface{}) Context {
    c := Context{}
    return c.With(keyvals...)
}

type Context []interface{}

func (c Context) With(keyvals ...interface{}) Context {
    n := len(c)
    return append(c[:n:n], keyvals...)
}

func (c Context) LogTo(logger Logger) error {
    ctx := c
    if containsValuer(ctx) {
        ctx = append(Context{}, ctx...)
        bindValues(ctx)
    }
    return logger.Log(ctx...)
}

The above code would get used like this:

ctx := log.With("a", 123)
...
ctx = ctx.With("b", "c")
...
ctx.With("msg", "message").LogTo(logger)

from kit.

On first read I resisted the idea of manipulating a first-order Context object and logging it "to" a destination, but after rolling it around a little bit, it feels like it could reasonable. Any reason not to s/LogTo/Log/? Thinking out loud a little bit: we're flying pretty close to an encoder or writer API, I wonder if it doesn't make sense to make that more explicit, with something like

type Logger interface {
    Log(Context) error
}

func (c Context) Log(dst Logger) error {
    return dst.Log(c)
}

...which raises the question of where best to put the valuer stuff. It feels strange to have it only occur when you context.Log(logger), and get ignored if you logger.Log(context). Maybe your version, having the logger take a keyvals, makes that more explicit.

from kit.