Example #1
0
  public MDCUnitOfWork(Exchange exchange) {
    super(exchange, LOG);

    // remember existing values
    this.originalExchangeId = MDC.get(MDC_EXCHANGE_ID);
    this.originalMessageId = MDC.get(MDC_MESSAGE_ID);
    this.originalBreadcrumbId = MDC.get(MDC_BREADCRUMB_ID);
    this.originalCorrelationId = MDC.get(MDC_CORRELATION_ID);
    this.originalRouteId = MDC.get(MDC_ROUTE_ID);
    this.originalCamelContextId = MDC.get(MDC_CAMEL_CONTEXT_ID);
    this.originalTransactionKey = MDC.get(MDC_TRANSACTION_KEY);

    // must add exchange and message id in constructor
    MDC.put(MDC_EXCHANGE_ID, exchange.getExchangeId());
    String msgId =
        exchange.hasOut() ? exchange.getOut().getMessageId() : exchange.getIn().getMessageId();
    MDC.put(MDC_MESSAGE_ID, msgId);
    // the camel context id is from exchange
    MDC.put(MDC_CAMEL_CONTEXT_ID, exchange.getContext().getName());
    // and add optional correlation id
    String corrId = exchange.getProperty(Exchange.CORRELATION_ID, String.class);
    if (corrId != null) {
      MDC.put(MDC_CORRELATION_ID, corrId);
    }
    // and add optional breadcrumb id
    String breadcrumbId = exchange.getIn().getHeader(Exchange.BREADCRUMB_ID, String.class);
    if (breadcrumbId != null) {
      MDC.put(MDC_BREADCRUMB_ID, breadcrumbId);
    }
  }
Example #2
0
  @Override
  public void requestInitialized(ServletRequestEvent sre) {
    if (corePlugin.isStagemonitorActive()) {
      final MeasurementSession measurementSession = corePlugin.getMeasurementSession();
      if (measurementSession.getApplicationName() != null) {
        MDC.put("application", measurementSession.getApplicationName());
      }
      if (measurementSession.getHostName() != null) {
        MDC.put("host", measurementSession.getHostName());
      }
      String instanceName = measurementSession.getInstanceName();
      if (instanceName == null) {
        instanceName = sre.getServletRequest().getServerName();
      }
      MDC.put("instance", instanceName);

      final String requestId = UUID.randomUUID().toString();
      sre.getServletRequest().setAttribute(STAGEMONITOR_REQUEST_ID_ATTR, requestId);

      if (Stagemonitor.isStarted()) {
        // don't store the requestId in MDC if stagemonitor is not active
        // so that thread pools that get created on startup don't inherit the requestId
        MDC.put("requestId", requestId);
      }
    }
  }
  @Override
  protected Object invokeUnderTrace(MethodInvocation invocation, Log logger) throws Throwable {

    // MDCにメソッド呼び出し情報をセットする。
    String beforeClassName = MDC.get(MDC_CLASS_NAME);
    String beforeMethodName = MDC.get(MDC_METHOD_NAME);
    MDC.put(MDC_CLASS_NAME, getClassForLogging(invocation.getThis()).getName());
    MDC.put(MDC_METHOD_NAME, invocation.getMethod().getName());

    try {
      return super.invokeUnderTrace(invocation, logger);

    } finally {
      // MDCのメソッド呼び出し情報を元に戻す。
      if (beforeClassName == null) {
        MDC.remove(MDC_CLASS_NAME);
      } else {
        MDC.put(MDC_CLASS_NAME, beforeClassName);
      }
      if (beforeMethodName == null) {
        MDC.remove(MDC_METHOD_NAME);
      } else {
        MDC.put(MDC_METHOD_NAME, beforeMethodName);
      }
    }
  }
Example #4
0
 protected void logQuery(Logger logger, String queryString, Collection<Object> parameters) {
   String normalizedQuery = queryString.replace('\n', ' ');
   MDC.put(QueryBase.MDC_QUERY, normalizedQuery);
   MDC.put(QueryBase.MDC_PARAMETERS, String.valueOf(parameters));
   if (logger.isDebugEnabled()) {
     logger.debug(normalizedQuery);
   }
 }
Example #5
0
 public static void addBotToMDC(PircBotX bot) {
   MDC.put("pircbotx.id", String.valueOf(bot.getBotId()));
   MDC.put(
       "pircbotx.connectionId",
       bot.getServerHostname() + "-" + bot.getBotId() + "-" + bot.getConnectionId());
   MDC.put("pircbotx.server", StringUtils.defaultString(bot.getServerHostname()));
   MDC.put("pircbotx.port", String.valueOf(bot.getServerPort()));
 }
