jesseduffield.lazygit/vendor/github.com/sirupsen/logrus/entry.go

package logrus

import (
	"bytes"
	"context"
	"fmt"
	"maps"
	"os"
	"reflect"
	"runtime"
	"strconv"
	"strings"
	"sync"
	"time"
)

var (

	// qualified package name, cached at first use
	logrusPackage string

	// Positions in the call stack when tracing to report the calling method.
	//
	// Start at the bottom of the stack before the package-name cache is primed.
	minimumCallerDepth = 1

	// Used for caller information initialisation
	callerInitOnce sync.Once
)

const (
	maximumCallerDepth int = 25
	knownLogrusFrames  int = 4
)

// ErrorKey defines the key when adding errors using [WithError], [Logger.WithError].
var ErrorKey = "error"

// Entry represents a single log event. It may be either an intermediate
// entry (created via WithField(s), WithContext, etc.) or a final entry
// that is emitted when one of the level methods (Trace, Debug, Info,
// Warn, Error, Fatal, Panic) is called.
//
// An Entry always belongs to a Logger. A nil Logger is invalid and will
// cause a panic when the entry is logged. Use [NewEntry] or Logger methods
// to construct entries.
//
// Entries are safe to reuse for adding fields and may be passed around
// to avoid field duplication. Each log operation operates on a copy
// of the Entry’s data to avoid mutation during formatting.
//
//nolint:recvcheck // Entry methods intentionally use both pointer and value receivers.
type Entry struct {
	// Logger is the Logger that owns this entry and is responsible for
	// formatting, hooks, and output. It must not be nil. An Entry without
	// a Logger is invalid and will panic when logged.
	Logger *Logger

	// Data contains all user-defined fields attached to this entry.
	Data Fields

	// Time is the timestamp for the log event. If zero when the entry is
	// logged, it defaults to the current time.
	Time time.Time

	// Level is the severity of the log entry. It is set when the entry
	// is fired and reflects the level used for that log call.
	Level Level

	// Caller contains the calling method information.
	//
	// When [Logger.ReportCaller] is enabled, Caller is populated automatically at
	// log time if it is nil. Hooks and formatters may inspect Caller.
	//
	// Applications generally should not modify Caller unless they intentionally
	// want to provide custom caller information.
	Caller *runtime.Frame

	// Message is the log message supplied to one of the logging methods
	// (Trace, Debug, Info, Warn, Error, Fatal, or Panic). It is set when
	// the entry is logged.
	Message string

	// Buffer is a reusable buffer provided to the formatter. It is set
	// before formatting in the normal log path; when nil, formatters
	// allocate their own.
	Buffer *bytes.Buffer

	// Context carries user-provided context for hooks and formatters.
	Context context.Context

	// err contains internal field-formatting errors.
	err string
}

// NewEntry creates a new [Entry] associated with the provided Logger.
// The logger must not be nil. Passing a nil logger results in a
// panic when a logging method (e.g., [Entry.Info], [Entry.Error], etc.)
// is called.
func NewEntry(logger *Logger) *Entry {
	return &Entry{
		Logger: logger,
		// Reserve default predefined fields and a little extra room.
		Data: make(Fields, defaultFields+3),
	}
}

// Dup creates a copy of the entry for further modification.
//
// Data is cloned to avoid mutating the original entry. Other fields
// (Logger, Time, Context, etc.) are copied by value.
func (entry *Entry) Dup() *Entry {
	dup := entry.dup()
	dup.Data = maps.Clone(entry.Data)
	return dup
}

// dup copies the entry fields shared by derived entries except Data, which
// callers must copy or initialize as appropriate for their use.
func (entry *Entry) dup() *Entry {
	return &Entry{
		Logger:  entry.Logger,
		Time:    entry.Time,
		Caller:  entry.Caller,
		Context: entry.Context,
		err:     entry.err,
	}
}

// Bytes returns the bytes representation of this entry from the formatter.
func (entry *Entry) Bytes() ([]byte, error) {
	// Snapshot the formatter under the lock to protect against concurrent
	// SetFormatter calls, then release the lock before formatting.
	// This avoids a data race and prevents a deadlock if Format() triggers
	// reentrant logging (e.g., a field's MarshalJSON calls logrus).
	//
	// See:
	//
	// - https://github.com/sirupsen/logrus/issues/1440
	// - https://github.com/sirupsen/logrus/issues/1448
	entry.Logger.mu.Lock()
	formatter := entry.Logger.Formatter
	entry.Logger.mu.Unlock()

	return formatter.Format(entry)
}

