public class EvaluatorFilter<E> extends AbstractMatcherFilter<E> {
    EventEvaluator<E> evaluator;
    @Override
    public void start() {
        if (evaluator != null) {
            super.start();
        } else {
            addError("No evaluator set for filter " + this.getName());
        }
    }
    public EventEvaluator<E> getEvaluator() {
        return evaluator;
    }
    public void setEvaluator(EventEvaluator<E> evaluator) {
        this.evaluator = evaluator;
    }
    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;
        }
    }
}

public interface EventEvaluator<E> extends ContextAware, LifeCycle {
    /**
     * Evaluates whether the event passed as parameter matches some user-specified
     * criteria.
     * 
     * <p>
     * The <code>Evaluator</code> is free to evaluate the event as it pleases. In
     * particular, the evaluation results <em>may</em> depend on previous events.
     * 
     * @param event The event to evaluate
     * @return true if there is a match, false otherwise.
     * @throws NullPointerException can be thrown in presence of null values
     * @throws EvaluationException  may be thrown during faulty evaluation
     */
    boolean evaluate(E event) throws NullPointerException, EvaluationException;
    /**
     * Evaluators are named entities.
     * 
     * @return The name of this evaluator.
     */
    String getName();
    /**
     * Evaluators are named entities.
     */
    void setName(String name);
}

abstract public class EventEvaluatorBase<E> extends ContextAwareBase implements EventEvaluator<E> {
    String name;
    boolean started;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        if (this.name != null) {
            throw new IllegalStateException("name has been already set");
        }
        this.name = name;
    }
    public boolean isStarted() {
        return started;
    }
    public void start() {
        started = true;
    }
    public void stop() {
        started = false;
    }
}

public class OnMarkerEvaluator extends EventEvaluatorBase<ILoggingEvent> {
    List<String> markerList = new ArrayList<String>();
    public void addMarker(String markerStr) {
        markerList.add(markerStr);
    }
    /**
     * Return true if event passed as parameter contains one of the specified
     * user-markers.
     */
    public boolean evaluate(ILoggingEvent event) throws NullPointerException, EvaluationException {
        List<Marker> markerListInEvent = event.getMarkerList();
        if (markerListInEvent == null || markerListInEvent.isEmpty()) {
            return false;
        }
        for (String markerStr : markerList) {
            for (Marker markerInEvent : markerListInEvent) {
                if (markerInEvent.contains(markerStr)) {
                    return true;
                }
            }
        }
        return false;
    }
}

public class OnErrorEvaluator extends EventEvaluatorBase<ILoggingEvent> {
    /**
     * 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;
    }
}

abstract public class JaninoEventEvaluatorBase<E> extends EventEvaluatorBase<E> {
    static Class<?> EXPRESSION_TYPE = boolean.class;
    static Class<?>[] THROWN_EXCEPTIONS = new Class[1];
    static public final int ERROR_THRESHOLD = 4;
    static {
        THROWN_EXCEPTIONS[0] = EvaluationException.class;
    }
    private String expression;
    ScriptEvaluator scriptEvaluator;
    private int errorCount = 0;
    public void start() {
        try {
            assert context != null;
            scriptEvaluator = new ScriptEvaluator(getDecoratedExpression(), EXPRESSION_TYPE, getParameterNames(),
                    getParameterTypes(), THROWN_EXCEPTIONS);
            super.start();
        } catch (Exception e) {
            addError("Could not start evaluator with expression [" + expression + "]", e);
        }
    }
    public boolean evaluate(E event) throws EvaluationException {
        if (!isStarted()) {
            throw new IllegalStateException("Evaluator [" + name + "] was called in stopped state");
        }
        try {
            Boolean result = (Boolean) scriptEvaluator.evaluate(getParameterValues(event));
            return result;
        } catch (Exception ex) {
            errorCount++;
            if (errorCount >= ERROR_THRESHOLD) {
                stop();
            }
            throw new EvaluationException("Evaluator [" + name + "] caused an exception", ex);
        }
    }
    //......
}

<filter class="ch.qos.logback.core.filter.EvaluatorFilter">
              <evaluator class="ch.qos.logback.classic.boolex.OnMarkerEvaluator">
                  <marker>consoleOnly</marker>
              </evaluator>
              <onMatch>DENY</onMatch>
            </filter>