Example #6
0
 @Test
 public void testConvertWithMultipleEntries() {
   MDC.put("testKey", "testValue");
   MDC.put("testKey2", "testValue2");
   ILoggingEvent le = createLoggingEvent();
   String result = converter.convert(le);
   boolean isConform = result.matches("testKey2?=testValue2?, testKey2?=testValue2?");
   assertTrue(result + " is not conform", isConform);
 }
 /** @see wicket.RequestCycle#onBeginRequest() */
 @SuppressWarnings("nls")
 @Override
 protected void onBeginRequest() {
   WebClientSession webClientSession = (WebClientSession) getSession();
   WebClient webClient = webClientSession.getWebClient();
   if (webClient != null) {
     if (webClient.getSolution() != null) {
       MDC.put("clientid", webClient.getClientID());
       MDC.put("solution", webClient.getSolution().getName());
     }
     J2DBGlobals.setServiceProvider(webClient);
     webClient.onBeginRequest(webClientSession);
   }
 }
Example #8
0
 @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();
   }
 }
Example #9
0
 @Test
 public void mdc() throws EvaluationException {
   MDC.put("key", "val");
   LoggingEvent event = makeEvent("x");
   doEvaluateAndCheck("e.mdc['key'] == 'val'", event, true);
   MDC.clear();
 }
Example #10
0
 /**
  * Wrapper around <code>MDC.put</code> and <code>MDC.remove</code>. <code>value</code> is allowed
  * to e null.
  */
 private static void setMdc(String key, String value) {
   if (value != null) {
     MDC.put(key, value);
   } else {
     MDC.remove(key);
   }
 }
  @Override
  public void service(final HttpServletRequest request, final HttpServletResponse response)
      throws ServletException, IOException {
    assert request != null;
    assert response != null;

    // Log the request URI+URL muck
    String uri = request.getRequestURI();
    if (request.getQueryString() != null) {
      uri = String.format("%s?%s", uri, request.getQueryString());
    }

    if (log.isDebugEnabled()) {
      log.debug(
          "Processing: {} {} ({}) [{}]",
          $(request.getMethod(), uri, request.getRequestURL(), request.getHeader(HUDSON_HEADER)));
    }

    MDC.put(getClass().getName(), uri);
    try {
      super.service(request, response);
    } finally {
      MDC.remove(getClass().getName());
    }

    // Include the version details of the api + model
    response.addHeader(HUDSON_HEADER, String.format("api=%s", getApiVersion()));
  }
  public Object step(int step) {
    helper.assertStep(step);
    try {
      MDC.put("fileset", logFilename);
      log.debug("Step " + step);
      Job j = activity.getChild();
      if (j == null) {
        throw helper.cancel(new ERR(), null, "null-job");
      } else if (!(j instanceof MetadataImportJob)) {
        throw helper.cancel(new ERR(), null, "unexpected-job-type", "job-type", j.ice_id());
      }

      if (step == 0) {
        return importMetadata((MetadataImportJob) j);
      } else if (step == 1) {
        return pixelData(null); // (ThumbnailGenerationJob) j);
      } else if (step == 2) {
        return generateThumbnails(null); // (PixelDataJob) j); Nulls image
      } else if (step == 3) {
        // TODO: indexing and scripting here as well.
        store.launchProcessing();
        return null;
      } else if (step == 4) {
        return objects;
      } else {
        throw helper.cancel(new ERR(), null, "bad-step", "step", "" + step);
      }
    } catch (MissingLibraryException mle) {
      notifyObservers(new ErrorHandler.MISSING_LIBRARY(fileName, mle, usedFiles, format));
      throw helper.cancel(new ERR(), mle, "import-missing-library", "filename", fileName);
    } catch (UnsupportedCompressionException uce) {
      // Handling as UNKNOWN_FORMAT for 4.3.0
      notifyObservers(new ErrorHandler.UNKNOWN_FORMAT(fileName, uce, this));
      throw helper.cancel(new ERR(), uce, "import-unknown-format", "filename", fileName);
    } catch (UnknownFormatException ufe) {
      notifyObservers(new ErrorHandler.UNKNOWN_FORMAT(fileName, ufe, this));
      throw helper.cancel(new ERR(), ufe, "import-unknown-format", "filename", fileName);
    } catch (IOException io) {
      notifyObservers(new ErrorHandler.FILE_EXCEPTION(fileName, io, usedFiles, format));
      throw helper.cancel(new ERR(), io, "import-file-exception", "filename", fileName);
    } catch (FormatException fe) {
      notifyObservers(new ErrorHandler.FILE_EXCEPTION(fileName, fe, usedFiles, format));
      throw helper.cancel(new ERR(), fe, "import-file-exception", "filename", fileName);
    } catch (Cancel c) {
      throw c;
    } catch (Throwable t) {
      notifyObservers(
          new ErrorHandler.INTERNAL_EXCEPTION(
              fileName, new RuntimeException(t), usedFiles, format));
      throw helper.cancel(new ERR(), t, "import-request-failure");
    } finally {
      try {
        long size = logPath.size();
        store.updateFileSize(logFile, size);
      } catch (Throwable t) {
        throw helper.cancel(new ERR(), t, "update-log-file-size");
      }
      MDC.clear();
    }
  }
