NDCMatchFilter for Log4J (1.2), with several modes of matching (equals, equals case insensitive, contains, regex). GPLv3

NDCMatchFilter.java

package net.teration.log4j.filter;

import java.util.regex.Pattern;
import java.util.regex.PatternSyntaxException;

import org.apache.log4j.Logger;
import org.apache.log4j.spi.Filter;
import org.apache.log4j.spi.LoggingEvent;

public class NDCMatchFilter extends Filter {

    private static enum Modes {
        EQUALS, EQUALS_IGNORE_CASE, CONTAINS, REGEX
    }

    private static class FilterContent {

        private String text = "";
        private Pattern pattern;
        private Modes mode;

        public boolean matches(final String _test) {
            if (_test == null) {
                return false;
            }
            switch (mode) {
                case EQUALS:
                    return _test.equals(text);
                case EQUALS_IGNORE_CASE:
                    return _test.equalsIgnoreCase(text);
                case CONTAINS:
                    return _test.contains(text);
                case REGEX:
                    return pattern.matcher(_test).find();
                default:
                    return false;
            }
        }
    }

    private FilterContent include, exclude;

    @Override
    public int decide(final LoggingEvent _event) {
        if (_event != null) {
            if (exclude != null && exclude.matches(_event.getNDC())) {
                return DENY;
            }
            if (include != null) {
                return include.matches(_event.getNDC()) ? ACCEPT : DENY;
            }
        }
        return NEUTRAL;
    }

    public String getInclude() {
        return include == null ? null : include.text;
    }

    public void setInclude(final String _include) {
        include = createFilter(_include);
    }

    public String getExclude() {
        return include == null ? null : exclude.text;
    }

    public void setExclude(final String _exclude) {
        exclude = createFilter(_exclude);
    }

    private FilterContent createFilter(final String _include) {
        final FilterContent fc = new FilterContent();
        fc.mode = Modes.EQUALS;
        fc.text = _include;
        if (_include != null && _include.length() > 0) {
            if (_include.length() > 1) {
                if (_include.charAt(0) == '|') {
                    fc.text = _include.substring(1);
                    fc.mode = Modes.CONTAINS;
                } else if (_include.charAt(0) == '~') {
                    fc.text = _include.substring(1);
                    fc.mode = Modes.EQUALS_IGNORE_CASE;
                } else if (_include.length() > 2 && _include.charAt(0) == '/') {
                    int lastSlash = _include.lastIndexOf('/');
                    if (lastSlash > 1) {
                        // assume regex
                        final String matchString = _include.substring(1, lastSlash);
                        int patternOpts = 0;
                        for (lastSlash++; lastSlash < _include.length(); lastSlash++) {
                            switch (_include.charAt(lastSlash)) {
                                case 'c':
                                    patternOpts |= Pattern.CANON_EQ;
                                    break;
                                case 'i':
                                    patternOpts |= Pattern.CASE_INSENSITIVE;
                                    break;
                                case 'x':
                                    patternOpts |= Pattern.COMMENTS;
                                    break;
                                case 's':
                                    patternOpts |= Pattern.DOTALL;
                                    break;
                                case 'l':
                                    patternOpts |= Pattern.LITERAL;
                                    break;
                                case 'm':
                                    patternOpts |= Pattern.MULTILINE;
                                    break;
                                case 'u':
                                    patternOpts |= Pattern.UNICODE_CASE;
                                    break;
                                case 'd':
                                    patternOpts |= Pattern.UNIX_LINES;
                                    break;
                            }
                        }
                        try {
                            fc.pattern = Pattern.compile(matchString, patternOpts);
                            fc.text = matchString; // not that it matters
                            fc.mode = Modes.REGEX;
                        } catch (final PatternSyntaxException e) {
                            Logger.getLogger(getClass()).error(_include, e);
                        }
                    }
                }
            }
        } else {
            return null;
        }
        return fc;
    }
}

NDCMatchFilterTest.java

package net.teration.log4j.filter;

import junit.framework.TestCase;

import org.apache.log4j.Level;
import org.apache.log4j.Logger;
import org.apache.log4j.NDC;
import org.apache.log4j.spi.Filter;
import org.apache.log4j.spi.LoggingEvent;

public class NDCMatchFilterTest extends TestCase {

    private NDCMatchFilter filter = new NDCMatchFilter();
    private LoggingEvent event = new LoggingEvent("cat", Logger.getRootLogger(), Level.INFO,
            "demoMEssage", null);

    public void testEmpty() {
        NDC.push("test");
        assertEquals(Filter.NEUTRAL, filter.decide(event));
        NDC.pop();
    }

