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 }