001 /* 002 * Licensed to the Apache Software Foundation (ASF) under one or more 003 * contributor license agreements. See the NOTICE file distributed with 004 * this work for additional information regarding copyright ownership. 005 * The ASF licenses this file to You under the Apache license, Version 2.0 006 * (the "License"); you may not use this file except in compliance with 007 * the License. You may obtain a copy of the License at 008 * 009 * http://www.apache.org/licenses/LICENSE-2.0 010 * 011 * Unless required by applicable law or agreed to in writing, software 012 * distributed under the License is distributed on an "AS IS" BASIS, 013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 014 * See the license for the specific language governing permissions and 015 * limitations under the license. 016 */ 017 package org.apache.logging.log4j.core.filter; 018 019 import org.apache.logging.log4j.Level; 020 import org.apache.logging.log4j.Marker; 021 import org.apache.logging.log4j.core.Filter; 022 import org.apache.logging.log4j.core.LifeCycle; 023 import org.apache.logging.log4j.core.LogEvent; 024 import org.apache.logging.log4j.core.Logger; 025 import org.apache.logging.log4j.status.StatusLogger; 026 import org.apache.logging.log4j.message.Message; 027 028 /** 029 * Users should extend this class to implement filters. Filters can be either context wide or attached to 030 * an appender. A filter may choose to support being called only from the context or only from an appender in 031 * which case it will only implement the required method(s). The rest will default to return NEUTRAL. 032 * 033 */ 034 public abstract class AbstractFilter implements Filter, LifeCycle { 035 /** 036 * Allow subclasses access to the status logger without creating another instance. 037 */ 038 protected static final org.apache.logging.log4j.Logger LOGGER = StatusLogger.getLogger(); 039 040 /** 041 * The onMatch Result. 042 */ 043 protected final Result onMatch; 044 045 /** 046 * The onMismatch Result. 047 */ 048 protected final Result onMismatch; 049 050 private boolean started; 051 052 /** 053 * The default constructor. 054 */ 055 protected AbstractFilter() { 056 this(null, null); 057 } 058 059 /** 060 * Constructor that allows the onMatch and onMismatch actions to be set. 061 * @param onMatch The result to return when a match occurs. 062 * @param onMismatch The result to return when a match dos not occur. 063 */ 064 protected AbstractFilter(final Result onMatch, final Result onMismatch) { 065 this.onMatch = onMatch == null ? Result.NEUTRAL : onMatch; 066 this.onMismatch = onMismatch == null ? Result.DENY : onMismatch; 067 } 068 069 /** 070 * Mark the Filter as started. 071 */ 072 public void start() { 073 started = true; 074 } 075 076 /** 077 * Determine if the the Filter has started. 078 * @return true if the Filter is started, false otherwise. 079 */ 080 public boolean isStarted() { 081 return started; 082 } 083 084 /** 085 * Mark the Filter as stopped. 086 */ 087 public void stop() { 088 started = false; 089 } 090 091 /** 092 * Returns the Result to be returned when a match does not occur. 093 * @return the onMismatch Result. 094 */ 095 public final Result getOnMismatch() { 096 return onMismatch; 097 } 098 099 /** 100 * Returns the Result to be returned when a match occurs. 101 * @return the onMatch Result. 102 */ 103 public final Result getOnMatch() { 104 return onMatch; 105 } 106 107 @Override 108 public String toString() { 109 return this.getClass().getSimpleName(); 110 } 111 112 /** 113 * Appender Filter method. The default returns NEUTRAL. 114 * @param logger the Logger. 115 * @param level The logging Level. 116 * @param marker The Marker, if any. 117 * @param msg The message, if present. 118 * @param params An array of parameters or null. 119 * @return The Result of filtering. 120 */ 121 public Result filter(final Logger logger, final Level level, final Marker marker, final String msg, 122 final Object... params) { 123 return Result.NEUTRAL; 124 } 125 126 /** 127 * Appender Filter method. The default returns NEUTRAL. 128 * @param logger the Logger. 129 * @param level The logging Level. 130 * @param marker The Marker, if any. 131 * @param msg The message, if present. 132 * @param t A throwable or null. 133 * @return The Result of filtering. 134 */ 135 public Result filter(final Logger logger, final Level level, final Marker marker, final Object msg, 136 final Throwable t) { 137 return Result.NEUTRAL; 138 } 139 140 /** 141 * Appender Filter method. The default returns NEUTRAL. 142 * @param logger the Logger. 143 * @param level The logging Level. 144 * @param marker The Marker, if any. 145 * @param msg The message, if present. 146 * @param t A throwable or null. 147 * @return The Result of filtering. 148 */ 149 public Result filter(final Logger logger, final Level level, final Marker marker, final Message msg, 150 final Throwable t) { 151 return Result.NEUTRAL; 152 } 153 154 /** 155 * Context Filter method. The default returns NEUTRAL. 156 * @param event The LogEvent. 157 * @return The Result of filtering. 158 */ 159 public Result filter(final LogEvent event) { 160 return Result.NEUTRAL; 161 } 162 }