Java 类ch.qos.logback.core.boolex.EvaluationException 实例源码

public FilterReply decide(E event) {
  // let us not throw an exception
  // see also bug #17.
  if (!isStarted() || !evaluator.isStarted()) {
    return FilterReply.NEUTRAL;
  }
  try {
    if (evaluator.evaluate(event)) {
      return onMatch;
    } else {
      return onMismatch;
    }
  } catch (EvaluationException e) {
    addError("Evaluator " + evaluator.getName() + " threw an exception", e);
    return FilterReply.NEUTRAL;
  }
}

/**
 * Return true if event passed as parameter contains one of the specified
 * user-markers.
 */
public boolean evaluate(ILoggingEvent event) throws NullPointerException,
    EvaluationException {

  Marker eventsMarker = event.getMarker();
  if (eventsMarker == null) {
    return false;
  }

  for (String markerStr : markerList) {
    if (eventsMarker.contains(markerStr)) {
      return true;
    }
  }
  return false;
}

@Test
public void testBogusExp2() {
  jee.setExpression("mdc.get(\"keyXN89\").equals(null)");
  jee.setName("bogus");
  jee.start();

  assertTrue(jee.isStarted());

  ILoggingEvent event = makeLoggingEvent(null);

  for (int i = 0; i < JaninoEventEvaluatorBase.ERROR_THRESHOLD; i++) {
    try {
      jee.evaluate(event);
      fail("should throw an exception");
    } catch (EvaluationException e) {
    }
  }
  // after a few attempts the evaluator should processPriorToRemoval
  assertFalse(jee.isStarted());

}

@Test
public void testSimpleEvaluator() throws NullPointerException, EvaluationException, JoranException {
  JoranConfigurator jc = new JoranConfigurator();
  LoggerContext loggerContext = new LoggerContext();
  jc.setContext(loggerContext);
  jc.doConfigure(ClassicTestConstants.JORAN_INPUT_PREFIX + "simpleEvaluator.xml");


  Map evalMap = (Map) loggerContext.getObject(CoreConstants.EVALUATOR_MAP);
  assertNotNull(evalMap);
  JaninoEventEvaluator evaluator = (JaninoEventEvaluator) evalMap.get("msgEval");
  assertNotNull(evaluator);

  Logger logger = loggerContext.getLogger("xx");
  ILoggingEvent event0 = new LoggingEvent("foo", logger, Level.DEBUG, "Hello world", null, null);
  assertTrue(evaluator.evaluate(event0));

  ILoggingEvent event1 = new LoggingEvent("foo", logger, Level.DEBUG, "random blurb", null, null);
  assertFalse(evaluator.evaluate(event1));
}

@Test
public void testIgnoreMarker() throws NullPointerException, EvaluationException, JoranException {
  JoranConfigurator jc = new JoranConfigurator();
  LoggerContext loggerContext = new LoggerContext();
  jc.setContext(loggerContext);
  jc.doConfigure(ClassicTestConstants.JORAN_INPUT_PREFIX + "ignore.xml");

  Map evalMap = (Map) loggerContext.getObject(CoreConstants.EVALUATOR_MAP);
  assertNotNull(evalMap);

  Logger logger = loggerContext.getLogger("xx");

  JaninoEventEvaluator evaluator = (JaninoEventEvaluator) evalMap.get("IGNORE_EVAL");
  LoggingEvent event = new LoggingEvent("foo", logger, Level.DEBUG, "Hello world",null, null);

  Marker ignoreMarker = MarkerFactory.getMarker("IGNORE");
  event.setMarker(ignoreMarker);
  assertTrue(evaluator.evaluate(event));

  logger.debug("hello", new Exception("test"));
  logger.debug(ignoreMarker, "hello ignore", new Exception("test"));

  //logger.debug("hello", new Exception("test"));

  //StatusPrinter.print(loggerContext.getStatusManager());
}

