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

var logrusPackage …

var minimumCallerDepth …

var callerInitOnce …

const maximumCallerDepth …

const knownLogrusFrames …

func init() { … }

var ErrorKey …

type Entry …

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

func (entry *Entry) Dup() *Entry { … }

// Returns the bytes representation of this entry from the formatter.
func (entry *Entry) Bytes() ([]byte, error) { … }

// Returns the string representation from the reader and ultimately the
// formatter.
func (entry *Entry) String() (string, error) { … }

// Add an error as single field (using the key defined in ErrorKey) to the Entry.
func (entry *Entry) WithError(err error) *Entry { … }

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

// Add a single field to the Entry.
func (entry *Entry) WithField(key string, value interface{ … }

// Add a map of fields to the Entry.
func (entry *Entry) WithFields(fields Fields) *Entry { … }

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

// getPackageName reduces a fully qualified function name to the package name
// There really ought to be to be a better way...
func getPackageName(f string) string { … }

// getCaller retrieves the name of the first non-logrus calling function
func getCaller() *runtime.Frame { … }

func (entry Entry) HasCaller() (has bool) { … }

func (entry *Entry) log(level Level, msg string) { … }

func (entry *Entry) getBufferPool() (pool BufferPool) { … }

func (entry *Entry) fireHooks() { … }

func (entry *Entry) write() { … }

// 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 Entry.Panic or Entry.Fatal should be used instead.
func (entry *Entry) Log(level Level, args ...interface{ … }

func (entry *Entry) Trace(args ...interface{ … }

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

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

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

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

func (entry *Entry) Warning(args ...interface{ … }

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

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

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

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

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

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

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

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

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

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

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

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

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

func (entry *Entry) Logln(level Level, args ...interface{ … }

func (entry *Entry) Traceln(args ...interface{ … }

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

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

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

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

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

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

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

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

// Sprintlnn => Sprint no newline. This is to get the behavior of how
// fmt.Sprintln where spaces are always added between operands, regardless of
// their type. Instead of vendoring the Sprintln implementation to spare a
// string allocation, we do the simplest thing.
func (entry *Entry) sprintlnn(args ...interface{ … }