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(Result onMatch, 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      public void start() {
73          started = true;
74      }
75  
76      /**
77       * Determine if the the Filter has started.
78       * @return true if the Filter is started, false otherwise.
79       */
80      public boolean isStarted() {
81          return started;
82      }
83  
84      /**
85       * Mark the Filter as stopped.
86       */
87      public void stop() {
88          started = false;
89      }
90  
91      /**
92       * Returns the Result to be returned when a match does not occur.
93       * @return the onMismatch Result.
94       */
95      public final Result getOnMismatch() {
96          return onMismatch;
97      }
98  
99      /**
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(Logger logger, Level level, Marker marker, String msg, Object[] params) {
122         return Result.NEUTRAL;
123     }
124 
125     /**
126      * Appender Filter method. The default returns NEUTRAL.
127      * @param logger the Logger.
128      * @param level The logging Level.
129      * @param marker The Marker, if any.
130      * @param msg The message, if present.
131      * @param t A throwable or null.
132      * @return The Result of filtering.
133      */
134     public Result filter(Logger logger, Level level, Marker marker, Object msg, Throwable t) {
135         return Result.NEUTRAL;
136     }
137 
138     /**
139      * Appender Filter method. The default returns NEUTRAL.
140      * @param logger the Logger.
141      * @param level The logging Level.
142      * @param marker The Marker, if any.
143      * @param msg The message, if present.
144      * @param t A throwable or null.
145      * @return The Result of filtering.
146      */
147     public Result filter(Logger logger, Level level, Marker marker, Message msg, Throwable t) {
148         return Result.NEUTRAL;
149     }
150 
151     /**
152      * Context Filter method. The default returns NEUTRAL.
153      * @param event The LogEvent.
154      * @return The Result of filtering.
155      */
156     public Result filter(LogEvent event) {
157         return Result.NEUTRAL;
158     }
159 }