@Test
public void testMultipleConditionsInExpression() throws NullPointerException, EvaluationException {
  LoggerContext loggerContext = new LoggerContext();
  Logger logger = loggerContext.getLogger("xx");
  JaninoEventEvaluator ee = new JaninoEventEvaluator();
  ee.setName("testEval");
  ee.setContext(loggerContext);
  //&&
  //&&
  ee.setExpression("message.contains(\"stacktrace\") && message.contains(\"logging\")");
  ee.start();
  //StatusPrinter.print(loggerContext);

  String message = "stacktrace bla bla logging";
  ILoggingEvent event = new LoggingEvent(this.getClass().getName(), logger, Level.DEBUG, message, null, null);

  assertTrue(ee.evaluate(event));
}

@Override
public boolean evaluate(ILoggingEvent event) throws NullPointerException,
        EvaluationException {
    long current = System.currentTimeMillis()/1000;
    if(event.getLevel().levelInt >= level.levelInt 
            && current - last > interval
            && using.compareAndSet(false, true)) {
        last = current;
        using.set(false);
        return true;
    }
    return false;
}

@Override
public boolean evaluate(ILoggingEvent event) throws NullPointerException,
        EvaluationException {
    if(event.getLevel().levelInt >= level.levelInt 
            && counter.incrementAndGet() == limit) {
        counter.set(NumberUtils.INTEGER_ZERO);
        return true;
    }
    return false;
}

@Test
public void withNullMarker_LBCORE_118() throws Exception {
  jee.setExpression("marker.contains(\"BLUE\")");
  jee.start();

  ILoggingEvent event = makeLoggingEvent(null);
  try {
    jee.evaluate(event);
    fail("We should not reach this point");
  } catch (EvaluationException ee) {
    // received an exception as expected
  }
}

@Test
public void throwable_LBCLASSIC_155_I() throws EvaluationException {
  jee.setExpression("throwable instanceof java.io.IOException");
  jee.start();

  LoggingEvent event = makeLoggingEvent(new IOException(""));
  assertTrue(jee.evaluate(event));
}

@Test
public void throwable_LBCLASSIC_155_II() throws EvaluationException {
  jee.setExpression("throwableProxy.getClassName().contains(\"IO\")");
  jee.start();

  LoggingEvent event = makeLoggingEvent(new IOException(""));
  assertTrue(jee.evaluate(event));
}

@Test
public void nullMDC() throws EvaluationException {
  MDC.clear();
  jee.setExpression("mdc.isEmpty()");
  jee.start();

  LoggingEvent event = makeLoggingEvent(null);
  assertTrue(jee.evaluate(event));
}

void doEvaluateAndCheck(String expression, ILoggingEvent event, boolean expected) throws EvaluationException {
  gee.setExpression(expression);
  gee.start();

  StatusPrinter.printInCaseOfErrorsOrWarnings(context);
  assertTrue(statusChecker.isErrorFree(0));

  ContextUtil contextUtil = new ContextUtil(context);
  contextUtil.addGroovyPackages(context.getFrameworkPackages());
  contextUtil.addFrameworkPackage(context.getFrameworkPackages(), "ch.qos.logback.classic.boolex");

  boolean result = gee.evaluate(event);
  assertEquals(expected, result);
}

@Test
public void msgRegex() throws EvaluationException {
  LoggingEvent event = makeEvent("Hello world");
  // partial match
  doEvaluateAndCheck("e.message =~ /xyz|wor/", event, true);
  // full match
  doEvaluateAndCheck("e.message ==~ /xyz|wor/", event, false);
}

@Test
public void mdc() throws EvaluationException {
  MDC.put("key", "val");
  LoggingEvent event = makeEvent("x");
  doEvaluateAndCheck("e.mdc['key'] == 'val'", event, true);
  MDC.clear();
}

double loop(GEventEvaluator gee) throws EvaluationException {
  long start = System.nanoTime();
  ILoggingEvent event = makeEvent("x");
  for (int i = 0; i < LEN; i++) {
    gee.evaluate(event);
  }
  long end = System.nanoTime();
  return (end - start) / LEN;
}

