基于过滤器实现日志链路跟踪

实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
package com.easyliao.framework.log;

import com.easyliao.framework.log.utils.RequestUtils;
import com.easyliao.framework.log.utils.TraceUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import org.slf4j.MDC;
import org.springframework.web.filter.OncePerRequestFilter;
import org.springframework.web.util.ContentCachingRequestWrapper;
import org.springframework.web.util.ContentCachingResponseWrapper;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;


/**
* @author cuishiying
* @date 2021-01-22
*/
@Slf4j
public class TraceFilter extends OncePerRequestFilter {

@Override
protected void doFilterInternal(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, FilterChain filterChain) throws ServletException, IOException {

ContentCachingRequestWrapper requestWrapper = new ContentCachingRequestWrapper(httpServletRequest);
ContentCachingResponseWrapper responseWrapper = new ContentCachingResponseWrapper(httpServletResponse);

//请求头传入存在以请求头传入的为准
String appTraceId = StringUtils.defaultString(httpServletRequest.getHeader(TraceConstant.HTTP_HEADER_TRACE_ID), TraceUtil.generateTraceId());
if (StringUtils.isNotEmpty(appTraceId)) {
MDC.put(TraceConstant.LOG_TRACE_ID, appTraceId);
}
long startTime = System.currentTimeMillis();
try {
filterChain.doFilter(requestWrapper, responseWrapper);
} finally {
if (log.isInfoEnabled()) {
long latency = System.currentTimeMillis() - startTime;
log.info("[REQUEST] {}:{} - {}, latency = {}, traceId = {}, header = {}, url-params = {}, form-params = {}, request-body = {}, response = {}",
httpServletRequest.getMethod(),
responseWrapper.getStatus(),
httpServletRequest.getRequestURL().toString(),
latency,
MDC.get(TraceConstant.LOG_TRACE_ID),
RequestUtils.getHeaders(httpServletRequest),
RequestUtils.getUrlParams(httpServletRequest),
RequestUtils.getFormParams(httpServletRequest),
RequestUtils.getRequestBody(requestWrapper),
RequestUtils.getResponseBody(responseWrapper)
);
}
MDC.clear();
}
}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
package com.easyliao.framework.log.utils;

import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.web.util.ContentCachingRequestWrapper;
import org.springframework.web.util.ContentCachingResponseWrapper;
import org.springframework.web.util.WebUtils;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.nio.charset.StandardCharsets;
import java.util.*;
import java.util.stream.Collectors;

/**
* 接口参数提取
* @author CUI SHIYING
*/
public class RequestUtils {

/**
* 将URL请求参数转换成Map
* @author show
* @param request
*/
public static Map<String, String> getUrlParams(HttpServletRequest request) {

String param = "";
if (Objects.isNull(request.getQueryString())) {
return Collections.emptyMap();
}
param = URLDecoder.decode(request.getQueryString(), StandardCharsets.UTF_8);
Map<String, String> result = new HashMap<>(16);
String[] params = param.split("&");
for (String s : params) {
int index = s.indexOf("=");
result.put(s.substring(0, index), s.substring(index + 1));
}
return result;
}

public static Map<String, String> getFormParams(HttpServletRequest request) {
Map<String, String> paramMap = new HashMap<>();
Map<String, String[]> requestMap = request.getParameterMap();
for (Map.Entry<String, String[]> entry : requestMap.entrySet()) {
if (entry.getValue().length == 1) {
paramMap.put(entry.getKey(), entry.getValue()[0]);
} else {
String[] values = entry.getValue();
String value = "";
for (String s : values) {
value = s + ",";
}
value = value.substring(0, value.length() - 1);
paramMap.put(entry.getKey(), value);
}
}
return paramMap;

}

/**
* 获取body中参数
* @param request
* @return
* @throws IOException
*/
public static String getBodyParams (HttpServletRequest request) throws IOException {
return request.getReader().lines().collect(Collectors.joining(System.lineSeparator())).replaceAll("\\s*|\\t|\\r|\\n", "");
}

// /**
// * 获取url参数和body参数
// * @param request
// * @return
// * @throws IOException
// */
// public static Map<String, String> getAllParams(HttpServletRequest request) throws IOException {
//
// SortedMap<String, String> sortedParams = new TreeMap<>();
//
// // 获取url参数
// Map<String, String> urlParams = getUrlParams(request);
// for (Map.Entry entry : urlParams.entrySet()) {
// sortedParams.put((String) entry.getKey(), (String) entry.getValue());
// }
//
// // 获取body参数
// if (!HttpMethod.GET.name().equals(request.getMethod())) {
// Map<String, String> bodyParams = getBodyParams(request);
// if (null != bodyParams) {
// for (Map.Entry entry : bodyParams.entrySet()) {
// sortedParams.put((String) entry.getKey(), (String) entry.getValue());
// }
// }
// }
//
// // 获取表单参数
// Map<String, String> formParams = getFormParams(request);
// for (Map.Entry entry : formParams.entrySet()) {
// sortedParams.put((String) entry.getKey(), (String) entry.getValue());
// }
//
// return sortedParams;
// }

public static String obtainParameter(HttpServletRequest request, String parameter) {
String result = request.getParameter(parameter);
return result == null ? "" : result;
}

public static boolean isJSONValid(String jsonInString) {
try {
final ObjectMapper mapper = new ObjectMapper();
mapper.readTree(jsonInString);
return true;
} catch (IOException e) {
return false;
}
}

public static Map<String, String> json2Map(String jsonInString) {
ObjectMapper mapper = new ObjectMapper();
Map<String, String> bodyMap = new HashMap<>();
try {
bodyMap = mapper.readValue(jsonInString, Map.class);
} catch (Exception e) {
bodyMap.put("string_body", jsonInString);
}
return bodyMap;
}

public static Map<String, String> getHeaders(HttpServletRequest request) {
Map<String, String> headerMap = new HashMap<>();

Enumeration<String> headerArray = request.getHeaderNames();
while (headerArray.hasMoreElements()) {
String headerName = (String) headerArray.nextElement();
headerMap.put(headerName, request.getHeader(headerName));
}
return headerMap;
}

public static String getRequestBody(ContentCachingRequestWrapper request) {
ContentCachingRequestWrapper wrapper = WebUtils.getNativeRequest(request, ContentCachingRequestWrapper.class);
if (wrapper != null) {
byte[] buf = wrapper.getContentAsByteArray();
if (buf.length > 0) {
try {
return new String(buf, 0, buf.length, wrapper.getCharacterEncoding()).replaceAll("\\s*|\\t|\\r|\\n", "");
} catch (UnsupportedEncodingException e) {
return " - ";
}
}
}
return " - ";
}
public static String getResponseBody(final HttpServletResponse response) throws IOException {
String payload = null;
ContentCachingResponseWrapper wrapper =
WebUtils.getNativeResponse(response, ContentCachingResponseWrapper.class);
if (wrapper != null) {
byte[] buf = wrapper.getContentAsByteArray();
if (buf.length > 0) {
payload = new String(buf, 0, buf.length, wrapper.getCharacterEncoding());
wrapper.copyBodyToResponse();
}
}
return null == payload ? " - " : payload.replaceAll("\\s*|\\t|\\r|\\n", "");
}
}

参考