// String returns the string representation from the reader and ultimately the
// formatter.
func (entry *Entry) String() (string, error) {
	serialized, err := entry.Bytes()
	if err != nil {
		return "", err
	}
	str := string(serialized)
	return str, nil
}

// WithError adds an error as single field (using the key defined in [ErrorKey])
// to the Entry.
func (entry *Entry) WithError(err error) *Entry {
	return entry.WithField(ErrorKey, err)
}

// WithContext adds a context to the Entry.
func (entry *Entry) WithContext(ctx context.Context) *Entry {
	dup := entry.dup()
	dup.Data = maps.Clone(entry.Data)
	dup.Context = ctx
	return dup
}

// WithField adds a single field to the Entry.
func (entry *Entry) WithField(key string, value any) *Entry {
	dup := entry.dup()
	dup.Data = maps.Clone(entry.Data)
	dup.addField(key, value)
	return dup
}

// WithFields adds a map of fields to the Entry.
func (entry *Entry) WithFields(fields Fields) *Entry {
	dup := entry.dup()
	dup.Data = make(Fields, len(entry.Data)+len(fields))
	maps.Copy(dup.Data, entry.Data)

	for key, value := range fields {
		dup.addField(key, value)
	}
	return dup
}

// WithTime overrides the time of the Entry.
func (entry *Entry) WithTime(t time.Time) *Entry {
	dup := entry.dup()
	dup.Data = maps.Clone(entry.Data)
	dup.Time = t
	return dup
}

func (entry *Entry) addField(key string, value any) {
	if _, ok := value.(error); !ok {
		t := reflect.TypeOf(value)
		if t != nil && (t.Kind() == reflect.Func || t.Kind() == reflect.Pointer && t.Elem().Kind() == reflect.Func) {
			if entry.err != "" {
				entry.err += ", skipping unsupported field " + strconv.Quote(key)
			} else {
				entry.err = "skipping unsupported field " + strconv.Quote(key)
			}
			return
		}
	}

	if entry.Data == nil {
		entry.Data = make(Fields, 1)
	}
	entry.Data[key] = value
}

// getPackageName reduces a fully qualified function name to the package name
// There really ought to be a better way...
func getPackageName(f string) string {
	for {
		lastPeriod := strings.LastIndex(f, ".")
		lastSlash := strings.LastIndex(f, "/")
		if lastPeriod > lastSlash {
			f = f[:lastPeriod]
		} else {
			break
		}
	}

	return f
}

// getCaller retrieves the name of the first non-logrus calling function
func getCaller() *runtime.Frame {
	// cache this package's fully-qualified name
	callerInitOnce.Do(func() {
		pcs := make([]uintptr, maximumCallerDepth)
		_ = runtime.Callers(0, pcs)

		// dynamic get the package name and the minimum caller depth
		for i := range maximumCallerDepth {
			funcName := runtime.FuncForPC(pcs[i]).Name()
			if strings.Contains(funcName, "getCaller") {
				logrusPackage = getPackageName(funcName)
				break
			}
		}

		minimumCallerDepth = knownLogrusFrames
	})

	// Restrict the lookback frames to avoid runaway lookups
	pcs := make([]uintptr, maximumCallerDepth)
	depth := runtime.Callers(minimumCallerDepth, pcs)
	frames := runtime.CallersFrames(pcs[:depth])

	for f, again := frames.Next(); again; f, again = frames.Next() {
		pkg := getPackageName(f.Function)

		// If the caller isn't part of this package, we're done
		if pkg != logrusPackage {
			return &f
		}
	}

	// if we got here, we failed to find the caller's context
	return nil
}

// HasCaller reports whether this Entry contains caller information.
//
// Caller may be set explicitly, or populated at log time when
// [Logger.ReportCaller] is enabled.
//
// Deprecated: use [Entry.Caller] != nil instead.
//
//go:fix inline
func (entry Entry) HasCaller() bool {
	return entry.Caller != nil
}

func (entry *Entry) logArgs(level Level, panicAfter bool, args ...any) {
	entry.log(level, panicAfter, sprint(args...))
}

