Java Examples for org.slf4j.MDC

public void startRequest(HttpServletRequest theRequest) {
    if (theRequest == null) {
        return;
    }
    Set<String> headerNames = new TreeSet<String>();
    for (Enumeration<String> enums = theRequest.getHeaderNames(); enums.hasMoreElements(); ) {
        headerNames.add(enums.nextElement());
    }
    ourLog.debug("Request headers: {}", headerNames);
    Enumeration<String> forwardedFors = theRequest.getHeaders("x-forwarded-for");
    StringBuilder b = new StringBuilder();
    for (Enumeration<String> enums = forwardedFors; enums != null && enums.hasMoreElements(); ) {
        if (b.length() > 0) {
            b.append(" / ");
        }
        b.append(enums.nextElement());
    }
    String forwardedFor = b.toString();
    String ip = theRequest.getRemoteAddr();
    if (StringUtils.isBlank(forwardedFor)) {
        org.slf4j.MDC.put(REMOTE_ADDR, ip);
        ourLog.debug("Request is from address: {}", ip);
    } else {
        org.slf4j.MDC.put(REMOTE_ADDR, forwardedFor);
        ourLog.debug("Request is from forwarded address: {}", forwardedFor);
    }
    String userAgent = StringUtils.defaultString(theRequest.getHeader("user-agent"));
    org.slf4j.MDC.put(REMOTE_UA, userAgent);
}

public void startRequest(HttpServletRequest theRequest) {
    if (theRequest == null) {
        return;
    }
    Set<String> headerNames = new TreeSet<String>();
    for (Enumeration<String> enums = theRequest.getHeaderNames(); enums.hasMoreElements(); ) {
        headerNames.add(enums.nextElement());
    }
    ourLog.debug("Request headers: {}", headerNames);
    Enumeration<String> forwardedFors = theRequest.getHeaders("x-forwarded-for");
    StringBuilder b = new StringBuilder();
    for (Enumeration<String> enums = forwardedFors; enums.hasMoreElements(); ) {
        if (b.length() > 0) {
            b.append(" / ");
        }
        b.append(enums.nextElement());
    }
    String forwardedFor = b.toString();
    String ip = theRequest.getRemoteAddr();
    if (StringUtils.isBlank(forwardedFor)) {
        org.slf4j.MDC.put(REMOTE_ADDR, ip);
        ourLog.debug("Request is from address: {}", ip);
    } else {
        org.slf4j.MDC.put(REMOTE_ADDR, forwardedFor);
        ourLog.debug("Request is from forwarded address: {}", forwardedFor);
    }
    String userAgent = StringUtils.defaultString(theRequest.getHeader("user-agent"));
    org.slf4j.MDC.put(REMOTE_UA, userAgent);
}

private void addMDCToSession() {
    Map<String, Object> map = MDC.getCopyOfContextMap();
    if (map != null) {
        Map<String, Object> sessionWrapper = new HashMap<String, Object>();
        sessionWrapper.put(":key", Integer.toString(map.hashCode()));
        sessionWrapper.put(":data", map);
        session(sessionWrapper);
    }
}

@Test
public void mdcTest() {
    final String KEY = "A";
    try {
        {
            String a0 = MDC.get(KEY);
            assertNull(a0);
        }
        {
            MDC.put(KEY, "1");
            String a1 = MDC.get(KEY);
            assertEquals(a1, "1");
        }
        {
            MDC.remove(KEY);
            String a1_gone = MDC.get(KEY);
            assertNull(a1_gone);
        }
        {
            MDC.put(KEY, "2");
            String a2 = MDC.get(KEY);
            assertEquals(a2, "2");
        }
    } finally {
        MDC.remove(KEY);
        String a2_gone = MDC.get(KEY);
        assertNull(a2_gone);
    }
}

/**
     * <p>Change configuration of LogBack.
     * Note that only this class accesses to LogBack, other classes should
     * access SLF4J instead of LogBack to keep portability.</p>
     *
     * @param option
     */
void configureLogger(CliOption option) {
    Logger root = (Logger) LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME);
    if (option.isDebug()) {
        // see http://stackoverflow.com/a/3838108
        root.setLevel(Level.ALL);
    } else {
        root.setLevel(Level.INFO);
    }
    if (option.getLogFile().isPresent()) {
        File logFile = option.getLogFile().get();
        MDC.put("logfile", logFile.getAbsolutePath());
    } else {
        root.getAppender("SIFT").stop();
    }
}

@BeforeEach
public void before() throws Exception {
    lc = new LoggerContext();
    JoranConfigurator configurator = new JoranConfigurator();
    configurator.setContext(lc);
    URL xmlConfigFile = getClass().getResource("/logback/logback-gelf-with-http.xml");
    configurator.doConfigure(xmlConfigFile);
    server = new NettyLocalHTTPServer();
    server.run();
    MDC.remove("mdcField1");
}

public void setUp() throws Exception {
    super.setUp();
    // start from a clean slate for each test
    listAppender = new ListAppender();
    listAppender.extractLocationInfo = true;
    org.apache.log4j.Logger eventLogger = org.apache.log4j.Logger.getLogger("EventLogger");
    eventLogger.addAppender(listAppender);
    eventLogger.setLevel(org.apache.log4j.Level.TRACE);
    eventLogger.setAdditivity(false);
    // Items that apply to any activity
    MDC.put("ipAddress", "192.168.1.110");
    MDC.put("login", "TestUSer");
    MDC.put("hostname", "localhost");
    MDC.put("productName", "SLF4J");
    MDC.put("locale", Locale.getDefault().getDisplayName());
    MDC.put("timezone", TimeZone.getDefault().getDisplayName());
}

public void setUp() throws Exception {
    super.setUp();
    // start from a clean slate for each test
    listAppender = new ListAppender();
    listAppender.extractLocationInfo = true;
    org.apache.log4j.Logger eventLogger = org.apache.log4j.Logger.getLogger("EventLogger");
    eventLogger.addAppender(listAppender);
    eventLogger.setLevel(org.apache.log4j.Level.TRACE);
    eventLogger.setAdditivity(false);
    // Items that apply to any activity
    MDC.put("ipAddress", "192.168.1.110");
    MDC.put("login", "TestUSer");
    MDC.put("hostname", "localhost");
    MDC.put("productName", "SLF4J");
    MDC.put("locale", Locale.getDefault().getDisplayName());
    MDC.put("timezone", TimeZone.getDefault().getDisplayName());
}

@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
    HttpServletRequest req = (HttpServletRequest) request;
    StringBuilder uriWithQueryString = new StringBuilder(req.getRequestURI());
    String queryString = req.getQueryString();
    if (queryString != null) {
        uriWithQueryString.append("?").append(queryString);
    }
    MDC.put("req.uriWithQueryString", uriWithQueryString.toString());
    try {
        chain.doFilter(request, response);
    } finally {
        MDC.remove("req.uriWithQueryString");
    }
}

public void testLookup() throws Exception {
    MDC.put("key", "value");
    MDC.put("number", "2");
    MDCStrLookup lookup = new MDCStrLookup();
    assertEquals("value", lookup.lookup("key"));
    assertEquals("2", lookup.lookup("number"));
    assertEquals(null, lookup.lookup(null));
    assertEquals(null, lookup.lookup(""));
    assertEquals(null, lookup.lookup("other"));
}

@Test
public final void assertThatChannelContextLoggingUpstreamChannelHandlerRemovedCurrentChannelFromMDCAfterReturning() throws Throwable {
    final ChannelContextLoggingUpstreamChannelHandler objectUnderTest = new ChannelContextLoggingUpstreamChannelHandler();
    final ChannelPipelineEmbedder embeddedPipeline = new DefaultChannelPipelineEmbedder(new ObjectSerializationTransportProtocolAdaptingUpstreamChannelHandler(), objectUnderTest);
    embeddedPipeline.connectChannel();
    final PingRequest pingRequest = new PingRequest();
    embeddedPipeline.receive(pingRequest);
    final String currentChannelInMdc = MDC.get(ChannelContextLoggingUpstreamChannelHandler.CURRENT_CHANNEL_MDC_KEY);
    assertNull("ChannelContextLoggingUpstreamChannelHandler did not remove current channel from MDC after returning", currentChannelInMdc);
}

public static void putMDCExecution(ActivityExecution e) {
    if (e.getId() != null)
        MDC.put(LOG_MDC_EXECUTION_ID, e.getId());
    if (e.getProcessDefinitionId() != null)
        MDC.put(LOG_MDC_PROCESSDEFINITION_ID, e.getProcessDefinitionId());
    if (e.getProcessInstanceId() != null)
        MDC.put(LOG_MDC_PROCESSINSTANCE_ID, e.getProcessInstanceId());
    if (e.getProcessBusinessKey() != null)
        MDC.put(LOG_MDC_BUSINESS_KEY, e.getProcessBusinessKey());
}

@Test
public void test() {
    assertThat(MDC.get("traceId")).isNull();
    assertThat(MDC.get("spanId")).isNull();
    testLogger.info("no span");
    Tracer tracer = Tracing.newBuilder().currentTraceContext(MDCCurrentTraceContext.create()).build().tracer();
    Span parent = tracer.newTrace();
    try (Tracer.SpanInScope wsParent = tracer.withSpanInScope(parent)) {
        testLogger.info("with span: " + parent);
        try (Tracer.SpanInScope noSpan = tracer.withSpanInScope(null)) {
            // make sure it doesn't crash
            noSpan.toString();
            testLogger.info("with no span");
            assertThat(ThreadContext.get("traceId")).isNull();
            assertThat(ThreadContext.get("spanId")).isNull();
        }
        // the trace id is now in the logging context
        assertThat(MDC.get("traceId")).isEqualTo(parent.context().traceIdString());
        assertThat(MDC.get("spanId")).isEqualTo(HexCodec.toLowerHex(parent.context().spanId()));
        Span child = tracer.newChild(parent.context());
        try (Tracer.SpanInScope wsChild = tracer.withSpanInScope(child)) {
            testLogger.info("with span: " + child);
            // nesting worked
            assertThat(MDC.get("traceId")).isEqualTo(child.context().traceIdString());
            assertThat(MDC.get("spanId")).isEqualTo(HexCodec.toLowerHex(child.context().spanId()));
        }
        testLogger.info("with span: " + parent);
        // old parent reverted
        assertThat(MDC.get("traceId")).isEqualTo(parent.context().traceIdString());
        assertThat(MDC.get("spanId")).isEqualTo(HexCodec.toLowerHex(parent.context().spanId()));
    }
    testLogger.info("no span");
    assertThat(MDC.get("traceId")).isNull();
    assertThat(MDC.get("spanId")).isNull();
}

@BeforeSuite
public void initSuiteMap(ITestContext testContext) throws Exception {
    String suiteName = testContext.getSuite().getName();
    MDC.put("suite", suiteName);
    // Workaround of https://jira.spring.io/browse/SPR-4072
    springTestContextBeforeTestClass();
    springTestContextPrepareTestInstance();
    suiteContext.putItContext(suiteName, new IntegrationTestContext());
    itContext = suiteContext.getItContext(suiteName);
}

public CompositeEntity getActorOrientedClass(String className, VersionSpecification versionSpec) throws ClassNotFoundException {
    RepositoryService repoSvc = Activator.getDefault().getRepositoryService();
    String projectCode = MDC.get(PROJECT_CODE);
    if (projectCode != null) {
        Project project = repoSvc.getProject(projectCode);
        if (project != null) {
            Flow flow = project.getFlow(className);
            if (flow.isClassDefinition()) {
                return flow;
            }
        }
    }
    try {
        return repoSvc.getSubmodel(className);
    } catch (Exception e) {
    }
    return null;
}

/**
   * <p>
   * Called by the <code>{@link Scheduler}</code> when a <code>{@link Trigger}</code>
   * fires that is associated with the <code>Job</code>.
   * </p>
   *
   * <p>
   * The implementation may wish to set a
   * {@link JobExecutionContext#setResult(Object) result} object on the
   * {@link JobExecutionContext} before this method exits.  The result itself
   * is meaningless to Quartz, but may be informative to
   * <code>{@link JobListener}s</code> or
   * <code>{@link TriggerListener}s</code> that are watching the job's
   * execution.
   * </p>
   *
   * @throws JobExecutionException if there is an exception while executing the job.
   */
