github.com/mongodb/grip@v0.0.0-20240213223901-f906268d82b9/slogger/logger.go (about)

     1  package slogger
     2  
     3  import (
     4  	"errors"
     5  
     6  	"github.com/mongodb/grip/message"
     7  	"github.com/mongodb/grip/send"
     8  )
     9  
    10  // Logger is a type that represents a single log instance. This is
    11  // analogous to the original slogger's Logger type; however, the
    12  // Appender field stores a slice of sned.Senders rather than
    13  // slogger.Appenders; however, the Appender type is defined in the new
    14  // slogger, and the NewAppenderSender and WrapAppender functions
    15  // afford the conversion.
    16  type Logger struct {
    17  	Name      string
    18  	Appenders []send.Sender
    19  }
    20  
    21  // Logf logs a message and a level to a logger instance. This returns a
    22  // pointer to a Log and a slice of errors that were gathered from every
    23  // Appender (nil errors included).
    24  //
    25  // In this implementation, Logf will never return an error. This part
    26  // of the type definition was retained for backwards compatibility
    27  func (l *Logger) Logf(level Level, messageFmt string, args ...interface{}) (*Log, []error) {
    28  	m := newPrefixedLog(l.Name, message.NewFormattedMessage(level.Priority(), messageFmt, args...))
    29  
    30  	for _, send := range l.Appenders {
    31  		send.Send(m)
    32  	}
    33  
    34  	return m, []error{}
    35  }
    36  
    37  // Errorf logs and returns its message as an error.
    38  //
    39  // Log and return a formatted error string.
    40  // Example:i
    41  //
    42  //	if whatIsExpected != whatIsReturned {
    43  //	    return slogger.Errorf(slogger.WARN, "Unexpected return value. Expected: %v Received: %v",
    44  //	        whatIsExpected, whatIsReturned)
    45  //	}
    46  func (l *Logger) Errorf(level Level, messageFmt string, args ...interface{}) error {
    47  	m := message.NewFormattedMessage(level.Priority(), messageFmt, args...)
    48  	log := newPrefixedLog(l.Name, m)
    49  
    50  	for _, send := range l.Appenders {
    51  		send.Send(log)
    52  	}
    53  
    54  	return errors.New(m.String())
    55  }
    56  
    57  // Stackf is designed to work in tandem with `NewStackError`. This
    58  // function is similar to `Logf`, but takes a `stackErr`
    59  // parameter. `stackErr` is expected to be of type StackError, but does
    60  // not have to be.
    61  //
    62  // In this implementation, Logf will never return an error. This part
    63  // of the type definition was retained for backwards compatibility.
    64  //
    65  // An additional difference is that the new implementation, will not
    66  // log if the error is nil, and the previous implementation would.
    67  func (l *Logger) Stackf(level Level, stackErr error, messageFmt string, args ...interface{}) (*Log, []error) {
    68  	m := newPrefixedLog(l.Name, message.NewErrorWrapMessage(level.Priority(), stackErr, messageFmt, args...))
    69  
    70  	// this check is not necessary, but prevents redundancy if
    71  	// there are multiple senders, as each might need to perform this
    72  	// check for themselves.
    73  	if !m.Loggable() {
    74  		return m, []error{}
    75  	}
    76  
    77  	for _, send := range l.Appenders {
    78  		send.Send(m)
    79  	}
    80  
    81  	return m, []error{}
    82  }