@Test
@Ignore
public void MANUAL_perfTest() throws EvaluationException {
  gee.setExpression("event.timeStamp < 100 && event.message != 'xx' ");
  gee.start();

  loop(gee);
  loop(gee);
  double avgDuration = loop(gee);

  long referencePerf = 500;
  BogoPerf.assertDuration(avgDuration, referencePerf,
          CoreConstants.REFERENCE_BIPS);
  System.out.println("Average duration " + avgDuration);
}

@Test
public void smoke() throws EvaluationException {
  evaluator.addMarker("M");
  evaluator.start();

  event.setMarker(MarkerFactory.getMarker("M"));
  assertTrue(evaluator.evaluate(event));
}

public boolean evaluate(Object event) throws NullPointerException,
    EvaluationException {
  counter++;

  if (counter == limit) {
    counter = 0;
    return true;
  } else {
    return false;
  }
}

public boolean evaluate(Object event) throws NullPointerException,
    EvaluationException {
  counter++;

  if (counter == LIMIT) {
    counter = 0;

    return true;
  } else {
    return false;
  }
}

@Override
public boolean evaluate(Object eventObject) throws NullPointerException, EvaluationException {
  IAccessEvent event = (IAccessEvent)eventObject;
  String url = event.getRequestURL();
  for(String expected:URLList) {
    if (url.contains(expected)) {
      return true;
    }
  }
  return false;
}

@Test
public void smoke() throws EvaluationException {
  evaluator.setExpression("event.getProtocol().equals(\"testProtocol\")");
  evaluator.start();
  IAccessEvent ae = new AccessEvent(request, response, serverAdapter);
  assertTrue( evaluator.evaluate(ae));
}

@Test
public void block() throws EvaluationException {
  evaluator.setExpression("String protocol = event.getProtocol();" +
          "return protocol.equals(\"testProtocol\");");
  evaluator.start();
  IAccessEvent ae = new AccessEvent(request, response, serverAdapter);
  assertTrue(evaluator.evaluate(ae));
}

@Test
public void invalidExpression() throws EvaluationException {
  evaluator.setExpression("return true");
  evaluator.start();
  IAccessEvent ae = new AccessEvent(request, response, serverAdapter);
 try {
   evaluator.evaluate(ae);
   fail("Was expecting an exception");
 } catch (IllegalStateException e) {
 }
}

@Test
public void testExpectTrueMultiple() throws EvaluationException {
  evaluator.addURL(expectedURL2);
  request.setRequestUri(expectedURL2);    
  IAccessEvent ae = new AccessEvent(request, response, serverAdapter);
  assertTrue(evaluator.evaluate(ae));    
}

/**
 * Perform SMTPAppender specific appending actions, delegating some of them to a subclass and checking if the event
 * triggers an e-mail to be sent.
 */
protected void append(E eventObject) {
    if (!checkEntryConditions()) {
        return;
    }

    String key = discriminator.getDiscriminatingValue(eventObject);
    long now = System.currentTimeMillis();
    final CyclicBuffer<E> cb = cbTracker.getOrCreate(key, now);
    subAppend(cb, eventObject);

    try {
        if (eventEvaluator.evaluate(eventObject)) {
            // clone the CyclicBuffer before sending out asynchronously
            CyclicBuffer<E> cbClone = new CyclicBuffer<E>(cb);
            // see http://jira.qos.ch/browse/LBCLASSIC-221
            cb.clear();

            if (asynchronousSending) {
                // perform actual sending asynchronously
                SenderRunnable senderRunnable = new SenderRunnable(cbClone,
                        eventObject);
                context.getExecutorService().execute(senderRunnable);
            } else {
                // synchronous sending
                sendBuffer(cbClone, eventObject);
            }
        }
    } catch (EvaluationException ex) {
        errorCount++;

        if (errorCount < CoreConstants.MAX_ERROR_COUNT) {
            addError("SMTPAppender's EventEvaluator threw an Exception-",
                    ex);
        }
    }

    // immediately remove the buffer if asked by the user
    if (eventMarksEndOfLife(eventObject)) {
        cbTracker.endOfLife(key);
    }

    cbTracker.removeStaleComponents(now);

    if ((lastTrackerStatusPrint + delayBetweenStatusMessages) < now) {
        addInfo("SMTPAppender [" + name + "] is tracking ["
                + cbTracker.getComponentCount() + "] buffers");
        lastTrackerStatusPrint = now;

        // quadruple 'delay' assuming less than max delay
        if (delayBetweenStatusMessages < MAX_DELAY_BETWEEN_STATUS_MESSAGES) {
            delayBetweenStatusMessages *= 4;
        }
    }
}