@Override
public void execute(JobExecutionContext context) throws JobExecutionException {
    Map<String, String> originalContext = MDC.getCopyOfContextMap();
    if (this.mdcContext != null) {
        MDC.setContextMap(this.mdcContext);
    }
    try {
        executeImpl(context);
    } finally {
        if (originalContext != null) {
            MDC.setContextMap(originalContext);
        } else {
            MDC.clear();
        }
    }
}

@Override
public void before(Object target) {
    Trace trace = traceContext.currentTraceObject();
    if (trace == null) {
        MDC.remove(TRANSACTION_ID);
        MDC.remove(SPAN_ID);
        return;
    } else {
        MDC.put(TRANSACTION_ID, trace.getTraceId().getTransactionId());
        MDC.put(SPAN_ID, String.valueOf(trace.getTraceId().getSpanId()));
    }
}

/**
	 * Sample filter that populates the MDC on every request.
	 * 
	 * @param servletRequest
	 *            The request to filter
	 * @param servletResponse
	 *            The response to filter
	 * @param filterChain
	 *            The filter chain for this context
	 */
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
    HttpServletRequest request = (HttpServletRequest) servletRequest;
    // put values into MDC
    MDC.put(HOSTNAME, servletRequest.getServerName());
    if (productName != null) {
        MDC.put(PRODUCTNAME, productName);
    }
    MDC.put("locale", servletRequest.getLocale().getDisplayName());
    // process plugins
    for (IPlugin plugin : plugins.values()) {
        plugin.execute(request);
    }
    // forward to the chain for processing
    filterChain.doFilter(servletRequest, servletResponse);
    MDC.clear();
}

@Override
public void before(Object target) {
    Trace trace = traceContext.currentTraceObject();
    if (trace == null) {
        MDC.remove(TRANSACTION_ID);
        MDC.remove(SPAN_ID);
        return;
    } else {
        MDC.put(TRANSACTION_ID, trace.getTraceId().getTransactionId());
        MDC.put(SPAN_ID, String.valueOf(trace.getTraceId().getSpanId()));
    }
}

@Override
public void invocationFinally() {
    Long start = startTime.get();
    //start will be null IF StartupBean was just invoked!!!! 
    if (start != null) {
        Request current = Request.current();
        long total = System.currentTimeMillis() - start;
        startTime.set(null);
        if (log.isInfoEnabled() && isProduction || (!current.path.startsWith("/public")))
            log.info("---ended request=" + current.method + ":" + current.path + " total time=" + total + " ms");
    }
    MDC.put("sessionid", "");
    MDC.put("user", "");
}

// API
@Override
public void contextInitialized(final ServletContextEvent sce) {
    // Logging context information
    MDC.put("appName", sce.getServletContext().getServletContextName());
    MDC.put("contextPath", sce.getServletContext().getContextPath());
    if (logger.isInfoEnabled()) {
        logger.info("INITIALIZING APPLICATION \"{}\" ON WEB CONTEXT \"{}\".", sce.getServletContext().getServletContextName(), sce.getServletContext().getContextPath());
    }
}

public static void putMDCExecution(ActivityExecution e) {
    if (e.getId() != null)
        MDC.put(LOG_MDC_EXECUTION_ID, e.getId());
    if (e.getProcessDefinitionId() != null)
        MDC.put(LOG_MDC_PROCESSDEFINITION_ID, e.getProcessDefinitionId());
    if (e.getProcessInstanceId() != null)
        MDC.put(LOG_MDC_PROCESSINSTANCE_ID, e.getProcessInstanceId());
    if (e.getProcessBusinessKey() != null)
        MDC.put(LOG_MDC_BUSINESS_KEY, e.getProcessBusinessKey());
}

public static Runnable wrapWithMDC(Runnable r) {
    Map<String, String> mdc = MDC.getCopyOfContextMap();
    return () -> {
        Map<String, String> oldMdc = MDC.getCopyOfContextMap();
        if (mdc == null) {
            MDC.clear();
        } else {
            MDC.setContextMap(mdc);
        }
        try {
            r.run();
        } finally {
            if (oldMdc == null) {
                MDC.clear();
            } else {
                MDC.setContextMap(oldMdc);
            }
        }
    };
}

@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
    try {
        Authenticate.updateFromSession(((HttpServletRequest) request).getSession(false));
        if (Authenticate.isLogged()) {
            MDC.put("user", Authenticate.getUser().getUsername());
        }
        chain.doFilter(request, response);
    } finally {
        MDC.remove("user");
        Authenticate.clear();
    }
}

@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
    try {
        Principal principal = ((HttpServletRequest) request).getUserPrincipal();
        if (principal != null) {
            MDC.put(LogConstants.USER, principal.getName());
        } else {
            MDC.put(LogConstants.USER, "?");
        }
        chain.doFilter(request, response);
    } finally {
        MDC.clear();
    }
}

@Override
public void handleMessage(SoapMessage msg) throws Fault {
    HttpServletRequest request = (HttpServletRequest) msg.get(AbstractHTTPDestination.HTTP_REQUEST);
    if (null != request) {
        String addr = request.getRemoteAddr();
        MDC.put(LOG_KEY_REMOTE_ADDR, addr);
        if (request.getSession() != null) {
            String sessionId = request.getSession().getId();
            MDC.put(LOG_KEY_SESSION_ID, sessionId);
        }
    }
}

protected void addEntriesInMDC(AuditDetails auditDetails) {
    if (auditDetails.getParam0() != null) {
        MDC.put("param0", auditDetails.getParam0().toString());
    }
    if (auditDetails.getParam1() != null) {
        MDC.put("param1", auditDetails.getParam1().toString());
    }
    if (auditDetails.getParam2() != null) {
        MDC.put("param2", auditDetails.getParam2().toString());
    }
}

@Override
public void handle(String target, Request baseRequest, HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException {
    // Collect Info for NDC/MDC
    MDC.put("localname", request.getLocalName());
    MDC.put("servername", request.getServerName());
    MDC.put("serverport", Integer.toString(request.getServerPort()));
    MDC.put("target", target);
    String contextPath = request.getContextPath();
    if (contextPath != null) {
        MDC.put("contextPath", contextPath);
    }
    MDC.put("remoteAddr", request.getRemoteAddr());
    String remoteUser = request.getRemoteUser();
    if (remoteUser != null) {
        MDC.put("remoteUser", remoteUser);
    }
    Principal principal = request.getUserPrincipal();
    if (principal != null) {
        MDC.put("principal", principal.getName());
    }
    try {
        super.handle(target, baseRequest, request, response);
    } finally {
        // Pop info out / clear the NDC/MDC
        MDC.clear();
    }
}

@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
    long t1 = System.nanoTime();
    HttpServletRequest req = (HttpServletRequest) request;
    HttpServletResponse res = (HttpServletResponse) response;
    // Add username to log context if user is logged
    Principal p = req.getUserPrincipal();
    String username = p != null ? p.getName() : null;
    if (username != null && !username.trim().isEmpty()) {
        MDC.put("username", username);
    } else {
        MDC.put("username", "anonymous");
    }
    String userOsName = req.getRemoteUser();
    if (userOsName != null) {
        MDC.put("identity", userOsName);
    } else {
        MDC.put("identity", "-");
    }
    // Session
    HttpSession s = req.getSession(false);
    if (s != null) {
        MDC.put("sessionid", s.getId());
    } else {
        MDC.put("sessionid", "-1");
    }
    // IP
    MDC.put("ip", req.getRemoteAddr());
    // Go on, and clean at the end.
    try {
        chain.doFilter(request, response);
    } finally {
        log.info("\"" + req.getMethod() + " " + req.getRequestURI() + " " + req.getProtocol() + "\" " + res.getStatus() + " - " + ((System.nanoTime() - t1) / 1000000));
        MDC.clear();
    }
}

public static void main(String args[]) throws Exception {
    final Logger logger = LoggerFactory.getLogger(LogbackClassicSandbox.class);
    int count = 50;
    if (args != null && args.length > 0) {
        count = Integer.parseInt(args[0]);
    }
    if (logger.isDebugEnabled())
        logger.debug("args: {}", (Object[]) args);
    MDC.put("key1", "value1");
    MDC.put("key2", "value2");
    if (logger.isDebugEnabled())
        logger.debug("Foobar!", new Throwable());
    for (int i = 0; i < count; i++) {
        InnerClass.execute();
        logger.trace("Trace!");
        logger.debug("Debug!");
        logger.info("Info!");
        logger.warn("Warn!");
        logger.error("Error!");
        logger.info(FOO_MARKER, "Info with marker!");
        try {
            Thread.sleep(100);
        } catch (InterruptedException ex) {
            break;
        }
    }
    LoggerContext loggerContext = (LoggerContext) LoggerFactory.getILoggerFactory();
    loggerContext.reset();
    for (int i = 0; i < count; i++) {
        InnerClass.execute();
        logger.trace("Trace!");
        logger.debug("Debug!");
        logger.info("Info!");
        logger.warn("Warn!");
        logger.error("Error!");
        try {
            Thread.sleep(100);
        } catch (InterruptedException ex) {
            break;
        }
    }
    System.out.println("before context.stop()");
    loggerContext.stop();
    System.out.println("End of main()");
}

public static void main(String[] args) throws Exception {
    // You can put values in the MDC at any time. Before anything else
    // we put the first name
    MDC.put("first", "Dorothy");
    // configure via the configuration file "chapters/mdc/simpleMDC.xml"
    // which ships with the examples
    configureViaXML_File();
    // For educational purposes, the same configuration can
    // be accomplished programmatically.
    //
    // programmaticConfiguration();
    Logger logger = LoggerFactory.getLogger(SimpleMDC.class);
    // We now put the last name
    MDC.put("last", "Parker");
    // The most beautiful two words in the English language according
    // to Dorothy Parker:
    logger.info("Check enclosed.");
    logger.debug("The most beautiful two words in English.");
    MDC.put("first", "Richard");
    MDC.put("last", "Nixon");
    logger.info("I am not a crook.");
    logger.info("Attributed to the former US president. 17 Nov 1973.");
}

public void logEvent(AuditEvent event) {
    String username = event.getUsername();
    if ((username != null) && StringUtils.isEmpty(MDC.get("username"))) {
        MDC.put("username", username);
    }
    if (AuditEvent.ERROR == event.getLevel()) {
        LOG.error(event.toString());
    } else {
        LOG.info(event.toString());
    }
}

@Override
public void handleMessage(VerbatimPersistedMessage message) {
    final TimerContext context = processTimer.time();
    try {
        MDC.put("datasetUuid", message.getDatasetUuid().toString());
        MDC.put("attempt", String.valueOf(message.getAttempt()));
        interpretedProcessor.buildInterpreted(message.getOccurrenceKey(), message.getStatus(), true, message.getAttempt(), message.getDatasetUuid());
    } finally {
        context.stop();
    }
}

@Override
public FilterReply decide(LoggingEvent event) {
    MDC.remove(FACILITY_CODE_KEY);
    int logFacilityCode = getLogFacilityCode(event.getLoggerName());
    // This
    MDC.put(FACILITY_CODE_KEY, new Integer(logFacilityCode).toString());
    if (logFacilityCode == SYSLOG_FACILITY_DEFAULT) {
        return FilterReply.ACCEPT;
    } else {
        return FilterReply.DENY;
    }
}

