vendor/github.com/aws/aws-sdk-go/aws/client/logger.go

   1 package client
   2
   3 import (
   4         "bytes"
   5         "fmt"
   6         "io"
   7         "io/ioutil"
   8         "net/http/httputil"
   9
  10         "github.com/aws/aws-sdk-go/aws"
  11         "github.com/aws/aws-sdk-go/aws/request"
  12 )
  13
  14 const logReqMsg = `DEBUG: Request %s/%s Details:
  15 ---[ REQUEST POST-SIGN ]-----------------------------
  16 %s
  17 -----------------------------------------------------`
  18
  19 const logReqErrMsg = `DEBUG ERROR: Request %s/%s:
  20 ---[ REQUEST DUMP ERROR ]-----------------------------
  21 %s
  22 ------------------------------------------------------`
  23
  24 type logWriter struct {
  25         // Logger is what we will use to log the payload of a response.
  26         Logger aws.Logger
  27         // buf stores the contents of what has been read
  28         buf *bytes.Buffer
  29 }
  30
  31 func (logger *logWriter) Write(b []byte) (int, error) {
  32         return logger.buf.Write(b)
  33 }
  34
  35 type teeReaderCloser struct {
  36         // io.Reader will be a tee reader that is used during logging.
  37         // This structure will read from a body and write the contents to a logger.
  38         io.Reader
  39         // Source is used just to close when we are done reading.
  40         Source io.ReadCloser
  41 }
  42
  43 func (reader *teeReaderCloser) Close() error {
  44         return reader.Source.Close()
  45 }
  46
  47 // LogHTTPRequestHandler is a SDK request handler to log the HTTP request sent
  48 // to a service. Will include the HTTP request body if the LogLevel of the
  49 // request matches LogDebugWithHTTPBody.
  50 var LogHTTPRequestHandler = request.NamedHandler{
  51         Name: "awssdk.client.LogRequest",
  52         Fn:   logRequest,
  53 }
  54
  55 func logRequest(r *request.Request) {
  56         logBody := r.Config.LogLevel.Matches(aws.LogDebugWithHTTPBody)
  57         bodySeekable := aws.IsReaderSeekable(r.Body)
  58
  59         b, err := httputil.DumpRequestOut(r.HTTPRequest, logBody)
  60         if err != nil {
  61                 r.Config.Logger.Log(fmt.Sprintf(logReqErrMsg,
  62                         r.ClientInfo.ServiceName, r.Operation.Name, err))
  63                 return
  64         }
  65
  66         if logBody {
  67                 if !bodySeekable {
  68                         r.SetReaderBody(aws.ReadSeekCloser(r.HTTPRequest.Body))
  69                 }
  70                 // Reset the request body because dumpRequest will re-wrap the
  71                 // r.HTTPRequest's Body as a NoOpCloser and will not be reset after
  72                 // read by the HTTP client reader.
  73                 if err := r.Error; err != nil {
  74                         r.Config.Logger.Log(fmt.Sprintf(logReqErrMsg,
  75                                 r.ClientInfo.ServiceName, r.Operation.Name, err))
  76                         return
  77                 }
  78         }
  79
  80         r.Config.Logger.Log(fmt.Sprintf(logReqMsg,
  81                 r.ClientInfo.ServiceName, r.Operation.Name, string(b)))
  82 }
  83
  84 // LogHTTPRequestHeaderHandler is a SDK request handler to log the HTTP request sent
  85 // to a service. Will only log the HTTP request's headers. The request payload
  86 // will not be read.
  87 var LogHTTPRequestHeaderHandler = request.NamedHandler{
  88         Name: "awssdk.client.LogRequestHeader",
  89         Fn:   logRequestHeader,
  90 }
  91
  92 func logRequestHeader(r *request.Request) {
  93         b, err := httputil.DumpRequestOut(r.HTTPRequest, false)
  94         if err != nil {
  95                 r.Config.Logger.Log(fmt.Sprintf(logReqErrMsg,
  96                         r.ClientInfo.ServiceName, r.Operation.Name, err))
  97                 return
  98         }
  99
 100         r.Config.Logger.Log(fmt.Sprintf(logReqMsg,
 101                 r.ClientInfo.ServiceName, r.Operation.Name, string(b)))
 102 }
 103
 104 const logRespMsg = `DEBUG: Response %s/%s Details:
 105 ---[ RESPONSE ]--------------------------------------
 106 %s
 107 -----------------------------------------------------`
 108
 109 const logRespErrMsg = `DEBUG ERROR: Response %s/%s:
 110 ---[ RESPONSE DUMP ERROR ]-----------------------------
 111 %s
 112 -----------------------------------------------------`
 113
 114 // LogHTTPResponseHandler is a SDK request handler to log the HTTP response
 115 // received from a service. Will include the HTTP response body if the LogLevel
 116 // of the request matches LogDebugWithHTTPBody.
 117 var LogHTTPResponseHandler = request.NamedHandler{
 118         Name: "awssdk.client.LogResponse",
 119         Fn:   logResponse,
 120 }
 121
 122 func logResponse(r *request.Request) {
 123         lw := &logWriter{r.Config.Logger, bytes.NewBuffer(nil)}
 124
 125         if r.HTTPResponse == nil {
 126                 lw.Logger.Log(fmt.Sprintf(logRespErrMsg,
 127                         r.ClientInfo.ServiceName, r.Operation.Name, "request's HTTPResponse is nil"))
 128                 return
 129         }
 130
 131         logBody := r.Config.LogLevel.Matches(aws.LogDebugWithHTTPBody)
 132         if logBody {
 133                 r.HTTPResponse.Body = &teeReaderCloser{
 134                         Reader: io.TeeReader(r.HTTPResponse.Body, lw),
 135                         Source: r.HTTPResponse.Body,
 136                 }
 137         }
 138
 139         handlerFn := func(req *request.Request) {
 140                 b, err := httputil.DumpResponse(req.HTTPResponse, false)
 141                 if err != nil {
 142                         lw.Logger.Log(fmt.Sprintf(logRespErrMsg,
 143                                 req.ClientInfo.ServiceName, req.Operation.Name, err))
 144                         return
 145                 }
 146
 147                 lw.Logger.Log(fmt.Sprintf(logRespMsg,
 148                         req.ClientInfo.ServiceName, req.Operation.Name, string(b)))
 149
 150                 if logBody {
 151                         b, err := ioutil.ReadAll(lw.buf)
 152                         if err != nil {
 153                                 lw.Logger.Log(fmt.Sprintf(logRespErrMsg,
 154                                         req.ClientInfo.ServiceName, req.Operation.Name, err))
 155                                 return
 156                         }
 157
 158                         lw.Logger.Log(string(b))
 159                 }
 160         }
 161
 162         const handlerName = "awsdk.client.LogResponse.ResponseBody"
 163
 164         r.Handlers.Unmarshal.SetBackNamed(request.NamedHandler{
 165                 Name: handlerName, Fn: handlerFn,
 166         })
 167         r.Handlers.UnmarshalError.SetBackNamed(request.NamedHandler{
 168                 Name: handlerName, Fn: handlerFn,
 169         })
 170 }
 171
 172 // LogHTTPResponseHeaderHandler is a SDK request handler to log the HTTP
 173 // response received from a service. Will only log the HTTP response's headers.
 174 // The response payload will not be read.
 175 var LogHTTPResponseHeaderHandler = request.NamedHandler{
 176         Name: "awssdk.client.LogResponseHeader",
 177         Fn:   logResponseHeader,
 178 }
 179
 180 func logResponseHeader(r *request.Request) {
 181         if r.Config.Logger == nil {
 182                 return
 183         }
 184
 185         b, err := httputil.DumpResponse(r.HTTPResponse, false)
 186         if err != nil {
 187                 r.Config.Logger.Log(fmt.Sprintf(logRespErrMsg,
 188                         r.ClientInfo.ServiceName, r.Operation.Name, err))
 189                 return
 190         }
 191
 192         r.Config.Logger.Log(fmt.Sprintf(logRespMsg,
 193                 r.ClientInfo.ServiceName, r.Operation.Name, string(b)))
 194 }