public void injectContext(JobDataMap jobDataMap) { final TraceeFilterConfiguration configuration = backend.getConfiguration(profile); if (!backend.isEmpty() && configuration.shouldProcessContext(AsyncDispatch)) { jobDataMap.put(TraceeConstants.TPIC_HEADER, backend.getConfiguration(profile).filterDeniedParams(backend.copyToMap(), AsyncDispatch)); } } }
@SuppressWarnings("unchecked") public void beforeProcessing(Message message) throws JMSException { if (backend.getConfiguration().shouldProcessContext(AsyncProcess)) { final Object encodedTraceeContext = message.getObjectProperty(TraceeConstants.JMS_HEADER_NAME); if (encodedTraceeContext != null) { final Map<String, String> contextFromMessage = (Map<String, String>) encodedTraceeContext; final Map<String, String> filteredContext = backend.getConfiguration().filterDeniedParams(contextFromMessage, AsyncProcess); backend.putAll(filteredContext); } } }
/** * This method handles the outgoing response */ @Override public void filter(final ContainerRequestContext requestContext, final ContainerResponseContext responseContext) { if (backend.getConfiguration().shouldProcessContext(OutgoingResponse)) { final Map<String, String> filtered = backend.getConfiguration().filterDeniedParams(backend.copyToMap(), OutgoingResponse); responseContext.getHeaders().putSingle(TraceeConstants.TPIC_HEADER, transportSerialization.render(filtered)); } backend.clear(); } }
void cleanUp() { if (backend.getConfiguration().shouldProcessContext(AsyncProcess)) { backend.clear(); } }
/** * Generate invocation id if it doesn't exist in TraceeBackend and configuration asks for one * * @param backend Currently used TraceeBackend */ public static void generateInvocationIdIfNecessary(final TraceeBackend backend) { if (backend != null && !backend.containsKey(TraceeConstants.INVOCATION_ID_KEY) && backend.getConfiguration().shouldGenerateInvocationId()) { backend.put(TraceeConstants.INVOCATION_ID_KEY, Utilities.createRandomAlphanumeric(backend.getConfiguration().generatedInvocationIdLength())); } }
protected final void handleOutgoing(SOAPMessageContext context) { final SOAPMessage msg = context.getMessage(); try { if (msg != null && !traceeBackend.isEmpty() && traceeBackend.getConfiguration().shouldProcessContext(OutgoingResponse)) { // get or create header final SOAPHeader header = getOrCreateHeader(msg); final Map<String, String> filteredContext = traceeBackend.getConfiguration().filterDeniedParams(traceeBackend.copyToMap(), OutgoingResponse); transportSerialization.renderSoapHeader(filteredContext, header); msg.saveChanges(); context.setMessage(msg); } } catch (final SOAPException e) { logger.error("TraceeServerHandler : Exception occurred during processing of outbound message."); logger.debug("Detailed: TraceeServerHandler : Exception occurred during processing of outbound message: {}", e.getMessage(), e); } finally { // must reset tracee context traceeBackend.clear(); } }
/** * Writes the current TraceeContext to the given javaee message. * This method is idempotent. */ protected void writeTraceeContextToMessage(Message message) throws JMSException { if (!backend.isEmpty() && backend.getConfiguration().shouldProcessContext(AsyncDispatch)) { final Map<String, String> filteredContext = backend.getConfiguration().filterDeniedParams(backend, AsyncDispatch); message.setObjectProperty(TraceeConstants.JMS_HEADER_NAME, filteredContext); } }
@Override public Object invoke(MethodInvocation invocation) throws Throwable { if (invocation instanceof ReflectiveMethodInvocation) { final ReflectiveMethodInvocation methodInvocation = (ReflectiveMethodInvocation) invocation; final Object tpicObj = methodInvocation.getUserAttribute(TraceeConstants.TPIC_HEADER); if (tpicObj instanceof Map) { @SuppressWarnings("unchecked") final Map<? extends String, ? extends String> tpic = (Map<? extends String, ? extends String>) tpicObj; backend.putAll(tpic); } } try { return invocation.proceed(); } finally { backend.clear(); } } }
final void doFilterHttp(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws IOException, ServletException { final TraceeFilterConfiguration configuration = backend.getConfiguration(profile); try { // we need to eagerly write ResponseHeaders since the inner servlets may flush the output stream // and writing of response headers become impossible afterwards. This is a best effort trade-off. writeContextToResponse(response, configuration); filterChain.doFilter(request, response); } finally { if (!response.isCommitted()) { writeContextToResponse(response, configuration); } } }
@Override public void requestDestroyed(ServletRequestEvent sre) { backend.clear(); }
private void handleHttpMessage(final Message message, final TraceeFilterConfiguration filterConfiguration) { final Map<String, List<String>> requestHeaders = CastUtils.cast((Map<?, ?>) message.get(Message.PROTOCOL_HEADERS)); if (requestHeaders != null && !requestHeaders.isEmpty()) { final List<String> traceeHeader = requestHeaders.get(TraceeConstants.TPIC_HEADER); if (traceeHeader != null && !traceeHeader.isEmpty()) { final Map<String, String> parsedContext = httpJsonSerializer.parse(traceeHeader); backend.putAll(filterConfiguration.filterDeniedParams(parsedContext, channel)); } } }
@Override public Object invoke(MethodInvocation invocation) throws Throwable { if (invocation instanceof ReflectiveMethodInvocation) { final Map<String, String> tpic = backend.copyToMap(); ((ReflectiveMethodInvocation) invocation).setUserAttribute(TraceeConstants.TPIC_HEADER, tpic); } return invocation.proceed(); }
/** * Writes a given log message. * * @param clazz the type used to get the logger for * @param logMessage the log message to write */ public void writeLogMessage(final Class clazz, final String logMessage) { TraceeLogger logger = Tracee.getBackend().getLoggerFactory().getLogger(clazz); }
public static void main(final String[] args) throws MalformedURLException { final TraceeLogger traceeLogger = traceeBackend.getLoggerFactory().getLogger(TestClient.class); final int b = 3; traceeBackend.remove(TraceeConstants.REQUEST_ID_KEY); MDC.remove(TraceeConstants.REQUEST_ID_KEY); traceeBackend.put(TraceeConstants.REQUEST_ID_KEY, "XYX"); traceeLogger.info("WS CALL WITH EXISTING REQUEST_ID : " + a + "+" + b + "=" + ws.sum(a, b)); traceeBackend.remove(TraceeConstants.REQUEST_ID_KEY); MDC.remove(TraceeConstants.REQUEST_ID_KEY);
protected final void handleOutgoing(SOAPMessageContext context) { final SOAPMessage msg = context.getMessage(); try { if (msg != null && !traceeBackend.isEmpty() && traceeBackend.getConfiguration().shouldProcessContext(OutgoingResponse)) { // get or create header final SOAPHeader header = getOrCreateHeader(msg); final Map<String, String> filteredContext = traceeBackend.getConfiguration().filterDeniedParams(traceeBackend.copyToMap(), OutgoingResponse); transportSerialization.renderSoapHeader(filteredContext, header); msg.saveChanges(); context.setMessage(msg); } } catch (final SOAPException e) { logger.error("TraceeServerHandler : Exception occurred during processing of outbound message."); logger.debug("Detailed: TraceeServerHandler : Exception occurred during processing of outbound message: {}", e.getMessage(), e); } finally { // must reset tracee context traceeBackend.clear(); } }
private void writeContextToResponse(HttpServletResponse response, TraceeFilterConfiguration configuration) { if (configuration.shouldProcessContext(OutgoingResponse) && !backend.isEmpty()) { final Map<String, String> filteredContext = backend.getConfiguration(profile).filterDeniedParams(backend, OutgoingResponse); response.setHeader(HTTP_HEADER_NAME, transportSerialization.render(filteredContext)); } }
void cleanUp() { if (backend.getConfiguration().shouldProcessContext(AsyncProcess)) { backend.clear(); } }
final void doFilterHttp(final HttpServletRequest request, final HttpServletResponse response, final FilterChain filterChain) throws IOException, ServletException { final TraceeFilterConfiguration configuration = backend.getConfiguration(profile); try { // we need to eagerly write ResponseHeaders since the inner servlets may flush the output stream // and writing of response headers become impossible afterwards. This is a best effort trade-off. writeContextToResponse(response, configuration); filterChain.doFilter(request, response); } finally { if (!response.isCommitted()) { writeContextToResponse(response, configuration); } } }
@Override public void afterCompletion(MessageContext messageContext, Object o, Exception e) { backend.clear(); } }
/** * Generate session id hash if it doesn't exist in TraceeBackend and configuration asks for one * * @param backend Currently used TraceeBackend * @param sessionId Current http sessionId */ public static void generateSessionIdIfNecessary(final TraceeBackend backend, final String sessionId) { if (backend != null && !backend.containsKey(TraceeConstants.SESSION_ID_KEY) && backend.getConfiguration().shouldGenerateSessionId()) { backend.put(TraceeConstants.SESSION_ID_KEY, Utilities.createAlphanumericHash(sessionId, backend.getConfiguration().generatedSessionIdLength())); } } }