func (entry *Entry) logf(level Level, panicAfter bool, format string, args ...any) {
	entry.log(level, panicAfter, fmt.Sprintf(format, args...))
}

// logln uses Sprintln for multiple arguments to preserve Println-style
// spacing between args, then trims the trailing newline.
func (entry *Entry) logln(level Level, panicAfter bool, args ...any) {
	if len(args) <= 1 {
		entry.log(level, panicAfter, sprint(args...))
		return
	}
	msg := fmt.Sprintln(args...)
	msg = msg[:len(msg)-1] // Trim the newline added by Sprintln; logging adds its own.
	entry.log(level, panicAfter, msg)
}

// log writes msg at level. If panicAfter is true, it panics with the fully
// populated entry after hooks and output have completed.
//
// The explicit flag keeps panic behavior limited to Panic, Panicf, and
// Panicln while avoiding a return value used only as the panic value.
// See #1283 and commits f96066e and 5f8c666.
func (entry *Entry) log(level Level, panicAfter bool, msg string) {
	newEntry := entry.dup()
	newEntry.Data = maps.Clone(entry.Data)

	if newEntry.Time.IsZero() {
		newEntry.Time = time.Now()
	}

	newEntry.Level = level
	newEntry.Message = msg

	logger := newEntry.Logger
	logger.mu.Lock()
	reportCaller := logger.ReportCaller
	bufPool := newEntry.getBufferPool()
	logger.mu.Unlock()

	// Preserve explicitly set caller information.
	if reportCaller && newEntry.Caller == nil {
		newEntry.Caller = getCaller()
	}

	// Select hooks based on the level for this log call. Hooks receive the
	// Entry and may mutate it, but that does not affect which hooks are
	// fired for this event.
	hooks := logger.hooksForLevel(level)
	newEntry.fireHooks(hooks)

	buffer := bufPool.Get()
	defer func() {
		newEntry.Buffer = nil
		buffer.Reset()
		bufPool.Put(buffer)
	}()
	buffer.Reset()
	newEntry.Buffer = buffer
	newEntry.write()
	newEntry.Buffer = nil

	// Panic here so the panic value contains the fully populated entry without
	// requiring log to return it to the caller.
	if panicAfter {
		panic(newEntry)
	}
}

func (entry *Entry) getBufferPool() (pool BufferPool) {
	if entry.Logger.BufferPool != nil {
		return entry.Logger.BufferPool
	}
	return bufferPool
}

func (entry *Entry) fireHooks(hooks []Hook) {
	for _, hook := range hooks {
		if err := hook.Fire(entry); err != nil {
			_, _ = fmt.Fprintln(os.Stderr, "Failed to fire hook:", err)
			return
		}
	}
}

func (entry *Entry) write() {
	// Snapshot the formatter under the lock to protect against concurrent
	// SetFormatter calls, then release the lock before formatting.
	// This avoids a deadlock when Format() triggers reentrant logging (e.g.,
	// a field's MarshalJSON calls logrus). See #1448, #1440.
	entry.Logger.mu.Lock()
	formatter := entry.Logger.Formatter
	entry.Logger.mu.Unlock()

	serialized, err := formatter.Format(entry)
	if err != nil {
		_, _ = fmt.Fprintln(os.Stderr, "Failed to format entry:", err)
		return
	}

	// Re-acquire the lock to serialize writes to the underlying io.Writer.
	entry.Logger.mu.Lock()
	defer entry.Logger.mu.Unlock()
	if _, err := entry.Logger.Out.Write(serialized); err != nil {
		_, _ = fmt.Fprintln(os.Stderr, "Failed to write to log:", err)
	}
}

// Log logs a message at the specified level.
//
// Using Log with [PanicLevel] or [FatalLevel] intentionally does not
// trigger a panic or exit. Log treats the level as logging severity only;
// use [Entry.Panic] or [Entry.Fatal] when those side effects are desired.
func (entry *Entry) Log(level Level, args ...any) {
	const panicAfter = false
	if entry.Logger.IsLevelEnabled(level) {
		entry.logArgs(level, panicAfter, args...)
	}
}

func (entry *Entry) Trace(args ...any) {
	entry.Log(TraceLevel, args...)
}