public static void log(Logger logger, BatchReport batchReport) {
    Map<String, List<BatchReportItem>> items = batchReport.getItems();
    Set<Entry<String, List<BatchReportItem>>> entries = items.entrySet();
    for (Entry<String, List<BatchReportItem>> entry : entries) {
        logger.info(entry.getKey());
        try {
            MDC.put(MDC_CONTEXT_KEY, entry.getKey());
            for (BatchReportItem reportItem : entry.getValue()) {
                if (BatchReportItemSeverity.INFO.equals(reportItem.getSeverity())) {
                    logger.info(reportItem.getMessage());
                } else if (BatchReportItemSeverity.DEBUG.equals(reportItem.getSeverity())) {
                    logger.debug(reportItem.getMessage());
                } else if (BatchReportItemSeverity.TRACE.equals(reportItem.getSeverity())) {
                    logger.trace(reportItem.getMessage());
                } else if (BatchReportItemSeverity.WARN.equals(reportItem.getSeverity())) {
                    logger.warn(reportItem.getMessage());
                } else if (BatchReportItemSeverity.ERROR.equals(reportItem.getSeverity())) {
                    if (reportItem.getException() != null) {
                        logger.error(reportItem.getMessage(), reportItem.getException());
                    } else {
                        logger.error(reportItem.getMessage());
                    }
                }
            }
        } finally {
            MDC.remove(MDC_CONTEXT_KEY);
        }
    }
}

private static void setValues(ServletRequest request) {
    HttpServletRequest httpReq = HttpServletRequest.class.cast(request);
    MDC.put(Key.REQUESTID, UUID.randomUUID().toString());
    MDC.put(Key.SRCIP, httpReq.getRemoteHost());
    // Authenticated username will be set in UserArgumentResolver iff authentication is required
    MDC.put(Key.USERNAME, "<ANONYMOUS>");
    String appId = httpReq.getHeader(LIIPI_APPLICATION_ID);
    if (appId != null) {
        MDC.put(Key.APPID, appId);
    }
}

public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
    try {
        chain.doFilter(request, response);
    } finally {
        ServletContext servletContext = request.getServletContext();
        Persistence persistence = (Persistence) servletContext.getAttribute(DatabaseModule.PERSISTENCE);
        MDC.clear();
        if (persistence != null && persistence.getModel() != null) {
            persistence.closeSessions();
        }
    }
}

public static Map<String, String> getCopyOfContextMap() {
    final boolean inheritable = MDC.get(CONTEXT_NON_INHERITABLE_KEY) == null;
    Map<String, String> result = null;
    if (inheritable) {
        //noinspection unchecked
        result = MDC.getCopyOfContextMap();
    }
    if (result == null) {
        result = Maps.newHashMap();
    }
    result.remove(CONTEXT_NON_INHERITABLE_KEY);
    return result;
}

@Override
public void handle(RestxRequestMatch match, RestxRequest req, RestxResponse resp, RestxContext ctx) throws IOException {
    RestxSession session = RestxSession.current();
    ImmutableMap<String, String> metadata = prepareSessionStatsMetadata(req, session);
    if (session.getPrincipal().isPresent()) {
        String name = session.getPrincipal().get().getName();
        sessions.touch(name, metadata);
        MDC.put("principal", name);
    } else {
        sessions.touch("anonymous@" + req.getClientAddress(), metadata);
    }
    ctx.nextHandlerMatch().handle(req, resp, ctx);
}

@Test
public void testLookup() throws Exception {
    MDC.put("key", "value");
    MDC.put("number", "2");
    MDCStrLookup lookup = new MDCStrLookup();
    assertEquals("value", lookup.lookup("key"));
    assertEquals("2", lookup.lookup("number"));
    assertEquals(null, lookup.lookup(null));
    assertEquals(null, lookup.lookup(""));
    assertEquals(null, lookup.lookup("other"));
}

@Test
public void testValueInMdc() {
    String mdcName = "key";
    String expectedValue = "value";
    Tag expectedTag = new BasicTag(mdcName, expectedValue);
    TagFactory factory = new MdcTagFactory("key");
    try (MDC.MDCCloseable closeable = MDC.putCloseable(mdcName, expectedValue)) {
        Tag actualTag = factory.createTag();
        Assert.assertEquals(expectedTag, actualTag);
    }
    // Make sure that the factory returns null after the MDC has been cleaned up.
    Assert.assertNull(factory.createTag());
}

@Test
public void run() throws Exception {
    // Given
    ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
    taskExecutor.afterPropertiesSet();
    final ThreadPoolTaskExecutor innerTaskExecutor = new MdcThreadPoolTaskExecutor();
    innerTaskExecutor.afterPropertiesSet();
    // Simple task which returns always the key from the MDC
    final FutureTask<String> innerTask = new FutureTask<String>(new Callable<String>() {

        public String call() throws Exception {
            return MDC.get("key");
        }
    });
    taskExecutor.execute(new Runnable() {

        @Override
        public void run() {
            MDC.put("key", "1");
            innerTaskExecutor.execute(innerTask);
        }
    });
    // Wait for Thread and verify that it contains the right value of key
    assertThat(innerTask.get(), is(equalTo("1")));
    // Wait 1sec. for outer thread
    Thread.sleep(1000);
    // Simple task which returns always the key from the MDC
    final FutureTask<String> innerTask2 = new FutureTask<String>(new Callable<String>() {

        public String call() throws Exception {
            return MDC.get("key");
        }
    });
    taskExecutor.execute(new Runnable() {

        @Override
        public void run() {
            MDC.put("key", "2");
            innerTaskExecutor.execute(innerTask2);
        }
    });
    // Wait for Thread and verify that it contains the right value of key
    assertThat(innerTask2.get(), is(equalTo("2")));
}

@Override
public FilterReply decide(Marker marker, Logger logger, Level level, String format, Object[] params, Throwable t) {
    //System.out.println("** Being called "+logger+"**"+level+"**"+marker);
    for (Map.Entry<String, Set<ConfigValueTuple>> entry : registeredMDCFilters.entrySet()) {
        String mdcValue = MDC.get(entry.getKey());
        if (mdcValue != null) {
            for (ConfigValueTuple valueTuple : entry.getValue()) {
                String rlevel = valueTuple.getLevel();
                if (mdcValue.equals(valueTuple.getValue())) {
                    if (rlevel == null) {
                        return onMatch;
                    }
                    Level registeredLevel = Level.toLevel(rlevel, Level.TRACE);
                    if (level.isGreaterOrEqual(registeredLevel)) {
                        return onMatch;
                    } else
                        return onMismatch;
                }
            }
        }
    }
    return onMismatch;
}

/** 
	 * @param channelContext
	 * @param clientAction
	 * @param packet
	 * @param extmsg
	 * @author: tanyaowu
	 */
@Override
public void traceClient(ChannelContext<SessionContext, P, R> channelContext, ClientAction clientAction, Packet packet, Map<String, Object> extmsg) {
    Map<String, Object> map = new HashMap<>();
    map.put("time", DateTime.now().toString(DatePattern.NORM_DATETIME_MS_FORMAT));
    map.put("action", clientAction);
    map.put("c_id", channelContext.getId());
    map.put("c", channelContext.toString());
    MDC.put("tio_client", channelContext.getClientNodeTraceFilename());
    if (packet != null) {
        //packet id
        map.put("p_id", channelContext.getClientNode().getPort() + "_" + packet.getId());
        map.put("p_respId", packet.getRespId());
        map.put("packet", packet.logstr());
    }
    if (extmsg != null) {
        map.putAll(extmsg);
    }
    clientTraceLog.info(Json.toJson(map));
}

@Override
protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
    long start = System.currentTimeMillis();
    MDC.put(MDC_KEY, getMappedDiagnosticContextMessage(request));
    try {
        filterChain.doFilter(request, response);
    } finally {
        if (log.isDebugEnabled()) {
            log.info(createMessage(request, start));
        }
        MDC.remove(MDC_KEY);
    }
}

public void run() {
    String name = Thread.currentThread().getName();
    try {
        MDC.put(YuGongConstants.MDC_TABLE_SHIT_KEY, spiltKey);
        Thread.currentThread().setName(this.getClass().getSimpleName() + "-" + StringUtils.join(Arrays.asList(record.getSchemaName(), record.getTableName()), '.'));
        if (translator(sourceDs, record)) {
            result.add(record);
        }
    } catch (Throwable e) {
        throw new YuGongException("failed record data : " + record.toString(), e);
    } finally {
        Thread.currentThread().setName(name);
    }
}

@Override
public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws IOException, ServletException {
    try {
        MDC.put(REMOTE_HOST, defaultIfBlank(remoteHost(req), NOT_AVAILABLE));
        MDC.put(SERVER_NAME, defaultIfBlank(req.getServerName(), NOT_AVAILABLE));
        MDC.put(PRINCIPAL, (String) SecurityContextHolder.getContext().getAuthentication().getPrincipal());
        chain.doFilter(req, res);
    } finally {
        MDC.remove(REMOTE_HOST);
        MDC.remove(SERVER_NAME);
        MDC.remove(PRINCIPAL);
    }
}

/**
     * Clears all values for the current thread.
     */
public void clear() {
    /**
         * Unfortunately log4j's MDC historically never had a mechanism to block remove keys,
         * so we're forced to do this one by one.
         */
    for (String key : allKeys()) {
        mdcBridge.remove(key);
    }
    PER_THREAD_CONTEXTS.getUnchecked(Thread.currentThread()).clear();
}

private void buildMDC(ServletRequest request) {
    if ((request instanceof HttpServletRequest) && MDC.getMDCAdapter() != null) {
        String url = ((HttpServletRequest) request).getRequestURI();
        Matcher matcher = pattern.matcher(url);
        if (matcher.find()) {
            MDC.put("viewName", matcher.group(1));
            MDC.put("viewVersion", matcher.group(2));
            MDC.put("viewInstanceName", matcher.group(3));
        }
    }
}

@Override
public void configure() throws Exception {
    // enable MDC
    context.setUseMDCLogging(true);
    from("direct:a").routeId("route-a").transacted().process(new Processor() {

        public void process(Exchange exchange) throws Exception {
            assertEquals("route-a", MDC.get("camel.routeId"));
            assertEquals(exchange.getExchangeId(), MDC.get("camel.exchangeId"));
            assertEquals(exchange.getIn().getMessageId(), MDC.get("camel.messageId"));
        }
    }).to("log:foo-before").to("direct:b").to("log:foo-after").process(new Processor() {

        public void process(Exchange exchange) throws Exception {
            assertEquals("route-a", MDC.get("camel.routeId"));
            assertEquals(exchange.getExchangeId(), MDC.get("camel.exchangeId"));
            assertEquals(exchange.getIn().getMessageId(), MDC.get("camel.messageId"));
        }
    });
    from("direct:b").routeId("route-b").process(new Processor() {

        public void process(Exchange exchange) throws Exception {
            assertEquals("route-b", MDC.get("camel.routeId"));
            assertEquals(exchange.getExchangeId(), MDC.get("camel.exchangeId"));
            assertEquals(exchange.getIn().getMessageId(), MDC.get("camel.messageId"));
        }
    }).to("log:bar").to("mock:result");
}

@Override
public String getValue(HttpContext httpContext) {
    List<String> headers = httpContext.getRequest().getRequestHeader(tenantHeader);
    if (headers == null || headers.size() == 0) {
        LOGGER.error("Tenant Header {} not present", tenantHeader);
        throw new WebApplicationException(Response.Status.BAD_REQUEST);
    } else if (headers.size() > 1) {
        LOGGER.error("Too many Tenant Headers {}:", tenantHeader, headers);
        throw new WebApplicationException(Response.Status.BAD_REQUEST);
    } else {
        MDC.put("service", headers.get(0));
        return headers.get(0);
    }
}

protected Invocation.Builder createWebResource(String url, String token, String tenant) {
    WebTarget webTarget = getClient().target(url);
    Invocation.Builder builder = webTarget.request(getType()).accept(getType());
    builder.header("X-Auth-Token", token);
    builder.header("Tenant-Id", tenant);
    String txId = MDC.get("txId");
    if (txId != null) {
        builder.header("txId", txId);
    }
    return builder;
}

