api/layer/object.go

@@ -12,6 +12,7 @@ import (
 	"fmt"
 	"io"
 	"mime"
+	"net/http"
 	"path/filepath"
 	"strconv"
 	"strings"
@@ -21,6 +22,7 @@ import (
 	"git.frostfs.info/TrueCloudLab/frostfs-s3-gw/api/data"
 	apiErrors "git.frostfs.info/TrueCloudLab/frostfs-s3-gw/api/errors"
 	"git.frostfs.info/TrueCloudLab/frostfs-s3-gw/internal/logs"
+	"git.frostfs.info/TrueCloudLab/frostfs-s3-gw/pkg/detector"
 	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/client"
 	cid "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/container/id"
 	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/object"
@@ -237,11 +239,11 @@ func (n *Layer) PutObject(ctx context.Context, p *PutObjectParams) (*data.Extend
 	if r != nil {
 		if len(p.Header[api.ContentType]) == 0 {
 			if contentType := MimeByFilePath(p.Object); len(contentType) == 0 {
-				d := newDetector(r)
+				d := detector.NewDetector(r, http.DetectContentType)
 				if contentType, err := d.Detect(); err == nil {
 					p.Header[api.ContentType] = contentType
 				}
-				r = d.MultiReader()
+				r = d.RestoredReader()
 			} else {
 				p.Header[api.ContentType] = contentType
 			}

api/middleware/log_http.go

@@ -4,31 +4,46 @@ package middleware
 
 import (
 	"bytes"
-	"encoding/base64"
-	"fmt"
 	"io"
 	"net/http"
 	"net/url"
 
 	"git.frostfs.info/TrueCloudLab/frostfs-s3-gw/internal/logs"
+	"git.frostfs.info/TrueCloudLab/frostfs-s3-gw/pkg/detector"
+	"git.frostfs.info/TrueCloudLab/frostfs-s3-gw/playback/utils"
 	"go.uber.org/zap"
 	"go.uber.org/zap/zapcore"
 	"gopkg.in/natefinch/lumberjack.v2"
 )
 
-type LogHTTPConfig struct {
+type (
+	LogHTTPConfig struct {
 		Enabled    bool
 		MaxBody    int64
 		MaxLogSize int
 		OutputPath string
 		UseGzip    bool
-	LogResponse bool
 	}
-
-type fileLogger struct {
+	fileLogger struct {
 		*zap.Logger
 		logRoller *lumberjack.Logger
 	}
+	// Implementation of zap.Sink for using lumberjack.
+	lumberjackSink struct {
+		*lumberjack.Logger
+	}
+	// responseReadWriter helps read http response body.
+	responseReadWriter struct {
+		http.ResponseWriter
+		response   *bytes.Buffer
+		statusCode int
+	}
+)
+
+const (
+	payloadLabel  = "payload"
+	responseLabel = "response"
+)
 
 var filelog = fileLogger{}
 
@@ -53,6 +68,13 @@ func newFileLogger(conf *LogHTTPConfig) (fileLogger, error) {
 	return flog, nil
 }
 
+func newResponseReadWriter(w http.ResponseWriter) *responseReadWriter {
+	return &responseReadWriter{
+		ResponseWriter: w,
+		response:       &bytes.Buffer{},
+	}
+}
+
 // registerOutputSink creates and registers sink for logger file output.
 func (f *fileLogger) registerOutputSink(conf *LogHTTPConfig) error {
 	f.logRoller = &lumberjack.Logger{
@@ -72,11 +94,6 @@ func (f *fileLogger) registerOutputSink(conf *LogHTTPConfig) error {
 	return nil
 }
 
-// Implementation of zap.Sink for using lumberjack.
-type lumberjackSink struct {
-	*lumberjack.Logger
-}
-
 func (lumberjackSink) Sync() error {
 	return nil
 }
@@ -98,17 +115,16 @@ func ReloadFileLogger(conf *LogHTTPConfig) error {
 	return nil
 }
 
-// responseReadWriter helps read http response body.
-type responseReadWriter struct {
-	http.ResponseWriter
-	response *bytes.Buffer
-}
-
 func (ww *responseReadWriter) Write(data []byte) (int, error) {
 	ww.response.Write(data)
 	return ww.ResponseWriter.Write(data)
 }
 
+func (ww *responseReadWriter) WriteHeader(code int) {
+	ww.statusCode = code
+	ww.ResponseWriter.WriteHeader(code)
+}
+
 func (ww *responseReadWriter) Flush() {
 	if f, ok := ww.ResponseWriter.(http.Flusher); ok {
 		f.Flush()
@@ -120,7 +136,7 @@ func LogHTTP(l *zap.Logger, config *LogHTTPConfig) Func {
 	var err error
 	filelog, err = newFileLogger(config)
 	if err != nil {
-		l.Warn(logs.FailedToInitializeHTTPLogger)
+		l.Error(logs.FailedToInitializeHTTPLogger)
 		return func(h http.Handler) http.Handler {
 			return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 				h.ServeHTTP(w, r)
@@ -133,38 +149,62 @@ func LogHTTP(l *zap.Logger, config *LogHTTPConfig) Func {
 				h.ServeHTTP(w, r)
 				return
 			}
-			var httplog = filelog.With(
-				zap.String("from", r.RemoteAddr),
-				zap.String("URI", r.RequestURI),
-				zap.String("method", r.Method),
-			)
 
-			httplog = withFieldIfExist(httplog, "query", r.URL.Query())
-			httplog = withFieldIfExist(httplog, "headers", r.Header)
-			if r.ContentLength > 0 && r.ContentLength <= config.MaxBody {
-				httplog, err = withBody(httplog, r)
-				if err != nil {
-					l.Warn(logs.FailedToGetRequestBody, zap.Error(err))
-				}
-			}
-			if !config.LogResponse {
+			httplog := filelog.getHTTPLogger(r).
+				withFieldIfExist("query", r.URL.Query()).
+				withFieldIfExist("headers", r.Header)
+
+			payload := getBody(r.Body, l)
+			r.Body = io.NopCloser(bytes.NewReader(payload))
+
+			payloadReader := io.LimitReader(bytes.NewReader(payload), config.MaxBody)
+			httplog = httplog.withProcessedBody(payloadLabel, payloadReader, l)
+
+			wr := newResponseReadWriter(w)
+			h.ServeHTTP(wr, r)
+
+			respReader := io.LimitReader(wr.response, config.MaxBody)
+			httplog = httplog.withProcessedBody(responseLabel, respReader, l)
+			httplog = httplog.with(zap.Int("status", wr.statusCode))
+
 			httplog.Info(logs.LogHTTP)
-				h.ServeHTTP(w, r)
-			} else {
-				var resp = bytes.Buffer{}
-				ww := &responseReadWriter{ResponseWriter: w, response: &resp}
-				h.ServeHTTP(ww, r)
-				if int64(resp.Len()) <= config.MaxBody {
-					httplog.With(zap.String("response", base64.StdEncoding.EncodeToString(resp.Bytes()))).
-						Info(logs.LogHTTP)
-				}
-			}
 		})
 	}
 }
 
+func (f *fileLogger) with(fields ...zap.Field) *fileLogger {
+	return &fileLogger{
+		Logger:    f.Logger.With(fields...),
+		logRoller: f.logRoller,
+	}
+}
+
+func (f *fileLogger) getHTTPLogger(r *http.Request) *fileLogger {
+	return &fileLogger{
+		Logger: f.Logger.With(
+			zap.String("from", r.RemoteAddr),
+			zap.String("URI", r.RequestURI),
+			zap.String("method", r.Method),
+			zap.String("protocol", r.Proto),
+		),
+		logRoller: f.logRoller,
+	}
+}
+
+func (f *fileLogger) withProcessedBody(label string, bodyReader io.Reader, l *zap.Logger) *fileLogger {
+	resp, err := processBody(bodyReader)
+	if err != nil {
+		l.Error(logs.FailedToProcessHTTPBody,
+			zap.Error(err),
+			zap.String("body type", payloadLabel))
+		return f
+	}
+
+	return f.with(zap.ByteString(label, resp))
+}
+
 // newLoggerConfig creates new zap.Config with disabled base fields.
-func (*fileLogger) newLoggerConfig() zap.Config {
+func (f *fileLogger) newLoggerConfig() zap.Config {
 	c := zap.NewProductionConfig()
 	c.DisableCaller = true
 	c.DisableStacktrace = true
@@ -172,28 +212,47 @@ func (*fileLogger) newLoggerConfig() zap.Config {
 	c.EncoderConfig.LevelKey = zapcore.OmitKey
 	c.EncoderConfig.TimeKey = zapcore.OmitKey
 	c.EncoderConfig.FunctionKey = zapcore.OmitKey
+	c.Sampling = nil
 
 	return c
 }
 
-// withBody reads body and attach it to log output.
-func withBody(httplog *zap.Logger, r *http.Request) (*zap.Logger, error) {
-	body, err := io.ReadAll(r.Body)
+func getBody(httpBody io.ReadCloser, l *zap.Logger) []byte {
+	defer httpBody.Close()
+
+	body, err := io.ReadAll(httpBody)
 	if err != nil {
-		return nil, fmt.Errorf("read body error: %w", err)
+		l.Error(logs.FailedToGetHTTPBody,
+			zap.Error(err),
+			zap.String("body type", payloadLabel))
+		return nil
+	}
+	return body
 }
-	defer r.Body.Close()
-	r.Body = io.NopCloser(bytes.NewBuffer(body))
 
-	httplog = httplog.With(zap.String("body", base64.StdEncoding.EncodeToString(body)))
+// processBody reads body and base64 encode it if it's not XML.
+func processBody(bodyReader io.Reader) ([]byte, error) {
+	resultBody := &bytes.Buffer{}
+	detect := detector.NewDetector(bodyReader, utils.DetectXML)
+	dataType, err := detect.Detect()
+	if err != nil {
+		return nil, err
+	}
+	writer := utils.ChooseWriter(dataType, resultBody)
+	if _, err = io.Copy(writer, detect.RestoredReader()); err != nil {
+		return nil, err
+	}
+	if err = writer.Close(); err != nil {
+		return nil, err
+	}
 
-	return httplog, nil
+	return resultBody.Bytes(), nil
 }
 
 // withFieldIfExist checks whether data is not empty and attach it to log output.
-func withFieldIfExist(log *zap.Logger, label string, data map[string][]string) *zap.Logger {
+func (f *fileLogger) withFieldIfExist(label string, data map[string][]string) *fileLogger {
 	if len(data) != 0 {
-		log = log.With(zap.Any(label, data))
+		return f.with(zap.Any(label, data))
 	}
-	return log
+	return f
 }

cmd/s3-gw/app.go

@@ -573,7 +573,6 @@ func (s *appSettings) updateHTTPLoggingSettings(cfg *viper.Viper, log *zap.Logge
 	s.httpLogging.MaxLogSize = cfg.GetInt(cfgHTTPLoggingMaxLogSize)
 	s.httpLogging.OutputPath = cfg.GetString(cfgHTTPLoggingDestination)
 	s.httpLogging.UseGzip = cfg.GetBool(cfgHTTPLoggingGzip)
-	s.httpLogging.LogResponse = cfg.GetBool(cfgHTTPLoggingLogResponse)
 	if err := s3middleware.ReloadFileLogger(s.httpLogging); err != nil {
 		log.Error(logs.FailedToReloadHTTPFileLogger, zap.Error(err))
 	}

cmd/s3-playback/modules/root.go

@@ -10,12 +10,14 @@ import (
 )
 
 const (
+	defaultPrintResponseLimit = 1024
 	configPath                = "config"
 	configPathFlag            = "config"
 	httpTimeout               = "http_timeout"
 	httpTimeoutFlag           = "http-timeout"
 	skipVerifyTLS             = "skip_verify_tls"
 	skipVerifyTLSFlag         = "skip-verify-tls"
+	printResponseLimit        = "print_response_limit"
 )
 
 var (
@@ -36,6 +38,8 @@ var (
 
 			_ = viper.BindPFlag(skipVerifyTLS, cmd.PersistentFlags().Lookup(skipVerifyTLSFlag))
 
+			viper.SetDefault(printResponseLimit, defaultPrintResponseLimit)
+
 			return nil
 		},
 		RunE: func(cmd *cobra.Command, _ []string) error {

cmd/s3-playback/modules/run.go

@@ -18,7 +18,9 @@ import (
 
 	"git.frostfs.info/TrueCloudLab/frostfs-s3-gw/api"
 	"git.frostfs.info/TrueCloudLab/frostfs-s3-gw/api/auth"
-	"git.frostfs.info/TrueCloudLab/frostfs-s3-gw/cmd/s3-playback/request"
+	"git.frostfs.info/TrueCloudLab/frostfs-s3-gw/pkg/detector"
+	"git.frostfs.info/TrueCloudLab/frostfs-s3-gw/playback"
+	"git.frostfs.info/TrueCloudLab/frostfs-s3-gw/playback/utils"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 )
@@ -55,26 +57,41 @@ func init() {
 	runCmd.Flags().String(endpointFlag, "", "endpoint URL")
 }
 
-func logResponse(cmd *cobra.Command, id int, resp *http.Response, logReq request.LoggedRequest) {
-	cmd.Println(strconv.Itoa(id)+")", logReq.Method, logReq.URI)
+func logResponse(cmd *cobra.Command, r *http.Request, resp *http.Response) {
+	cmd.Println(r.Method, r.URL.RequestURI())
 	cmd.Println(resp.Status)
-	if resp.ContentLength != 0 {
-		body, err := io.ReadAll(io.LimitReader(resp.Body, resp.ContentLength))
+	if resp.ContentLength == 0 {
+		return
+	}
+	detect := detector.NewDetector(resp.Body, utils.DetectXML)
+	dataType, err := detect.Detect()
 	if err != nil {
-			cmd.Println(id, err)
+		cmd.Println(err.Error())
+		return
 	}
-		cmd.Println(string(body))
+	body := &bytes.Buffer{}
+	resultWriter := utils.ChooseWriter(dataType, body)
+	_, err = io.Copy(resultWriter, io.LimitReader(detect.RestoredReader(), viper.GetInt64(printResponseLimit)))
+	if err != nil {
+		cmd.Println(err)
+		return
 	}
+	if err = resultWriter.Close(); err != nil {
+		cmd.Printf("could not close response body: %s\n", err)
+		return
+	}
+
+	cmd.Println(body.String())
 	cmd.Println()
 }
 
 func run(cmd *cobra.Command, _ []string) error {
-	ctx := request.SetCredentials(
+	ctx := playback.SetCredentials(
 		cmd.Context(),
 		viper.GetString(awsAccessKey),
 		viper.GetString(awsSecretKey),
 	)
-	ctx = request.WithMultiparts(ctx)
+	ctx = playback.WithMultiparts(ctx)
 
 	file, err := os.Open(viper.GetString(logPathFlag))
 	if err != nil {
@@ -109,13 +126,14 @@ func run(cmd *cobra.Command, _ []string) error {
 		case <-ctx.Done():
 			return fmt.Errorf("interrupted: %w", ctx.Err())
 		default:
-			resp, err := playback(ctx, logReq, client)
+			r, resp, err := playbackRequest(ctx, logReq, client)
 			if err != nil {
 				cmd.PrintErrln(strconv.Itoa(id)+")", "failed to playback request:", err)
 				id++
 				continue
 			}
-			logResponse(cmd, id, resp, logReq)
+			cmd.Print(strconv.Itoa(id) + ") ")
+			logResponse(cmd, r, resp)
 			id++
 		}
 	}
@@ -123,8 +141,8 @@ func run(cmd *cobra.Command, _ []string) error {
 	return nil
 }
 
-func getRequestFromLog(reader *bufio.Reader) (request.LoggedRequest, error) {
-	var logReq request.LoggedRequest
+func getRequestFromLog(reader *bufio.Reader) (playback.LoggedRequest, error) {
+	var logReq playback.LoggedRequest
 	req, err := reader.ReadString('\n')
 	if err != nil {
 		return logReq, err
@@ -138,55 +156,55 @@ func getRequestFromLog(reader *bufio.Reader) (request.LoggedRequest, error) {
 	return logReq, nil
 }
 
-// playback creates http.Request from LoggedRequest and sends it to specified endpoint.
-func playback(ctx context.Context, logReq request.LoggedRequest, client *http.Client) (*http.Response, error) {
+// playbackRequest creates http.Request from LoggedRequest and sends it to specified endpoint.
+func playbackRequest(ctx context.Context, logReq playback.LoggedRequest, client *http.Client) (*http.Request, *http.Response, error) {
 	r, err := prepareRequest(ctx, logReq)
 	if err != nil {
-		return nil, fmt.Errorf("failed to prepare request: %w", err)
+		return nil, nil, fmt.Errorf("failed to prepare request: %w", err)
 	}
 	resp, err := client.Do(r)
 	if err != nil {
-		return nil, fmt.Errorf("failed to send request: %w", err)
+		return nil, nil, fmt.Errorf("failed to send request: %w", err)
 	}
 
 	respBody, err := io.ReadAll(resp.Body)
 	if err != nil {
-		return nil, fmt.Errorf("failed to read response body: %w", err)
+		return nil, nil, fmt.Errorf("failed to read response body: %w", err)
 	}
 	defer resp.Body.Close()
 
-	if err = request.HandleResponse(ctx, r, respBody, logReq.Response); err != nil {
-		return nil, fmt.Errorf("failed to register multipart upload: %w", err)
+	if err = playback.HandleResponse(ctx, r, respBody, logReq.Response); err != nil {
+		return nil, nil, fmt.Errorf("failed to register multipart upload: %w", err)
 	}
 	resp.Body = io.NopCloser(bytes.NewBuffer(respBody))
 
-	return resp, nil
+	return r, resp, nil
 }
 
 // prepareRequest creates request from logs and modifies its signature and uploadId (if presents).
-func prepareRequest(ctx context.Context, logReq request.LoggedRequest) (*http.Request, error) {
+func prepareRequest(ctx context.Context, logReq playback.LoggedRequest) (*http.Request, error) {
 	r, err := http.NewRequestWithContext(ctx, logReq.Method, viper.GetString(endpointFlag)+logReq.URI,
-		bytes.NewReader(logReq.Body))
+		bytes.NewReader(logReq.Payload))
 	if err != nil {
 		return nil, err
 	}
 	r.Header = logReq.Header
 
-	err = request.SwapUploadID(ctx, r)
+	err = playback.SwapUploadID(ctx, r)
 	if err != nil {
 		return nil, err
 	}
 
 	sha256hash := sha256.New()
-	sha256hash.Write(logReq.Body)
+	sha256hash.Write(logReq.Payload)
 	r.Header.Set(auth.AmzContentSHA256, hex.EncodeToString(sha256hash.Sum(nil)))
 	if r.Header.Get(api.ContentMD5) != "" {
 		sha256hash.Reset()
 		md5hash := md5.New()
-		md5hash.Write(logReq.Body)
+		md5hash.Write(logReq.Payload)
 		r.Header.Set(api.ContentMD5, base64.StdEncoding.EncodeToString(md5hash.Sum(nil)))
 	}
-	err = request.Sign(ctx, r)
+	err = playback.Sign(ctx, r)
 	if err != nil {
 		return nil, err
 	}

config/playback/playback.yaml

@@ -1,7 +1,8 @@
 endpoint: http://localhost:8084
-log: ./log/multipart5.log
+log: ./log/request.log
 credentials:
   access_key: CAtUxDSSFtuVyVCjHTMhwx3eP3YSPo5ffwbPcnKfcdrD06WwUSn72T5EBNe3jcgjL54rmxFM6u3nUAoNBps8qJ1PD
   secret_key: 560027d81c277de7378f71cbf12a32e4f7f541de724be59bcfdbfdc925425f30
 http_timeout: 60s
 skip_verify_tls: false
+print_response_limit: 1024

docs/configuration.md

@@ -389,7 +389,6 @@ http_logging:
   max_log_size: 20
   gzip: true
   destination: stdout
-  log_response: true
 ```
 
 | Parameter      | Type   | SIGHUP reload | Default value | Description                                                                                                                                                                                 |
@@ -399,7 +398,6 @@ http_logging:
 | `max_log_size` | int    | yes           | 50            | Log file size threshold (in megabytes) to be moved in backup file. After reaching  threshold, initial filename is appended with timestamp. And new empty file with initial name is created. |
 | `gzip`         | bool   | yes           | false         | Whether to enable Gzip compression to backup log files.                                                                                                                                     |
 | `destination`  | string | yes           | stdout        | Specify path for log output. Accepts log file path, or "stdout" and "stderr" reserved words to print in output streams. File and folders are created if necessary.                          |
-| `log_response` | bool   | yes           | true          | Whether to attach response body to the log.                                                                                                                                                 |
 
 
 ### `cache` section

docs/playback.md

@@ -31,14 +31,15 @@ If corresponding flag is set, it overrides parameter from config.
 
 ### Configuration parameters
 
-#### Global params
+#### Global parameters
 | # | Config parameter name | Flag name       | Type     | Default value | Description                                                                   |
-|---|-----------------------|-----------------|----------|---------------|--------------------------------------------------------|
+|---|-----------------------|-----------------|----------|---------------|-------------------------------------------------------------------------------|
 | 1 | -                     | config          | string   | -             | config file path (e.g. `./config/playback.yaml`)                              |
 | 2 | http_timeout          | http-timeout    | duration | 60s           | http request timeout                                                          |
 | 3 | skip_verify_tls       | skip-verify-tls | bool     | false         | skips tls certificate verification for https endpoints                        |
 | 4 | credentials.accessKey | -               | string   | -             | AWS access key id                                                             |
 | 5 | credentials.secretKey | -               | string   | -             | AWS secret key                                                                |
+| 6 | print_response_limit  | -               | int      | 1024          | max response length to be printed in stdout, the rest of body will be omitted |
 
 #### `run` command parameters
 | # | Config parameter name | Flag name | Type   | Default value | Description                                            |

internal/logs/logs.go

@@ -101,9 +101,10 @@ const (
 	FailedToResolveCID                                   = "failed to resolve CID"                                                                             // Debug in ../../api/middleware/metrics.go
 	RequestStart                                         = "request start"                                                                                     // Info in ../../api/middleware/reqinfo.go
 	LogHTTP                                              = "http log"                                                                                          // Info in ../../api/middleware/log_http.go
-	FailedToInitializeHTTPLogger                         = "failed to initialize http logger"                                                                  // Warn in ../../api/middleware/log_http.go
-	FailedToReloadHTTPFileLogger                         = "failed to reload http file logger"                                                                 // Warn in ../../api/middleware/log_http.go
-	FailedToGetRequestBody                               = "failed to get request body"                                                                        // Warn in ../../api/middleware/log_http.go
+	FailedToInitializeHTTPLogger                         = "failed to initialize http logger"                                                                  // Error in ../../api/middleware/log_http.go
+	FailedToReloadHTTPFileLogger                         = "failed to reload http file logger"                                                                 // Error in ../../api/middleware/log_http.go
+	FailedToGetHTTPBody                                  = "failed to get http body"                                                                           // Error in ../../api/middleware/log_http.go
+	FailedToProcessHTTPBody                              = "failed to process http body"                                                                       // Error in ../../api/middleware/log_http.go
 	LogHTTPDisabledInThisBuild                           = "http logging disabled in this build"                                                               // Warn in ../../api/middleware/log_http_stub.go
 	FailedToUnescapeObjectName                           = "failed to unescape object name"                                                                    // Warn in ../../api/middleware/reqinfo.go
 	InvalidDefaultMaxAge                                 = "invalid defaultMaxAge"                                                                             // Fatal in ../../cmd/s3-gw/app_settings.go

pkg/detector/detector.go

@@ -1,15 +1,15 @@
-package layer
+package detector
 
 import (
 	"io"
-	"net/http"
 )
 
 type (
-	detector struct {
+	Detector struct {
 		io.Reader
 		err        error
 		data       []byte
+		detectFunc func([]byte) string
 	}
 	errReader struct {
 		data   []byte
@@ -36,23 +36,24 @@ func (r *errReader) Read(b []byte) (int, error) {
 	return n, nil
 }
 
-func newDetector(reader io.Reader) *detector {
-	return &detector{
+func NewDetector(reader io.Reader, detectFunc func([]byte) string) *Detector {
+	return &Detector{
 		data:       make([]byte, contentTypeDetectSize),
 		Reader:     reader,
+		detectFunc: detectFunc,
 	}
 }
 
-func (d *detector) Detect() (string, error) {
+func (d *Detector) Detect() (string, error) {
 	n, err := d.Reader.Read(d.data)
 	if err != nil && err != io.EOF {
 		d.err = err
 		return "", err
 	}
 	d.data = d.data[:n]
-	return http.DetectContentType(d.data), nil
+	return d.detectFunc(d.data), nil
 }
 
-func (d *detector) MultiReader() io.Reader {
+func (d *Detector) RestoredReader() io.Reader {
 	return io.MultiReader(newReader(d.data, d.err), d.Reader)
 }

playback/multipart.go

@@ -1,4 +1,4 @@
-package request
+package playback
 
 import (
 	"context"

playback/request.go

@@ -1,16 +1,21 @@
-package request
+package playback
 
 import (
 	"context"
 	"errors"
+	"fmt"
+	"io"
 	"net/http"
 	"net/url"
 	"regexp"
+	"strconv"
 	"strings"
 	"time"
 
 	"git.frostfs.info/TrueCloudLab/frostfs-s3-gw/api"
 	"git.frostfs.info/TrueCloudLab/frostfs-s3-gw/api/auth"
+	"git.frostfs.info/TrueCloudLab/frostfs-s3-gw/pkg/detector"
+	"git.frostfs.info/TrueCloudLab/frostfs-s3-gw/playback/utils"
 	v4 "github.com/aws/aws-sdk-go-v2/aws/signer/v4"
 	"github.com/aws/aws-sdk-go-v2/credentials"
 )
@@ -22,14 +27,15 @@ var (
 )
 
 type (
+	httpBody      []byte
 	LoggedRequest struct {
 		From     string      `json:"from"`
 		URI      string      `json:"URI"`
 		Method   string      `json:"method"`
+		Payload  httpBody    `json:"payload,omitempty"`
+		Response httpBody    `json:"response,omitempty"`
 		Query    url.Values  `json:"query"`
-		Body     []byte      `json:"body"`
 		Header   http.Header `json:"headers"`
-		Response []byte      `json:"response"`
 	}
 	Credentials struct {
 		AccessKey string
@@ -39,6 +45,25 @@ type (
 	multipartKey struct{}
 )
 
+func (h *httpBody) UnmarshalJSON(data []byte) error {
+	unquoted, err := strconv.Unquote(string(data))
+	if err != nil {
+		return fmt.Errorf("failed to unquote data: %w", err)
+	}
+	detect := detector.NewDetector(strings.NewReader(unquoted), utils.DetectXML)
+	dataType, err := detect.Detect()
+	if err != nil {
+		return fmt.Errorf("failed to detect data: %w", err)
+	}
+	reader := utils.ChooseReader(dataType, detect.RestoredReader())
+	*h, err = io.ReadAll(reader)
+	if err != nil {
+		return fmt.Errorf("failed to unmarshal httpbody: %w", err)
+	}
+
+	return nil
+}
+
 func SetCredentials(ctx context.Context, accessKey, secretKey string) context.Context {
 	return context.WithValue(ctx, contextKey{},
 		Credentials{

playback/request_test.go

@@ -1,4 +1,4 @@
-package request
+package playback
 
 import (
 	"strings"

playback/utils/utils.go

@@ -0,0 +1,49 @@
+package utils
+
+import (
+	"bytes"
+	"encoding/base64"
+	"encoding/xml"
+	"io"
+)
+
+type nopCloseWriter struct {
+	io.Writer
+}
+
+func (b nopCloseWriter) Close() error {
+	return nil
+}
+
+const (
+	nonXML  = "nonXML"
+	typeXML = "application/XML"
+)
+
+func DetectXML(data []byte) string {
+	token, err := xml.NewDecoder(bytes.NewReader(data)).RawToken()
+	if err != nil {
+		return nonXML
+	}
+
+	switch token.(type) {
+	case xml.StartElement, xml.ProcInst:
+		return typeXML
+	}
+	return nonXML
+}
+
+func ChooseWriter(dataType string, bodyWriter io.Writer) io.WriteCloser {
+	writeCloser := nopCloseWriter{bodyWriter}
+	if dataType == typeXML {
+		return writeCloser
+	}
+	return base64.NewEncoder(base64.StdEncoding, bodyWriter)
+}
+
+func ChooseReader(dataType string, bodyReader io.Reader) io.Reader {
+	if dataType == typeXML {
+		return bodyReader
+	}
+	return base64.NewDecoder(base64.StdEncoding, bodyReader)
+}