| package aws |
| |
| import ( |
| "log" |
| "os" |
| ) |
| |
| // A LogLevelType defines the level logging should be performed at. Used to instruct |
| // the SDK which statements should be logged. |
| type LogLevelType uint |
| |
| // LogLevel returns the pointer to a LogLevel. Should be used to workaround |
| // not being able to take the address of a non-composite literal. |
| func LogLevel(l LogLevelType) *LogLevelType { |
| return &l |
| } |
| |
| // Value returns the LogLevel value or the default value LogOff if the LogLevel |
| // is nil. Safe to use on nil value LogLevelTypes. |
| func (l *LogLevelType) Value() LogLevelType { |
| if l != nil { |
| return *l |
| } |
| return LogOff |
| } |
| |
| // Matches returns true if the v LogLevel is enabled by this LogLevel. Should be |
| // used with logging sub levels. Is safe to use on nil value LogLevelTypes. If |
| // LogLevel is nil, will default to LogOff comparison. |
| func (l *LogLevelType) Matches(v LogLevelType) bool { |
| c := l.Value() |
| return c&v == v |
| } |
| |
| // AtLeast returns true if this LogLevel is at least high enough to satisfies v. |
| // Is safe to use on nil value LogLevelTypes. If LogLevel is nil, will default |
| // to LogOff comparison. |
| func (l *LogLevelType) AtLeast(v LogLevelType) bool { |
| c := l.Value() |
| return c >= v |
| } |
| |
| const ( |
| // LogOff states that no logging should be performed by the SDK. This is the |
| // default state of the SDK, and should be use to disable all logging. |
| LogOff LogLevelType = iota * 0x1000 |
| |
| // LogDebug state that debug output should be logged by the SDK. This should |
| // be used to inspect request made and responses received. |
| LogDebug |
| ) |
| |
| // Debug Logging Sub Levels |
| const ( |
| // LogDebugWithSigning states that the SDK should log request signing and |
| // presigning events. This should be used to log the signing details of |
| // requests for debugging. Will also enable LogDebug. |
| LogDebugWithSigning LogLevelType = LogDebug | (1 << iota) |
| |
| // LogDebugWithHTTPBody states the SDK should log HTTP request and response |
| // HTTP bodys in addition to the headers and path. This should be used to |
| // see the body content of requests and responses made while using the SDK |
| // Will also enable LogDebug. |
| LogDebugWithHTTPBody |
| |
| // LogDebugWithRequestRetries states the SDK should log when service requests will |
| // be retried. This should be used to log when you want to log when service |
| // requests are being retried. Will also enable LogDebug. |
| LogDebugWithRequestRetries |
| |
| // LogDebugWithRequestErrors states the SDK should log when service requests fail |
| // to build, send, validate, or unmarshal. |
| LogDebugWithRequestErrors |
| |
| // LogDebugWithEventStreamBody states the SDK should log EventStream |
| // request and response bodys. This should be used to log the EventStream |
| // wire unmarshaled message content of requests and responses made while |
| // using the SDK Will also enable LogDebug. |
| LogDebugWithEventStreamBody |
| ) |
| |
| // A Logger is a minimalistic interface for the SDK to log messages to. Should |
| // be used to provide custom logging writers for the SDK to use. |
| type Logger interface { |
| Log(...interface{}) |
| } |
| |
| // A LoggerFunc is a convenience type to convert a function taking a variadic |
| // list of arguments and wrap it so the Logger interface can be used. |
| // |
| // Example: |
| // s3.New(sess, &aws.Config{Logger: aws.LoggerFunc(func(args ...interface{}) { |
| // fmt.Fprintln(os.Stdout, args...) |
| // })}) |
| type LoggerFunc func(...interface{}) |
| |
| // Log calls the wrapped function with the arguments provided |
| func (f LoggerFunc) Log(args ...interface{}) { |
| f(args...) |
| } |
| |
| // NewDefaultLogger returns a Logger which will write log messages to stdout, and |
| // use same formatting runes as the stdlib log.Logger |
| func NewDefaultLogger() Logger { |
| return &defaultLogger{ |
| logger: log.New(os.Stdout, "", log.LstdFlags), |
| } |
| } |
| |
| // A defaultLogger provides a minimalistic logger satisfying the Logger interface. |
| type defaultLogger struct { |
| logger *log.Logger |
| } |
| |
| // Log logs the parameters to the stdlib logger. See log.Println. |
| func (l defaultLogger) Log(args ...interface{}) { |
| l.logger.Println(args...) |
| } |