Настройка логирования HTTP-запросов в Spring Boot: полное руководство

# Логирование веб-запросов
logging.level.org.springframework.web=DEBUG

# Логирование запросов к БД
logging.level.org.hibernate.SQL=DEBUG
logging.level.org.hibernate.type.descriptor.sql.BasicBinder=TRACE

@Component
@Order(Ordered.HIGHEST_PRECEDENCE)
public class RequestResponseLoggingFilter implements Filter {

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

@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
throws IOException, ServletException {

HttpServletRequest httpRequest = (HttpServletRequest) request;
HttpServletResponse httpResponse = (HttpServletResponse) response;

// Создаем обертки для запроса и ответа
CachedBodyHttpServletRequest cachedRequest = new CachedBodyHttpServletRequest(httpRequest);
ContentCachingResponseWrapper responseWrapper = new ContentCachingResponseWrapper(httpResponse);

long startTime = System.currentTimeMillis();

// Логируем запрос
logRequest(cachedRequest);

// Передаем обертки дальше по цепочке фильтров
chain.doFilter(cachedRequest, responseWrapper);

// Логируем ответ
logResponse(responseWrapper, System.currentTimeMillis() – startTime);

// Важно! Копируем данные из обертки обратно в оригинальный ответ
responseWrapper.copyBodyToResponse();
}

private void logRequest(CachedBodyHttpServletRequest request) throws IOException {
String requestBody = new String(request.getCachedBody(), StandardCharsets.UTF_8);
log.info("REQUEST [{}] {} {} – Headers: {}, Body: {}", 
request.getRemoteAddr(),
request.getMethod(), 
request.getRequestURI(),
getHeadersAsString(request),
requestBody);
}

private void logResponse(ContentCachingResponseWrapper response, long executionTime) {
String responseBody = new String(response.getContentAsByteArray(), StandardCharsets.UTF_8);
log.info("RESPONSE – Status: {}, Time: {}ms, Body: {}", 
response.getStatus(),
executionTime,
responseBody);
}

private String getHeadersAsString(HttpServletRequest request) {
StringBuilder headers = new StringBuilder();
Enumeration<String> headerNames = request.getHeaderNames();
while (headerNames.hasMoreElements()) {
String headerName = headerNames.nextElement();
headers.append(headerName).append("=").append(request.getHeader(headerName)).append(", ");
}
return headers.toString();
}
}

public class CachedBodyHttpServletRequest extends HttpServletRequestWrapper {

private byte[] cachedBody;

public CachedBodyHttpServletRequest(HttpServletRequest request) throws IOException {
super(request);
this.cachedBody = StreamUtils.copyToByteArray(request.getInputStream());
}

@Override
public ServletInputStream getInputStream() throws IOException {
return new CachedServletInputStream(cachedBody);
}

@Override
public BufferedReader getReader() throws IOException {
return new BufferedReader(new InputStreamReader(getInputStream(), StandardCharsets.UTF_8));
}

public byte[] getCachedBody() {
return cachedBody;
}

// Дополнительный класс для обертки массива байтов в ServletInputStream
private static class CachedServletInputStream extends ServletInputStream {

private final ByteArrayInputStream inputStream;

public CachedServletInputStream(byte[] cachedBody) {
this.inputStream = new ByteArrayInputStream(cachedBody);
}

@Override
public int read() throws IOException {
return inputStream.read();
}

@Override
public boolean isFinished() {
return inputStream.available() == 0;
}

@Override
public boolean isReady() {
return true;
}

@Override
public void setReadListener(ReadListener readListener) {
throw new UnsupportedOperationException("setReadListener is not implemented");
}
}
}

private boolean shouldLogRequest(HttpServletRequest request) {
String path = request.getRequestURI();

// Пропускаем health checks и статические ресурсы
return !path.contains("/actuator/health") && 
!path.endsWith(".css") &&
!path.endsWith(".js") &&
!path.endsWith(".png") &&
!path.endsWith(".jpg") &&
!path.endsWith(".ico");
}

@Component
public class LoggingInterceptor implements HandlerInterceptor {

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

@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
// Сохраняем время начала обработки запроса
request.setAttribute("startTime", System.currentTimeMillis());

if (handler instanceof HandlerMethod) {
HandlerMethod handlerMethod = (HandlerMethod) handler;
log.info("Handling request [{}] to {}.{}",
request.getMethod(),
handlerMethod.getBeanType().getSimpleName(),
handlerMethod.getMethod().getName());
}

return true;
}

@Override
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) {
// Логирование после обработки контроллером, но до рендеринга представления
if (modelAndView != null) {
log.info("View name: {}", modelAndView.getViewName());
log.info("Model attributes: {}", modelAndView.getModel());
}
}

@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
// Вычисляем время выполнения запроса
long startTime = (Long) request.getAttribute("startTime");
long executionTime = System.currentTimeMillis() – startTime;

log.info("Request completed with status {} in {}ms", response.getStatus(), executionTime);

if (ex != null) {
log.error("Exception during request processing: ", ex);
}
}
}

@Configuration
public class WebMvcConfig implements WebMvcConfigurer {

private final LoggingInterceptor loggingInterceptor;

public WebMvcConfig(LoggingInterceptor loggingInterceptor) {
this.loggingInterceptor = loggingInterceptor;
}

@Override
public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(loggingInterceptor)
.addPathPatterns("/**") // Применяем ко всем путям
.excludePathPatterns("/static/**"); // Исключаем статические ресурсы
}
}

