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.appender;
018    
019    import java.io.Serializable;
020    
021    import org.apache.logging.log4j.core.Appender;
022    import org.apache.logging.log4j.core.ErrorHandler;
023    import org.apache.logging.log4j.core.Filter;
024    import org.apache.logging.log4j.core.LifeCycle;
025    import org.apache.logging.log4j.core.LogEvent;
026    import org.apache.logging.log4j.core.Layout;
027    import org.apache.logging.log4j.core.filter.AbstractFilterable;
028    import org.apache.logging.log4j.status.StatusLogger;
029    import org.apache.logging.log4j.Logger;
030    
031    /**
032     * Abstract base class for Appenders. Although Appenders do not have to extend this class, doing so
033     * will simplify their implementation.
034     *
035     * @param <T> The {@link Layout}'s {@link Serializable} type.
036     */
037    public abstract class AbstractAppender<T extends Serializable> extends AbstractFilterable
038        implements Appender<T>, LifeCycle {
039        /**
040         * Allow subclasses access to the status logger without creating another instance.
041         */
042        protected static final Logger LOGGER = StatusLogger.getLogger();
043    
044        /**
045         * Appenders set this by calling super.start().
046         */
047        private boolean started = false;
048    
049        private final Layout<T> layout;
050    
051        private final String name;
052    
053        private final boolean handleException;
054    
055        private ErrorHandler handler = new DefaultErrorHandler(this);
056    
057        /**
058         * Constructor that defaults to suppressing exceptions.
059         * @param name The Appender name.
060         * @param filter The Filter to associate with the Appender.
061         * @param layout The layout to use to format the event.
062         */
063        protected AbstractAppender(final String name, final Filter filter, final Layout<T> layout) {
064            this(name, filter, layout, true);
065        }
066    
067        /**
068         * Constructor.
069         * @param name The Appender name.
070         * @param filter The Filter to associate with the Appender.
071         * @param layout The layout to use to format the event.
072         * @param handleException If true, exceptions will be logged and suppressed. If false errors will be
073         * logged and then passed to the application.
074         */
075        protected AbstractAppender(final String name, final Filter filter, final Layout<T> layout,
076                                   final boolean handleException) {
077            super(filter);
078            this.name = name;
079            this.layout = layout;
080            this.handleException = handleException;
081        }
082    
083        /**
084         * Returns the ErrorHandler, if any.
085         * @return The ErrorHandler.
086         */
087        public ErrorHandler getHandler() {
088            return handler;
089        }
090    
091        /**
092         * The handler must be set before the appender is started.
093         * @param handler The ErrorHandler to use.
094         */
095        public void setHandler(final ErrorHandler handler) {
096            if (handler == null) {
097                LOGGER.error("The handler cannot be set to null");
098            }
099            if (isStarted()) {
100                LOGGER.error("The handler cannot be changed once the appender is started");
101                return;
102            }
103            this.handler = handler;
104        }
105    
106        /**
107         * Close the stream associated with the Appender.
108         */
109        public void close() {
110    
111        }
112    
113        /**
114         * Returns the name of the Appender.
115         * @return The name of the Appender.
116         */
117        public String getName() {
118            return name;
119        }
120    
121        /**
122         * Returns the Layout for the appender.
123         * @return The Layout used to format the event.
124         */
125        public Layout<T> getLayout() {
126            return layout;
127        }
128    
129        /**
130         * Some appenders need to propogate exceptions back to the application. When suppressException is false the
131         * AppenderControl will allow the exception to percolate.
132         * @return true if exceptions will be supressed, false otherwise.
133         */
134        public boolean isExceptionSuppressed() {
135            return handleException;
136        }
137    
138        /**
139         * Start the Appender.
140         */
141        public void start() {
142            startFilter();
143            this.started = true;
144        }
145    
146        /**
147         * Stop the Appender.
148         */
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        public boolean isStarted() {
159            return started;
160        }
161    
162        @Override
163        public String toString() {
164            return name;
165        }
166    
167        /**
168         * Handle an error with a message.
169         * @param msg The message.
170         */
171        public void error(final String msg) {
172            handler.error(msg);
173        }
174    
175        /**
176         * Handle an error with a message and an exception.
177         * @param msg The message.
178         * @param t The Throwable.
179         */
180        public void error(final String msg, final Throwable t) {
181            handler.error(msg, t);
182        }
183    
184        /**
185         * Handle an error with a message, and exception and a logging event.
186         * @param msg The message.
187         * @param event The LogEvent.
188         * @param t The Throwable.
189         */
190        public void error(final String msg, final LogEvent event, final Throwable t) {
191            handler.error(msg, event, t);
192        }
193    
194    }