Conteúdo do item:

Registrar Log

Como registrar todas as entradas e saídas das suas APIS

LogDTO.java

import java.util.HashMap;

import org.springframework.stereotype.Component;
import org.springframework.web.context.annotation.RequestScope;

import com.fasterxml.jackson.databind.annotation.JsonSerialize;

import br.com.bradesco.cardtech.cise.utils.logs.LogSerializer;

@Component
@RequestScope
@JsonSerialize(using = LogSerializer.class, as = String.class)
public class LogDTO {

	private String uri;
	
	private int statusCode;
	
	private String method;
	
	private String remoteAddress;

	private HashMap<String, String> requestHeaders;

	private Object requestBody;

	private Object responseBody;

	private HashMap<String, String> responseHeaders;

	public String getUri() {
		return uri;
	}

	public void setUri(String uri) {
		this.uri = uri;
	}

	public String getMethod() {
		return method;
	}

	public void setMethod(String method) {
		this.method = method;
	}

	public Object getRequestBody() {
		return requestBody;
	}

	public void setRequestBody(Object requestBody) {
		this.requestBody = requestBody;
	}

	public Object getResponseBody() {
		return responseBody;
	}

	public void setResponseBody(Object responseBody) {
		this.responseBody = responseBody;
	}

	public HashMap<String, String> getRequestHeaders() {
		return requestHeaders;
	}

	public void setRequestHeaders(HashMap<String, String> requestHeaders) {
		this.requestHeaders = requestHeaders;
	}

	public String getRemoteAddress() {
		return remoteAddress;
	}

	public void setRemoteAddress(String remoteAddress) {
		this.remoteAddress = remoteAddress;
	}

	public HashMap<String, String> getResponseHeaders() {
		return responseHeaders;
	}

	public void setResponseHeaders(HashMap<String, String> responseHeaders) {
		this.responseHeaders = responseHeaders;
	}

	public int getStatusCode() {
		return statusCode;
	}

	public void setStatusCode(int statusCode) {
		this.statusCode = statusCode;
	}

}

LogSerializer.java

import java.io.IOException;

import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.SerializerProvider;

import br.com.bradesco.cardtech.cise.utils.logs.domain.LogDTO;

public class LogSerializer extends JsonSerializer<LogDTO> {
	@Override
	public void serialize(LogDTO value, JsonGenerator jgen, SerializerProvider provider) throws IOException {
		if (value != null) {
			jgen.writeStartObject();
			jgen.writeStringField("uri", value.getUri());
			jgen.writeStringField("method", value.getMethod());
			jgen.writeStringField("remoteAddress", value.getRemoteAddress());
			jgen.writeObjectField("requestHeaders", value.getRequestHeaders());
			jgen.writeObjectField("requestBody", value.getRequestBody());
			jgen.writeObjectField("responseHeaders", value.getResponseHeaders());
			jgen.writeObjectField("responseBody", value.getResponseBody());
			jgen.writeEndObject();
		}
	}
}

LoggingHandlerInterceptor .java

