1 /* 2 * Licensed to the Apache Software Foundation (ASF) under one or more 3 * contributor license agreements. See the NOTICE file distributed with 4 * this work for additional information regarding copyright ownership. 5 * The ASF licenses this file to You under the Apache license, Version 2.0 6 * (the "License"); you may not use this file except in compliance with 7 * the License. You may obtain a copy of the License at 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the license for the specific language governing permissions and 15 * limitations under the license. 16 */ 17 package org.apache.logging.log4j.core.filter; 18 19 import org.apache.logging.log4j.Level; 20 import org.apache.logging.log4j.Marker; 21 import org.apache.logging.log4j.core.Filter; 22 import org.apache.logging.log4j.core.LifeCycle; 23 import org.apache.logging.log4j.core.LogEvent; 24 import org.apache.logging.log4j.core.Logger; 25 import org.apache.logging.log4j.status.StatusLogger; 26 import org.apache.logging.log4j.message.Message; 27 28 /** 29 * Users should extend this class to implement filters. Filters can be either context wide or attached to 30 * an appender. A filter may choose to support being called only from the context or only from an appender in 31 * which case it will only implement the required method(s). The rest will default to return NEUTRAL. 32 * 33 */ 34 public abstract class AbstractFilter implements Filter, LifeCycle { 35 /** 36 * Allow subclasses access to the status logger without creating another instance. 37 */ 38 protected static final org.apache.logging.log4j.Logger LOGGER = StatusLogger.getLogger(); 39 40 /** 41 * The onMatch Result. 42 */ 43 protected final Result onMatch; 44 45 /** 46 * The onMismatch Result. 47 */ 48 protected final Result onMismatch; 49 50 private boolean started; 51 52 /** 53 * The default constructor. 54 */ 55 protected AbstractFilter() { 56 this(null, null); 57 } 58 59 /** 60 * Constructor that allows the onMatch and onMismatch actions to be set. 61 * @param onMatch The result to return when a match occurs. 62 * @param onMismatch The result to return when a match dos not occur. 63 */ 64 protected AbstractFilter(final Result onMatch, final Result onMismatch) { 65 this.onMatch = onMatch == null ? Result.NEUTRAL : onMatch; 66 this.onMismatch = onMismatch == null ? Result.DENY : onMismatch; 67 } 68 69 /** 70 * Mark the Filter as started. 71 */ 72 @Override 73 public void start() { 74 started = true; 75 } 76 77 /** 78 * Determine if the the Filter has started. 79 * @return true if the Filter is started, false otherwise. 80 */ 81 @Override 82 public boolean isStarted() { 83 return started; 84 } 85 86 /** 87 * Mark the Filter as stopped. 88 */ 89 @Override 90 public void stop() { 91 started = false; 92 } 93 94 /** 95 * Returns the Result to be returned when a match does not occur. 96 * @return the onMismatch Result. 97 */ 98 @Override 99 public final Result getOnMismatch() { 100 return onMismatch; 101 } 102 103 /** 104 * Returns the Result to be returned when a match occurs. 105 * @return the onMatch Result. 106 */ 107 @Override 108 public final Result getOnMatch() { 109 return onMatch; 110 } 111 112 @Override 113 public String toString() { 114 return this.getClass().getSimpleName(); 115 } 116 117 /** 118 * Appender Filter method. The default returns NEUTRAL. 119 * @param logger the Logger. 120 * @param level The logging Level. 121 * @param marker The Marker, if any. 122 * @param msg The message, if present. 123 * @param params An array of parameters or null. 124 * @return The Result of filtering. 125 */ 126 @Override 127 public Result filter(final Logger logger, final Level level, final Marker marker, final String msg, 128 final Object... params) { 129 return Result.NEUTRAL; 130 } 131 132 /** 133 * Appender Filter method. The default returns NEUTRAL. 134 * @param logger the Logger. 135 * @param level The logging Level. 136 * @param marker The Marker, if any. 137 * @param msg The message, if present. 138 * @param t A throwable or null. 139 * @return The Result of filtering. 140 */ 141 @Override 142 public Result filter(final Logger logger, final Level level, final Marker marker, final Object msg, 143 final Throwable t) { 144 return Result.NEUTRAL; 145 } 146 147 /** 148 * Appender Filter method. The default returns NEUTRAL. 149 * @param logger the Logger. 150 * @param level The logging Level. 151 * @param marker The Marker, if any. 152 * @param msg The message, if present. 153 * @param t A throwable or null. 154 * @return The Result of filtering. 155 */ 156 @Override 157 public Result filter(final Logger logger, final Level level, final Marker marker, final Message msg, 158 final Throwable t) { 159 return Result.NEUTRAL; 160 } 161 162 /** 163 * Context Filter method. The default returns NEUTRAL. 164 * @param event The LogEvent. 165 * @return The Result of filtering. 166 */ 167 @Override 168 public Result filter(final LogEvent event) { 169 return Result.NEUTRAL; 170 } 171 }