text: 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...)
  }
  