Skip binary dump on http client TRACE level

[putstrln]

TRACE level is really useful for the headers and the text response body, but is there a way to mute the log if the content is binary since it just floods the logs.

[sdelamo]

you can configure logback to use different levels for different logger names

[TatyOko28]

Problem

TRACE level logging is extremely useful for debugging HTTP requests and responses because it shows:

• Request/response headers
• Text response bodies (JSON, XML, HTML, etc.)

However, when the response body is binary (images, PDFs, ZIP files, protobuf, etc.), TRACE logging dumps the entire binary content as garbled text, which:

• Floods the logs with thousands of lines of unreadable characters
• Causes performance issues (logging large binary payloads)
• Makes finding real logs nearly impossible
• Can even cause out-of-memory errors for large files

Solution 1: Use @Filter with content type detection (Recommended)

Create a server filter that selectively logs based on Content-Type header.

import io.micronaut.context.annotation.Requires;
import io.micronaut.core.annotation.Order;
import io.micronaut.http.HttpRequest;
import io.micronaut.http.MutableHttpResponse;
import io.micronaut.http.filter.FilterChain;
import io.micronaut.http.filter.HttpServerFilter;
import io.micronaut.http.filter.ServerFilterChain;
import io.micronaut.http.filter.ServerFilterPhase;
import org.reactivestreams.Publisher;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import reactor.core.publisher.Flux;

import java.util.Set;

@Requires(property = "micronaut.http.server.filters.binary-log-filter.enabled", value = "true", defaultValue = "true")
@Order(ServerFilterPhase.TRACE.before()) // Run before TRACE logging
public class BinaryContentLoggingFilter implements HttpServerFilter {

    private static final Logger log = LoggerFactory.getLogger(BinaryContentLoggingFilter.class);

    // Binary content types to skip logging body for
    private static final Set<String> BINARY_CONTENT_TYPES = Set.of(
        "application/octet-stream",
        "application/pdf",
        "application/zip",
        "application/x-zip-compressed",
        "application/x-tar",
        "application/x-gzip",
        "application/java-archive",
        "image/jpeg",
        "image/png",
        "image/gif",
        "image/webp",
        "image/svg+xml",  // SVG is text but can be large
        "video/mp4",
        "video/mpeg",
        "audio/mpeg",
        "application/x-protobuf",
        "application/protobuf"
    );

    @Override
    public Publisher<MutableHttpResponse<?>> doFilter(HttpRequest<?> request, ServerFilterChain chain) {
        return Flux.from(chain.proceed(request))
            .doOnNext(response -> {
                // Check if response is binary
                String contentType = response.getContentType().map(Object::toString).orElse("");
                
                if (isBinaryContentType(contentType)) {
                    // Mute the body logging by removing the body attribute
                    // This prevents TRACE logger from dumping binary content
                    response.getAttributes().put("micronaut.http.filter.binary-body", "true");
                    
                    if (log.isTraceEnabled()) {
                        log.trace("Response with binary content type '{}' - body logging suppressed", contentType);
                    }
                }
            });
    }

    private boolean isBinaryContentType(String contentType) {
        if (contentType == null) {
            return false;
        }
        String lower = contentType.toLowerCase();
        return BINARY_CONTENT_TYPES.stream().anyMatch(lower::startsWith);
    }

    @Override
    public int getOrder() {
        return ServerFilterPhase.TRACE.order() - 10; // Run before TRACE logging
    }
}

Enable/disable via configuration:

micronaut:
  http:
    server:
      filters:
        binary-log-filter:
          enabled: true

---