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