Example #13
0
  public void loginProcess() {

    MDC.put("reqId", ECTUtils.generateToken());

    logger.info("loginProcess!!");

    logger.info("userName : {} , passWord : {}", userName, "********");

    if (!validateLongin()) {
      addError("loggin fial!!");
      return;
    }

    /** * Authen Login */
    try {

      String nPassWord = ECTUtils.encrypt(passWord);

      loginUser = getAuthenDao().loginUser(userName, nPassWord);

    } catch (Exception ex) {

      logger.error("Cannot Authen : ", ex);
      return;
    }

    if (loginUser == null) {

      addError(MessageUtils.getResourceBundleString("login.authen.fail"));

      logger.warn("Login {} fail!!", loginUser);

      return;
    }

    if (!loginUser.getIsActive()) {

      addError(MessageUtils.getResourceBundleString("login.authen.disabled"));

      logger.warn("Login {} block user was disbled!!", loginUser);

      return;
    }

    loggedIn = true;

    super.getRequest().getSession().setAttribute("userAuthen", loginUser);

    addInfo(MessageUtils.getResourceBundleString("login.loginprocess"));

    String path = JsfUtil.getContextPath();

    logger.trace("path : {}", path);

    executeJavaScript(
        "setTimeout(function(){window.location='"
            + path
            + "/pages/form/index.xhtml?firstLogin=true';blockUI.show();},100);");
  }
Example #14
0
 /**
  * Initialize the logger.
  *
  * @param state Source state
  */
 private void initLogger(SourceState state) {
   StringBuilder sb = new StringBuilder();
   sb.append("[");
   sb.append(StringUtils.stripToEmpty(state.getProp(ConfigurationKeys.SOURCE_QUERYBASED_SCHEMA)));
   sb.append("_");
   sb.append(StringUtils.stripToEmpty(state.getProp(ConfigurationKeys.SOURCE_ENTITY)));
   sb.append("]");
   MDC.put("sourceInfo", sb.toString());
 }
Example #15
0
  @Test
  public void testConvertWithOneEntry() {
    String k = "MDCConverterTest_k" + diff;
    String v = "MDCConverterTest_v" + diff;

    MDC.put(k, v);
    ILoggingEvent le = createLoggingEvent();
    String result = converter.convert(le);
    assertEquals(k + "=" + v, result);
  }
 @Override
 public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
   MDC.put("channel", String.format("[id: 0x%08x]", ctx.channel().hashCode()));
   if (evt instanceof IdleStateEvent) {
     LOGGER.error(
         "Idle connection ({}). PDUs received: {}",
         ctx.channel().remoteAddress(),
         this.amountOfResponsesReceived);
   }
   super.userEventTriggered(ctx, evt);
 }
Example #17
0
 /**
  * Test endpoint to generate an unexpected exception. Used to confirm that unexpected exceptions
  * are mapped to WebAPIException types and handled gracefully.
  *
  * @return
  * @throws Exception
  */
 @GET
 @Path("/unhandledexception")
 @Produces(MediaType.TEXT_PLAIN)
 public String getUnhandledException() throws Exception {
   MDC.put(
       "getUnhandledException.someSetting",
       "Fake context specific data that should be logged automatically.");
   m_logger.debug("Throwing InterruptedException for test purposes.");
   // any type of exception will do, as long as it is not a WebAPIException.
   throw new InterruptedException("Something bad happened.");
 }
  /** {@inheritDoc} */
  @Override
  public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
      throws IOException, ServletException {
    try {
      MDC.put(Version.MDC_ATTRIBUTE, Version.getVersion());
      MDC.put(CLIENT_ADDRESS_MDC_ATTRIBUTE, request.getRemoteAddr());
      MDC.put(SERVER_ADDRESS_MDC_ATTRIBUTE, request.getServerName());
      MDC.put(SERVER_PORT_MDC_ATTRIBUTE, Integer.toString(request.getServerPort()));
      if (request instanceof HttpServletRequest) {
        final HttpSession session = ((HttpServletRequest) request).getSession();
        if (session != null) {
          MDC.put(JSESSIONID_MDC_ATTRIBUTE, session.getId());
        }
      }

      chain.doFilter(request, response);
    } finally {
      MDC.clear();
    }
  }
