package logrus

import "github.com/sirupsen/logrus"

Index ¶

• type Entry
• func NewEntry(logger *Logger) *Entry
• func (entry *Entry) Debug(args ...interface{})
• func (entry *Entry) Debugf(format string, args ...interface{})
• func (entry *Entry) Debugln(args ...interface{})
• func (entry *Entry) Error(args ...interface{})
• func (entry *Entry) Errorf(format string, args ...interface{})
• func (entry *Entry) Errorln(args ...interface{})
• func (entry *Entry) Fatal(args ...interface{})
• func (entry *Entry) Fatalf(format string, args ...interface{})
• func (entry *Entry) Fatalln(args ...interface{})
• func (entry *Entry) Info(args ...interface{})
• func (entry *Entry) Infof(format string, args ...interface{})
• func (entry *Entry) Infoln(args ...interface{})
• func (entry *Entry) Panic(args ...interface{})
• func (entry *Entry) Panicf(format string, args ...interface{})
• func (entry *Entry) Panicln(args ...interface{})
• func (entry *Entry) Print(args ...interface{})
• func (entry *Entry) Printf(format string, args ...interface{})
• func (entry *Entry) Println(args ...interface{})
• func (entry *Entry) Reader() (*bytes.Buffer, error)
• func (entry *Entry) String() (string, error)
• func (entry *Entry) Warn(args ...interface{})
• func (entry *Entry) Warnf(format string, args ...interface{})
• func (entry *Entry) Warningf(format string, args ...interface{})
• func (entry *Entry) Warningln(args ...interface{})
• func (entry *Entry) Warnln(args ...interface{})
• func (entry *Entry) WithField(key string, value interface{}) *Entry
• func (entry *Entry) WithFields(fields Fields) *Entry
• type Fields
• type Formatter
• type Hook
• type JSONFormatter
• func (f *JSONFormatter) Format(entry *Entry) ([]byte, error)
• type Level
• type Logger
• func New() *Logger
• func (logger *Logger) Debug(args ...interface{})
• func (logger *Logger) Debugf(format string, args ...interface{})
• func (logger *Logger) Debugln(args ...interface{})
• func (logger *Logger) Error(args ...interface{})
• func (logger *Logger) Errorf(format string, args ...interface{})
• func (logger *Logger) Errorln(args ...interface{})
• func (logger *Logger) Fatal(args ...interface{})
• func (logger *Logger) Fatalf(format string, args ...interface{})
• func (logger *Logger) Fatalln(args ...interface{})
• func (logger *Logger) Info(args ...interface{})
• func (logger *Logger) Infof(format string, args ...interface{})
• func (logger *Logger) Infoln(args ...interface{})
• func (logger *Logger) Panic(args ...interface{})
• func (logger *Logger) Panicf(format string, args ...interface{})
• func (logger *Logger) Panicln(args ...interface{})
• func (logger *Logger) Print(args ...interface{})
• func (logger *Logger) Printf(format string, args ...interface{})
• func (logger *Logger) Println(args ...interface{})
• func (logger *Logger) Warn(args ...interface{})
• func (logger *Logger) Warnf(format string, args ...interface{})
• func (logger *Logger) Warning(args ...interface{})
• func (logger *Logger) Warningf(format string, args ...interface{})
• func (logger *Logger) Warningln(args ...interface{})
• func (logger *Logger) Warnln(args ...interface{})
• func (logger *Logger) WithField(key string, value interface{}) *Entry
• func (logger *Logger) WithFields(fields Fields) *Entry
• type StdLogger
• type TextFormatter
• func (f *TextFormatter) AppendKeyValue(serialized []byte, key, value interface{}) []byte
• func (f *TextFormatter) Format(entry *Entry) ([]byte, error)

Types ¶

type Entry ¶

type Entry struct {
	Logger *Logger
	Data   Fields
}

func NewEntry ¶

func NewEntry(logger *Logger) *Entry

func (*Entry) Debug ¶

func (entry *Entry) Debug(args ...interface{})

func (*Entry) Debugf ¶

func (entry *Entry) Debugf(format string, args ...interface{})

func (*Entry) Debugln ¶

func (entry *Entry) Debugln(args ...interface{})

func (*Entry) Error ¶

func (entry *Entry) Error(args ...interface{})

func (*Entry) Errorf ¶

func (entry *Entry) Errorf(format string, args ...interface{})

func (*Entry) Errorln ¶

func (entry *Entry) Errorln(args ...interface{})

func (*Entry) Fatal ¶