@Override
public void beforeInvocation(IInvokedMethod method, ITestResult testResult) {
    ITestClass testClass = method.getTestMethod().getTestClass();
    Class testClassToBeInvoked = testClass.getRealClass();
    if (testClassToBeInvoked != currentTestClass) {
        currentTestClass = testClassToBeInvoked;
        startTime.set(System.currentTimeMillis());
        MDC.put("testClass", currentTestClass.getSimpleName());
        logger.info("STARTING TEST CLASS");
        if (seleniumConfig != null) {
            seleniumConfig.destroy();
        }
        seleniumConfig = new JCommuneSeleniumConfig();
        XmlSuite suite = testClass.getXmlTest().getSuite();
        try {
            seleniumConfig.init(suite.getParameter("webDriverUrl"), suite.getParameter("appUrl"), currentTestClass.getSimpleName());
        } catch (Exception e) {
            logger.error("Unexpected error during Selenium configuration.", e);
            throw new RuntimeException(e);
        }
        seleniumConfig.printSeleniumSessionId(testClass.getName());
    }
}

@Override
public void doFilter(final ServletRequest request, final ServletResponse response, final FilterChain chain) throws IOException, ServletException {
    if (request instanceof HttpServletRequest && response instanceof HttpServletResponse) {
        final boolean siteLocal = isSiteLocalRequest(request);
        final String requestId = buildRequestId(siteLocal, (HttpServletRequest) request);
        MDC.put(REQUEST_ID, requestId);
        request.setAttribute(REQUEST_ID, requestId);
        // Response headers must be set prior to handling request as Transfer-Encoding is "chunked"
        sendRequestId(siteLocal, (HttpServletResponse) response, requestId);
    }
    chain.doFilter(request, response);
}

@Test
public void testIds() {
    MappedDiagnosticLogSegregationContext testLogCtx = new MappedDiagnosticLogSegregationContext();
    String logId = "logid";
    testLogCtx.setLogSegregationId(logId);
    assertEquals(testLogCtx.getLogSegragationId(), logId);
    assertEquals(MDC.get(MappedDiagnosticLogSegregationContext.LOG_SEGREGATION_ID), logId);
    String queryId = "queryId";
    testLogCtx.setLogSegragationAndQueryId(queryId);
    assertEquals(testLogCtx.getQueryId(), queryId);
    assertEquals(testLogCtx.getLogSegragationId(), queryId);
    assertEquals(MDC.get(MappedDiagnosticLogSegregationContext.LOG_SEGREGATION_ID), queryId);
    assertEquals(MDC.get(MappedDiagnosticLogSegregationContext.QUERY_LOG_ID), queryId);
    String logId2 = "logid2";
    testLogCtx.setLogSegregationId(logId2);
    assertEquals(testLogCtx.getLogSegragationId(), logId2);
    assertEquals(MDC.get(MappedDiagnosticLogSegregationContext.LOG_SEGREGATION_ID), logId2);
    assertEquals(testLogCtx.getQueryId(), queryId);
    assertEquals(MDC.get(MappedDiagnosticLogSegregationContext.QUERY_LOG_ID), queryId);
    String queryId2 = "queryId2";
    testLogCtx.setQueryId(queryId2);
    assertEquals(testLogCtx.getQueryId(), queryId2);
    assertEquals(testLogCtx.getLogSegragationId(), logId2);
    assertEquals(MDC.get(MappedDiagnosticLogSegregationContext.LOG_SEGREGATION_ID), logId2);
    assertEquals(MDC.get(MappedDiagnosticLogSegregationContext.QUERY_LOG_ID), queryId2);
}

/**
	 * @see Filter#doFilter(ServletRequest, ServletResponse, FilterChain)
	 */
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
    // user
    String user = null;
    SecurityContext securityContext = SecurityContextHolder.getContext();
    if (securityContext != null) {
        Authentication authentication = securityContext.getAuthentication();
        if (authentication != null && authentication.isAuthenticated()) {
            user = authentication.getName();
        }
    }
    if (user != null) {
        MDC.put("user", user);
    }
    // remote address
    String remote = request.getRemoteAddr();
    if (remote != null) {
        MDC.put("remote", remote);
    }
    chain.doFilter(request, response);
}

@Test
@SuppressWarnings("unchecked")
public void noUser() {
    MDC.remove("user");
    HttpRequestContext request = Mockito.mock(HttpRequestContext.class);
    Mockito.when(request.getUserPrincipal()).thenReturn(null);
    MultivaluedMap map = Mockito.mock(MultivaluedMap.class);
    Mockito.when(map.getFirst(UserProvider.USER_NAME_PARAM)).thenReturn(null);
    Mockito.when(request.getQueryParameters()).thenReturn(map);
    HttpContext context = Mockito.mock(HttpContext.class);
    Mockito.when(context.getRequest()).thenReturn(request);
    UserProvider up = new UserProvider();
    Assert.assertNull(up.getValue(context));
    Assert.assertNull(MDC.get("user"));
}

public void doFilter(final ServletRequest req, final ServletResponse res, final FilterChain chain) throws IOException, ServletException {
    final HttpServletResponse response;
    final HttpServletRequest request;
    if (res instanceof HttpServletResponse) {
        response = (HttpServletResponse) res;
    } else {
        throw new IllegalStateException("Cannot cast ServletResponse to HttpServletResponse.");
    }
    if (req instanceof HttpServletRequest) {
        request = (HttpServletRequest) req;
    } else {
        throw new IllegalStateException("Cannot cast ServletRequest to HttpServletRequest.");
    }
    final ErrorAwareHttpServletResponseWrapper errorAwareResponse = new ErrorAwareHttpServletResponseWrapper(response);
    final String username;
    if (SecurityContextHolder.getContext() != null && SecurityContextHolder.getContext().getAuthentication() != null) {
        username = SecurityContextHolder.getContext().getAuthentication().getName();
    } else {
        username = null;
    }
    final String sessionId = request.getSession().getId();
    final String requestUrl = request.getRequestURL().toString();
    MDC.put("username", username);
    MDC.put("sessionId", sessionId);
    MDC.put("requestUrl", requestUrl);
    try {
        chain.doFilter(request, errorAwareResponse);
        if (HttpServletResponse.SC_NOT_FOUND == errorAwareResponse.getErrorCode()) {
            LOGGER.error("Page '" + request.getServletPath() + "' was not found.");
        }
    } finally {
        MDC.remove("username");
        MDC.remove("sessionId");
        MDC.remove("requestUrl");
    }
}

@VisibleForTesting
ReturnType dispatchWithTimeout(final Callable<PluginDispatcherReturnType<ReturnType>> task, final long timeout, final TimeUnit unit) throws TimeoutException, ExecutionException, InterruptedException {
    final ExecutorService pluginExecutor = paymentExecutors.getPluginExecutorService();
    // Wrap existing callable to keep the original requestId
    final Callable<PluginDispatcherReturnType<ReturnType>> callableWithRequestData = new CallableWithRequestData(Request.getPerThreadRequestData(), UUIDs.getRandom(), ThreadContext.getSecurityManager(), ThreadContext.getSubject(), MDC.getCopyOfContextMap(), task);
    final Future<PluginDispatcherReturnType<ReturnType>> future = pluginExecutor.submit(callableWithRequestData);
    final PluginDispatcherReturnType<ReturnType> pluginDispatcherResult = future.get(timeout, unit);
    if (pluginDispatcherResult instanceof WithProfilingPluginDispatcherReturnType) {
        // Transfer state from dispatch thread into current one.
        final ProfilingData currentThreadProfilingData = Profiling.getPerThreadProfilingData();
        if (currentThreadProfilingData != null) {
            currentThreadProfilingData.merge(((WithProfilingPluginDispatcherReturnType) pluginDispatcherResult).getProfilingData());
        }
    }
    return pluginDispatcherResult.getReturnType();
}

@Test
public void testIds() {
    MappedDiagnosticLogSegregationContext testLogCtx = new MappedDiagnosticLogSegregationContext();
    String logId = "logid";
    testLogCtx.setLogSegregationId(logId);
    assertEquals(testLogCtx.getLogSegragationId(), logId);
    assertEquals(MDC.get(MappedDiagnosticLogSegregationContext.LOG_SEGREGATION_ID), logId);
    String queryId = "queryId";
    testLogCtx.setLogSegragationAndQueryId(queryId);
    assertEquals(testLogCtx.getQueryId(), queryId);
    assertEquals(testLogCtx.getLogSegragationId(), queryId);
    assertEquals(MDC.get(MappedDiagnosticLogSegregationContext.LOG_SEGREGATION_ID), queryId);
    assertEquals(MDC.get(MappedDiagnosticLogSegregationContext.QUERY_LOG_ID), queryId);
    String logId2 = "logid2";
    testLogCtx.setLogSegregationId(logId2);
    assertEquals(testLogCtx.getLogSegragationId(), logId2);
    assertEquals(MDC.get(MappedDiagnosticLogSegregationContext.LOG_SEGREGATION_ID), logId2);
    assertEquals(testLogCtx.getQueryId(), queryId);
    assertEquals(MDC.get(MappedDiagnosticLogSegregationContext.QUERY_LOG_ID), queryId);
    String queryId2 = "queryId2";
    testLogCtx.setQueryId(queryId2);
    assertEquals(testLogCtx.getQueryId(), queryId2);
    assertEquals(testLogCtx.getLogSegragationId(), logId2);
    assertEquals(MDC.get(MappedDiagnosticLogSegregationContext.LOG_SEGREGATION_ID), logId2);
    assertEquals(MDC.get(MappedDiagnosticLogSegregationContext.QUERY_LOG_ID), queryId2);
}

@Test
public void testWholeCycle() throws JoranException {
    String mdcKey = "cycle";
    configure(SIFT_FOLDER_PREFIX + "completeCycle.xml");
    MDC.put(mdcKey, "a");
    logger.debug("smoke");
    long timestamp = System.currentTimeMillis();
    SiftingAppender sa = (SiftingAppender) root.getAppender("SIFT");
    ListAppender<ILoggingEvent> listAppender = (ListAppender<ILoggingEvent>) sa.getAppenderTracker().find("a");
    assertNotNull(listAppender);
    List<ILoggingEvent> eventList = listAppender.list;
    assertEquals(1, listAppender.list.size());
    assertEquals("smoke", eventList.get(0).getMessage());
    MDC.remove(mdcKey);
    LoggingEvent le = new LoggingEvent("x", logger, Level.INFO, "hello", null, null);
    le.setTimeStamp(timestamp + ComponentTracker.DEFAULT_TIMEOUT + 1);
    sa.doAppend(le);
    assertFalse(listAppender.isStarted());
    assertEquals(1, sa.getAppenderTracker().allKeys().size());
    assertTrue(sa.getAppenderTracker().allKeys().contains("cycleDefault"));
}

@Override
protected void logException(Exception ex, HttpServletRequest request) {
    Integer statusCode = determineStatusCode(request, determineViewName(ex, request));
    if (statusCode / 100 == 5) {
        User currentUser = (User) request.getSession().getAttribute(SessionService.CURRENT_USER);
        if (currentUser != null) {
            MDC.put("currentUserId", String.valueOf(currentUser.getId()));
            MDC.put("currentUserName", currentUser.getName());
            MDC.put("currentUserEmail", currentUser.getEmail());
        } else {
            MDC.put("CurrentUser", "not login!");
        }
        if (ex.getStackTrace() != null && ex.getStackTrace().length > 0) {
            String loggerName = ex.getStackTrace()[0].getClassName();
            LoggerFactory.getLogger(loggerName).error(ex.getMessage(), ex);
        } else {
            logger.error(ex.getMessage(), ex);
        }
    }
    super.logException(ex, request);
}

/**
     * @see org.aopalliance.intercept.MethodInterceptor#invoke(org.aopalliance.intercept.MethodInvocation)
     */
