fix: stop logging large content [IDE-1351] (#397)

Author: rrama

pkg/networking/logging.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"io"
 	"net/http"
+	"strings"
 
 	"github.com/pkg/errors"
 	"github.com/rs/zerolog"
@@ -14,7 +15,21 @@ import (
 const defaultNetworkLogLevel = zerolog.DebugLevel
 const extendedNetworkLogLevel = zerolog.TraceLevel
 const maxNumberOfRequestBodyCharacters = 60
-const maxNumberOfResponseBodyCharacters = -1 // log complete response body
+const maxNumberOfResponseBodyCharacters = 10 * 1024 // 10KiB, to ensure we don't log an entire CLI download response that is interrupted.
+
+// Binary content types that should not have their response bodies logged to avoid memory issues
+var binaryMIMETypes = []string{
+	"application/octet-stream",  // Standard binary MIME type
+	"binary/octet-stream",       // Non-standard but sometimes used
+	"application/zip",           // ZIP archives
+	"application/gzip",          // GZIP archives
+	"application/x-gzip",        // Alternative GZIP MIME type
+	"application/x-tar",         // TAR archives
+	"application/x-executable",  // Executable files
+	"application/x-msdownload",  // Windows executables
+	"application/x-mach-binary", // macOS binaries
+	"application/x-elf",         // Linux ELF binaries
+}
 
 func shouldNotLog(currentLevel zerolog.Level, levelToLogAt zerolog.Level) bool {
 	// Don't log if logger level is above the threshold
@@ -109,6 +124,17 @@ func shortenStringFromCenter(str string, maxCharacters int64) string {
 	return str
 }
 
+// isBinaryContent checks if the content type indicates binary data that shouldn't be logged
+func isBinaryContent(contentType string) bool {
+	mimeType := strings.ToLower(strings.TrimSpace(strings.Split(contentType, ";")[0]))
+	for _, binaryMIMEType := range binaryMIMETypes {
+		if mimeType == binaryMIMEType {
+			return true
+		}
+	}
+	return false
+}
+
 func LogRequest(r *http.Request, logger *zerolog.Logger) {
 	if shouldNotLog(logger.GetLevel(), defaultNetworkLogLevel) { // Don't log if logger level is above the threshold
 		return
@@ -141,6 +167,12 @@ func LogResponse(response *http.Response, logger *zerolog.Logger) {
 			return
 		}
 
+		// Skip response body logging for binary content to avoid memory issues with large binary downloads.
+		if isBinaryContent(response.Header.Get("Content-Type")) {
+			logger.WithLevel(defaultNetworkLogLevel).Msgf("%s body: [BINARY CONTENT - NOT LOGGED]", logPrefixResponse)
+			return
+		}
+
 		logBody(logger, defaultNetworkLogLevel, logPrefixResponse, getResponseBody(response), response.Header, maxNumberOfResponseBodyCharacters)
 	}
 }

pkg/networking/logging_test.go

@@ -6,6 +6,7 @@ import (
 	"io"
 	"net/http"
 	"net/http/httptest"
+	"strings"
 	"testing"
 
 	"github.com/rs/zerolog"
@@ -216,6 +217,86 @@ func Test_LogResponse_nolog(t *testing.T) {
 	})
 }
 
+func Test_LogResponse_skipsBinaryContent(t *testing.T) {
+	tests := []struct {
+		name        string
+		contentType string
+		isBinary    bool
+	}{
+		{
+			name:        "binary/octet-stream",
+			contentType: "binary/octet-stream",
+			isBinary:    true,
+		},
+		{
+			name:        "text/plain",
+			contentType: "text/plain",
+			isBinary:    false,
+		},
+		{
+			name:        "application/json",
+			contentType: "application/json",
+			isBinary:    false,
+		},
+		{
+			name:        "empty content type",
+			contentType: "",
+			isBinary:    false,
+		},
+		{
+			name:        "case insensitive",
+			contentType: "APPLICATION/OCTET-STREAM",
+			isBinary:    true,
+		},
+		{
+			name:        "with charset",
+			contentType: "application/octet-stream; charset=utf-8",
+			isBinary:    true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			content := bytes.NewBufferString("")
+			logger := zerolog.New(content).Level(zerolog.TraceLevel)
+
+			var testData string
+			if tt.isBinary {
+				testData = "binary data that should not be logged"
+			} else {
+				testData = "text data that should be logged"
+			}
+			response := &http.Response{
+				Status:     "200 OK",
+				StatusCode: http.StatusOK,
+				Header:     http.Header{},
+				Body:       io.NopCloser(strings.NewReader(testData)),
+			}
+			if tt.contentType != "" {
+				response.Header.Set("Content-Type", tt.contentType)
+			}
+
+			// Act
+			LogResponse(response, &logger)
+
+			logOutput := content.String()
+			assert.Contains(t, logOutput, "< response [0x0]: 200 OK")
+
+			if tt.contentType != "" {
+				assert.Contains(t, logOutput, "Content-Type:["+tt.contentType+"]")
+			}
+
+			if tt.isBinary {
+				assert.Contains(t, logOutput, "[BINARY CONTENT - NOT LOGGED]")
+				assert.NotContains(t, logOutput, testData)
+			} else {
+				assert.NotContains(t, logOutput, "[BINARY CONTENT - NOT LOGGED]")
+				assert.Contains(t, logOutput, testData)
+			}
+		})
+	}
+}
+
 func Test_logRoundTrip(t *testing.T) {
 	config := configuration.NewWithOpts()
 	expectedResponseBody := "hello client"