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.core.config.plugins.Plugin;
26  import org.apache.logging.log4j.core.config.plugins.PluginElement;
27  import org.apache.logging.log4j.core.config.plugins.PluginFactory;
28  import org.apache.logging.log4j.message.Message;
29  
30  import java.util.ArrayList;
31  import java.util.Arrays;
32  import java.util.Collections;
33  import java.util.Iterator;
34  import java.util.List;
35  
36  /**
37   * Composes and invokes one or more filters.
38   */
39  @Plugin(name = "filters", type = "Core", printObject = true)
40  public final class CompositeFilter implements Iterable<Filter>, Filter, LifeCycle {
41  
42      private final List<Filter> filters;
43      private final boolean hasFilters;
44  
45      private boolean isStarted;
46  
47      private CompositeFilter() {
48          this.filters = new ArrayList<Filter>();
49          this.hasFilters = false;
50      }
51  
52      private CompositeFilter(final List<Filter> filters) {
53          if (filters == null) {
54              this.filters = Collections.unmodifiableList(new ArrayList<Filter>());
55              this.hasFilters = false;
56              return;
57          }
58          this.filters = Collections.unmodifiableList(filters);
59          this.hasFilters = this.filters.size() > 0;
60      }
61  
62      public CompositeFilter addFilter(final Filter filter) {
63          final List<Filter> filters = new ArrayList<Filter>(this.filters);
64          filters.add(filter);
65          return new CompositeFilter(Collections.unmodifiableList(filters));
66      }
67  
68      public CompositeFilter removeFilter(final Filter filter) {
69          final List<Filter> filters = new ArrayList<Filter>(this.filters);
70          filters.remove(filter);
71          return new CompositeFilter(Collections.unmodifiableList(filters));
72      }
73  
74      public Iterator<Filter> iterator() {
75          return filters.iterator();
76      }
77  
78      public List<Filter> getFilters() {
79          return filters;
80      }
81  
82      public boolean hasFilters() {
83          return hasFilters;
84      }
85  
86      public int size() {
87          return filters.size();
88      }
89  
90      public void start() {
91          for (final Filter filter : filters) {
92              if (filter instanceof LifeCycle) {
93                  ((LifeCycle) filter).start();
94              }
95          }
96          isStarted = true;
97      }
98  
99      public void stop() {
100         for (final Filter filter : filters) {
101             if (filter instanceof LifeCycle) {
102                 ((LifeCycle) filter).stop();
103             }
104         }
105         isStarted = false;
106     }
107 
108     public boolean isStarted() {
109         return isStarted;
110     }
111 
112     /**
113      * Returns the result that should be returned when the filter does not match the event.
114      *
115      * @return the Result that should be returned when the filter does not match the event.
116      */
117     public Result getOnMismatch() {
118         return Result.NEUTRAL;
119     }
120 
121     /**
122      * Returns the result that should be returned when the filter matches the event.
123      *
124      * @return the Result that should be returned when the filter matches the event.
125      */
126     public Result getOnMatch() {
127         return Result.NEUTRAL;
128     }
129 
130     /**
131      * Filter an event.
132      *
133      * @param logger
134      *            The Logger.
135      * @param level
136      *            The event logging Level.
137      * @param marker
138      *            The Marker for the event or null.
139      * @param msg
140      *            String text to filter on.
141      * @param params
142      *            An array of parameters or null.
143      * @return the Result.
144      */
145     public Result filter(final Logger logger, final Level level, final Marker marker, final String msg,
146                          final Object... params) {
147         Result result = Result.NEUTRAL;
148         for (final Filter filter : filters) {
149             result = filter.filter(logger, level, marker, msg, params);
150             if (result == Result.ACCEPT || result == Result.DENY) {
151                 return result;
152             }
153         }
154         return result;
155     }
156 
157     /**
158      * Filter an event.
159      *
160      * @param logger
161      *            The Logger.
162      * @param level
163      *            The event logging Level.
164      * @param marker
165      *            The Marker for the event or null.
166      * @param msg
167      *            Any Object.
168      * @param t
169      *            A Throwable or null.
170      * @return the Result.
171      */
172     public Result filter(final Logger logger, final Level level, final Marker marker, final Object msg,
173                          final Throwable t) {
174         Result result = Result.NEUTRAL;
175         for (final Filter filter : filters) {
176             result = filter.filter(logger, level, marker, msg, t);
177             if (result == Result.ACCEPT || result == Result.DENY) {
178                 return result;
179             }
180         }
181         return result;
182     }
183 
184     /**
185      * Filter an event.
186      *
187      * @param logger
188      *            The Logger.
189      * @param level
190      *            The event logging Level.
191      * @param marker
192      *            The Marker for the event or null.
193      * @param msg
194      *            The Message
195      * @param t
196      *            A Throwable or null.
197      * @return the Result.
198      */
199     public Result filter(final Logger logger, final Level level, final Marker marker, final Message msg,
200                          final Throwable t) {
201         Result result = Result.NEUTRAL;
202         for (final Filter filter : filters) {
203             result = filter.filter(logger, level, marker, msg, t);
204             if (result == Result.ACCEPT || result == Result.DENY) {
205                 return result;
206             }
207         }
208         return result;
209     }
210 
211     /**
212      * Filter an event.
213      *
214      * @param event
215      *            The Event to filter on.
216      * @return the Result.
217      */
218     public Result filter(final LogEvent event) {
219         Result result = Result.NEUTRAL;
220         for (final Filter filter : filters) {
221             result = filter.filter(event);
222             if (result == Result.ACCEPT || result == Result.DENY) {
223                 return result;
224             }
225         }
226         return result;
227     }
228 
229     @Override
230     public String toString() {
231         final StringBuilder sb = new StringBuilder();
232         for (final Filter filter : filters) {
233             if (sb.length() == 0) {
234                 sb.append("{");
235             } else {
236                 sb.append(", ");
237             }
238             sb.append(filter.toString());
239         }
240         if (sb.length() > 0) {
241             sb.append("}");
242         }
243         return sb.toString();
244     }
245 
246     /**
247      * Create a CompositeFilter.
248      *
249      * @param filters
250      *            An array of Filters to call.
251      * @return The CompositeFilter.
252      */
253     @PluginFactory
254     public static CompositeFilter createFilters(@PluginElement("filters") final Filter[] filters) {
255         final List<Filter> f = filters == null || filters.length == 0 ?
256             new ArrayList<Filter>() : Arrays.asList(filters);
257         return new CompositeFilter(f);
258     }
259 
260 }