    public void testEqualsInclude() {
        filter.setInclude("test");
        NDC.push("test");
        assertEquals(Filter.ACCEPT, filter.decide(event));
        NDC.pop();
    }

    public void testNotEqualsInclude() {
        filter.setInclude("es");
        NDC.push("test");
        assertEquals(Filter.DENY, filter.decide(event));
        NDC.pop();
    }

    public void testNotContainsMatchInclude() {
        filter.setInclude("es");
        NDC.push("test");
        assertEquals(Filter.DENY, filter.decide(event));
        NDC.pop();
    }

    public void testContainsInclude() {
        filter.setInclude("|es");
        NDC.push("test");
        assertEquals(Filter.ACCEPT, filter.decide(event));
        NDC.pop();
    }

    public void testNotContainsInclude() {
        filter.setInclude("|ex");
        NDC.push("test");
        assertEquals(Filter.DENY, filter.decide(event));
        NDC.pop();
    }

    public void testEqualsCaseInclude() {
        filter.setInclude("~TEST");
        NDC.push("test");
        assertEquals(Filter.ACCEPT, filter.decide(event));
        NDC.pop();
    }

    public void testEqualsCaseNotInclude() {
        filter.setInclude("~TEXT");
        NDC.push("test");
        assertEquals(Filter.DENY, filter.decide(event));
        NDC.pop();
    }

    public void testNotCaseEqualsNotInclude() {
        filter.setInclude("TEST");
        NDC.push("test");
        assertEquals(Filter.DENY, filter.decide(event));
        NDC.pop();
    }

    public void testBC1() {
        filter.setInclude("~");
        NDC.push("test");
        assertEquals(Filter.DENY, filter.decide(event));
        NDC.pop();
    }

    public void testBC2() {
        filter.setInclude("~");
        NDC.push("~");
        assertEquals(Filter.ACCEPT, filter.decide(event));
        NDC.pop();
    }

    public void testBC3() {
        filter.setInclude("||");
        NDC.push("aa|bb");
        assertEquals(Filter.ACCEPT, filter.decide(event));
        NDC.pop();
    }

    public void testBC4() {
        filter.setInclude("/");
        NDC.push("aa|bb");
        assertEquals(Filter.DENY, filter.decide(event));
        NDC.pop();
    }

    public void testBC5() {
        filter.setInclude("/");
        NDC.push("/");
        assertEquals(Filter.ACCEPT, filter.decide(event));
        NDC.pop();
    }

    public void testBC4a() {
        filter.setInclude("/test");
        NDC.push("aa|bb");
        assertEquals(Filter.DENY, filter.decide(event));
        NDC.pop();
    }

    public void testBC5a() {
        filter.setInclude("/test");
        NDC.push("/test");
        assertEquals(Filter.ACCEPT, filter.decide(event));
        NDC.pop();
    }

    public void testBC6() {
        filter.setInclude("//");
        NDC.push("test");
        assertEquals(Filter.DENY, filter.decide(event));
        NDC.pop();
    }

    public void testBC7() {
        filter.setInclude("///");
        NDC.push("test");
        assertEquals(Filter.DENY, filter.decide(event));
        NDC.pop();
    }

    public void testBC7a() {
        filter.setInclude("///");
        NDC.push("/");
        assertEquals(Filter.ACCEPT, filter.decide(event));
        NDC.pop();
    }

    public void testBC8() {
        filter.setInclude("/*//");
        NDC.push("test");
        assertEquals(Filter.DENY, filter.decide(event));
        NDC.pop();
    }

    public void testRegexInclude() {
        filter.setInclude("/es/");
        NDC.push("test");
        assertEquals(Filter.ACCEPT, filter.decide(event));
        NDC.pop();
    }

    public void testRegexInclude2() {
        filter.setInclude("/^es/");
        NDC.push("test");
        assertEquals(Filter.DENY, filter.decide(event));
        NDC.pop();
    }

    public void testRegexInclude3() {
        filter.setInclude("/eS/");
        NDC.push("test");
        assertEquals(Filter.DENY, filter.decide(event));
        NDC.pop();
    }

    public void testRegexInclude4() {
        filter.setInclude("/eS/i");
        NDC.push("test");
        assertEquals(Filter.ACCEPT, filter.decide(event));
        NDC.pop();
    }

    public void testRegexInclude5() {
        filter.setInclude("/eST/bahi");
        NDC.push("test");
        assertEquals(Filter.ACCEPT, filter.decide(event));
        NDC.pop();
    }