public Object invoke(final MethodInvocation arg0) throws Throwable {
    if (arg0 != null) {
        final Object[] args = arg0.getArguments();
        if (args != null && args.length > 0) {
            final Object last = args[args.length - 1];
            if (Ice.Current.class.isAssignableFrom(last.getClass())) {
                final Ice.Current current = (Ice.Current) last;
                final Map<String, String> ctx = current.ctx;
                if (ctx != null && ctx.size() > 0) {
                    cd.setContext(ctx);
                    if (ctx.containsKey("omero.logfilename")) {
                        if (ctx.containsKey("omero.logfilename.token") && token.equals(ctx.get("omero.logfilename.token"))) {
                            MDC.put("fileset", ctx.get("omero.logfilename"));
                        } else {
                            throw new SecurityViolation(null, null, "Setting the omero.logfilename value is" + " not permitted without a secure" + " server token!");
                        }
                    }
                }
            }
        }
    }
    try {
        return arg0.proceed();
    } finally {
        MDC.clear();
    }
}

@Override
public void handle(Context context) throws Exception {
    MDC.put("clientId", "AsyncRx");
    log.debug("Handle");
    context.promise( f -> {
        Observable.<String>create( s -> s.onNext("te")).map( str -> {
            if (str.length() < 3) {
                throw new ValidationException();
            }
            return str;
        }).subscribe( str -> {
            log.debug("RETURN: " + str);
            f.success("str");
        },  ex -> {
            log.error(ex.toString());
            f.error(ex);
        });
    }).onError( ex -> {
        log.error("VETO ERROR");
    }).then( str -> {
        log.debug("VETO SUCCESS: " + str);
    });
    context.promise( f -> {
        Observable<List<String>> lst = Observable.merge(oper1(context), oper2(context)).toList();
        lst.subscribe((List<String> list) -> {
            StringBuilder strb = new StringBuilder();
            list.forEach( s -> strb.append(s).append(" "));
            log.debug(" OUTPUT: " + list);
            f.success(strb.toString());
        });
    }).then( s -> {
        log.debug("RENDER: " + s);
        context.render(s);
    });
}

@Override
protected void filter(HttpServletRequest request, HttpServletResponse response, FilterChain chain) throws IOException, ServletException {
    MDC.clear();
    MDC.put(MDC_IS_CLEARED_ON_EACH_REQUEST, "true");
    String ip = request.getRemoteAddr();
    String url = ServletUtils.getOriginatingRequestUrlWithQueryString(request);
    String referer = ServletUtils.getReferer(request);
    String userAgent = ServletUtils.getUserAgent(request);
    HttpSession session = request.getSession(false);
    MDC.put(IP, ip);
    MDC.put(URL, url);
    if (referer != null) {
        MDC.put(REFERER, referer);
    }
    if (userAgent != null) {
        MDC.put(USER_AGENT, userAgent);
    }
    if (session != null) {
        MDC.put(SESSION_ID, session.getId());
    }
    chain.doFilter(request, response);
}

/*
	 * (non-Javadoc)
	 * @see javax.servlet.Filter#doFilter(javax.servlet.ServletRequest, javax.servlet.ServletResponse,
	 * javax.servlet.FilterChain)
	 */
@Override
public void doFilter(final ServletRequest request, final ServletResponse response, final FilterChain chain) throws IOException, ServletException {
    try {
        final SecurityContext context = SecurityContextHolder.getContext();
        String uid = null;
        if (context != null) {
            final Authentication authentication = context.getAuthentication();
            if (authentication != null) {
                uid = context.getAuthentication().getName();
            }
        }
        MDC.put(identifiert, uid == null ? NOT_KNOWN : uid);
        chain.doFilter(request, response);
    } finally {
        MDC.remove(identifiert);
    }
}

/**
     * Adds all MDC key-value pairs as HTTP header where the key starts
     * with 'X-Sling-'
     */
private static void addSlingHeaders(HttpRequest m) {
    Map<?, ?> mdc = MDC.getCopyOfContextMap();
    if (mdc != null) {
        for (Map.Entry<?, ?> e : mdc.entrySet()) {
            Object key = e.getKey();
            if (key instanceof String && ((String) key).startsWith(SLING_HEADER_PREFIX) && e.getValue() instanceof String) {
                m.addHeader((String) key, (String) e.getValue());
            }
        }
    }
}

@Test
public void testMdc() throws Exception {
    Stagemonitor.startMonitoring(new MeasurementSession("MDCSpanEventListenerTest", "testHost", "testInstance"));
    when(corePlugin.getMeasurementSession()).thenReturn(new MeasurementSession("MDCSpanEventListenerTest", "testHost", "testInstance"));
    mdcSpanInterceptor.onStart(spanWrapper);
    assertNotNull(MDC.get("spanId"));
    assertNotNull(MDC.get("traceId"));
    assertNull(MDC.get("parentId"));
    mdcSpanInterceptor.onFinish(spanWrapper, null, 0);
    assertEquals("testHost", MDC.get("host"));
    assertEquals("MDCSpanEventListenerTest", MDC.get("application"));
    assertEquals("testInstance", MDC.get("instance"));
    assertNull(MDC.get("spanId"));
    assertNull(MDC.get("traceId"));
    assertNull(MDC.get("parentId"));
}

@Test
public void testMdc() throws Exception {
    Stagemonitor.startMonitoring(new MeasurementSession("MDCSpanEventListenerTest", "testHost", "testInstance"));
    when(corePlugin.getMeasurementSession()).thenReturn(new MeasurementSession("MDCSpanEventListenerTest", "testHost", "testInstance"));
    mdcSpanInterceptor.onStart(spanWrapper);
    assertNotNull(MDC.get("spanId"));
    assertNotNull(MDC.get("traceId"));
    assertNull(MDC.get("parentId"));
    mdcSpanInterceptor.onFinish(spanWrapper, null, 0);
    assertEquals("testHost", MDC.get("host"));
    assertEquals("MDCSpanEventListenerTest", MDC.get("application"));
    assertEquals("testInstance", MDC.get("instance"));
    assertNull(MDC.get("spanId"));
    assertNull(MDC.get("traceId"));
    assertNull(MDC.get("parentId"));
}

@Override
public Writer append(char c) throws IOException {
    if (c == '\n' && lineBuffer.length() > 0) {
        try {
            logger.info(lineBuffer.toString());
            String validationError = MDC.get(OutputValidationException.MDC_KEY);
            if (validationError != null) {
                throw new OutputValidationException(validationError);
            }
        } finally {
            MDC.remove(OutputValidationException.MDC_KEY);
        }
        lineBuffer.setLength(0);
        statistics.incrementLogs();
    } else {
        lineBuffer.append(c);
    }
    return this;
}

public static void doLog(String action, String image, String containerId, DockerCmd<?> cmd, @Nullable Exception e) {
    MDC.put(MDC_PREFIX + ".Action", action);
    MDC.put(MDC_PREFIX + ".Image", image);
    MDC.put(MDC_PREFIX + ".ContainerId", containerId);
    try {
        MDC.put(MDC_PREFIX + ".Command", objectMapper.writeValueAsString(cmd));
    } catch (JsonProcessingException ignored) {
    }
    if (e != null) {
        MDC.put(MDC_PREFIX + ".Exception", e.getLocalizedMessage());
        log.trace("{} action with image: {}, containerId: {}", action, image, containerId, e);
    } else {
        log.trace("{} action with image: {}, containerId: {}", action, image, containerId);
    }
    MDC.remove(MDC_PREFIX + ".Action");
    MDC.remove(MDC_PREFIX + ".Image");
    MDC.remove(MDC_PREFIX + ".ContainerId");
    MDC.remove(MDC_PREFIX + ".Command");
    MDC.remove(MDC_PREFIX + ".Exception");
}

@Override
public Principal getValue(HttpContext httpContext) {
    Principal principal = httpContext.getRequest().getUserPrincipal();
    if (principal == null) {
        final String user = httpContext.getRequest().getQueryParameters().getFirst(USER_NAME_PARAM);
        if (user != null) {
            principal = new Principal() {

                @Override
                public String getName() {
                    return new UserParam(user).value();
                }
            };
        }
    }
    if (principal != null) {
        MDC.put("user", principal.getName());
    }
    return principal;
}

/**
	 * Init the AceWiki servlet, get its Backend from ServletContext according
	 * to its config in web.xml or create backend if no 'backend' parameter
	 * exist.
	 *
	 * @param config servlet config.
	 */
public void init(ServletConfig config) throws ServletException {
    parameters = getInitParameters(config);
    if (loggerContext == null) {
        loggerContext = new LoggerContext("syst", "syst", "0");
    }
    loggerContext.propagateWithinThread();
    org.slf4j.MDC.put("type", "appl");
    backendName = config.getInitParameter("backend");
    if (backendName != null) {
        log.info("use backend: {}", backendName);
        while (true) {
            backend = (Backend) config.getServletContext().getAttribute(backendName);
            if (backend != null)
                break;
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                break;
            }
        }
        // merge backend parameters
        Map<String, String> p = parameters;
        parameters = new HashMap<String, String>();
        parameters.putAll(backend.getParameters());
        parameters.putAll(p);
    } else {
        log.info("create backend");
        APE.setParameters(parameters);
        backend = new Backend(parameters);
    }
    super.init(config);
}

/**
   *
   * @param execution the execution that this segment belongs to
   * @param execType indicates whether this segment is execution on a compute or blocking thread
   * @param executionSegment the execution segment that is to be executed
   * @throws Exception any
   */
public void intercept(Execution execution, ExecType execType, Block executionSegment) throws Exception {
    MDCHolder holder = execution.maybeGet(MDCHolder.TYPE).orElse(null);
    if (holder == null) {
        MDC.clear();
        holder = new MDCHolder();
        init.execute(execution);
        execution.add(MDCHolder.TYPE, holder);
    } else {
        if (holder.map == null) {
            MDC.clear();
        } else {
            MDC.setContextMap(holder.map);
        }
    }
    try {
        executionSegment.execute();
    } finally {
        holder.map = MDC.getCopyOfContextMap();
        MDC.clear();
    }
}

/**
   * Gather context information for the given HTTP request and return
   * a log message appropriate for logging at the start of the request.
   * <p/>
   * <p>The following context information is gathered:
   * <ul>
   * <li>"ID" - an identifier for the current thread;</li>
   * <li>"host" - the remote host (IP address or host name);</li>
   * <li>"userid" - the id of the remote user;</li>
   * <li>"startTime" - the system time in millis when this request is started (i.e., when this method is called); and</li>
   * <li>"request" - The HTTP request, e.g., "GET /index.html HTTP/1.1".</li>
   * </ul>
   * <p/>
   * <p>Call this method at the start of each HttpServlet doXXX() method
   * (e.g., doGet(), doPut()) or Spring MVC Controller handle() method.
   *
   * @param req the current request
   * @return a log message appropriate for the start of the request.
   */
public static String setupRequestContext(HttpServletRequest req) {
    // Setup context.
    //HttpSession session = req.getSession(false);
    /* MDC.put("host", req.getRemoteHost());
    MDC.put("ident", (session == null) ? "-" : session.getId());
    MDC.put("userid", req.getRemoteUser() != null ? req.getRemoteUser() : "-"); */
    MDC.put("ID", Long.toString(logServerAccessId.incrementAndGet()));
    MDC.put("startTime", Long.toString(System.currentTimeMillis()));
    String query = req.getQueryString();
    query = (query != null) ? "?" + query : "";
    Formatter request = new Formatter();
    request.format("\"%s %s%s %s\"", req.getMethod(), req.getRequestURI(), query, req.getProtocol());
    MDC.put("request", request.toString());
    return "Remote host: " + req.getRemoteHost() + " - Request: " + request.toString();
}