Example #19
0
 /**
  * Test endpoint to generate an AMServerProtocolException with a message.
  *
  * @return
  * @throws Exception
  */
 @GET
 @Path("/amserverprotocolexception1")
 @Produces(MediaType.TEXT_PLAIN)
 public String getAMServerProtocolException1() throws Exception {
   MDC.put(
       "getAMServerProtocolException1.someSetting",
       "Fake context specific data that should be logged automatically.");
   m_logger.debug("Throwing AMServerProtocolException for test purposes.");
   // Note that in this case there is no error code and no context data.
   throw new AMServerProtocolException(
       "Uploading the content failed.", "myserver:myport", "Could not find file.");
 }
Example #20
0
  @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);
  }
Example #21
0
    public void done(boolean doneSync) {
      try {
        if (!doneSync) {
          // when done asynchronously then restore information from previous thread
          if (breadcrumbId != null) {
            MDC.put(MDC_BREADCRUMB_ID, breadcrumbId);
          }
          if (exchangeId != null) {
            MDC.put(MDC_EXCHANGE_ID, exchangeId);
          }
          if (messageId != null) {
            MDC.put(MDC_MESSAGE_ID, messageId);
          }
          if (correlationId != null) {
            MDC.put(MDC_CORRELATION_ID, correlationId);
          }
          if (camelContextId != null) {
            MDC.put(MDC_CAMEL_CONTEXT_ID, camelContextId);
          }
        }
        // need to setup the routeId finally
        if (routeId != null) {
          MDC.put(MDC_ROUTE_ID, routeId);
        }

      } finally {
        // muse ensure delegate is invoked
        delegate.done(doneSync);
      }
    }
  @Override
  protected void channelRead0(ChannelHandlerContext ctx, ByteBuf ucpPacket) throws Exception {
    MDC.put("channel", String.format("[id: 0x%08x]", ctx.channel().hashCode()));

    this.amountOfResponsesReceived++;

    if (this.amountOfResponsesReceived
        == this.amountOfMessages) { // each packet has had its response
      LOGGER.info("Each packet sent has had its response, closing channel");
      numberOfResultsReceived.incrementAndGet();
      ctx.close();
    }
  }
 // TODO MISSING JAVADOC
 @AroundInvoke
 public Object call(final InvocationContext invocationContext) throws Exception {
   final String id = MDC.get(TRANSACTION_ID);
   if (id != null) {
     return invocationContext.proceed();
   }
   MDC.put(TRANSACTION_ID, Long.toHexString(RANDOM.nextLong()));
   try {
     return invocationContext.proceed();
   } finally {
     MDC.remove(TRANSACTION_ID);
   }
 }
Example #24
0
  @Override
  public <R, E extends Throwable> R doRetryable(
      final IRetryableTask<R, E> task, final IRetryStrategy strategy)
      throws RetryerException, InterruptedException {
    checkArgument(task != null, "task can't be null");
    checkArgument(strategy != null, "strategy can't be null");
    int tryNo = 0;
    final List<Throwable> reasons = Lists.newArrayList();
    MDC.put("task", task.toString());
    try {
      while (true) {
        try {
          log.debug("try #{}...", tryNo);
          if (Thread.interrupted()) {
            throw new InterruptedException("Interrupted on " + tryNo + " try");
          }
          return task.execute(tryNo);
        } catch (InterruptedException e) {
          log.debug("try #{} interrupted: {}", tryNo, e.getMessage());
          throw e;
        } catch (final Throwable reason) {
          log.debug("try #{} failed: {}", tryNo, reason.getMessage());

          reasons.add(reason);

          // cleanup
          if (task.isFatalReason(tryNo, reason)) {
            throw new RetryerException(reasons);
          }

          final RetryInfo retryInfo = strategy.shouldRetry(tryNo, reason);

          if (retryInfo.shouldFail()) {
            throw new RetryerException(reasons);
          } else {
            final long delay = retryInfo.delay();
            if (delay > 0) {
              log.debug("retry after {} ms", delay);
              Thread.sleep(delay);
            } else {
              log.debug("retry now");
            }
          }
        } finally {
          tryNo++;
        }
      }
    } finally {
      MDC.remove("task");
    }
  }
  public void begin(int transactionTimeout) {
    TransactionID txId = currentTransactionIdThreadLocal.get();
    if (txId != null) {
      throw new TransactionException("transaction already started");
    }

    TransactionContext newTx =
        new TransactionContext(transactionTimeout, transactionIDFactory.createTransactionID());
    contextMap.put(newTx.getTransactionId(), newTx);
    currentTransactionIdThreadLocal.set(newTx.getTransactionId());

    MDC.put(MDC_KEY, newTx.getTransactionId().toString());
    LOG.debug("begun transaction {}", newTx.getTransactionId());
  }
  @Override
  public void doFilter(
      ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain)
      throws IOException, ServletException {
    String sessionId = ((HttpServletRequest) servletRequest).getSession().getId();
    String url = ((HttpServletRequest) servletRequest).getRequestURI();
    String httpMethod = ((HttpServletRequest) servletRequest).getMethod();
    String ip = servletRequest.getRemoteAddr();

    try {
      MDC.put(SESSION_ID, sessionId);
      MDC.put(URL, url);
      MDC.put(HTTP_METHOD, httpMethod);
      MDC.put(IP, ip);
      Logger.info("one request started before filter");
      filterChain.doFilter(servletRequest, servletResponse);
      Logger.info("one request finished after filter");
    } finally {
      MDC.remove(SESSION_ID);
      MDC.remove(URL);
      MDC.remove(HTTP_METHOD);
      MDC.remove(IP);
    }
  }
