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 org.apache.mina.core.filterchain.IoFilter;
23  import org.apache.mina.core.filterchain.IoFilterAdapter;
24  import org.apache.mina.core.session.IdleStatus;
25  import org.apache.mina.core.session.IoEventType;
26  import org.apache.mina.core.session.IoSession;
27  import org.apache.mina.core.write.WriteRequest;
28  import org.slf4j.Logger;
29  import org.slf4j.LoggerFactory;
30  
31  /**
32   * Logs all MINA protocol events.  Each event can be
33   * tuned to use a different level based on the user's specific requirements.  Methods
34   * are in place that allow the user to use either the get or set method for each event
35   * and pass in the {@link IoEventType} and the {@link LogLevel}.
36   *
37   * By default, all events are logged to the {@link LogLevel#INFO} level except
38   * {@link IoFilterAdapter#exceptionCaught(IoFilter.NextFilter, IoSession, Throwable)},
39   * which is logged to {@link LogLevel#WARN}.
40   *
41   * @author <a href="http://mina.apache.org">Apache MINA Project</a>
42   * @org.apache.xbean.XBean
43   */
44  public class LoggingFilter extends IoFilterAdapter {
45      /** The logger name */
46      private final String name;
47      
48      /** The logger */
49      private final Logger logger;
50      
51      /** The log level for the exceptionCaught event. Default to WARN. */
52      private LogLevel exceptionCaughtLevel = LogLevel.WARN;
53      
54      /** The log level for the messageSent event. Default to INFO. */
55      private LogLevel messageSentLevel = LogLevel.INFO;
56      
57      /** The log level for the messageReceived event. Default to INFO. */
58      private LogLevel messageReceivedLevel = LogLevel.INFO;
59      
60      /** The log level for the sessionCreated event. Default to INFO. */
61      private LogLevel sessionCreatedLevel = LogLevel.INFO;
62      
63      /** The log level for the sessionOpened event. Default to INFO. */
64      private LogLevel sessionOpenedLevel = LogLevel.INFO;
65      
66      /** The log level for the sessionIdle event. Default to INFO. */
67      private LogLevel sessionIdleLevel = LogLevel.INFO;
68      
69      /** The log level for the sessionClosed event. Default to INFO. */
70      private LogLevel sessionClosedLevel = LogLevel.INFO;
71      
72      /**
73       * Default Constructor.
74       */
75      public LoggingFilter() {
76          this(LoggingFilter.class.getName());
77      }
78      
79      /**
80       * Create a new NoopFilter using a class name
81       * 
82       * @param clazz the cass which name will be used to create the logger
83       */
84      public LoggingFilter(Class<?> clazz) {
85          this(clazz.getName());
86      }
87  
88      /**
89       * Create a new NoopFilter using a name
90       * 
91       * @param name the name used to create the logger. If null, will default to "NoopFilter"
92       */
93      public LoggingFilter(String name) {
94          if (name == null) {
95              this.name = LoggingFilter.class.getName();
96          } else {
97              this.name = name;
98          }
99          
100         logger = LoggerFactory.getLogger(this.name);
101     }
102 
103     /**
104      * @return The logger's name
105      */
106     public String getName() {
107         return name;
108     }
109     
110     /**
111      * Log if the logger and the current event log level are compatible. We log
112      * a message and an exception.
113      * 
114      * @param eventLevel the event log level as requested by the user
115      * @param message the message to log
116      * @param cause the exception cause to log
117      */
118     private void log(LogLevel eventLevel, String message, Throwable cause) {
119         switch (eventLevel) {
120             case TRACE : logger.trace(message, cause); return;
121             case DEBUG : logger.debug(message, cause); return;
122             case INFO  : logger.info(message, cause); return;
123             case WARN  : logger.warn(message, cause); return;
124             case ERROR : logger.error(message, cause); return;
125             default    : return;
126         }
127     }
128 
129     /**
130      * Log if the logger and the current event log level are compatible. We log
131      * a formated message and its parameters. 
132      * 
133      * @param eventLevel the event log level as requested by the user
134      * @param message the formated message to log
135      * @param param the parameter injected into the message
136      */
137     private void log(LogLevel eventLevel, String message, Object param) {
138         switch (eventLevel) {
139             case TRACE : logger.trace(message, param); return;
140             case DEBUG : logger.debug(message, param); return;
141             case INFO  : logger.info(message, param); return;
142             case WARN  : logger.warn(message, param); return;
143             case ERROR : logger.error(message, param); return;
144             default    : return;
145         }
146     }
147 
148     /**
149      * Log if the logger and the current event log level are compatible. We log
150      * a simple message. 
151      * 
152      * @param eventLevel the event log level as requested by the user
153      * @param message the message to log
154      */
155     private void log(LogLevel eventLevel, String message) {
156         switch (eventLevel) {
157             case TRACE : logger.trace(message); return;
158             case DEBUG : logger.debug(message); return;
159             case INFO  : logger.info(message); return;
160             case WARN  : logger.warn(message); return;
161             case ERROR : logger.error(message); return;
162             default    : return;
163         }
164     }
165 
166     @Override
167     public void exceptionCaught(NextFilter nextFilter, IoSession session,
168             Throwable cause) throws Exception {
169         log(exceptionCaughtLevel, "EXCEPTION :", cause);
170         nextFilter.exceptionCaught(session, cause);
171     }
172 
173     @Override
174     public void messageReceived(NextFilter nextFilter, IoSession session,
175             Object message) throws Exception {
176         log(messageReceivedLevel, "RECEIVED: {}", message );
177         nextFilter.messageReceived(session, message);
178     }
179 
180     @Override
181     public void messageSent(NextFilter nextFilter, IoSession session,
182             WriteRequest writeRequest) throws Exception {
183         log(messageSentLevel, "SENT: {}", writeRequest.getMessage() );
184         nextFilter.messageSent(session, writeRequest);
185     }
186 
187     @Override
188     public void sessionCreated(NextFilter nextFilter, IoSession session)
189             throws Exception {
190         log(sessionCreatedLevel, "CREATED");
191         nextFilter.sessionCreated(session);
192     }
193 
194     @Override
195     public void sessionOpened(NextFilter nextFilter, IoSession session)
196     throws Exception {
197         log(sessionOpenedLevel, "OPENED");
198         nextFilter.sessionOpened(session);
199     }
200 
201     @Override
202     public void sessionIdle(NextFilter nextFilter, IoSession session,
203             IdleStatus status) throws Exception {
204         log(sessionIdleLevel, "IDLE");
205         nextFilter.sessionIdle(session, status);
206     }
207 
208     @Override
209     public void sessionClosed(NextFilter nextFilter, IoSession session) throws Exception {
210         log(sessionClosedLevel, "CLOSED");
211         nextFilter.sessionClosed(session);
212     }
213     
214     /**
215      * Set the LogLevel for the ExceptionCaught event.
216      * 
217      * @param level The LogLevel to set
218      */
219     public void setExceptionCaughtLogLevel(LogLevel level) {
220         exceptionCaughtLevel = level;
221     }
222     
223     /**
224      * Get the LogLevel for the ExceptionCaught event.
225      * 
226      * @return The LogLevel for the ExceptionCaught eventType
227      */
228     public LogLevel getExceptionCaughtLogLevel() {
229         return exceptionCaughtLevel;
230     }
231     
232     /**
233      * Set the LogLevel for the MessageReceived event.
234      * 
235      * @param level The LogLevel to set
236      */
237     public void setMessageReceivedLogLevel(LogLevel level) {
238         messageReceivedLevel = level;
239     }
240     
241     /**
242      * Get the LogLevel for the MessageReceived event.
243      * 
244      * @return The LogLevel for the MessageReceived eventType
245      */
246     public LogLevel getMessageReceivedLogLevel() {
247         return messageReceivedLevel;
248     }
249     
250     /**
251      * Set the LogLevel for the MessageSent event.
252      * 
253      * @param level The LogLevel to set
254      */
255     public void setMessageSentLogLevel(LogLevel level) {
256         messageSentLevel = level;
257     }
258     
259     /**
260      * Get the LogLevel for the MessageSent event.
261      * 
262      * @return The LogLevel for the MessageSent eventType
263      */
264     public LogLevel getMessageSentLogLevel() {
265         return messageSentLevel;
266     }
267     
268     /**
269      * Set the LogLevel for the SessionCreated event.
270      * 
271      * @param level The LogLevel to set
272      */
273     public void setSessionCreatedLogLevel(LogLevel level) {
274         sessionCreatedLevel = level;
275     }
276     
277     /**
278      * Get the LogLevel for the SessionCreated event.
279      * 
280      * @return The LogLevel for the SessionCreated eventType
281      */
282     public LogLevel getSessionCreatedLogLevel() {
283         return sessionCreatedLevel;
284     }
285     
286     /**
287      * Set the LogLevel for the SessionOpened event.
288      * 
289      * @param level The LogLevel to set
290      */
291     public void setSessionOpenedLogLevel(LogLevel level) {
292         sessionOpenedLevel = level;
293     }
294     
295     /**
296      * Get the LogLevel for the SessionOpened event.
297      * 
298      * @return The LogLevel for the SessionOpened eventType
299      */
300     public LogLevel getSessionOpenedLogLevel() {
301         return sessionOpenedLevel;
302     }
303     
304     /**
305      * Set the LogLevel for the SessionIdle event.
306      * 
307      * @param level The LogLevel to set
308      */
309     public void setSessionIdleLogLevel(LogLevel level) {
310         sessionIdleLevel = level;
311     }
312     
313     /**
314      * Get the LogLevel for the SessionIdle event.
315      * 
316      * @return The LogLevel for the SessionIdle eventType
317      */
318     public LogLevel getSessionIdleLogLevel() {
319         return sessionIdleLevel;
320     }
321     
322     /**
323      * Set the LogLevel for the SessionClosed event.
324      * 
325      * @param level The LogLevel to set
326      */
327     public void setSessionClosedLogLevel(LogLevel level) {
328         sessionClosedLevel = level;
329     }
330 
331     /**
332      * Get the LogLevel for the SessionClosed event.
333      * 
334      * @return The LogLevel for the SessionClosed eventType
335      */
336     public LogLevel getSessionClosedLogLevel() {
337         return sessionClosedLevel;
338     }
339 }