public void messageReceived(final ChannelHandlerContext ctx, MessageEvent e) throws Exception {
    ChannelBuffer buffer = (ChannelBuffer) e.getMessage();
    final Packet packet = Packet.parseFrom(buffer.readBytes(buffer.readableBytes()).array());
    switch(packet.getVersion()) {
        case SUPPORTED_VERSION:
        default:
            final ClientAuth clientAuth = ClientAuth.parseFrom(packet.getBody());
            // 如果存在订阅信�
            if (StringUtils.isNotEmpty(clientAuth.getDestination()) && StringUtils.isNotEmpty(clientAuth.getClientId())) {
                ClientIdentity clientIdentity = new ClientIdentity(clientAuth.getDestination(), Short.valueOf(clientAuth.getClientId()), clientAuth.getFilter());
                try {
                    MDC.put("destination", clientIdentity.getDestination());
                    embeddedServer.subscribe(clientIdentity);
                    // 设置状�数�
                    ctx.setAttachment(clientIdentity);
                    // �试�动，如果已��动，忽略
                    if (!embeddedServer.isStart(clientIdentity.getDestination())) {
                        ServerRunningMonitor runningMonitor = ServerRunningMonitors.getRunningMonitor(clientIdentity.getDestination());
                        if (!runningMonitor.isStart()) {
                            runningMonitor.start();
                        }
                    }
                } finally {
                    MDC.remove("destination");
                }
            }
            NettyUtils.ack(ctx.getChannel(), new ChannelFutureListener() {

                public void operationComplete(ChannelFuture future) throws Exception {
                    logger.info("remove unused channel handlers after authentication is done successfully.");
                    ctx.getPipeline().remove(HandshakeInitializationHandler.class.getName());
                    ctx.getPipeline().remove(ClientAuthenticationHandler.class.getName());
                    int readTimeout = defaultSubscriptorDisconnectIdleTimeout;
                    int writeTimeout = defaultSubscriptorDisconnectIdleTimeout;
                    if (clientAuth.getNetReadTimeout() > 0) {
                        readTimeout = clientAuth.getNetReadTimeout();
                    }
                    if (clientAuth.getNetWriteTimeout() > 0) {
                        writeTimeout = clientAuth.getNetWriteTimeout();
                    }
                    IdleStateHandler idleStateHandler = new IdleStateHandler(NettyUtils.hashedWheelTimer, readTimeout, writeTimeout, 0);
                    ctx.getPipeline().addBefore(SessionHandler.class.getName(), IdleStateHandler.class.getName(), idleStateHandler);
                    IdleStateAwareChannelHandler idleStateAwareChannelHandler = new IdleStateAwareChannelHandler() {

                        public void channelIdle(ChannelHandlerContext ctx, IdleStateEvent e) throws Exception {
                            logger.warn("channel:{} idle timeout exceeds, close channel to save server resources...", ctx.getChannel());
                            ctx.getChannel().close();
                        }
                    };
                    ctx.getPipeline().addBefore(SessionHandler.class.getName(), IdleStateAwareChannelHandler.class.getName(), idleStateAwareChannelHandler);
                }
            });
            break;
    }
}

@Override
public FilterReply decide(Marker marker, Logger logger, Level level, String s, Object[] objects, Throwable throwable) {
    if (!isStarted()) {
        return FilterReply.NEUTRAL;
    }
    String mdcLevel = MDC.get(key);
    if (mdcLevel == null) {
        return FilterReply.NEUTRAL;
    }
    /* Logger children do not actually have to start with the prefix of their
         * parent, but it's a de facto convention and logback doesn't surface any
         * other way to access child loggers.
         */
    boolean isChild = (Logger.ROOT_LOGGER_NAME.equals(topLogger)) ? true : logger.getName().startsWith(topLogger);
    // the MDC, then we will default to INFO.
    if (isChild && level.isGreaterOrEqual(Level.toLevel(mdcLevel, Level.INFO))) {
        return onMatch;
    }
    return onMismatch;
}

@Override
public void doFilter(final ServletRequest servletRequest, final ServletResponse servletResponse, final FilterChain filterChain) throws IOException, ServletException {
    try {
        final HttpServletRequest request = (HttpServletRequest) servletRequest;
        addContextAttribute("remoteAddress", request.getRemoteAddr());
        addContextAttribute("remoteUser", request.getRemoteUser());
        addContextAttribute("serverName", request.getServerName());
        addContextAttribute("serverPort", String.valueOf(request.getServerPort()));
        addContextAttribute("locale", request.getLocale().getDisplayName());
        addContextAttribute("contentType", request.getContentType());
        addContextAttribute("contextPath", request.getContextPath());
        addContextAttribute("localAddress", request.getLocalAddr());
        addContextAttribute("localPort", String.valueOf(request.getLocalPort()));
        addContextAttribute("remotePort", String.valueOf(request.getRemotePort()));
        addContextAttribute("pathInfo", request.getPathInfo());
        addContextAttribute("protocol", request.getProtocol());
        addContextAttribute("authType", request.getAuthType());
        addContextAttribute("method", request.getMethod());
        addContextAttribute("queryString", request.getQueryString());
        addContextAttribute("requestUri", request.getRequestURI());
        addContextAttribute("scheme", request.getScheme());
        addContextAttribute("timezone", TimeZone.getDefault().getDisplayName());
        final Map<String, String[]> params = request.getParameterMap();
        params.keySet().forEach( k -> {
            final String[] values = params.get(k);
            addContextAttribute(k, Arrays.toString(values));
        });
        Collections.list(request.getAttributeNames()).forEach( a -> addContextAttribute(a, request.getAttribute(a)));
        final String cookieValue = this.ticketGrantingTicketCookieGenerator.retrieveCookieValue(request);
        if (StringUtils.isNotBlank(cookieValue)) {
            final Principal p = this.ticketRegistrySupport.getAuthenticatedPrincipalFrom(cookieValue);
            if (p != null) {
                addContextAttribute("principal", p.getId());
            }
        }
        filterChain.doFilter(servletRequest, servletResponse);
    } finally {
        MDC.clear();
    }
}

private void setAppenderForLogger() {
    String cleanMac = settop.getLogDirectory();
    if (cleanMac == null) {
        cleanMac = "UnknownMac";
    }
    Map<String, String> mdcMap = new HashMap<String, String>();
    mdcMap.put("SettopMac", cleanMac);
    mdcMap.put("LogFileName", "RebootDetection.log");
    MDC.setContextMap(mdcMap);
    URL logFileUrl = getClass().getResource("/reboot-report-log4j.xml");
    DOMConfigurator.configure(logFileUrl);
    rebootDetectionLogger = LoggerFactory.getLogger("RebootDetection");
}

protected void setupMdc() {
    Long processId = null;
    String logicName = null, processUuid = null, processName = null, topProcessName = null, resourceId = null;
    String resourceType = null, topResourceId = null, topResourceType = null;
    StringBuilder fullPath = new StringBuilder();
    for (ParentLog log : currentLog) {
        if (fullPath.length() > 0) {
            fullPath.append("->");
        }
        if (log instanceof ProcessExecutionLog) {
            fullPath.append(log.getName());
            if (processUuid == null) {
                processUuid = ((ProcessExecutionLog) log).getId();
            }
            if (processId == null) {
                processId = ((ProcessExecutionLog) log).getProcessId();
            }
            if (topProcessName == null) {
                topProcessName = log.getName();
            }
            if (topResourceType == null) {
                topResourceType = ((ProcessExecutionLog) log).getResourceType();
            }
            if (topResourceId == null) {
                topResourceId = ((ProcessExecutionLog) log).getResourceId();
            }
            processName = log.getName();
            resourceType = ((ProcessExecutionLog) log).getResourceType();
            resourceId = ((ProcessExecutionLog) log).getResourceId();
        } else if (log instanceof ProcessLogicExecutionLog) {
            fullPath.append("(").append(log.getName()).append(")");
            logicName = log.getName();
        }
    }
    String prettyResource = null;
    String prettyProcess = null;
    StringBuilder buffer = new StringBuilder();
    if (topResourceType != null) {
        buffer.append(topResourceType).append(":").append(topResourceId);
        if (!ObjectUtils.equals(resourceId, topResourceId) || !ObjectUtils.equals(resourceType, topResourceType)) {
            buffer.append("->").append(resourceType).append(":").append(resourceId);
        }
        prettyResource = buffer.toString();
    }
    buffer.setLength(0);
    if (topProcessName != null) {
        buffer.append(topProcessName);
        if (!ObjectUtils.equals(topProcessName, processName)) {
            buffer.append("->").append(processName);
        }
        prettyProcess = buffer.toString();
    }
    MDC.put(PROCESS_ID, processId == null ? null : processId.toString());
    MDC.put(LOGIC_NAME, logicName);
    MDC.put(PROCESS_UUID, processUuid);
    MDC.put(PROCESS_NAME, processName);
    MDC.put(TOP_PROCESS_NAME, topProcessName);
    MDC.put(RESOURCE_ID, resourceId);
    MDC.put(RESOURCE_TYPE, resourceType);
    MDC.put(TOP_RESOURCE_ID, topResourceId);
    MDC.put(TOP_RESOURCE_TYPE, topResourceType);
    MDC.put(PRETTY_PROCESS, prettyProcess);
    MDC.put(PRETTY_RESOURCE, prettyResource);
    MDC.put(LOGIC_PATH, fullPath.toString());
}

/**
     * Put ogc service type (wms, wmts ...) and service id in {@link MDC}. <br >
     * This information can be used afterward in logger configuration.
     */
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
    if (request instanceof HttpServletRequest) {
        HttpServletRequest httpServletRequest = (HttpServletRequest) request;
        String requestURI = httpServletRequest.getRequestURI();
        if (requestURI.startsWith(servletPath)) {
            String path = requestURI.substring(servletPath.length());
            //Remove jsessionid
            int jsessionid = path.indexOf(";jsessionid=");
            if (jsessionid != -1) {
                path = path.substring(0, jsessionid);
            }
            String[] split = path.split("/");
            if (split.length > 1) {
                try {
                    MDC.put(OGC, "true");
                    String serviceType = split[0];
                    String serviceName = split[1];
                    String log = serviceType;
                    if ("admin".equals(serviceName)) {
                        //This is not a service call, but a admin console
                        serviceName = httpServletRequest.getParameter("id");
                        final String command = httpServletRequest.getParameter("request");
                        log += " " + serviceName + " (" + command + ")";
                        path = serviceType + "/" + serviceName;
                    } else {
                        log += " " + serviceName;
                    }
                    MDC.put(ogcServiceLogKey, log);
                    MDC.put(servicePathKey, path);
                    chain.doFilter(request, response);
                    return;
                } finally {
                    MDC.remove(OGC);
                    MDC.remove(ogcServiceLogKey);
                    MDC.remove(servicePathKey);
                }
            }
        } else {
            LOGGER.warn("MDCFilter is misconfigured in regard with WS mapping: " + requestURI);
        }
    }
    chain.doFilter(request, response);
}

@Override
public void send(LogEvent event) {
    String cat = "org.apache.cxf.services." + event.getPortTypeName().getLocalPart() + "." + event.getType();
    Logger log = LoggerFactory.getLogger(cat);
    Set<String> keys = new HashSet<>();
    try {
        put(keys, "Type", event.getType().toString());
        put(keys, "Address", event.getAddress());
        put(keys, "HttpMethod", event.getHttpMethod());
        put(keys, "Content-Type", event.getContentType());
        put(keys, "ResponseCode", event.getResponseCode());
        put(keys, "ExchangeId", event.getExchangeId());
        put(keys, "MessageId", event.getMessageId());
        if (event.getServiceName() != null) {
            put(keys, "ServiceName", localPart(event.getServiceName()));
            put(keys, "PortName", localPart(event.getPortName()));
            put(keys, "PortTypeName", localPart(event.getPortTypeName()));
        }
        if (event.getFullContentFile() != null) {
            put(keys, "FullContentFile", event.getFullContentFile().getAbsolutePath());
        }
        put(keys, "Headers", event.getHeaders().toString());
        log.info(MarkerFactory.getMarker(event.getServiceName() != null ? "SOAP" : "REST"), getLogMessage(event));
    } finally {
        for (String key : keys) {
            MDC.remove(key);
        }
    }
}

/**
     * Removes the diagnostic context information pushed the last.
     * Clients should call this method before leaving a diagnostic
     * context.
     */