@ControllerAdvice
public class LoggingHandlerInterceptor extends RequestBodyAdviceAdapter
		implements HandlerInterceptor, ResponseBodyAdvice<Object> {

	private static final String API_KEY = "api-key";
	private static final String X_API_KEY = "x-api-key";
	private static final String X_BRAD_AUTH = "x-Brad-Auth";

	private final Log logger = LogFactory.getLog(this.getClass());

	@Autowired
	private LogDTO logDTO;

	private HashMap<String, String> removeHeaders(HashMap<String, String> headersLog) {
		// removendo itens
		headersLog.entrySet().removeIf(e -> {
			return e.getKey().equalsIgnoreCase(HttpHeaders.AUTHORIZATION) || e.getKey().equalsIgnoreCase(X_BRAD_AUTH)
					|| e.getKey().equalsIgnoreCase(API_KEY) || e.getKey().equalsIgnoreCase(X_API_KEY);
		});

		return headersLog;
	}

	@Override
	public Object afterBodyRead(Object body, HttpInputMessage inputMessage, MethodParameter parameter, Type targetType,
			Class<? extends HttpMessageConverter<?>> converterType) {

		if (inputMessage.getHeaders().size() > 0) {
			logDTO.setRequestHeaders(
					removeHeaders((HashMap<String, String>) inputMessage.getHeaders().toSingleValueMap()));
		}
		logDTO.setRequestBody(body);

		return super.afterBodyRead(body, inputMessage, parameter, targetType, converterType);
	}

	@Override
	public Object handleEmptyBody(Object body, HttpInputMessage inputMessage, MethodParameter methodParameter,
			Type targetType, Class<? extends HttpMessageConverter<?>> converterType) {

		if (inputMessage.getHeaders().size() > 0) {
			logDTO.setRequestHeaders(
					removeHeaders((HashMap<String, String>) inputMessage.getHeaders().toSingleValueMap()));
		}
		logDTO.setRequestBody(body);

		return super.handleEmptyBody(body, inputMessage, methodParameter, targetType, converterType);
	}

	@Override
	public Object beforeBodyWrite(Object body, MethodParameter methodParameter, MediaType mediaType,
			Class<? extends HttpMessageConverter<?>> converterType, ServerHttpRequest request,
			ServerHttpResponse response) {

		/* Objeto do tipo Health sao serao logado para evitar estouro de disco */
		if (body instanceof CompositeHealth) {
			return body;
		}

		if (response != null) {

			if (response.getHeaders().size() > 0) {
				logDTO.setResponseHeaders((HashMap<String, String>) response.getHeaders().toSingleValueMap());
			}
			
			if(response instanceof ServletServerHttpResponse) {
				logDTO.setStatusCode(((ServletServerHttpResponse) response).getServletResponse().getStatus());
			}else if(response instanceof HttpServletResponse) {
				logDTO.setStatusCode(((HttpServletResponse) response).getStatus());	
			}
			
		}

		logDTO.setRemoteAddress(request.getRemoteAddress().toString());
		logDTO.setUri(request.getURI().toString());
		logDTO.setMethod(request.getMethodValue());
		logDTO.setResponseBody(body);
		logger.info(logToJson(logDTO));

		return body;
	}

	@Override
	public boolean supports(MethodParameter arg0, Type arg1, Class<? extends HttpMessageConverter<?>> arg2) {
		return true;
	}

	@Override
	public boolean supports(MethodParameter arg0, Class<? extends HttpMessageConverter<?>> arg1) {
		return true;
	}

	@Override
	public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
			throws Exception {

		// Logando em caso de 201
		if (response != null && response.getStatus() == 201) {
			HashMap<String, String> headerResponse = new HashMap<>();

			Iterator<String> headerNames = response.getHeaderNames().iterator();
			while (headerNames.hasNext()) {
				String headerName = headerNames.next();
				headerResponse.put(headerName, response.getHeader(headerName));
			}

			if(response instanceof ServletServerHttpResponse) {
				logDTO.setStatusCode(((ServletServerHttpResponse) response).getServletResponse().getStatus());
			}else if(response instanceof HttpServletResponse) {
				logDTO.setStatusCode((response).getStatus());	
			}
			
			logDTO.setResponseHeaders(headerResponse);
			logDTO.setRemoteAddress(request.getRemoteAddr());
			logDTO.setUri(request.getRequestURI());
			logDTO.setMethod(request.getMethod());
			logger.info(logToJson(logDTO));
		}

	}

	private String logToJson(LogDTO logDTO) {
		ObjectMapper mapper = new ObjectMapper();
		mapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
		String jsonString = "";

		try {
			jsonString = mapper.writeValueAsString(logDTO);
		} catch (Exception e) {
			logger.error(e);
		}
		return jsonString;
	}
}

log all inputs and outputs; request; response; log;