Make Nix builds work

1 files changed, 186 insertions, 0 deletions

diff --git a/vendor/github.com/sirupsen/logrus/logrus.go b/vendor/github.com/sirupsen/logrus/logrus.go
new file mode 100644
index 0000000..2f16224
--- /dev/null
+++ b/vendor/github.com/sirupsen/logrus/logrus.go
@@ -0,0 +1,186 @@
+package logrus
+
+import (
+        "fmt"
+        "log"
+        "strings"
+)
+
+// Fields type, used to pass to `WithFields`.
+type Fields map[string]interface{}
+
+// Level type
+type Level uint32
+
+// Convert the Level to a string. E.g. PanicLevel becomes "panic".
+func (level Level) String() string {
+        if b, err := level.MarshalText(); err == nil {
+                return string(b)
+        } else {
+                return "unknown"
+        }
+}
+
+// ParseLevel takes a string level and returns the Logrus log level constant.
+func ParseLevel(lvl string) (Level, error) {
+        switch strings.ToLower(lvl) {
+        case "panic":
+                return PanicLevel, nil
+        case "fatal":
+                return FatalLevel, nil
+        case "error":
+                return ErrorLevel, nil
+        case "warn", "warning":
+                return WarnLevel, nil
+        case "info":
+                return InfoLevel, nil
+        case "debug":
+                return DebugLevel, nil
+        case "trace":
+                return TraceLevel, nil
+        }
+
+        var l Level
+        return l, fmt.Errorf("not a valid logrus Level: %q", lvl)
+}
+
+// UnmarshalText implements encoding.TextUnmarshaler.
+func (level *Level) UnmarshalText(text []byte) error {
+        l, err := ParseLevel(string(text))
+        if err != nil {
+                return err
+        }
+
+        *level = l
+
+        return nil
+}
+
+func (level Level) MarshalText() ([]byte, error) {
+        switch level {
+        case TraceLevel:
+                return []byte("trace"), nil
+        case DebugLevel:
+                return []byte("debug"), nil
+        case InfoLevel:
+                return []byte("info"), nil
+        case WarnLevel:
+                return []byte("warning"), nil
+        case ErrorLevel:
+                return []byte("error"), nil
+        case FatalLevel:
+                return []byte("fatal"), nil
+        case PanicLevel:
+                return []byte("panic"), nil
+        }
+
+        return nil, fmt.Errorf("not a valid logrus level %d", level)
+}
+
+// A constant exposing all logging levels
+var AllLevels = []Level{
+        PanicLevel,
+        FatalLevel,
+        ErrorLevel,
+        WarnLevel,
+        InfoLevel,
+        DebugLevel,
+        TraceLevel,
+}
+
+// These are the different logging levels. You can set the logging level to log
+// on your instance of logger, obtained with `logrus.New()`.
+const (
+        // PanicLevel level, highest level of severity. Logs and then calls panic with the
+        // message passed to Debug, Info, ...
+        PanicLevel Level = iota
+        // FatalLevel level. Logs and then calls `logger.Exit(1)`. It will exit even if the
+        // logging level is set to Panic.
+        FatalLevel
+        // ErrorLevel level. Logs. Used for errors that should definitely be noted.
+        // Commonly used for hooks to send errors to an error tracking service.
+        ErrorLevel
+        // WarnLevel level. Non-critical entries that deserve eyes.
+        WarnLevel
+        // InfoLevel level. General operational entries about what's going on inside the
+        // application.
+        InfoLevel
+        // DebugLevel level. Usually only enabled when debugging. Very verbose logging.
+        DebugLevel
+        // TraceLevel level. Designates finer-grained informational events than the Debug.
+        TraceLevel
+)
+
+// Won't compile if StdLogger can't be realized by a log.Logger
+var (
+        _ StdLogger = &log.Logger{}
+        _ StdLogger = &Entry{}
+        _ StdLogger = &Logger{}
+)
+
+// StdLogger is what your logrus-enabled library should take, that way
+// it'll accept a stdlib logger and a logrus logger. There's no standard
+// interface, this is the closest we get, unfortunately.
+type StdLogger interface {
+        Print(...interface{})
+        Printf(string, ...interface{})
+        Println(...interface{})
+
+        Fatal(...interface{})
+        Fatalf(string, ...interface{})
+        Fatalln(...interface{})
+
+        Panic(...interface{})
+        Panicf(string, ...interface{})
+        Panicln(...interface{})
+}
+
+// The FieldLogger interface generalizes the Entry and Logger types
+type FieldLogger interface {
+        WithField(key string, value interface{}) *Entry
+        WithFields(fields Fields) *Entry
+        WithError(err error) *Entry
+
+        Debugf(format string, args ...interface{})
+        Infof(format string, args ...interface{})
+        Printf(format string, args ...interface{})
+        Warnf(format string, args ...interface{})
+        Warningf(format string, args ...interface{})
+        Errorf(format string, args ...interface{})
+        Fatalf(format string, args ...interface{})
+        Panicf(format string, args ...interface{})
+
+        Debug(args ...interface{})
+        Info(args ...interface{})
+        Print(args ...interface{})
+        Warn(args ...interface{})
+        Warning(args ...interface{})
+        Error(args ...interface{})
+        Fatal(args ...interface{})
+        Panic(args ...interface{})
+
+        Debugln(args ...interface{})
+        Infoln(args ...interface{})
+        Println(args ...interface{})
+        Warnln(args ...interface{})
+        Warningln(args ...interface{})
+        Errorln(args ...interface{})
+        Fatalln(args ...interface{})
+        Panicln(args ...interface{})
+
+        // IsDebugEnabled() bool
+        // IsInfoEnabled() bool
+        // IsWarnEnabled() bool
+        // IsErrorEnabled() bool
+        // IsFatalEnabled() bool
+        // IsPanicEnabled() bool
+}
+
+// Ext1FieldLogger (the first extension to FieldLogger) is superfluous, it is
+// here for consistancy. Do not use. Use Logger or Entry instead.
+type Ext1FieldLogger interface {
+        FieldLogger
+        Tracef(format string, args ...interface{})
+        Trace(args ...interface{})
+        Traceln(args ...interface{})
+}