Better logging interoperability

[kirides]

The current StructuredLogger interface is too basic and requires manually filtering some data, especially the levels

Suggestion:

• Drop "ts" from the key-value pair (is provided by used logger anyways)
• Drop "level" from
• Add "Debug", "Info", "Warn", "Error" functions to (maybe to a separate, more specific Logger interface)
  • These functions should as first parameter take the actual log message, afterwards a "key-value" of structured information, like the current interface
    this allows us to more comfortably use other loggers and simplify implementing the interface for certain use cases.

currently:

type signalRLogger struct {
    zap *zap.Logger
}

func (l *signalRLogger) Log(keyVals ...interface{}) error {
    if l.zap == nil {
        var err error
        l.zap, err = zap.NewDevelopment()
        if err != nil {
            return err
        }
    }
    lvl := level.DebugValue()
    logger := l.zap.Sugar()
    for i := 0; i < len(keyVals); i += 2 {
        _, isStr := keyVals[i].(string)
        if !isStr {
            // wtf
            continue
        }
        if keyVals[i] == "ts" {
            continue
        }
        if keyVals[i] == level.Key() {
            if gokit, ok := keyVals[i+1].(level.Value); ok {
                lvl = gokit
            }
            continue
        }
        logger = logger.With(keyVals[i], keyVals[i+1])
    }

    switch lvl {
    case level.DebugValue():
        logger.Debug()
    case level.InfoValue():
        logger.Info()
    case level.WarnValue():
        logger.Warn()
    case level.ErrorValue():
        logger.Error()
    default:
        logger.Error()
    }

    return nil
}

proposed:

type StructuredLogger interface {
    Debug(message string, keyVals interface{}) error
    Info(message string, keyVals interface{}) error
    Warn(message string, keyVals interface{}) error
    Error(message string, keyVals interface{}) error
}

// example implementation with zap

func (l *signalRLogger) Debug(message string, keyVals ...interface{}) error {
    l.zap.Sugar().Debugw(message, keyVals...)
    return nil
}

func (l *signalRLogger) Info(message string, keyVals ...interface{}) error {
    l.zap.Sugar().Infow(message, keyVals...)
    return nil
}

func (l *signalRLogger) Warn(message string, keyVals ...interface{}) error {
    l.zap.Sugar().Warnw(message, keyVals...)
    return nil
}

func (l *signalRLogger) Error(message string, keyVals ...interface{}) error {
    l.zap.Sugar().Errorw(message, keyVals...)
    return nil
}

// example in go-kit/log

func (l *signalRLogger) Debug(message string, keyVals ...interface{}) error {
    return gokit.With(level.Debug(gokitLogger), "message", message).Log(keyVals...)
}

func (l *signalRLogger) Info(message string, keyVals ...interface{}) error {
    return gokit.With(level.Info(gokitLogger), "message", message).Log(keyVals...)
}

func (l *signalRLogger) Warn(message string, keyVals ...interface{}) error {
    return gokit.With(level.Warn(gokitLogger), "message", message).Log(keyVals...)
}

func (l *signalRLogger) Error(message string, keyVals ...interface{}) error {
    return gokit.With(level.Error(gokitLogger), "message", message).Log(keyVals...)
}

[philippseith]

See https://github.com/go-kit/log#readme why the interface is as it is

[kirides]

i guess that's fine. Will have to live with that quirky workaround for now ;)