View Javadoc

1   /*
2    *  Licensed to the Apache Software Foundation (ASF) under one
3    *  or more contributor license agreements.  See the NOTICE file
4    *  distributed with this work for additional information
5    *  regarding copyright ownership.  The ASF licenses this file
6    *  to you under the Apache License, Version 2.0 (the
7    *  "License"); you may not use this file except in compliance
8    *  with the License.  You may obtain a copy of the License at
9    *
10   *    http://www.apache.org/licenses/LICENSE-2.0
11   *
12   *  Unless required by applicable law or agreed to in writing,
13   *  software distributed under the License is distributed on an
14   *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15   *  KIND, either express or implied.  See the License for the
16   *  specific language governing permissions and limitations
17   *  under the License.
18   *
19   */
20  package org.apache.mina.filter.logging;
21  
22  import java.util.Map;
23  
24  import org.apache.mina.common.IdleStatus;
25  import org.apache.mina.common.IoEventType;
26  import org.apache.mina.common.IoFilter;
27  import org.apache.mina.common.IoFilterAdapter;
28  import org.apache.mina.common.IoSession;
29  import org.apache.mina.common.WriteRequest;
30  import org.apache.mina.util.CopyOnWriteMap;
31  import org.slf4j.Logger;
32  import org.slf4j.LoggerFactory;
33  
34  /**
35   * Logs all MINA protocol events.  Each event can be
36   * tuned to use a different level based on the user's specific requirements.  Methods
37   * are in place that allow the user to use either the get or set method for each event
38   * and pass in the {@link IoEventType} and the {@link LogLevel}.
39   *
40   * By default, all events are logged to the {@link LogLevel#INFO} level except
41   * {@link IoFilterAdapter#exceptionCaught(IoFilter.NextFilter, IoSession, Throwable)},
42   * which is logged to {@link LogLevel#WARN}.
43   *
44   * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
45   * @version $Rev: 616100 $, $Date: 2008-01-28 15:58:32 -0700 (Mon, 28 Jan 2008) $
46   */
47  public class LoggingFilter extends IoFilterAdapter {
48  
49      private final Map<IoEventType, LogLevel> logSettings = new CopyOnWriteMap<IoEventType, LogLevel>();
50      private final String name;
51      private final Logger logger;
52      /**
53       * Default Constructor.
54       */
55      public LoggingFilter() {
56          this(LoggingFilter.class.getName());
57      }
58  
59      public LoggingFilter(Class<?> clazz) {
60          this(clazz.getName());
61      }
62  
63      public LoggingFilter(String name) {
64          if (name == null) {
65              throw new NullPointerException("name should not be null");
66          }
67          this.name = name;
68          this.logger = LoggerFactory.getLogger(name);
69  
70          // Exceptions will be logged to WARN as default.
71          setLogLevel(IoEventType.EXCEPTION_CAUGHT, LogLevel.WARN);
72          setLogLevel(IoEventType.MESSAGE_RECEIVED, LogLevel.INFO);
73          setLogLevel(IoEventType.MESSAGE_SENT, LogLevel.INFO);
74          setLogLevel(IoEventType.SESSION_CLOSED, LogLevel.INFO);
75          setLogLevel(IoEventType.SESSION_CREATED, LogLevel.INFO);
76          setLogLevel(IoEventType.SESSION_IDLE, LogLevel.INFO);
77          setLogLevel(IoEventType.SESSION_OPENED, LogLevel.INFO);
78      }
79  
80      public String getName() {
81          return name;
82      }
83  
84      @Override
85      public void exceptionCaught(NextFilter nextFilter, IoSession session,
86              Throwable cause) throws Exception {
87          getLogLevel(IoEventType.EXCEPTION_CAUGHT).log(logger, "EXCEPTION: ", cause);
88          nextFilter.exceptionCaught(session, cause);
89      }
90  
91      @Override
92      public void messageReceived(NextFilter nextFilter, IoSession session,
93              Object message) throws Exception {
94          log(IoEventType.MESSAGE_RECEIVED, "RECEIVED: {}", message);
95          nextFilter.messageReceived(session, message);
96      }
97  
98      @Override
99      public void messageSent(NextFilter nextFilter, IoSession session,
100             WriteRequest writeRequest) throws Exception {
101         log(IoEventType.MESSAGE_SENT, "SENT: {}", writeRequest.getMessage());
102         nextFilter.messageSent(session, writeRequest);
103     }
104 
105     @Override
106     public void sessionClosed(NextFilter nextFilter, IoSession session) throws Exception {
107         log(IoEventType.SESSION_CLOSED, "CLOSED", null);
108         nextFilter.sessionClosed(session);
109     }
110 
111     @Override
112     public void sessionCreated(NextFilter nextFilter, IoSession session)
113             throws Exception {
114         log(IoEventType.SESSION_CREATED, "CREATED", null);
115         nextFilter.sessionCreated(session);
116     }
117 
118     @Override
119     public void sessionIdle(NextFilter nextFilter, IoSession session,
120             IdleStatus status) throws Exception {
121         log(IoEventType.SESSION_IDLE, "IDLE: {}", status);
122         nextFilter.sessionIdle(session, status);
123     }
124 
125     @Override
126     public void sessionOpened(NextFilter nextFilter, IoSession session)
127             throws Exception {
128         log(IoEventType.SESSION_OPENED, "OPENED", null);
129         nextFilter.sessionOpened(session);
130     }
131 
132     private void log(IoEventType eventType, String format, Object arg) {
133         getLogLevel(eventType).log(logger, format, new Object[] { arg });    
134     }
135 
136     /**
137      * Sets the {@link LogLevel} to be used when exceptions are logged.
138      *
139      * @param logLevel
140      * 	The {@link LogLevel} to be used when exceptions are logged.
141      */
142     public void setExceptionCaughtLogLevel(LogLevel logLevel) {
143         setLogLevel(IoEventType.EXCEPTION_CAUGHT, logLevel);
144     }
145 
146     /**
147      * Sets the {@link LogLevel} to be used when message received events are logged.
148      *
149      * @param logLevel
150      * 	The {@link LogLevel} to be used when message received events are logged.
151      */
152     public void setMessageReceivedLogLevel(LogLevel logLevel) {
153         setLogLevel(IoEventType.MESSAGE_RECEIVED, logLevel);
154     }
155 
156     /**
157      * Sets the {@link LogLevel} to be used when message sent events are logged.
158      *
159      * @param logLevel
160      * 	The {@link LogLevel} to be used when message sent events are logged.
161      */
162     public void setMessageSentLogLevel(LogLevel logLevel) {
163         setLogLevel(IoEventType.MESSAGE_SENT, logLevel);
164     }
165 
166     /**
167      * Sets the {@link LogLevel} to be used when session closed events are logged.
168      *
169      * @param logLevel
170      * 	The {@link LogLevel} to be used when session closed events are logged.
171      */
172     public void setSessionClosedLogLevel(LogLevel logLevel) {
173         setLogLevel(IoEventType.SESSION_CLOSED, logLevel);
174     }
175 
176     /**
177      * Sets the {@link LogLevel} to be used when session created events are logged.
178      *
179      * @param logLevel
180      * 	The {@link LogLevel} to be used when session created events are logged.
181      */
182     public void setSessionCreatedLogLevel(LogLevel logLevel) {
183         setLogLevel(IoEventType.SESSION_CREATED, logLevel);
184     }
185 
186     /**
187      * Sets the {@link LogLevel} to be used when session idle events are logged.
188      *
189      * @param logLevel
190      * 	The {@link LogLevel} to be used when session idle events are logged.
191      */
192     public void setSessionIdleLogLevel(LogLevel logLevel) {
193         setLogLevel(IoEventType.SESSION_IDLE, logLevel);
194     }
195 
196     /**
197      * Sets the {@link LogLevel} to be used when session opened events are logged.
198      *
199      * @param logLevel
200      * 	The {@link LogLevel} to be used when session opened events are logged.
201      */
202     public void setSessionOpenedLogLevel(LogLevel logLevel) {
203         setLogLevel(IoEventType.SESSION_OPENED, logLevel);
204     }
205 
206     /**
207      * This method sets the log level for the supplied {@link LogLevel}
208      * event.
209      *
210      * @param eventType the type of the event that is to be updated with
211      *                  the new {@link LogLevel}
212      * @param logLevel  the new {@link LogLevel} to be used to log the
213      *                  specified event
214      */
215     public void setLogLevel(IoEventType eventType, LogLevel logLevel) {
216         if (eventType == null) {
217             throw new NullPointerException("eventType");
218         }
219         if (logLevel == null) {
220             throw new NullPointerException("logLevel");
221         }
222 
223         logSettings.put(eventType, logLevel);
224     }
225 
226     /**
227      * Returns the log level for the supplied event type.
228      *
229      * @param eventType the type of the event
230      */
231     public LogLevel getLogLevel(IoEventType eventType) {
232         if (eventType == null) {
233             throw new NullPointerException("eventType");
234         }
235 
236         return logSettings.get(eventType);
237     }
238 
239     /**
240      * This method returns the {@link LogLevel} that is used to log
241      * exception caught events.
242      *
243      * @return
244      * 	The {@link LogLevel} used when logging exception caught events
245      */
246     public LogLevel getExceptionCaughtLogLevel() {
247         return getLogLevel(IoEventType.EXCEPTION_CAUGHT);
248     }
249 
250     /**
251      * This method returns the {@link LogLevel} that is used to log
252      * message received events.
253      *
254      * @return
255      * 	The {@link LogLevel} used when logging message received events
256      */
257     public LogLevel getMessageReceivedLogLevel() {
258         return getLogLevel(IoEventType.MESSAGE_RECEIVED);
259     }
260 
261     /**
262      * This method returns the {@link LogLevel} that is used to log
263      * message sent events.
264      *
265      * @return
266      * 	The {@link LogLevel} used when logging message sent events
267      */
268     public LogLevel getMessageSentLogLevel() {
269         return getLogLevel(IoEventType.MESSAGE_SENT);
270     }
271 
272     /**
273      * This method returns the {@link LogLevel} that is used to log
274      * session closed events.
275      *
276      * @return
277      * 	The {@link LogLevel} used when logging session closed events
278      */
279     public LogLevel getSessionClosedLogLevel() {
280         return getLogLevel(IoEventType.SESSION_CLOSED);
281     }
282 
283     /**
284      * This method returns the {@link LogLevel} that is used to log
285      * session created events.
286      *
287      * @return
288      * 	The {@link LogLevel} used when logging session created events
289      */
290     public LogLevel getSessionCreatedLogLevel() {
291         return getLogLevel(IoEventType.SESSION_CREATED);
292     }
293 
294     /**
295      * This method returns the {@link LogLevel} that is used to log
296      * session idle events.
297      *
298      * @return
299      * 	The {@link LogLevel} used when logging session idle events
300      */
301     public LogLevel getSessionIdleLogLevel() {
302         return getLogLevel(IoEventType.SESSION_IDLE);
303     }
304 
305     /**
306      * This method returns the {@link LogLevel} that is used to log
307      * session opened events.
308      *
309      * @return
310      * 	The {@link LogLevel} used when logging session opened events
311      */
312     public LogLevel getSessionOpenedLogLevel() {
313         return getLogLevel(IoEventType.SESSION_OPENED);
314     }
315 }