public static String pop() {
    String top = null;
    String ndc = MDC.get(KEY_NDC);
    if (ndc != null) {
        String positions = MDC.get(KEY_POSITIONS);
        int pos = positions.lastIndexOf(',');
        if (pos == -1) {
            top = ndc;
            MDC.remove(KEY_NDC);
            MDC.remove(KEY_POSITIONS);
        } else {
            int offset = Integer.parseInt(positions.substring(pos + 1));
            top = ndc.substring(offset + 1);
            MDC.put(KEY_NDC, ndc.substring(0, offset));
            MDC.put(KEY_POSITIONS, positions.substring(0, pos));
        }
    }
    return top;
}

/**
     * Starts the thread
     */
public void run() {
    try {
        if (CONSUMER_LOG.isDebugEnabled()) {
            MDC.put("Replica", "Pinger");
            CONSUMER_LOG.debug("Starting the provider's pinger");
        }
        while (!stop) {
            for (ReplicationConsumer consumer : consumers) {
                consumer.ping();
            }
            Thread.sleep(sleepTime);
        }
    } catch (InterruptedException ie) {
        CONSUMER_LOG.debug("The pinger has been interrupted");
    }
}

/**
	 * @param request the servlet request
	 * @param response the servlet response
	 * @param chain the filter chain
	 * @throws IOException if there is a problem
	 * @throws ServletException if there is a problem
	 */
public final void doFilter(final ServletRequest request, final ServletResponse response, final FilterChain chain) throws IOException, ServletException {
    if (request.getParameter(parameterName) != null && request.getParameter(parameterName).trim().length() > 0) {
        MDC.put(LoggingConstants.MDC_CLIENT_NAME_KEY, request.getParameter(parameterName));
        try {
            chain.doFilter(request, response);
        } finally {
            MDC.remove(LoggingConstants.MDC_CLIENT_NAME_KEY);
        }
    } else {
        ((HttpServletResponse) response).sendError(HttpStatus.BAD_REQUEST.value(), "Required parameter " + parameterName + " not present in request");
        return;
    }
}

public GridFTPClient call() throws ServerException, IOException, InterruptedException, ClientException {
    MDC.setContextMap(ctx);
    MDC.put("host", host);
    /*
        int stacksize = ctx.size();
        while (! ctx.empty() ) {
            NDC.push( (String) ctx.pop() );
        }
        */
    try {
        log.info("creating client");
        final GridFTPClient cnt = new GridFTPClient(host, port);
        credProvider.installCredentials(cnt);
        validateClient(cnt);
        return cnt;
    } finally {
        MDC.remove("host");
    //            for( int i=0; i < stacksize; ++i )
    //                ctx.push( NDC.pop() );
    }
}

@Test
public void mdc() throws Exception {
    HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
    Mockito.when(request.getUserPrincipal()).thenReturn(null);
    Mockito.when(request.getMethod()).thenReturn("METHOD");
    Mockito.when(request.getPathInfo()).thenReturn("/pathinfo");
    ServletResponse response = Mockito.mock(ServletResponse.class);
    final AtomicBoolean invoked = new AtomicBoolean();
    FilterChain chain = new FilterChain() {

        @Override
        public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse) throws IOException, ServletException {
            assertEquals(MDC.get("hostname"), null);
            assertEquals(MDC.get("user"), null);
            assertEquals(MDC.get("method"), "METHOD");
            assertEquals(MDC.get("path"), "/pathinfo");
            invoked.set(true);
        }
    };
    MDC.clear();
    Filter filter = new MDCFilter();
    filter.init(null);
    filter.doFilter(request, response, chain);
    assertTrue(invoked.get());
    assertNull(MDC.get("hostname"));
    assertNull(MDC.get("user"));
    assertNull(MDC.get("method"));
    assertNull(MDC.get("path"));
    Mockito.when(request.getUserPrincipal()).thenReturn(new Principal() {

        @Override
        public String getName() {
            return "name";
        }
    });
    invoked.set(false);
    chain = new FilterChain() {

        @Override
        public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse) throws IOException, ServletException {
            assertEquals(MDC.get("hostname"), null);
            assertEquals(MDC.get("user"), "name");
            assertEquals(MDC.get("method"), "METHOD");
            assertEquals(MDC.get("path"), "/pathinfo");
            invoked.set(true);
        }
    };
    filter.doFilter(request, response, chain);
    assertTrue(invoked.get());
    HostnameFilter.HOSTNAME_TL.set("HOST");
    invoked.set(false);
    chain = new FilterChain() {

        @Override
        public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse) throws IOException, ServletException {
            assertEquals(MDC.get("hostname"), "HOST");
            assertEquals(MDC.get("user"), "name");
            assertEquals(MDC.get("method"), "METHOD");
            assertEquals(MDC.get("path"), "/pathinfo");
            invoked.set(true);
        }
    };
    filter.doFilter(request, response, chain);
    assertTrue(invoked.get());
    HostnameFilter.HOSTNAME_TL.remove();
    filter.destroy();
}

@Test
public void mdc() throws Exception {
    HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
    Mockito.when(request.getUserPrincipal()).thenReturn(null);
    Mockito.when(request.getMethod()).thenReturn("METHOD");
    Mockito.when(request.getPathInfo()).thenReturn("/pathinfo");
    ServletResponse response = Mockito.mock(ServletResponse.class);
    final AtomicBoolean invoked = new AtomicBoolean();
    FilterChain chain = new FilterChain() {

        @Override
        public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse) throws IOException, ServletException {
            assertEquals(MDC.get("hostname"), null);
            assertEquals(MDC.get("user"), null);
            assertEquals(MDC.get("method"), "METHOD");
            assertEquals(MDC.get("path"), "/pathinfo");
            invoked.set(true);
        }
    };
    MDC.clear();
    Filter filter = new MDCFilter();
    filter.init(null);
    filter.doFilter(request, response, chain);
    assertTrue(invoked.get());
    assertNull(MDC.get("hostname"));
    assertNull(MDC.get("user"));
    assertNull(MDC.get("method"));
    assertNull(MDC.get("path"));
    Mockito.when(request.getUserPrincipal()).thenReturn(new Principal() {

        @Override
        public String getName() {
            return "name";
        }
    });
    invoked.set(false);
    chain = new FilterChain() {

        @Override
        public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse) throws IOException, ServletException {
            assertEquals(MDC.get("hostname"), null);
            assertEquals(MDC.get("user"), "name");
            assertEquals(MDC.get("method"), "METHOD");
            assertEquals(MDC.get("path"), "/pathinfo");
            invoked.set(true);
        }
    };
    filter.doFilter(request, response, chain);
    assertTrue(invoked.get());
    HostnameFilter.HOSTNAME_TL.set("HOST");
    invoked.set(false);
    chain = new FilterChain() {

        @Override
        public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse) throws IOException, ServletException {
            assertEquals(MDC.get("hostname"), "HOST");
            assertEquals(MDC.get("user"), "name");
            assertEquals(MDC.get("method"), "METHOD");
            assertEquals(MDC.get("path"), "/pathinfo");
            invoked.set(true);
        }
    };
    filter.doFilter(request, response, chain);
    assertTrue(invoked.get());
    HostnameFilter.HOSTNAME_TL.remove();
    filter.destroy();
}

@Test
public void mdc() throws Exception {
    HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
    Mockito.when(request.getUserPrincipal()).thenReturn(null);
    Mockito.when(request.getMethod()).thenReturn("METHOD");
    Mockito.when(request.getPathInfo()).thenReturn("/pathinfo");
    ServletResponse response = Mockito.mock(ServletResponse.class);
    final AtomicBoolean invoked = new AtomicBoolean();
    FilterChain chain = new FilterChain() {

        @Override
        public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse) throws IOException, ServletException {
            assertEquals(MDC.get("hostname"), null);
            assertEquals(MDC.get("user"), null);
            assertEquals(MDC.get("method"), "METHOD");
            assertEquals(MDC.get("path"), "/pathinfo");
            invoked.set(true);
        }
    };
    MDC.clear();
    Filter filter = new MDCFilter();
    filter.init(null);
    filter.doFilter(request, response, chain);
    assertTrue(invoked.get());
    assertNull(MDC.get("hostname"));
    assertNull(MDC.get("user"));
    assertNull(MDC.get("method"));
    assertNull(MDC.get("path"));
    Mockito.when(request.getUserPrincipal()).thenReturn(new Principal() {

        @Override
        public String getName() {
            return "name";
        }
    });
    invoked.set(false);
    chain = new FilterChain() {

        @Override
        public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse) throws IOException, ServletException {
            assertEquals(MDC.get("hostname"), null);
            assertEquals(MDC.get("user"), "name");
            assertEquals(MDC.get("method"), "METHOD");
            assertEquals(MDC.get("path"), "/pathinfo");
            invoked.set(true);
        }
    };
    filter.doFilter(request, response, chain);
    assertTrue(invoked.get());
    HostnameFilter.HOSTNAME_TL.set("HOST");
    invoked.set(false);
    chain = new FilterChain() {

        @Override
        public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse) throws IOException, ServletException {
            assertEquals(MDC.get("hostname"), "HOST");
            assertEquals(MDC.get("user"), "name");
            assertEquals(MDC.get("method"), "METHOD");
            assertEquals(MDC.get("path"), "/pathinfo");
            invoked.set(true);
        }
    };
    filter.doFilter(request, response, chain);
    assertTrue(invoked.get());
    HostnameFilter.HOSTNAME_TL.remove();
    filter.destroy();
}

@Test
public void mdc() throws Exception {
    HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
    Mockito.when(request.getUserPrincipal()).thenReturn(null);
    Mockito.when(request.getMethod()).thenReturn("METHOD");
    Mockito.when(request.getPathInfo()).thenReturn("/pathinfo");
    ServletResponse response = Mockito.mock(ServletResponse.class);
    final AtomicBoolean invoked = new AtomicBoolean();
    FilterChain chain = new FilterChain() {

        @Override
        public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse) throws IOException, ServletException {
            assertEquals(MDC.get("hostname"), null);
            assertEquals(MDC.get("user"), null);
            assertEquals(MDC.get("method"), "METHOD");
            assertEquals(MDC.get("path"), "/pathinfo");
            invoked.set(true);
        }
    };
    MDC.clear();
    Filter filter = new MDCFilter();
    filter.init(null);
    filter.doFilter(request, response, chain);
    assertTrue(invoked.get());
    assertNull(MDC.get("hostname"));
    assertNull(MDC.get("user"));
    assertNull(MDC.get("method"));
    assertNull(MDC.get("path"));
    Mockito.when(request.getUserPrincipal()).thenReturn(new Principal() {

        @Override
        public String getName() {
            return "name";
        }
    });
    invoked.set(false);
    chain = new FilterChain() {

        @Override
        public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse) throws IOException, ServletException {
            assertEquals(MDC.get("hostname"), null);
            assertEquals(MDC.get("user"), "name");
            assertEquals(MDC.get("method"), "METHOD");
            assertEquals(MDC.get("path"), "/pathinfo");
            invoked.set(true);
        }
    };
    filter.doFilter(request, response, chain);
    assertTrue(invoked.get());
    HostnameFilter.HOSTNAME_TL.set("HOST");
    invoked.set(false);
    chain = new FilterChain() {

        @Override
        public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse) throws IOException, ServletException {
            assertEquals(MDC.get("hostname"), "HOST");
            assertEquals(MDC.get("user"), "name");
            assertEquals(MDC.get("method"), "METHOD");
            assertEquals(MDC.get("path"), "/pathinfo");
            invoked.set(true);
        }
    };
    filter.doFilter(request, response, chain);
    assertTrue(invoked.get());
    HostnameFilter.HOSTNAME_TL.remove();
    filter.destroy();
}