public boolean evaluate(ILoggingEvent event) throws NullPointerException,
        EvaluationException {
    return event.getLevel().levelInt >= Level.WARN_INT;
}

/**
 * Perform SMTPAppender specific appending actions, delegating some of them to
 * a subclass and checking if the event triggers an e-mail to be sent.
 */
protected void append(E eventObject) {

  if (!checkEntryConditions()) {
    return;
  }

  String key = discriminator.getDiscriminatingValue(eventObject);
  long now = System.currentTimeMillis();
  final CyclicBuffer<E> cb = cbTracker.getOrCreate(key, now);
  subAppend(cb, eventObject);

  try {
    if (eventEvaluator.evaluate(eventObject)) {
      // clone the CyclicBuffer before sending out asynchronously
      CyclicBuffer<E> cbClone = new CyclicBuffer<E>(cb);
      // see http://jira.qos.ch/browse/LBCLASSIC-221
      cb.clear();

      if (asynchronousSending) {
        // perform actual sending asynchronously
        SenderRunnable senderRunnable = new SenderRunnable(cbClone, eventObject);
        context.getExecutorService().execute(senderRunnable);
      } else {
        // synchronous sending
        sendBuffer(cbClone, eventObject);
      }
    }
  } catch (EvaluationException ex) {
    errorCount++;
    if (errorCount < CoreConstants.MAX_ERROR_COUNT) {
      addError("SMTPAppender's EventEvaluator threw an Exception-", ex);
    }
  }

  // immediately remove the buffer if asked by the user
  if (eventMarksEndOfLife(eventObject)) {
    cbTracker.endOfLife(key);
  }

  cbTracker.removeStaleComponents(now);

  if (lastTrackerStatusPrint + delayBetweenStatusMessages < now) {
    addInfo("SMTPAppender [" + name + "] is tracking [" + cbTracker.getComponentCount() + "] buffers");
    lastTrackerStatusPrint = now;
    // quadruple 'delay' assuming less than max delay
    if (delayBetweenStatusMessages < MAX_DELAY_BETWEEN_STATUS_MESSAGES) {
      delayBetweenStatusMessages *= 4;
    }
  }
}

public String convert(ILoggingEvent le) {
  StringBuilder buf = new StringBuilder();

  if (evaluatorList != null) {
    boolean printCallerData = false;
    for (int i = 0; i < evaluatorList.size(); i++) {
      EventEvaluator<ILoggingEvent> ee = evaluatorList.get(i);
      try {
        if (ee.evaluate(le)) {
          printCallerData = true;
          break;
        }
      } catch (EvaluationException eex) {
        errorCount++;
        if (errorCount < MAX_ERROR_COUNT) {
          addError("Exception thrown for evaluator named [" + ee.getName()
              + "]", eex);
        } else if (errorCount == MAX_ERROR_COUNT) {
          ErrorStatus errorStatus = new ErrorStatus(
              "Exception thrown for evaluator named [" + ee.getName() + "].",
              this, eex);
          errorStatus.add(new ErrorStatus(
              "This was the last warning about this evaluator's errors."
                  + "We don't want the StatusManager to get flooded.", this));
          addStatus(errorStatus);
        }

      }
    }

    if (!printCallerData) {
      return CoreConstants.EMPTY_STRING;
    }
  }

  StackTraceElement[] cda = le.getCallerData();
  if (cda != null && cda.length > depthStart) {
    int limit = depthEnd < cda.length ? depthEnd : cda.length;

    for (int i = depthStart; i < limit; i++) {
      buf.append(getCallerLinePrefix());
      buf.append(i);
      buf.append("\t at ");
      buf.append(cda[i]);
      buf.append(CoreConstants.LINE_SEPARATOR);
    }
    return buf.toString();
  } else {
    return CallerData.CALLER_DATA_NA;
  }
}

