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)); }