kubernetes/vendor/github.com/sirupsen/logrus/logger.go

type LogFunction …

type Logger …

type exitFunc …

type MutexWrap …

func (mw *MutexWrap) Lock() { … }

func (mw *MutexWrap) Unlock() { … }

func (mw *MutexWrap) Disable() { … }

// 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 = &logrus.Logger{
//      Out: os.Stderr,
//      Formatter: new(logrus.TextFormatter),
//      Hooks: make(logrus.LevelHooks),
//      Level: logrus.DebugLevel,
//    }
//
// It's recommended to make this a global instance called `log`.
func New() *Logger { … }

func (logger *Logger) newEntry() *Entry { … }

func (logger *Logger) releaseEntry(entry *Entry) { … }

// WithField allocates a new entry and adds a field to it.
// Debug, Print, Info, Warn, Error, Fatal or Panic must be then applied to
// this new returned entry.
// If you want multiple fields, use `WithFields`.
func (logger *Logger) WithField(key string, value interface{ … }

// Adds a struct of fields to the log entry. All it does is call `WithField` for
// each `Field`.
func (logger *Logger) WithFields(fields Fields) *Entry { … }

// Add an error as single field to the log entry.  All it does is call
// `WithError` for the given `error`.
func (logger *Logger) WithError(err error) *Entry { … }

// Add a context to the log entry.
func (logger *Logger) WithContext(ctx context.Context) *Entry { … }

// Overrides the time of the log entry.
func (logger *Logger) WithTime(t time.Time) *Entry { … }

func (logger *Logger) Logf(level Level, format string, args ...interface{ … }

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

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

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

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

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

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

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

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

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

// Log will log a message at the level given as parameter.
// Warning: using Log at Panic or Fatal level will not respectively Panic nor Exit.
// For this behaviour Logger.Panic or Logger.Fatal should be used instead.
func (logger *Logger) Log(level Level, args ...interface{ … }

func (logger *Logger) LogFn(level Level, fn LogFunction) { … }

func (logger *Logger) Trace(args ...interface{ … }

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

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

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

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

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

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

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

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

func (logger *Logger) TraceFn(fn LogFunction) { … }

func (logger *Logger) DebugFn(fn LogFunction) { … }

func (logger *Logger) InfoFn(fn LogFunction) { … }

func (logger *Logger) PrintFn(fn LogFunction) { … }

func (logger *Logger) WarnFn(fn LogFunction) { … }

func (logger *Logger) WarningFn(fn LogFunction) { … }

func (logger *Logger) ErrorFn(fn LogFunction) { … }

func (logger *Logger) FatalFn(fn LogFunction) { … }

func (logger *Logger) PanicFn(fn LogFunction) { … }

func (logger *Logger) Logln(level Level, args ...interface{ … }

func (logger *Logger) Traceln(args ...interface{ … }

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

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

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

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

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

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

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

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

func (logger *Logger) Exit(code int) { … }

//When file is opened with appending mode, it's safe to
//write concurrently to a file (within 4k message on Linux).
//In these cases user can choose to disable the lock.
func (logger *Logger) SetNoLock() { … }

func (logger *Logger) level() Level { … }

// SetLevel sets the logger level.
func (logger *Logger) SetLevel(level Level) { … }

// GetLevel returns the logger level.
func (logger *Logger) GetLevel() Level { … }

// AddHook adds a hook to the logger hooks.
func (logger *Logger) AddHook(hook Hook) { … }

// IsLevelEnabled checks if the log level of the logger is greater than the level param
func (logger *Logger) IsLevelEnabled(level Level) bool { … }

// SetFormatter sets the logger formatter.
func (logger *Logger) SetFormatter(formatter Formatter) { … }

// SetOutput sets the logger output.
func (logger *Logger) SetOutput(output io.Writer) { … }

func (logger *Logger) SetReportCaller(reportCaller bool) { … }

// ReplaceHooks replaces the logger hooks and returns the old ones
func (logger *Logger) ReplaceHooks(hooks LevelHooks) LevelHooks { … }

// SetBufferPool sets the logger buffer pool.
func (logger *Logger) SetBufferPool(pool BufferPool) { … }