func (entry *Entry) Fatal(args ...interface{})

func (*Entry) Fatalf ¶

func (entry *Entry) Fatalf(format string, args ...interface{})

func (*Entry) Fatalln ¶

func (entry *Entry) Fatalln(args ...interface{})

func (*Entry) Info ¶

func (entry *Entry) Info(args ...interface{})

func (*Entry) Infof ¶

func (entry *Entry) Infof(format string, args ...interface{})

func (*Entry) Infoln ¶

func (entry *Entry) Infoln(args ...interface{})

func (*Entry) Panic ¶

func (entry *Entry) Panic(args ...interface{})

func (*Entry) Panicf ¶

func (entry *Entry) Panicf(format string, args ...interface{})

func (*Entry) Panicln ¶

func (entry *Entry) Panicln(args ...interface{})

func (*Entry) Print ¶

func (entry *Entry) Print(args ...interface{})

func (*Entry) Printf ¶

func (entry *Entry) Printf(format string, args ...interface{})

func (*Entry) Println ¶

func (entry *Entry) Println(args ...interface{})

func (*Entry) Reader ¶

func (entry *Entry) Reader() (*bytes.Buffer, error)

func (*Entry) String ¶

func (entry *Entry) String() (string, error)

func (*Entry) Warn ¶

func (entry *Entry) Warn(args ...interface{})

func (*Entry) Warnf ¶

func (entry *Entry) Warnf(format string, args ...interface{})

func (*Entry) Warningf ¶

func (entry *Entry) Warningf(format string, args ...interface{})

func (*Entry) Warningln ¶

func (entry *Entry) Warningln(args ...interface{})

func (*Entry) Warnln ¶

func (entry *Entry) Warnln(args ...interface{})

func (*Entry) WithField ¶

func (entry *Entry) WithField(key string, value interface{}) *Entry

func (*Entry) WithFields ¶

func (entry *Entry) WithFields(fields Fields) *Entry

type Fields ¶

type Fields map[string]interface{}

Fields type, used to pass to `WithFields`.

type Formatter ¶

type Formatter interface {
	Format(*Entry) ([]byte, error)
}

The Formatter interface is used to implement a custom Formatter. It takes an `Entry`. It exposes all the fields, including the default ones:

* `entry.Data["msg"]`. The message passed from Info, Warn, Error .. * `entry.Data["time"]`. The timestamp. * `entry.Data["level"]. The level the entry was logged at.

Any additional fields added with `WithField` or `WithFields` are also in `entry.Data`. Format is expected to return an array of bytes which are then logged to `logger.Out`.

type Hook ¶

type Hook interface {
	Levels() []Level
	Fire(*Entry) error
}

A hook to be fired when logging on the logging levels returned from `Levels()` on your implementation of the interface. Note that this is not fired in a goroutine or a channel with workers, you should handle such functionality yourself if your call is non-blocking and you don't wish for the logging calls for levels returned from `Levels()` to block.

type JSONFormatter ¶

type JSONFormatter struct {
}

func (*JSONFormatter) Format ¶

func (f *JSONFormatter) Format(entry *Entry) ([]byte, error)

type Level ¶

type Level uint8

Level type

const (
	// Panic level, highest level of severity. Logs and then calls panic with the
	// message passed to Debug, Info, ...
	Panic Level = iota
	// Fatal level. Logs and then calls `os.Exit(1)`. It will exit even if the
	// logging level is set to Panic.
	Fatal
	// Error level. Logs. Used for errors that should definitely be noted.
	// Commonly used for hooks to send errors to an error tracking service.
	Error
	// Warn level. Non-critical entries that deserve eyes.
	Warn
	// Info level. General operational entries about what's going on inside the
	// application.
	Info
	// Debug level. Usually only enabled when debugging. Very verbose logging.
	Debug
)

These are the different logging levels. You can set the logging level to log on your instance of logger, obtained with `logrus.New()`.

type Logger ¶

type Logger struct {
	// The logs are `io.Copy`'d to this in a mutex. It's common to set this to a
	// file, or leave it default which is `os.Stdout`. You can also set this to
	// something more adventorous, such as logging to Kafka.
	Out io.Writer
	// Hooks for the logger instance. These allow firing events based on logging
	// levels and log entries. For example, to send errors to an error tracking
	// service, log to StatsD or dump the core on fatal errors.
	Hooks levelHooks
	// All log entries pass through the formatter before logged to Out. The
	// included formatters are `TextFormatter` and `JSONFormatter` for which
	// TextFormatter is the default. In development (when a TTY is attached) it
	// logs with colors, but to a file it wouldn't. You can easily implement your
	// own that implements the `Formatter` interface, see the `README` or included
	// formatters for examples.
	Formatter Formatter
	// The logging level the logger should log at. This is typically (and defaults
	// to) `logrus.Info`, which allows Info(), Warn(), Error() and Fatal() to be
	// logged. `logrus.Debug` is useful in
	Level Level
	// contains filtered or unexported fields
}

func New ¶

func New() *Logger

Creates a new logger. Configuration should be set by changing `Formatter`, `Out` and `Hooks` directly on the default logger instance. You can also just instantiate your own:

var log = &Logger{
  Out: os.Stderr,
  Formatter: new(JSONFormatter),
  Hooks: make(levelHooks),
  Level: logrus.Debug,
}

It's recommended to make this a global instance called `log`.

func (*Logger) Debug ¶

func (logger *Logger) Debug(args ...interface{})

func (*Logger) Debugf ¶

func (logger *Logger) Debugf(format string, args ...interface{})

func (*Logger) Debugln ¶

func (logger *Logger) Debugln(args ...interface{})

func (*Logger) Error ¶

func (logger *Logger) Error(args ...interface{})

func (*Logger) Errorf ¶

func (logger *Logger) Errorf(format string, args ...interface{})

func (*Logger) Errorln ¶

func (logger *Logger) Errorln(args ...interface{})

func (*Logger) Fatal ¶

func (logger *Logger) Fatal(args ...interface{})

func (*Logger) Fatalf ¶

func (logger *Logger) Fatalf(format string, args ...interface{})

func (*Logger) Fatalln ¶

func (logger *Logger) Fatalln(args ...interface{})

func (*Logger) Info ¶

func (logger *Logger) Info(args ...interface{})

func (*Logger) Infof ¶

func (logger *Logger) Infof(format string, args ...interface{})

func (*Logger) Infoln ¶

func (logger *Logger) Infoln(args ...interface{})

func (*Logger) Panic ¶

func (logger *Logger) Panic(args ...interface{})

func (*Logger) Panicf ¶

func (logger *Logger) Panicf(format string, args ...interface{})

func (*Logger) Panicln ¶

func (logger *Logger) Panicln(args ...interface{})

func (*Logger) Print ¶

func (logger *Logger) Print(args ...interface{})

func (*Logger) Printf ¶

func (logger *Logger) Printf(format string, args ...interface{})

func (*Logger) Println ¶

func (logger *Logger) Println(args ...interface{})

func (*Logger) Warn ¶

func (logger *Logger) Warn(args ...interface{})

func (*Logger) Warnf ¶

func (logger *Logger) Warnf(format string, args ...interface{})

func (*Logger) Warning ¶

func (logger *Logger) Warning(args ...interface{})

func (*Logger) Warningf ¶

func (logger *Logger) Warningf(format string, args ...interface{})

func (*Logger) Warningln ¶

func (logger *Logger) Warningln(args ...interface{})

func (*Logger) Warnln ¶

func (logger *Logger) Warnln(args ...interface{})

func (*Logger) WithField ¶

func (logger *Logger) WithField(key string, value interface{}) *Entry

Adds a field to the log entry, note that you it doesn't log until you call Debug, Print, Info, Warn, Fatal or Panic. It only creates a log entry. Ff you want multiple fields, use `WithFields`.

func (*Logger) WithFields ¶

func (logger *Logger) WithFields(fields Fields) *Entry

Adds a struct of fields to the log entry. All it does is call `WithField` for each `Field`.

type StdLogger ¶

type StdLogger interface {
	Print(...interface{})
	Printf(string, ...interface{})
	Println(...interface{})

	Fatal(...interface{})
	Fatalf(string, ...interface{})
	Fatalln(...interface{})

	Panic(...interface{})
	Panicf(string, ...interface{})
	Panicln(...interface{})
}

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 TextFormatter ¶

type TextFormatter struct {
	// Set to true to bypass checking for a TTY before outputting colors.
	ForceColors bool
}

func (*TextFormatter) AppendKeyValue ¶

func (f *TextFormatter) AppendKeyValue(serialized []byte, key, value interface{}) []byte

func (*TextFormatter) Format ¶

func (f *TextFormatter) Format(entry *Entry) ([]byte, error)

Source Files ¶

entry.go formatter.go hooks.go json_formatter.go logger.go logrus.go text_formatter.go

Directories ¶