Example #27
0
 /**
  * Test endpoint to generate a BadRequestException with status code, message, errorDescription and
  * some context key value pairs.
  *
  * @return
  * @throws Exception
  */
 @GET
 @Path("/badrequestexception")
 @Produces(MediaType.TEXT_PLAIN)
 public String getBadRequestException() throws Exception {
   MDC.put(
       "getBadRequestException.someSetting",
       "Fake context specific data that should be logged automatically.");
   m_logger.debug("Throwing getBadRequestException for test purposes.");
   // Note that in this case there is no error code and no context data.
   throw new BadRequestException(
       "PARAMETER_DEVICEID_MISSING",
       null,
       ResourceUtilities.DEFAULT_LOCALE,
       ResourceUtilities.NON_LOCALIZABLE_BASE);
 }
Example #28
0
 /**
  * Test endpoint to generate a BadRequestException with status code, message, errorDescription and
  * some context key value pairs.
  *
  * @return
  * @throws Exception
  */
 @GET
 @Path("/internalservererrorexception")
 @Produces(MediaType.TEXT_PLAIN)
 public String getInternalServerErrorException() throws Exception {
   MDC.put(
       "getInternalServerErrorException.someSetting",
       "Fake context specific data that should be logged automatically.");
   m_logger.debug("Throwing InternalServerErrorException for test purposes.");
   // Note that in this case there is no error code and no context data.
   throw new InternalServerErrorException(
       "THIS_IS_INTERNAL_ERROR",
       "SETTING_INI_XYZ_NOT_CONFIGURED",
       null,
       ResourceUtilities.DEFAULT_LOCALE,
       ResourceUtilities.NON_LOCALIZABLE_BASE);
 }
  @Override
  public IUndecorator decorate() throws Exception {
    final String originValue = MDC.get(m_mdcKey);
    MDC.put(m_mdcKey, m_mdcValueProvider.value());

    // Restore origin value upon completion of the command.
    return new IUndecorator() {

      @Override
      public void undecorate(final Throwable throwable) {
        if (originValue != null) {
          MDC.put(m_mdcKey, originValue);
        } else {
          MDC.remove(m_mdcKey);
        }
      }
    };
  }
  @Test
  public void LBCLASSIC_104() throws Exception {
    buildSMTPAppender(smtpServer.getSmtp().getPort(), SYNCHRONOUS);
    smtpAppender.setAsynchronousSending(false);
    smtpAppender.setLayout(buildPatternLayout(lc, DEFAULT_PATTERN));
    smtpAppender.start();
    logger.addAppender(smtpAppender);
    MDC.put("key", "val");
    logger.debug("hello");
    MDC.clear();
    logger.error("an error", new Exception("an exception"));

    MimeMultipart mp = verify(smtpServer, TEST_SUBJECT);
    String body = GreenMailUtil.getBody(mp.getBodyPart(0));
    assertTrue("missing HEADER in body", body.startsWith(HEADER.trim()));
    assertTrue("missing MDC in body", body.contains("key=val"));
    assertTrue("missing FOOTER in body", body.endsWith(FOOTER.trim()));
  }