View Javadoc

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 }