    public void testRegexInclude6() {
        filter.setInclude("/e/s/");
        NDC.push("te/st");
        assertEquals(Filter.ACCEPT, filter.decide(event));
        NDC.pop();
    }

    public void testRegexInclude7() {
        filter.setInclude("/^tes/");
        NDC.push("test");
        assertEquals(Filter.ACCEPT, filter.decide(event));
        NDC.pop();
    }

    public void testRegexInclude8() {
        filter.setInclude("/est$/");
        NDC.push("test");
        assertEquals(Filter.ACCEPT, filter.decide(event));
        NDC.pop();
    }

    public void testRegexInclude9() {
        filter.setInclude("/EsT$/bahi");
        NDC.push("test");
        assertEquals(Filter.ACCEPT, filter.decide(event));
        NDC.pop();
    }

    public void testNoNDC() {
        filter.setInclude("test");
        filter.setExclude("xtest");
        assertEquals(Filter.DENY, filter.decide(event));
    }

    public void testNoNDCNoInclude() {
        filter.setExclude("xtest");
        assertEquals(Filter.NEUTRAL, filter.decide(event));
    }

    public void testNull() {
        assertEquals(Filter.NEUTRAL, filter.decide(null));
    }

    public void testNoNDCNoExclude() {
        filter.setInclude("xtest");
        assertEquals(Filter.DENY, filter.decide(event));
    }

    public void testNullNDC() {
        filter.setInclude("test");
        filter.setExclude("xtest");
        NDC.push(null);
        assertEquals(Filter.DENY, filter.decide(event));
        NDC.pop();
    }

    public void testEmptyNDC() {
        filter.setExclude("xtest");
        NDC.push("");
        assertEquals(Filter.NEUTRAL, filter.decide(event));
        NDC.pop();
    }

    public void testEmptyNDCInclude() {
        filter.setInclude("xtest");
        NDC.push("");
        assertEquals(Filter.DENY, filter.decide(event));
        NDC.pop();
    }

    public void testEmptyNDCIncludeRegex() {
        filter.setInclude("/.*/");
        NDC.push("");
        assertEquals(Filter.ACCEPT, filter.decide(event));
        NDC.pop();
    }

    public void testExcludeOnly() {
        filter.setExclude("test");
        NDC.push("test");
        assertEquals(Filter.DENY, filter.decide(event));
        NDC.pop();
    }

    public void testExcludeNoMatch() {
        filter.setExclude("test");
        NDC.push("testx");
        assertEquals(Filter.NEUTRAL, filter.decide(event));
        NDC.pop();
    }

    public void testExcludeRegex1() {
        filter.setExclude("/es/");
        NDC.push("test");
        assertEquals(Filter.DENY, filter.decide(event));
        NDC.pop();
    }

    public void testExcludeRegex2() {
        filter.setExclude("/eS/");
        NDC.push("test");
        assertEquals(Filter.NEUTRAL, filter.decide(event));
        NDC.pop();
    }

    public void testExcludeRegex3() {
        filter.setExclude("/eS/i");
        NDC.push("test");
        assertEquals(Filter.DENY, filter.decide(event));
        NDC.pop();
    }

    public void testIncludeExcludeRegex1() {
        filter.setInclude("/test/l");
        filter.setExclude("/es/");
        NDC.push("test");
        assertEquals(Filter.DENY, filter.decide(event));
        NDC.pop();
    }

    public void testIncludeExcludeRegex2() {
        filter.setInclude("/test/l");
        filter.setExclude("/eS/");
        NDC.push("test");
        assertEquals(Filter.ACCEPT, filter.decide(event));
        NDC.pop();
    }

    public void testIncludeExcludeRegex3() {
        filter.setInclude("/es/");
        filter.setExclude("/eS/");
        NDC.push("test");
        assertEquals(Filter.ACCEPT, filter.decide(event));
        NDC.pop();
    }

    public void testIncludeNull() {
        filter.setInclude(null);
        NDC.push("test");
        assertEquals(Filter.NEUTRAL, filter.decide(event));
        NDC.pop();
    }

    public void testIncludeEmpty() {
        filter.setInclude("");
        NDC.push("test");
        assertEquals(Filter.NEUTRAL, filter.decide(event));
        NDC.pop();
    }

    public void testExcludeNull() {
        filter.setExclude(null);
        NDC.push("test");
        assertEquals(Filter.NEUTRAL, filter.decide(event));
        NDC.pop();
    }

    public void testExcludeEmpty() {
        filter.setExclude("");
        NDC.push("test");
        assertEquals(Filter.NEUTRAL, filter.decide(event));
        NDC.pop();
    }

}