001: /*
002: * Licensed to the Apache Software Foundation (ASF) under one
003: * or more contributor license agreements. See the NOTICE file
004: * distributed with this work for additional information
005: * regarding copyright ownership. The ASF licenses this file
006: * to you under the Apache License, Version 2.0 (the
007: * "License"); you may not use this file except in compliance
008: * with the License. You may obtain a copy of the License at
009: *
010: * http://www.apache.org/licenses/LICENSE-2.0
011: *
012: * Unless required by applicable law or agreed to in writing,
013: * software distributed under the License is distributed on an
014: * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
015: * KIND, either express or implied. See the License for the
016: * specific language governing permissions and limitations
017: * under the License.
018: *
019: */
020: package org.apache.mina.filter.logging;
021:
022: import java.util.Map;
023:
024: import org.apache.mina.common.IdleStatus;
025: import org.apache.mina.common.IoEventType;
026: import org.apache.mina.common.IoFilter;
027: import org.apache.mina.common.IoFilterAdapter;
028: import org.apache.mina.common.IoSession;
029: import org.apache.mina.common.WriteRequest;
030: import org.apache.mina.util.CopyOnWriteMap;
031: import org.slf4j.Logger;
032: import org.slf4j.LoggerFactory;
033:
034: /**
035: * Logs all MINA protocol events. Each event can be
036: * tuned to use a different level based on the user's specific requirements. Methods
037: * are in place that allow the user to use either the get or set method for each event
038: * and pass in the {@link IoEventType} and the {@link LogLevel}.
039: *
040: * By default, all events are logged to the {@link LogLevel#INFO} level except
041: * {@link IoFilterAdapter#exceptionCaught(IoFilter.NextFilter, IoSession, Throwable)},
042: * which is logged to {@link LogLevel#WARN}.
043: *
044: * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
045: * @version $Rev: 616100 $, $Date: 2008-01-28 15:58:32 -0700 (Mon, 28 Jan 2008) $
046: */
047: public class LoggingFilter extends IoFilterAdapter {
048:
049: private final Map<IoEventType, LogLevel> logSettings = new CopyOnWriteMap<IoEventType, LogLevel>();
050: private final String name;
051: private final Logger logger;
052:
053: /**
054: * Default Constructor.
055: */
056: public LoggingFilter() {
057: this (LoggingFilter.class.getName());
058: }
059:
060: public LoggingFilter(Class<?> clazz) {
061: this (clazz.getName());
062: }
063:
064: public LoggingFilter(String name) {
065: if (name == null) {
066: throw new NullPointerException("name should not be null");
067: }
068: this .name = name;
069: this .logger = LoggerFactory.getLogger(name);
070:
071: // Exceptions will be logged to WARN as default.
072: setLogLevel(IoEventType.EXCEPTION_CAUGHT, LogLevel.WARN);
073: setLogLevel(IoEventType.MESSAGE_RECEIVED, LogLevel.INFO);
074: setLogLevel(IoEventType.MESSAGE_SENT, LogLevel.INFO);
075: setLogLevel(IoEventType.SESSION_CLOSED, LogLevel.INFO);
076: setLogLevel(IoEventType.SESSION_CREATED, LogLevel.INFO);
077: setLogLevel(IoEventType.SESSION_IDLE, LogLevel.INFO);
078: setLogLevel(IoEventType.SESSION_OPENED, LogLevel.INFO);
079: }
080:
081: public String getName() {
082: return name;
083: }
084:
085: @Override
086: public void exceptionCaught(NextFilter nextFilter,
087: IoSession session, Throwable cause) throws Exception {
088: getLogLevel(IoEventType.EXCEPTION_CAUGHT).log(logger,
089: "EXCEPTION: ", cause);
090: nextFilter.exceptionCaught(session, cause);
091: }
092:
093: @Override
094: public void messageReceived(NextFilter nextFilter,
095: IoSession session, Object message) throws Exception {
096: log(IoEventType.MESSAGE_RECEIVED, "RECEIVED: {}", message);
097: nextFilter.messageReceived(session, message);
098: }
099:
100: @Override
101: public void messageSent(NextFilter nextFilter, IoSession session,
102: WriteRequest writeRequest) throws Exception {
103: log(IoEventType.MESSAGE_SENT, "SENT: {}", writeRequest
104: .getMessage());
105: nextFilter.messageSent(session, writeRequest);
106: }
107:
108: @Override
109: public void sessionClosed(NextFilter nextFilter, IoSession session)
110: throws Exception {
111: log(IoEventType.SESSION_CLOSED, "CLOSED", null);
112: nextFilter.sessionClosed(session);
113: }
114:
115: @Override
116: public void sessionCreated(NextFilter nextFilter, IoSession session)
117: throws Exception {
118: log(IoEventType.SESSION_CREATED, "CREATED", null);
119: nextFilter.sessionCreated(session);
120: }
121:
122: @Override
123: public void sessionIdle(NextFilter nextFilter, IoSession session,
124: IdleStatus status) throws Exception {
125: log(IoEventType.SESSION_IDLE, "IDLE: {}", status);
126: nextFilter.sessionIdle(session, status);
127: }
128:
129: @Override
130: public void sessionOpened(NextFilter nextFilter, IoSession session)
131: throws Exception {
132: log(IoEventType.SESSION_OPENED, "OPENED", null);
133: nextFilter.sessionOpened(session);
134: }
135:
136: private void log(IoEventType eventType, String format, Object arg) {
137: getLogLevel(eventType)
138: .log(logger, format, new Object[] { arg });
139: }
140:
141: /**
142: * Sets the {@link LogLevel} to be used when exceptions are logged.
143: *
144: * @param logLevel
145: * The {@link LogLevel} to be used when exceptions are logged.
146: */
147: public void setExceptionCaughtLogLevel(LogLevel logLevel) {
148: setLogLevel(IoEventType.EXCEPTION_CAUGHT, logLevel);
149: }
150:
151: /**
152: * Sets the {@link LogLevel} to be used when message received events are logged.
153: *
154: * @param logLevel
155: * The {@link LogLevel} to be used when message received events are logged.
156: */
157: public void setMessageReceivedLogLevel(LogLevel logLevel) {
158: setLogLevel(IoEventType.MESSAGE_RECEIVED, logLevel);
159: }
160:
161: /**
162: * Sets the {@link LogLevel} to be used when message sent events are logged.
163: *
164: * @param logLevel
165: * The {@link LogLevel} to be used when message sent events are logged.
166: */
167: public void setMessageSentLogLevel(LogLevel logLevel) {
168: setLogLevel(IoEventType.MESSAGE_SENT, logLevel);
169: }
170:
171: /**
172: * Sets the {@link LogLevel} to be used when session closed events are logged.
173: *
174: * @param logLevel
175: * The {@link LogLevel} to be used when session closed events are logged.
176: */
177: public void setSessionClosedLogLevel(LogLevel logLevel) {
178: setLogLevel(IoEventType.SESSION_CLOSED, logLevel);
179: }
180:
181: /**
182: * Sets the {@link LogLevel} to be used when session created events are logged.
183: *
184: * @param logLevel
185: * The {@link LogLevel} to be used when session created events are logged.
186: */
187: public void setSessionCreatedLogLevel(LogLevel logLevel) {
188: setLogLevel(IoEventType.SESSION_CREATED, logLevel);
189: }
190:
191: /**
192: * Sets the {@link LogLevel} to be used when session idle events are logged.
193: *
194: * @param logLevel
195: * The {@link LogLevel} to be used when session idle events are logged.
196: */
197: public void setSessionIdleLogLevel(LogLevel logLevel) {
198: setLogLevel(IoEventType.SESSION_IDLE, logLevel);
199: }
200:
201: /**
202: * Sets the {@link LogLevel} to be used when session opened events are logged.
203: *
204: * @param logLevel
205: * The {@link LogLevel} to be used when session opened events are logged.
206: */
207: public void setSessionOpenedLogLevel(LogLevel logLevel) {
208: setLogLevel(IoEventType.SESSION_OPENED, logLevel);
209: }
210:
211: /**
212: * This method sets the log level for the supplied {@link LogLevel}
213: * event.
214: *
215: * @param eventType the type of the event that is to be updated with
216: * the new {@link LogLevel}
217: * @param logLevel the new {@link LogLevel} to be used to log the
218: * specified event
219: */
220: public void setLogLevel(IoEventType eventType, LogLevel logLevel) {
221: if (eventType == null) {
222: throw new NullPointerException("eventType");
223: }
224: if (logLevel == null) {
225: throw new NullPointerException("logLevel");
226: }
227:
228: logSettings.put(eventType, logLevel);
229: }
230:
231: /**
232: * Returns the log level for the supplied event type.
233: *
234: * @param eventType the type of the event
235: */
236: public LogLevel getLogLevel(IoEventType eventType) {
237: if (eventType == null) {
238: throw new NullPointerException("eventType");
239: }
240:
241: return logSettings.get(eventType);
242: }
243:
244: /**
245: * This method returns the {@link LogLevel} that is used to log
246: * exception caught events.
247: *
248: * @return
249: * The {@link LogLevel} used when logging exception caught events
250: */
251: public LogLevel getExceptionCaughtLogLevel() {
252: return getLogLevel(IoEventType.EXCEPTION_CAUGHT);
253: }
254:
255: /**
256: * This method returns the {@link LogLevel} that is used to log
257: * message received events.
258: *
259: * @return
260: * The {@link LogLevel} used when logging message received events
261: */
262: public LogLevel getMessageReceivedLogLevel() {
263: return getLogLevel(IoEventType.MESSAGE_RECEIVED);
264: }
265:
266: /**
267: * This method returns the {@link LogLevel} that is used to log
268: * message sent events.
269: *
270: * @return
271: * The {@link LogLevel} used when logging message sent events
272: */
273: public LogLevel getMessageSentLogLevel() {
274: return getLogLevel(IoEventType.MESSAGE_SENT);
275: }
276:
277: /**
278: * This method returns the {@link LogLevel} that is used to log
279: * session closed events.
280: *
281: * @return
282: * The {@link LogLevel} used when logging session closed events
283: */
284: public LogLevel getSessionClosedLogLevel() {
285: return getLogLevel(IoEventType.SESSION_CLOSED);
286: }
287:
288: /**
289: * This method returns the {@link LogLevel} that is used to log
290: * session created events.
291: *
292: * @return
293: * The {@link LogLevel} used when logging session created events
294: */
295: public LogLevel getSessionCreatedLogLevel() {
296: return getLogLevel(IoEventType.SESSION_CREATED);
297: }
298:
299: /**
300: * This method returns the {@link LogLevel} that is used to log
301: * session idle events.
302: *
303: * @return
304: * The {@link LogLevel} used when logging session idle events
305: */
306: public LogLevel getSessionIdleLogLevel() {
307: return getLogLevel(IoEventType.SESSION_IDLE);
308: }
309:
310: /**
311: * This method returns the {@link LogLevel} that is used to log
312: * session opened events.
313: *
314: * @return
315: * The {@link LogLevel} used when logging session opened events
316: */
317: public LogLevel getSessionOpenedLogLevel() {
318: return getLogLevel(IoEventType.SESSION_OPENED);
319: }
320: }
|