func (entry *Entry) Debug(args ...any) {
	entry.Log(DebugLevel, args...)
}

func (entry *Entry) Print(args ...any) {
	entry.Info(args...)
}

func (entry *Entry) Info(args ...any) {
	entry.Log(InfoLevel, args...)
}

func (entry *Entry) Warn(args ...any) {
	entry.Log(WarnLevel, args...)
}

func (entry *Entry) Warning(args ...any) {
	entry.Warn(args...)
}

func (entry *Entry) Error(args ...any) {
	entry.Log(ErrorLevel, args...)
}

func (entry *Entry) Fatal(args ...any) {
	entry.Log(FatalLevel, args...)
	entry.Logger.Exit(1)
}

func (entry *Entry) Panic(args ...any) {
	const panicAfter = true
	if entry.Logger.IsLevelEnabled(PanicLevel) {
		entry.logArgs(PanicLevel, panicAfter, args...)
	}
}

// Entry Printf family functions

// Logf logs a formatted message at the specified level.
//
// Using Logf with [PanicLevel] or [FatalLevel] intentionally does not
// trigger a panic or exit. Logf treats the level as logging severity only;
// use [Entry.Panicf] or [Entry.Fatalf] when those side effects are desired.
func (entry *Entry) Logf(level Level, format string, args ...any) {
	const panicAfter = false
	if entry.Logger.IsLevelEnabled(level) {
		entry.logf(level, panicAfter, format, args...)
	}
}

func (entry *Entry) Tracef(format string, args ...any) {
	entry.Logf(TraceLevel, format, args...)
}

func (entry *Entry) Debugf(format string, args ...any) {
	entry.Logf(DebugLevel, format, args...)
}

func (entry *Entry) Infof(format string, args ...any) {
	entry.Logf(InfoLevel, format, args...)
}

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

func (entry *Entry) Warnf(format string, args ...any) {
	entry.Logf(WarnLevel, format, args...)
}

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

func (entry *Entry) Errorf(format string, args ...any) {
	entry.Logf(ErrorLevel, format, args...)
}

func (entry *Entry) Fatalf(format string, args ...any) {
	entry.Logf(FatalLevel, format, args...)
	entry.Logger.Exit(1)
}

func (entry *Entry) Panicf(format string, args ...any) {
	const panicAfter = true
	if entry.Logger.IsLevelEnabled(PanicLevel) {
		entry.logf(PanicLevel, panicAfter, format, args...)
	}
}

// Entry Println family functions

// Logln logs a message at the specified level with Println-style spacing.
//
// Using Logln with [PanicLevel] or [FatalLevel] intentionally does not
// trigger a panic or exit. Logln treats the level as logging severity only;
// use [Entry.Panicln] or [Entry.Fatalln] when those side effects are desired.
func (entry *Entry) Logln(level Level, args ...any) {
	const panicAfter = false
	if entry.Logger.IsLevelEnabled(level) {
		entry.logln(level, panicAfter, args...)
	}
}

func (entry *Entry) Traceln(args ...any) {
	entry.Logln(TraceLevel, args...)
}

func (entry *Entry) Debugln(args ...any) {
	entry.Logln(DebugLevel, args...)
}

func (entry *Entry) Infoln(args ...any) {
	entry.Logln(InfoLevel, args...)
}

func (entry *Entry) Println(args ...any) {
	entry.Infoln(args...)
}

func (entry *Entry) Warnln(args ...any) {
	entry.Logln(WarnLevel, args...)
}

func (entry *Entry) Warningln(args ...any) {
	entry.Warnln(args...)
}

func (entry *Entry) Errorln(args ...any) {
	entry.Logln(ErrorLevel, args...)
}

func (entry *Entry) Fatalln(args ...any) {
	entry.Logln(FatalLevel, args...)
	entry.Logger.Exit(1)
}

func (entry *Entry) Panicln(args ...any) {
	const panicAfter = true
	if entry.Logger.IsLevelEnabled(PanicLevel) {
		entry.logln(PanicLevel, panicAfter, args...)
	}
}

// sprint is fmt.Sprint with fast paths for zero or one string argument.
func sprint(args ...any) string {
	switch len(args) {
	case 0:
		return ""
	case 1:
		if msg, ok := args[0].(string); ok {
			return msg
		}
	}
	return fmt.Sprint(args...)
}