public String convert(ILoggingEvent event) {

    IThrowableProxy tp = event.getThrowableProxy();
    if (tp == null) {
      return CoreConstants.EMPTY_STRING;
    }

    // an evaluator match will cause stack printing to be skipped
    if (evaluatorList != null) {
      boolean printStack = true;
      for (int i = 0; i < evaluatorList.size(); i++) {
        EventEvaluator<ILoggingEvent> ee = evaluatorList.get(i);
        try {
          if (ee.evaluate(event)) {
            printStack = false;
            break;
          }
        } catch (EvaluationException eex) {
          errorCount++;
          if (errorCount < CoreConstants.MAX_ERROR_COUNT) {
            addError("Exception thrown for evaluator named [" + ee.getName()
                    + "]", eex);
          } else if (errorCount == CoreConstants.MAX_ERROR_COUNT) {
            ErrorStatus errorStatus = new ErrorStatus(
                    "Exception thrown for evaluator named [" + ee.getName() + "].",
                    this, eex);
            errorStatus.add(new ErrorStatus(
                    "This was the last warning about this evaluator's errors."
                            + "We don't want the StatusManager to get flooded.", this));
            addStatus(errorStatus);
          }
        }
      }

      if (!printStack) {
        return CoreConstants.EMPTY_STRING;
      }
    }

    return throwableProxyToString(tp);
  }

/**
 * Return true if event passed as parameter has level ERROR or higher, returns
 * false otherwise.
 */
public boolean evaluate(ILoggingEvent event) throws NullPointerException,
    EvaluationException {
  return event.getLevel().levelInt >= Level.ERROR_INT;
}

public boolean evaluate(ILoggingEvent event) throws NullPointerException, EvaluationException {
  if (delegateEvaluator == null) {
    return false;
  }
  return delegateEvaluator.doEvaluate(event);
}

@Test
public void smoke() throws EvaluationException {
  doEvaluateAndCheck("1==1", null, true);
}

@Test
public void level() throws EvaluationException {
  LoggingEvent event = makeEvent("x");
  doEvaluateAndCheck("e.level == DEBUG", event, true);
}

@Test
public void nullMarker() throws EvaluationException {
  LoggingEvent event = makeEvent("x");
  doEvaluateAndCheck("e.marker?.name == 'YELLOW'", event, false);
}

@Test
public void marker() throws EvaluationException {
  LoggingEvent event = makeEvent("x");
  event.setMarker(markerA);
  doEvaluateAndCheck("e.marker?.name == 'A'", event, true);
}

@Test
public void nullMDC() throws EvaluationException {
  LoggingEvent event = makeEvent("x");
  doEvaluateAndCheck("e.mdc?.get('key') == 'val'", event, false);
}

@Test
public void callerData() throws EvaluationException {
  LoggingEvent event = makeEvent("x");
  doEvaluateAndCheck("e.callerData.find{ it.className =~ /junit/ }", event, true);
}

@Test
public void nullMarkerInEvent() throws EvaluationException {
  evaluator.addMarker("M");
  evaluator.start();
  assertFalse(evaluator.evaluate(event));
}

@Test
public void nullMarkerInEvaluator() throws EvaluationException {
  evaluator.addMarker("M");
  evaluator.start();
  assertFalse(evaluator.evaluate(event));
}