@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
    try {
        MDC.put(KEY_AUTHENTICATEDUSERNICKNAME, VALUE_ABSENT);
        MDC.put(KEY_USERAGENT, VALUE_ABSENT);
        MDC.put(KEY_USERAGENTCODE, VALUE_ABSENT);
        Optional<ObjectId> authenticatedUserOidOptional = AuthenticationHelper.getAuthenticatedUserObjectId();
        if (authenticatedUserOidOptional.isPresent()) {
            ObjectContext context = serverRuntime.getContext();
            User user = User.getByObjectId(context, authenticatedUserOidOptional.get());
            MDC.put(KEY_AUTHENTICATEDUSERNICKNAME, user.getNickname());
        }
        if (HttpServletRequest.class.isAssignableFrom(request.getClass())) {
            HttpServletRequest hRequest = (HttpServletRequest) request;
            String userAgent = hRequest.getHeader(HttpHeaders.USER_AGENT);
            if (!Strings.isNullOrEmpty(userAgent)) {
                MDC.put(KEY_USERAGENT, userAgent);
                Optional<Agent> agentOptional = browserDetect(userAgent);
                if (agentOptional.isPresent()) {
                    MDC.put(KEY_USERAGENTCODE, agentOptional.get().getCode());
                }
            }
        }
        chain.doFilter(request, response);
    } finally {
        MDC.clear();
    }
}

@Test
public void mdc() throws Exception {
    HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
    Mockito.when(request.getUserPrincipal()).thenReturn(null);
    Mockito.when(request.getMethod()).thenReturn("METHOD");
    Mockito.when(request.getPathInfo()).thenReturn("/pathinfo");
    ServletResponse response = Mockito.mock(ServletResponse.class);
    final AtomicBoolean invoked = new AtomicBoolean();
    FilterChain chain = new FilterChain() {

        @Override
        public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse) throws IOException, ServletException {
            assertEquals(MDC.get("hostname"), null);
            assertEquals(MDC.get("user"), null);
            assertEquals(MDC.get("method"), "METHOD");
            assertEquals(MDC.get("path"), "/pathinfo");
            invoked.set(true);
        }
    };
    MDC.clear();
    Filter filter = new MDCFilter();
    filter.init(null);
    filter.doFilter(request, response, chain);
    assertTrue(invoked.get());
    assertNull(MDC.get("hostname"));
    assertNull(MDC.get("user"));
    assertNull(MDC.get("method"));
    assertNull(MDC.get("path"));
    Mockito.when(request.getUserPrincipal()).thenReturn(new Principal() {

        @Override
        public String getName() {
            return "name";
        }
    });
    invoked.set(false);
    chain = new FilterChain() {

        @Override
        public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse) throws IOException, ServletException {
            assertEquals(MDC.get("hostname"), null);
            assertEquals(MDC.get("user"), "name");
            assertEquals(MDC.get("method"), "METHOD");
            assertEquals(MDC.get("path"), "/pathinfo");
            invoked.set(true);
        }
    };
    filter.doFilter(request, response, chain);
    assertTrue(invoked.get());
    HostnameFilter.HOSTNAME_TL.set("HOST");
    invoked.set(false);
    chain = new FilterChain() {

        @Override
        public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse) throws IOException, ServletException {
            assertEquals(MDC.get("hostname"), "HOST");
            assertEquals(MDC.get("user"), "name");
            assertEquals(MDC.get("method"), "METHOD");
            assertEquals(MDC.get("path"), "/pathinfo");
            invoked.set(true);
        }
    };
    filter.doFilter(request, response, chain);
    assertTrue(invoked.get());
    HostnameFilter.HOSTNAME_TL.remove();
    filter.destroy();
}

private void deliverMetricsContext(String traceId, String parentId, String remote) {
    MetricTraceContext ctx = new MetricTraceContext();
    ctx.setTraceId(traceId);
    Stack<String> stack = new Stack<String>();
    stack.push(parentId);
    ctx.setTraceStack(stack);
    ctx.setRemote(remote);
    MetricTraceContextHolder.setMetricTraceContext(ctx);
    MDC.put("traceId", traceId);
}

@Override
@SuppressFBWarnings(value = "BC_UNCONFIRMED_CAST", justification = "The ServletRequest is cast to an HttpServletRequest which is always the case since all requests use the HTTP protocol.")
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain chain) throws IOException, ServletException {
    try {
        // Store the session Id.
        HttpSession session = ((HttpServletRequest) servletRequest).getSession();
        MDC.put(SESSION_ID_KEY, "sessionId=" + session.getId());
        String userId = "";
        // Try to extract the actual username from the security context.
        if (SecurityContextHolder.getContext().getAuthentication() != null) {
            Object principal = SecurityContextHolder.getContext().getAuthentication().getPrincipal();
            if (principal instanceof User) {
                User user = (User) principal;
                userId = user.getUsername();
            } else {
                userId = principal.toString();
            }
        }
        MDC.put(USER_ID_KEY, "userId=" + userId);
        // Call the next filter in the chain.
        chain.doFilter(servletRequest, servletResponse);
    } finally {
        // Remove the MDC properties to ensure they don't accidentally get used by anybody else.
        MDC.remove(USER_ID_KEY);
        MDC.remove(SESSION_ID_KEY);
    }
}

@Test
public void mdc() throws Exception {
    HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
    Mockito.when(request.getUserPrincipal()).thenReturn(null);
    Mockito.when(request.getMethod()).thenReturn("METHOD");
    Mockito.when(request.getPathInfo()).thenReturn("/pathinfo");
    ServletResponse response = Mockito.mock(ServletResponse.class);
    final AtomicBoolean invoked = new AtomicBoolean();
    FilterChain chain = new FilterChain() {

        @Override
        public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse) throws IOException, ServletException {
            assertEquals(MDC.get("hostname"), null);
            assertEquals(MDC.get("user"), null);
            assertEquals(MDC.get("method"), "METHOD");
            assertEquals(MDC.get("path"), "/pathinfo");
            invoked.set(true);
        }
    };
    MDC.clear();
    Filter filter = new MDCFilter();
    filter.init(null);
    filter.doFilter(request, response, chain);
    assertTrue(invoked.get());
    assertNull(MDC.get("hostname"));
    assertNull(MDC.get("user"));
    assertNull(MDC.get("method"));
    assertNull(MDC.get("path"));
    Mockito.when(request.getUserPrincipal()).thenReturn(new Principal() {

        @Override
        public String getName() {
            return "name";
        }
    });
    invoked.set(false);
    chain = new FilterChain() {

        @Override
        public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse) throws IOException, ServletException {
            assertEquals(MDC.get("hostname"), null);
            assertEquals(MDC.get("user"), "name");
            assertEquals(MDC.get("method"), "METHOD");
            assertEquals(MDC.get("path"), "/pathinfo");
            invoked.set(true);
        }
    };
    filter.doFilter(request, response, chain);
    assertTrue(invoked.get());
    HostnameFilter.HOSTNAME_TL.set("HOST");
    invoked.set(false);
    chain = new FilterChain() {

        @Override
        public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse) throws IOException, ServletException {
            assertEquals(MDC.get("hostname"), "HOST");
            assertEquals(MDC.get("user"), "name");
            assertEquals(MDC.get("method"), "METHOD");
            assertEquals(MDC.get("path"), "/pathinfo");
            invoked.set(true);
        }
    };
    filter.doFilter(request, response, chain);
    assertTrue(invoked.get());
    HostnameFilter.HOSTNAME_TL.remove();
    filter.destroy();
}

@Override
public Object answer(InvocationOnMock invocation) throws Throwable {
    assertThat(MDC.get("server")).isEqualTo("host_example_net_4321");
    assertThat(MDC.get("metric")).isEqualTo("host_example_net_4321.MemoryAlias.ObjectPendingFinalizationCount");
    assertThat(MDC.get("value")).isEqualTo("10");
    assertThat(MDC.get("attributeName")).isEqualTo("ObjectPendingFinalizationCount");
    assertThat(MDC.get("key")).isEqualTo("ObjectPendingFinalizationCount");
    assertThat(MDC.get("epoch")).isEqualTo("0");
    return null;
}

@Override
public void handleRequest(final HttpServerExchange exchange) throws Exception {
    // check if the cid is in the request header
    String cId = exchange.getRequestHeaders().getFirst(Constants.CORRELATION_ID);
    if (cId == null) {
        // if not, generate a UUID and put it into the request header
        cId = Util.getUUID();
        exchange.getRequestHeaders().put(new HttpString(Constants.CORRELATION_ID), cId);
    }
    // Add the cId into MDC so that all log statement will have cId as part of it.
    MDC.put(CID, cId);
    //logger.debug("Init cId:" + cId);
    next.handleRequest(exchange);
}

@Override
public void run() {
    MDC.put("localServerSocketAddress", server.getDisplayableLocalSocketAddress());
    logger.info("POP server {} started", server.getDisplayableLocalSocketAddress());
    while (!shuttingDown) {
        try {
            connectionPermits.acquire();
        } catch (InterruptedException e) {
            if (!shuttingDown)
                logger.debug("Server socket thread was interrupted " + "unexpectedly", e);
            Thread.currentThread().interrupt();
            break;
        }
        SessionThread sessionThread;
        try {
            Socket socket = serverSocket.accept();
            sessionThread = new SessionThread(server, this, socket);
        } catch (IOException e) {
            connectionPermits.release();
            if (!shuttingDown) {
                logger.error("Error accepting connection", e);
            }
            continue;
        }
        // because it will check the count of sessions
        synchronized (this) {
            sessionThreads.add(sessionThread);
        }
        sessionThread.start();
    }
    closeServerSocket();
    logger.info("POP server {} stopped accepting connections", server.getDisplayableLocalSocketAddress());
    MDC.remove("localServerSocketAddress");
}

@Test
public void testDump() {
    MDC.put(MemoryAppender.MDC_DISCRIMINATOR_FIELD, "mysession");
    logger.debug("foo");
    logger.debug("bar");
    MDC.put(MemoryAppender.MDC_DISCRIMINATOR_FIELD, "notMysession");
    logger.debug("baz");
    memoryAppender.dump("mysession");
    verify(dumpAppender, times(2)).doAppend(any());
}

@Override
public F.Promise<Result> call(final Http.Context context) throws Throwable {
    if (PoseidonPropertyService.getProperty("tokenvalidation").equals("disabled")) {
        logger.info("Validation disabled, skipping token validation");
        User dummyuser = User.findByUsername("dummyuser");
        if (dummyuser == null) {
            throw new PoseidonException(Http.Status.BAD_REQUEST, "Dummyuser not configured");
        }
        api.v1.User user = userMapper.mapToApi(dummyuser);
        context.args.put(PoseidonController.USER, user);
        return delegate.call(context);
    }
    // Get token from header or session
    String accessToken = context.request().getHeader(AUTHORIZATION);
    // validate Bearer token in header
    if (invalidBearer(accessToken)) {
        String msg = "Authorization header missing";
        logger.info(msg);
        return notAuthorized(context, msg);
    }
    // bearer exist, do more fine grained validation
    try {
        String tokenUID = accessToken.replaceFirst("Bearer ", "");
        MDC.put("token", tokenUID);
        logger.debug("finding token");
        TokenService tokenService = new TokenService();
        Token token = tokenService.findByTokenValue(tokenUID);
        tokenService.validateToken(token);
        tokenService.validateUser(token);
        tokenService.validateUserPermission(token, configuration.requiredPermission());
        api.v1.User user = userMapper.mapToApi(token.user);
        context.args.put(PoseidonController.USER, user);
        return delegate.call(context);
    } catch (TokenException te) {
        logger.info("TokenException: status {},message {} ", te.getErrorCode(), te.getMessage());
        if (te.getErrorCode() == Http.Status.UNAUTHORIZED) {
            return notAuthorized(context, te.getMessage());
        } else if (te.getErrorCode() == Http.Status.FORBIDDEN) {
            return forbidden(context, te.getMessage());
        } else {
            logger.error("Unhandled status handling TokenException");
            return internalServerError(context, te.getMessage());
        }
    } finally {
        MDC.remove("token");
        MDC.remove("userid");
    }
}

public static Runnable wrap(final Runnable runnable, final Map<String, String> context) {
    return () -> {
        Map<String, String> previous = MDC.getCopyOfContextMap();
        if (context == null) {
            MDC.clear();
        } else {
            MDC.setContextMap(context);
        }
        try {
            runnable.run();
        } finally {
            if (previous == null) {
                MDC.clear();
            } else {
                MDC.setContextMap(previous);
            }
        }
    };
}