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.appender;
18  
19  import java.io.Serializable;
20  
21  import org.apache.logging.log4j.Logger;
22  import org.apache.logging.log4j.core.Appender;
23  import org.apache.logging.log4j.core.ErrorHandler;
24  import org.apache.logging.log4j.core.Filter;
25  import org.apache.logging.log4j.core.Layout;
26  import org.apache.logging.log4j.core.LifeCycle;
27  import org.apache.logging.log4j.core.LogEvent;
28  import org.apache.logging.log4j.core.filter.AbstractFilterable;
29  import org.apache.logging.log4j.status.StatusLogger;
30  
31  /**
32   * Abstract base class for Appenders. Although Appenders do not have to extend this class, doing so
33   * will simplify their implementation.
34   *
35   * @param <T> The {@link Layout}'s {@link Serializable} type.
36   */
37  public abstract class AbstractAppender<T extends Serializable> extends AbstractFilterable
38      implements Appender<T>, LifeCycle {
39      /**
40       * Allow subclasses access to the status logger without creating another instance.
41       */
42      protected static final Logger LOGGER = StatusLogger.getLogger();
43  
44      /**
45       * Appenders set this by calling super.start().
46       */
47      private boolean started = false;
48  
49      private final Layout<T> layout;
50  
51      private final String name;
52  
53      private final boolean handleException;
54  
55      private ErrorHandler handler = new DefaultErrorHandler(this);
56  
57      /**
58       * Constructor that defaults to suppressing exceptions.
59       * @param name The Appender name.
60       * @param filter The Filter to associate with the Appender.
61       * @param layout The layout to use to format the event.
62       */
63      protected AbstractAppender(final String name, final Filter filter, final Layout<T> layout) {
64          this(name, filter, layout, true);
65      }
66  
67      /**
68       * Constructor.
69       * @param name The Appender name.
70       * @param filter The Filter to associate with the Appender.
71       * @param layout The layout to use to format the event.
72       * @param handleException If true, exceptions will be logged and suppressed. If false errors will be
73       * logged and then passed to the application.
74       */
75      protected AbstractAppender(final String name, final Filter filter, final Layout<T> layout,
76                                 final boolean handleException) {
77          super(filter);
78          this.name = name;
79          this.layout = layout;
80          this.handleException = handleException;
81      }
82  
83      /**
84       * Returns the ErrorHandler, if any.
85       * @return The ErrorHandler.
86       */
87      @Override
88      public ErrorHandler getHandler() {
89          return handler;
90      }
91  
92      /**
93       * The handler must be set before the appender is started.
94       * @param handler The ErrorHandler to use.
95       */
96      @Override
97      public void setHandler(final ErrorHandler handler) {
98          if (handler == null) {
99              LOGGER.error("The handler cannot be set to null");
100         }
101         if (isStarted()) {
102             LOGGER.error("The handler cannot be changed once the appender is started");
103             return;
104         }
105         this.handler = handler;
106     }
107 
108     /**
109      * Returns the name of the Appender.
110      * @return The name of the Appender.
111      */
112     @Override
113     public String getName() {
114         return name;
115     }
116 
117     /**
118      * Returns the Layout for the appender.
119      * @return The Layout used to format the event.
120      */
121     @Override
122     public Layout<T> getLayout() {
123         return layout;
124     }
125 
126     /**
127      * Some appenders need to propagate exceptions back to the application. When suppressException is false the
128      * AppenderControl will allow the exception to percolate.
129      * @return true if exceptions will be suppressed, false otherwise.
130      */
131     @Override
132     public boolean isExceptionSuppressed() {
133         return handleException;
134     }
135 
136     /**
137      * Start the Appender.
138      */
139     @Override
140     public void start() {
141         startFilter();
142         this.started = true;
143     }
144 
145     /**
146      * Stop the Appender.
147      */
148     @Override
149     public void stop() {
150         this.started = false;
151         stopFilter();
152     }
153 
154     /**
155      * Returns true if the Appender is started, false otherwise.
156      * @return true if the Appender is started, false otherwise.
157      */
158     @Override
159     public boolean isStarted() {
160         return started;
161     }
162 
163     @Override
164     public String toString() {
165         return name;
166     }
167 
168     /**
169      * Handle an error with a message.
170      * @param msg The message.
171      */
172     public void error(final String msg) {
173         handler.error(msg);
174     }
175 
176     /**
177      * Handle an error with a message and an exception.
178      * @param msg The message.
179      * @param t The Throwable.
180      */
181     public void error(final String msg, final Throwable t) {
182         handler.error(msg, t);
183     }
184 
185     /**
186      * Handle an error with a message, and exception and a logging event.
187      * @param msg The message.
188      * @param event The LogEvent.
189      * @param t The Throwable.
190      */
191     public void error(final String msg, final LogEvent event, final Throwable t) {
192         handler.error(msg, event, t);
193     }
194 
195 }