KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > jboss > web > jsf > integration > config > Log4JConversionFilter


1 /*
2  * JBoss, Home of Professional Open Source
3  * Copyright 2006, JBoss Inc., and individual contributors as indicated
4  * by the @authors tag. See the copyright.txt in the distribution for a
5  * full listing of individual contributors.
6  *
7  * This is free software; you can redistribute it and/or modify it
8  * under the terms of the GNU Lesser General Public License as
9  * published by the Free Software Foundation; either version 2.1 of
10  * the License, or (at your option) any later version.
11  *
12  * This software is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with this software; if not, write to the Free
19  * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
20  * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
21  */
22
23 package org.jboss.web.jsf.integration.config;
24
25 import java.util.HashMap JavaDoc;
26 import java.util.Map JavaDoc;
27 import java.util.logging.Filter JavaDoc;
28 import java.util.logging.Formatter JavaDoc;
29 import java.util.logging.Level JavaDoc;
30 import java.util.logging.LogRecord JavaDoc;
31 import java.util.logging.SimpleFormatter JavaDoc;
32 import org.jboss.logging.Logger;
33
34 /**
35  * This filter is used to convert java.util.logging messages from the JSF RI
36  * to Log4J messages.
37  *
38  * @author Stan Silvert
39  */
40 public class Log4JConversionFilter implements Filter JavaDoc
41 {
42     
43     // cache Logger instances. Logger.getLogger() is known to be slow.
44 // See http://www.qos.ch/logging/thinkAgain.jsp
45 private Map JavaDoc<String JavaDoc, Logger> loggerCache = new HashMap JavaDoc<String JavaDoc, Logger>();
46     
47     private Formatter JavaDoc formatter = new SimpleFormatter JavaDoc();
48     
49     // should we log the INFO level config messages that tell about
50 // servlet context params?
51 private boolean logConfigMessages;
52     
53     public Log4JConversionFilter(boolean logConfigMessages)
54     {
55         this.logConfigMessages = logConfigMessages;
56     }
57     
58     private boolean isConfigStartupMessage(LogRecord JavaDoc record)
59     {
60         return record.getMessage().equals("jsf.config.listener.version") ||
61                record.getMessage().equals("jsf.config.listener.version.complete");
62     }
63     
64     /**
65      * If the JSF RI message should be logged, convert the JDK 1.4
66      * LogRecord to a Log4J message.
67      *
68      * @return <code>false</code> because JDK 1.4 logging should not happen
69      * for JSF if this filter is active.
70      */
71     public boolean isLoggable(LogRecord JavaDoc record)
72     {
73         if (!logConfigMessages && isConfigStartupMessage(record)) return false;
74         
75         Logger logger = getLogger(record);
76         
77         if (record.getThrown() != null)
78         {
79             logWithThrowable(logger, record);
80         }
81         else
82         {
83             logWithoutThrowable(logger, record);
84         }
85         
86         return false;
87     }
88     
89     private void logWithThrowable(Logger logger, LogRecord JavaDoc record)
90     {
91         int loggedLevel = record.getLevel().intValue();
92         Object JavaDoc message = formatter.formatMessage(record);
93         Throwable JavaDoc throwable = record.getThrown();
94         
95         if (loggedLevel == Level.INFO.intValue())
96         {
97             logger.info(message, throwable);
98             return;
99         }
100         
101         if (loggedLevel == Level.WARNING.intValue())
102         {
103             logger.warn(message, throwable);
104             return;
105         }
106         
107         if (loggedLevel == Level.SEVERE.intValue())
108         {
109             logger.fatal(message, throwable);
110             return;
111         }
112     
113         logger.info(message, throwable);
114     }
115     
116     private void logWithoutThrowable(Logger logger, LogRecord JavaDoc record)
117     {
118         int loggedLevel = record.getLevel().intValue();
119         Object JavaDoc message = formatter.formatMessage(record);
120         
121         if (loggedLevel == Level.INFO.intValue())
122         {
123             logger.info(message);
124             return;
125         }
126         
127         if (loggedLevel == Level.WARNING.intValue())
128         {
129             logger.warn(message);
130             return;
131         }
132         
133         if (loggedLevel == Level.SEVERE.intValue())
134         {
135             logger.fatal(message);
136             return;
137         }
138     
139         logger.info(message);
140     }
141     
142     // get the Log4J logger corresponding to the java.util.logger.LogRecord
143 private Logger getLogger(LogRecord JavaDoc record)
144     {
145         String JavaDoc loggerName = record.getLoggerName();
146         Logger logger = loggerCache.get(loggerName);
147         if (logger == null)
148         {
149             logger = Logger.getLogger(loggerName);
150             loggerCache.put(loggerName, logger);
151         }
152         
153         return logger;
154     }
155     
156 }
157
Popular Tags