package logrus

import "github.com/sirupsen/logrus"

Index ¶

• type AirbrakeHook
• func (hook *AirbrakeHook) Fire(entry *Entry) error
• func (hook *AirbrakeHook) Levels() []Level
• 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 AirbrakeHook ¶

type AirbrakeHook struct{}

AirbrakeHook to send exceptions to an exception-tracking service compatible with the Airbrake API. You must set: * airbrake.Endpoint * airbrake.ApiKey * airbrake.Environment (only sends exceptions when set to "production")

Before using this hook, to send exceptions. Entries that trigger an Error, Fatal or Panic should now include an "Error" field to send to Airbrake.

func (*AirbrakeHook) Fire ¶

func (hook *AirbrakeHook) Fire(entry *Entry) error

func (*AirbrakeHook) Levels ¶

func (hook *AirbrakeHook) Levels() []Level

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 ¶

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

Directories ¶