@ControllerAdvice
public class GlobalExceptionHandler {

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

/**
* Обработка специфических бизнес-исключений
*/
@ExceptionHandler(BusinessException.class)
public ResponseEntity<ErrorResponse> handleBusinessException(BusinessException ex, WebRequest request) {
log.warn("Business exception: {} for request {}", ex.getMessage(), getRequestDetails(request), ex);

ErrorResponse errorResponse = new ErrorResponse(
HttpStatus.BAD_REQUEST.value(),
ex.getMessage(),
generateErrorId()
);

return new ResponseEntity<>(errorResponse, HttpStatus.BAD_REQUEST);
}

/**
* Обработка ValidationException
*/
@ExceptionHandler(MethodArgumentNotValidException.class)
public ResponseEntity<ErrorResponse> handleValidationException(
MethodArgumentNotValidException ex, WebRequest request) {

List<String> validationErrors = ex.getBindingResult()
.getFieldErrors()
.stream()
.map(error -> error.getField() + ": " + error.getDefaultMessage())
.collect(Collectors.toList());

String errorMessage = "Validation failed: " + String.join(", ", validationErrors);

log.warn("Validation failed for request {}: {}", 
getRequestDetails(request), validationErrors, ex);

ErrorResponse errorResponse = new ErrorResponse(
HttpStatus.BAD_REQUEST.value(),
errorMessage,
generateErrorId()
);

return new ResponseEntity<>(errorResponse, HttpStatus.BAD_REQUEST);
}

/**
* Обработка всех остальных исключений
*/
@ExceptionHandler(Exception.class)
public ResponseEntity<ErrorResponse> handleAllExceptions(Exception ex, WebRequest request) {
String errorId = generateErrorId();

log.error("Unexpected error occurred (ID: {}): {} for request {}", 
errorId, ex.getMessage(), getRequestDetails(request), ex);

ErrorResponse errorResponse = new ErrorResponse(
HttpStatus.INTERNAL_SERVER_ERROR.value(),
"An unexpected error occurred. Reference: " + errorId,
errorId
);

return new ResponseEntity<>(errorResponse, HttpStatus.INTERNAL_SERVER_ERROR);
}

/**
* Создание уникального ID для отслеживания ошибки
*/
private String generateErrorId() {
return UUID.randomUUID().toString();
}

/**
* Извлечение деталей запроса для логирования
*/
private String getRequestDetails(WebRequest request) {
if (request instanceof ServletWebRequest) {
ServletWebRequest servletRequest = (ServletWebRequest) request;
HttpServletRequest httpRequest = servletRequest.getNativeRequest(HttpServletRequest.class);

if (httpRequest != null) {
return httpRequest.getMethod() + " " + httpRequest.getRequestURI();
}
}

return request.getDescription(false);
}

/**
* Класс для структурированного ответа об ошибке
*/
@Getter
@AllArgsConstructor
public static class ErrorResponse {
private int status;
private String message;
private String errorId;
}
}

@Component
@Order(Ordered.HIGHEST_PRECEDENCE)
public class MdcLoggingFilter implements Filter {

@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
throws IOException, ServletException {

HttpServletRequest httpRequest = (HttpServletRequest) request;

// Генерируем уникальный ID запроса
String requestId = UUID.randomUUID().toString();

try {
// Добавляем данные в MDC
MDC.put("requestId", requestId);
MDC.put("method", httpRequest.getMethod());
MDC.put("path", httpRequest.getRequestURI());
MDC.put("remoteAddr", httpRequest.getRemoteAddr());

// Извлекаем ID пользователя из JWT токена, если есть
Optional.ofNullable(httpRequest.getHeader("Authorization"))
.map(this::extractUserIdFromToken)
.ifPresent(userId -> MDC.put("userId", userId));

// Продолжаем выполнение цепочки фильтров
chain.doFilter(request, response);

} finally {
// Очищаем MDC после завершения запроса
MDC.clear();
}
}

private String extractUserIdFromToken(String authHeader) {
// Логика извлечения ID пользователя из JWT токена
// В реальном приложении тут должна быть полноценная валидация токена
if (authHeader.startsWith("Bearer ")) {
try {
String token = authHeader.substring(7);
// Упрощенный пример, в реальности используйте проверенную библиотеку для JWT
String payload = new String(Base64.getDecoder().decode(token.split("\\.")[1]));
return new JSONObject(payload).getString("sub");
} catch (Exception e) {
// Игнорируем ошибки парсинга
return "unknown";
}
}
return "unknown";
}
}

<configuration>
<appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
<encoder>
<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} – [rid:%X{requestId}] [user:%X{userId}] [%X{method} %X{path}] %msg%n</pattern>
</encoder>
</appender>

<root level="info">
<appender-ref ref="CONSOLE" />
</root>
</configuration>

<configuration>
<appender name="ASYNC" class="ch.qos.logback.classic.AsyncAppender">
<discardingThreshold>0</discardingThreshold>
<queueSize>256</queueSize>
<appender-ref ref="FILE" />
</appender>

<appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
<file>logs/application.log</file>
<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
<fileNamePattern>logs/application.%d{yyyy-MM-dd}.log</fileNamePattern>
<maxHistory>30</maxHistory>
<totalSizeCap>3GB</totalSizeCap>
</rollingPolicy>
<encoder class="net.logstash.logback.encoder.LogstashEncoder" />
</appender>

<root level="info">
<appender-ref ref="ASYNC" />
</root>

<!-- Повышенный уровень логирования для часто вызываемых классов -->
<logger name="org.springframework.web.filter.CommonsRequestLoggingFilter" level="WARN" />
</configuration>

# application-dev.properties
logging.level.root=INFO
logging.level.com.myapp=DEBUG
logging.level.org.springframework.web=DEBUG

# application-prod.properties
logging.level.root=WARN
logging.level.com.myapp=INFO
logging.level.org.springframework.web=WARN