self-hosted/minio
self-hosted/minio
1
0
Fork 0
mirror of https://github.com/minio/minio synced 2024-09-15 22:20:34 +00:00
Code Issues Packages Projects Releases Wiki Activity
minio/cmd/http-tracer.go

251 lines
6.6 KiB
Go
Raw Normal View History

update license change for MinIO Signed-off-by: Harshavardhana <harsha@minio.io>
2021-04-18 19:41:13 +00:00
// Copyright (c) 2015-2021 MinIO, Inc.
//
// This file is part of MinIO Object Storage stack
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
log: Store http request/responses in a log file (#4804) When MINIO_TRACE_DIR is provided, create a new log file and store all HTTP requests + responses data, body are excluded to reduce memory consumption. MINIO_HTTP_TRACE=1 enables logging. Use non mem consuming http req/resp recorders, the maximum is about 32k per request. This logs to STDOUT, body logging is disabled for PutObject PutObjectPart GetObject.
2017-10-25 02:04:51 +00:00
Add admin API to send trace notifications to registered (#7128) Remove current functionality to log trace to file using MINIO_HTTP_TRACE env, and replace it with mc admin trace command on mc client.
2019-06-08 22:54:41 +00:00
package cmd
log: Store http request/responses in a log file (#4804) When MINIO_TRACE_DIR is provided, create a new log file and store all HTTP requests + responses data, body are excluded to reduce memory consumption. MINIO_HTTP_TRACE=1 enables logging. Use non mem consuming http req/resp recorders, the maximum is about 32k per request. This logs to STDOUT, body logging is disabled for PutObject PutObjectPart GetObject.
2017-10-25 02:04:51 +00:00
import (
"bytes"
Trace all http requests (#15064) Add a generic handler that adds a new tracing context to the request if tracing is enabled. Other handlers are free to modify the tracing context to update information on the fly, such as, func name, enable body logging etc.. With this commit, requests like this ``` curl -H "Host: ::1:3000" http://localhost:9000/ ``` will be traced as well.
2022-06-24 06:19:24 +00:00
"context"
log: Store http request/responses in a log file (#4804) When MINIO_TRACE_DIR is provided, create a new log file and store all HTTP requests + responses data, body are excluded to reduce memory consumption. MINIO_HTTP_TRACE=1 enables logging. Use non mem consuming http req/resp recorders, the maximum is about 32k per request. This logs to STDOUT, body logging is disabled for PutObject PutObjectPart GetObject.
2017-10-25 02:04:51 +00:00
"io"
Fix host address returned in admin API calls (#7846)
2019-07-06 03:41:35 +00:00
"net"
log: Store http request/responses in a log file (#4804) When MINIO_TRACE_DIR is provided, create a new log file and store all HTTP requests + responses data, body are excluded to reduce memory consumption. MINIO_HTTP_TRACE=1 enables logging. Use non mem consuming http req/resp recorders, the maximum is about 32k per request. This logs to STDOUT, body logging is disabled for PutObject PutObjectPart GetObject.
2017-10-25 02:04:51 +00:00
"net/http"
"reflect"
Redact LDAP password if any in request trace (#11750) Fixes: #11742
2021-03-09 22:43:16 +00:00
"regexp"
log: Store http request/responses in a log file (#4804) When MINIO_TRACE_DIR is provided, create a new log file and store all HTTP requests + responses data, body are excluded to reduce memory consumption. MINIO_HTTP_TRACE=1 enables logging. Use non mem consuming http req/resp recorders, the maximum is about 32k per request. This logs to STDOUT, body logging is disabled for PutObject PutObjectPart GetObject.
2017-10-25 02:04:51 +00:00
"runtime"
Add admin API to send trace notifications to registered (#7128) Remove current functionality to log trace to file using MINIO_HTTP_TRACE env, and replace it with mc admin trace command on mc client.
2019-06-08 22:54:41 +00:00
"strconv"
log: Store http request/responses in a log file (#4804) When MINIO_TRACE_DIR is provided, create a new log file and store all HTTP requests + responses data, body are excluded to reduce memory consumption. MINIO_HTTP_TRACE=1 enables logging. Use non mem consuming http req/resp recorders, the maximum is about 32k per request. This logs to STDOUT, body logging is disabled for PutObject PutObjectPart GetObject.
2017-10-25 02:04:51 +00:00
"strings"
"time"
Add admin API to send trace notifications to registered (#7128) Remove current functionality to log trace to file using MINIO_HTTP_TRACE env, and replace it with mc admin trace command on mc client.
2019-06-08 22:54:41 +00:00
move madmin to github.com/minio/madmin-go (#12239)
2021-05-06 15:52:02 +00:00
"github.com/minio/madmin-go"
rename all remaining packages to internal/ (#12418) This is to ensure that there are no projects that try to import `minio/minio/pkg` into their own repo. Any such common packages should go to `https://github.com/minio/pkg`
2021-06-01 21:59:40 +00:00
"github.com/minio/minio/internal/handlers"
"github.com/minio/minio/internal/logger"
log: Store http request/responses in a log file (#4804) When MINIO_TRACE_DIR is provided, create a new log file and store all HTTP requests + responses data, body are excluded to reduce memory consumption. MINIO_HTTP_TRACE=1 enables logging. Use non mem consuming http req/resp recorders, the maximum is about 32k per request. This logs to STDOUT, body logging is disabled for PutObject PutObjectPart GetObject.
2017-10-25 02:04:51 +00:00
)
// recordRequest - records the first recLen bytes
// of a given io.Reader
type recordRequest struct {
// Data source to record
io.Reader
// Response body should be logged
logBody bool
// Internal recording buffer
buf bytes.Buffer
trace api: add call stats to trace (#7915) Stats such as call latency, bytes received and sent have been added
2019-07-18 22:29:17 +00:00
// total bytes read including header size
bytesRead int
log: Store http request/responses in a log file (#4804) When MINIO_TRACE_DIR is provided, create a new log file and store all HTTP requests + responses data, body are excluded to reduce memory consumption. MINIO_HTTP_TRACE=1 enables logging. Use non mem consuming http req/resp recorders, the maximum is about 32k per request. This logs to STDOUT, body logging is disabled for PutObject PutObjectPart GetObject.
2017-10-25 02:04:51 +00:00
}
feat: Add RX/TX to audit logging (#13382) add additional values for audit logging
2021-10-08 02:03:46 +00:00
func (r *recordRequest) Close() error {
// no-op
return nil
}
log: Store http request/responses in a log file (#4804) When MINIO_TRACE_DIR is provided, create a new log file and store all HTTP requests + responses data, body are excluded to reduce memory consumption. MINIO_HTTP_TRACE=1 enables logging. Use non mem consuming http req/resp recorders, the maximum is about 32k per request. This logs to STDOUT, body logging is disabled for PutObject PutObjectPart GetObject.
2017-10-25 02:04:51 +00:00
func (r *recordRequest) Read(p []byte) (n int, err error) {
n, err = r.Reader.Read(p)
trace api: add call stats to trace (#7915) Stats such as call latency, bytes received and sent have been added
2019-07-18 22:29:17 +00:00
r.bytesRead += n
log: Store http request/responses in a log file (#4804) When MINIO_TRACE_DIR is provided, create a new log file and store all HTTP requests + responses data, body are excluded to reduce memory consumption. MINIO_HTTP_TRACE=1 enables logging. Use non mem consuming http req/resp recorders, the maximum is about 32k per request. This logs to STDOUT, body logging is disabled for PutObject PutObjectPart GetObject.
2017-10-25 02:04:51 +00:00
if r.logBody {
r.buf.Write(p[:n])
}
if err != nil {
return n, err
}
return n, err
}
feat: Add RX/TX to audit logging (#13382) add additional values for audit logging
2021-10-08 02:03:46 +00:00
Trace all http requests (#15064) Add a generic handler that adds a new tracing context to the request if tracing is enabled. Other handlers are free to modify the tracing context to update information on the fly, such as, func name, enable body logging etc.. With this commit, requests like this ``` curl -H "Host: ::1:3000" http://localhost:9000/ ``` will be traced as well.
2022-06-24 06:19:24 +00:00
func (r *recordRequest) BodySize() int {
return r.bytesRead
trace api: add call stats to trace (#7915) Stats such as call latency, bytes received and sent have been added
2019-07-18 22:29:17 +00:00
}
log: Store http request/responses in a log file (#4804) When MINIO_TRACE_DIR is provided, create a new log file and store all HTTP requests + responses data, body are excluded to reduce memory consumption. MINIO_HTTP_TRACE=1 enables logging. Use non mem consuming http req/resp recorders, the maximum is about 32k per request. This logs to STDOUT, body logging is disabled for PutObject PutObjectPart GetObject.
2017-10-25 02:04:51 +00:00
// Return the bytes that were recorded.
func (r *recordRequest) Data() []byte {
Log error response even if a handler doesn't logBody (#7867)
2019-07-10 18:49:02 +00:00
// If body logging is enabled then we return the actual body
if r.logBody {
return r.buf.Bytes()
}
// ... otherwise we return <BODY> placeholder
Cleanup ResponseWriter function for audit and trace (#8283)
2019-09-23 20:34:28 +00:00
return logger.BodyPlaceHolder
log: Store http request/responses in a log file (#4804) When MINIO_TRACE_DIR is provided, create a new log file and store all HTTP requests + responses data, body are excluded to reduce memory consumption. MINIO_HTTP_TRACE=1 enables logging. Use non mem consuming http req/resp recorders, the maximum is about 32k per request. This logs to STDOUT, body logging is disabled for PutObject PutObjectPart GetObject.
2017-10-25 02:04:51 +00:00
}
Redact LDAP password if any in request trace (#11750) Fixes: #11742
2021-03-09 22:43:16 +00:00
var ldapPwdRegex = regexp.MustCompile("(^.*?)LDAPPassword=([^&]*?)(&(.*?))?$")
// redact LDAP password if part of string
func redactLDAPPwd(s string) string {
parts := ldapPwdRegex.FindStringSubmatch(s)
if len(parts) > 0 {
return parts[1] + "LDAPPassword=*REDACTED*" + parts[3]
}
return s
}
Trace: Replace function name with API prefix (#7794) This change is required for `Admin Trace`
2019-06-18 20:55:13 +00:00
// getOpName sanitizes the operation name for mc
func getOpName(name string) (op string) {
op = strings.TrimPrefix(name, "github.com/minio/minio/cmd.")
op = strings.TrimSuffix(op, "Handler-fm")
op = strings.Replace(op, "objectAPIHandlers", "s3", 1)
op = strings.Replace(op, "adminAPIHandlers", "admin", 1)
Revert "deprecate embedded browser (#12163)" This reverts commit 736d8cbac483d8bf56c3422ca9a9c4c3e043c6cf. Bring contrib files for older contributions
2021-04-30 02:01:43 +00:00
op = strings.Replace(op, "(*webAPIHandlers)", "web", 1)
Trace: Replace function name with API prefix (#7794) This change is required for `Admin Trace`
2019-06-18 20:55:13 +00:00
op = strings.Replace(op, "(*storageRESTServer)", "internal", 1)
op = strings.Replace(op, "(*peerRESTServer)", "internal", 1)
op = strings.Replace(op, "(*lockRESTServer)", "internal", 1)
accessKeyId missing should return appropriate error in AssumeRole (#9048) For a non-existent user server would return STS not initialized ``` aws --profile harsha --endpoint-url http://localhost:9000 \ sts assume-role \ --role-arn arn:xxx:xxx:xxx:xxxx \ --role-session-name anything ``` instead return an appropriate error as expected by STS API Additionally also format the `trace` output for STS APIs
2020-02-26 20:26:47 +00:00
op = strings.Replace(op, "(*stsAPIHandlers)", "sts", 1)
Trace: Replace function name with API prefix (#7794) This change is required for `Admin Trace`
2019-06-18 20:55:13 +00:00
op = strings.Replace(op, "LivenessCheckHandler", "healthcheck", 1)
op = strings.Replace(op, "ReadinessCheckHandler", "healthcheck", 1)
accessKeyId missing should return appropriate error in AssumeRole (#9048) For a non-existent user server would return STS not initialized ``` aws --profile harsha --endpoint-url http://localhost:9000 \ sts assume-role \ --role-arn arn:xxx:xxx:xxx:xxxx \ --role-session-name anything ``` instead return an appropriate error as expected by STS API Additionally also format the `trace` output for STS APIs
2020-02-26 20:26:47 +00:00
op = strings.Replace(op, "-fm", "", 1)
Trace: Replace function name with API prefix (#7794) This change is required for `Admin Trace`
2019-06-18 20:55:13 +00:00
return op
}
Trace all http requests (#15064) Add a generic handler that adds a new tracing context to the request if tracing is enabled. Other handlers are free to modify the tracing context to update information on the fly, such as, func name, enable body logging etc.. With this commit, requests like this ``` curl -H "Host: ::1:3000" http://localhost:9000/ ``` will be traced as well.
2022-06-24 06:19:24 +00:00
type contextTraceReqType string
trace api: add call stats to trace (#7915) Stats such as call latency, bytes received and sent have been added
2019-07-18 22:29:17 +00:00
Trace all http requests (#15064) Add a generic handler that adds a new tracing context to the request if tracing is enabled. Other handlers are free to modify the tracing context to update information on the fly, such as, func name, enable body logging etc.. With this commit, requests like this ``` curl -H "Host: ::1:3000" http://localhost:9000/ ``` will be traced as well.
2022-06-24 06:19:24 +00:00
const contextTraceReqKey = contextTraceReqType("request-trace-info")
trace: Add storage & OS tracing (#11889)
2021-03-27 06:24:07 +00:00
Trace all http requests (#15064) Add a generic handler that adds a new tracing context to the request if tracing is enabled. Other handlers are free to modify the tracing context to update information on the fly, such as, func name, enable body logging etc.. With this commit, requests like this ``` curl -H "Host: ::1:3000" http://localhost:9000/ ``` will be traced as well.
2022-06-24 06:19:24 +00:00
// Hold related tracing data of a http request, any handler
// can modify this struct to modify the trace information .
type traceCtxt struct {
requestRecorder *recordRequest
responseRecorder *logger.ResponseWriter
funcName string
}
trace: Add storage & OS tracing (#11889)
2021-03-27 06:24:07 +00:00
Trace all http requests (#15064) Add a generic handler that adds a new tracing context to the request if tracing is enabled. Other handlers are free to modify the tracing context to update information on the fly, such as, func name, enable body logging etc.. With this commit, requests like this ``` curl -H "Host: ::1:3000" http://localhost:9000/ ``` will be traced as well.
2022-06-24 06:19:24 +00:00
// If trace is enabled, execute the request if it is traced by other handlers
// otherwise, generate a trace event with request information but no response.
func httpTracer(h http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if globalTrace.NumSubscribers() == 0 {
h.ServeHTTP(w, r)
return
}
trace: enhance trace experience further
2021-03-27 20:19:14 +00:00
Trace all http requests (#15064) Add a generic handler that adds a new tracing context to the request if tracing is enabled. Other handlers are free to modify the tracing context to update information on the fly, such as, func name, enable body logging etc.. With this commit, requests like this ``` curl -H "Host: ::1:3000" http://localhost:9000/ ``` will be traced as well.
2022-06-24 06:19:24 +00:00
// Create tracing data structure and associate it to the request context
tc := traceCtxt{}
ctx := context.WithValue(r.Context(), contextTraceReqKey, &tc)
r = r.WithContext(ctx)
// Setup a http request and response body recorder
reqRecorder := &recordRequest{Reader: r.Body}
respRecorder := logger.NewResponseWriter(w)
tc.requestRecorder = reqRecorder
tc.responseRecorder = respRecorder
trace: enhance trace experience further
2021-03-27 20:19:14 +00:00
Trace all http requests (#15064) Add a generic handler that adds a new tracing context to the request if tracing is enabled. Other handlers are free to modify the tracing context to update information on the fly, such as, func name, enable body logging etc.. With this commit, requests like this ``` curl -H "Host: ::1:3000" http://localhost:9000/ ``` will be traced as well.
2022-06-24 06:19:24 +00:00
// Execute call.
r.Body = reqRecorder
reqStartTime := time.Now().UTC()
h.ServeHTTP(respRecorder, r)
reqEndTime := time.Now().UTC()
// Calculate input body size with headers
reqHeaders := r.Header.Clone()
reqHeaders.Set("Host", r.Host)
if len(r.TransferEncoding) == 0 {
reqHeaders.Set("Content-Length", strconv.Itoa(int(r.ContentLength)))
} else {
reqHeaders.Set("Transfer-Encoding", strings.Join(r.TransferEncoding, ","))
}
inputBytes := reqRecorder.BodySize()
for k, v := range reqHeaders {
inputBytes += len(k) + len(v)
trace: enhance trace experience further
2021-03-27 20:19:14 +00:00
}
trace: Add storage & OS tracing (#11889)
2021-03-27 06:24:07 +00:00
Trace all http requests (#15064) Add a generic handler that adds a new tracing context to the request if tracing is enabled. Other handlers are free to modify the tracing context to update information on the fly, such as, func name, enable body logging etc.. With this commit, requests like this ``` curl -H "Host: ::1:3000" http://localhost:9000/ ``` will be traced as well.
2022-06-24 06:19:24 +00:00
// Calculate node name
nodeName := r.Host
if nodeName == "" || globalIsDistErasure {
nodeName = globalLocalNodeName
}
if host, port, err := net.SplitHostPort(nodeName); err == nil {
if port == "443" || port == "80" {
nodeName = host
}
}
Fix incorrect request start time (#10516) Log request start time BEFORE starting processing the request
2020-09-18 16:30:52 +00:00
Trace all http requests (#15064) Add a generic handler that adds a new tracing context to the request if tracing is enabled. Other handlers are free to modify the tracing context to update information on the fly, such as, func name, enable body logging etc.. With this commit, requests like this ``` curl -H "Host: ::1:3000" http://localhost:9000/ ``` will be traced as well.
2022-06-24 06:19:24 +00:00
// Calculate reqPath
reqPath := r.URL.RawPath
if reqPath == "" {
reqPath = r.URL.Path
}
fix: missing path in admin trace (#12373) PR #12360 introduced a change which seems to have added a regression, the RawPath in r.URL seems to be empty, if it is fallback to r.URL.Path instead.
2021-05-26 15:04:12 +00:00
Trace all http requests (#15064) Add a generic handler that adds a new tracing context to the request if tracing is enabled. Other handlers are free to modify the tracing context to update information on the fly, such as, func name, enable body logging etc.. With this commit, requests like this ``` curl -H "Host: ::1:3000" http://localhost:9000/ ``` will be traced as well.
2022-06-24 06:19:24 +00:00
// Calculate function name
funcName := tc.funcName
if funcName == "" {
funcName = "<unknown>"
}
Fix incorrect request start time (#10516) Log request start time BEFORE starting processing the request
2020-09-18 16:30:52 +00:00
Trace all http requests (#15064) Add a generic handler that adds a new tracing context to the request if tracing is enabled. Other handlers are free to modify the tracing context to update information on the fly, such as, func name, enable body logging etc.. With this commit, requests like this ``` curl -H "Host: ::1:3000" http://localhost:9000/ ``` will be traced as well.
2022-06-24 06:19:24 +00:00
rq := madmin.TraceRequestInfo{
Time: reqStartTime,
Proto: r.Proto,
Method: r.Method,
RawQuery: redactLDAPPwd(r.URL.RawQuery),
Client: handlers.GetSourceIP(r),
Headers: reqHeaders,
Path: reqPath,
Body: reqRecorder.Data(),
}
Fix incorrect request start time (#10516) Log request start time BEFORE starting processing the request
2020-09-18 16:30:52 +00:00
Trace all http requests (#15064) Add a generic handler that adds a new tracing context to the request if tracing is enabled. Other handlers are free to modify the tracing context to update information on the fly, such as, func name, enable body logging etc.. With this commit, requests like this ``` curl -H "Host: ::1:3000" http://localhost:9000/ ``` will be traced as well.
2022-06-24 06:19:24 +00:00
rs := madmin.TraceResponseInfo{
Time: reqEndTime,
Headers: respRecorder.Header().Clone(),
StatusCode: respRecorder.StatusCode,
Body: respRecorder.Body(),
}
Log error response even if a handler doesn't logBody (#7867)
2019-07-10 18:49:02 +00:00
Trace all http requests (#15064) Add a generic handler that adds a new tracing context to the request if tracing is enabled. Other handlers are free to modify the tracing context to update information on the fly, such as, func name, enable body logging etc.. With this commit, requests like this ``` curl -H "Host: ::1:3000" http://localhost:9000/ ``` will be traced as well.
2022-06-24 06:19:24 +00:00
cs := madmin.TraceCallStats{
Latency: rs.Time.Sub(respRecorder.StartTime),
InputBytes: inputBytes,
OutputBytes: respRecorder.Size(),
TimeToFirstByte: respRecorder.TimeToFirstByte,
}
Fix incorrect request start time (#10516) Log request start time BEFORE starting processing the request
2020-09-18 16:30:52 +00:00
Trace all http requests (#15064) Add a generic handler that adds a new tracing context to the request if tracing is enabled. Other handlers are free to modify the tracing context to update information on the fly, such as, func name, enable body logging etc.. With this commit, requests like this ``` curl -H "Host: ::1:3000" http://localhost:9000/ ``` will be traced as well.
2022-06-24 06:19:24 +00:00
t := madmin.TraceInfo{
TraceType: madmin.TraceHTTP,
FuncName: funcName,
NodeName: nodeName,
Time: reqStartTime,
ReqInfo: rq,
RespInfo: rs,
CallStats: cs,
}
Log error response even if a handler doesn't logBody (#7867)
2019-07-10 18:49:02 +00:00
Trace all http requests (#15064) Add a generic handler that adds a new tracing context to the request if tracing is enabled. Other handlers are free to modify the tracing context to update information on the fly, such as, func name, enable body logging etc.. With this commit, requests like this ``` curl -H "Host: ::1:3000" http://localhost:9000/ ``` will be traced as well.
2022-06-24 06:19:24 +00:00
globalTrace.Publish(t)
})
}
func httpTrace(f http.HandlerFunc, logBody bool) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
tc, ok := r.Context().Value(contextTraceReqKey).(*traceCtxt)
if !ok {
// Tracing is not enabled for this request
f.ServeHTTP(w, r)
return
}
tc.funcName = getOpName(runtime.FuncForPC(reflect.ValueOf(f).Pointer()).Name())
tc.requestRecorder.logBody = logBody
tc.responseRecorder.LogAllBody = logBody
tc.responseRecorder.LogErrBody = true
trace api: add call stats to trace (#7915) Stats such as call latency, bytes received and sent have been added
2019-07-18 22:29:17 +00:00
Trace all http requests (#15064) Add a generic handler that adds a new tracing context to the request if tracing is enabled. Other handlers are free to modify the tracing context to update information on the fly, such as, func name, enable body logging etc.. With this commit, requests like this ``` curl -H "Host: ::1:3000" http://localhost:9000/ ``` will be traced as well.
2022-06-24 06:19:24 +00:00
f.ServeHTTP(w, r)
Allow audit logging to work while tracing (#8077) It is observed that when `mc admin trace` is being used due to ResponseWriter wrapper, we loose information about statusCode,statusText for audit logging. This PR fixes this behavior
2019-08-15 23:17:46 +00:00
}
Trace all http requests (#15064) Add a generic handler that adds a new tracing context to the request if tracing is enabled. Other handlers are free to modify the tracing context to update information on the fly, such as, func name, enable body logging etc.. With this commit, requests like this ``` curl -H "Host: ::1:3000" http://localhost:9000/ ``` will be traced as well.
2022-06-24 06:19:24 +00:00
}
func httpTraceAll(f http.HandlerFunc) http.HandlerFunc {
return httpTrace(f, true)
}
func httpTraceHdrs(f http.HandlerFunc) http.HandlerFunc {
return httpTrace(f, false)
log: Store http request/responses in a log file (#4804) When MINIO_TRACE_DIR is provided, create a new log file and store all HTTP requests + responses data, body are excluded to reduce memory consumption. MINIO_HTTP_TRACE=1 enables logging. Use non mem consuming http req/resp recorders, the maximum is about 32k per request. This logs to STDOUT, body logging is disabled for PutObject PutObjectPart GetObject.
2017-10-25 02:04:51 +00:00
}
Reference in a new issue Copy permalink