Coverage Report

Coverage Report - org.apache.ojb.broker.util.logging.LoggerFactoryImpl

Classes in this File

2.273

 package org.apache.ojb.broker.util.logging;
 
 /* Copyright 2002-2005 The Apache Software Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 import java.util.HashMap;
 import java.util.Map;
 
 import org.apache.ojb.broker.util.ClassHelper;
 import org.apache.commons.lang.SystemUtils;
 
 /**
  * The factory class <code>LoggerFactory</code> can be used
  * to create <code>Logger</code> instances.
  * The <code>Logger</code>-implementation class served
  * by the factory is configured by settings in the
  * OJB.properties file.
  *
  * @author Thomas Mahler
  * @author <a href="leandro@ibnetwork.com.br">Leandro Rodrigo Saad Cruz</a>
  * @version $Id: LoggerFactoryImpl.java,v 1.1 2007-08-24 22:17:32 ewestfal Exp $
  * @see <a href="http://jakarta.apache.org/log4j/docs/index.html">jakarta-log4j</a>
  */
 public class LoggerFactoryImpl
 {
     public static final String BOOT_LOG_LEVEL_STR = "OJB.bootLogLevel";
     protected static final String BOOT_STR = "BOOT";
     protected static final String DEFAULT_STR = "DEFAULT";
     protected static final LoggerFactoryImpl INSTANCE = new LoggerFactoryImpl();
 
     private Logger defaultLogger = null;
 
     private Logger bootLogger = null;
 
     private boolean bootLoggerIsReassigned = false;
 
     /** Used for caching logger instances */
     private Map cache = new HashMap();
     /** The configuration */
     private LoggingConfiguration conf;
 
     // yes. it's a singleton !
     private LoggerFactoryImpl()
     {
     }
 
     public static LoggerFactoryImpl getInstance()
     {
         return INSTANCE;
     }
 
     private LoggingConfiguration getConfiguration()
     {
         if(conf == null)
         {
             // this will load the configuration
             conf = new LoggingConfiguration();
         }
         return conf;
     }
 
     /**
      * returns a minimal logger that needs no configuration
      * and can thus be safely used during OJB boot phase
      * (i.e. when OJB.properties have not been loaded).
      *
      * @return Logger the OJB BootLogger
      */
     public Logger getBootLogger()
     {
         if(bootLogger == null)
         {
             // create a StringBuffer based Logger for boot log operations
             bootLogger = createStringBufferLogger_Boot();
         }
         return bootLogger;
     }
 
 
     /**
      * returns the default logger. This Logger can
      * be used when it is not appropriate to use a
      * dedicated fresh Logger instance.
      *
      * @return default Logger
      */
     public Logger getDefaultLogger()
     {
         if(defaultLogger == null)
         {
             defaultLogger = getLogger(DEFAULT_STR);
         }
         return defaultLogger;
     }
 
 
     /**
      * returns a Logger. The Logger is named
      * after the full qualified name of input parameter clazz
      *
      * @param clazz the Class which name is to be used as name
      * @return Logger the returned Logger
      */
     public Logger getLogger(Class clazz)
     {
         return getLogger(clazz.getName());
     }
 
 
     /**
      * returns a Logger.
      *
      * @param loggerName the name of the Logger
      * @return Logger the returned Logger
      */
     public Logger getLogger(String loggerName)
     {
         Logger logger;
         //lookup in the cache first
         logger = (Logger) cache.get(loggerName);
 
         if(logger == null)
         {
             try
             {
                 // get the configuration (not from the configurator because this is independent)
                 logger = createLoggerInstance(loggerName);
                 if(getBootLogger().isDebugEnabled())
                 {
                     getBootLogger().debug("Using logger class '"
                             + (getConfiguration() != null ? getConfiguration().getLoggerClass() : null)
                             + "' for " + loggerName);
                 }
                 // configure the logger
                 getBootLogger().debug("Initializing logger instance " + loggerName);
                 logger.configure(conf);
             }
             catch(Throwable t)
             {
                 // do reassign check and signal logger creation failure
                 reassignBootLogger(true);
                 logger = getBootLogger();
                 getBootLogger().error("[" + this.getClass().getName()
                             + "] Could not initialize logger " + (conf != null ? conf.getLoggerClass() : null), t);
             }
             //cache it so we can get it faster the next time
             cache.put(loggerName, logger);
             // do reassign check
             reassignBootLogger(false);
         }
         return logger;
     }
 
     /**
      * Creates a new Logger instance for the specified name.
      */
     private Logger createLoggerInstance(String loggerName) throws Exception
     {
         Class loggerClass = getConfiguration().getLoggerClass();
         Logger log = (Logger) ClassHelper.newInstance(loggerClass, String.class, loggerName);
         log.configure(getConfiguration());
         return log;
     }
 
     /**
      *
      * @param forceError
      */
     protected synchronized void reassignBootLogger(boolean forceError)
     {
         // if the boot logger was already reassigned do nothing
         if(!bootLoggerIsReassigned)
         {
             Logger newBootLogger = null;
             String name = getBootLogger().getName();
             try
             {
                 // 1. try to use a Logger instance based on the configuration files
                 newBootLogger = createLoggerInstance(name);
             }
             catch(Exception e) {/*ignore*/}
             if(newBootLogger == null)
             {
                 // 2. if no logging library can be found, use OJB's console logger
                 newBootLogger = createPoorMansLogger_Boot();
             }
             if(getBootLogger() instanceof StringBufferLoggerImpl)
             {
                 /*
                 if the StringBuffer based Logger was used for OJB bootstrap process
                 get the logging statement string and log it on the "real" Logger instance
                 */
                 StringBufferLoggerImpl strLogger = (StringBufferLoggerImpl) getBootLogger();
                 String bootMessage = strLogger.flushLogBuffer();
                 String eol = SystemUtils.LINE_SEPARATOR;
                 if(forceError || strLogger.isErrorLog())
                 {
                     newBootLogger.error("-- boot log messages -->" + eol + bootMessage);
                 }
                 else
                 {
                     newBootLogger.info("-- boot log messages -->" + eol + bootMessage);
                 }
             }
             bootLogger = newBootLogger;
             bootLoggerIsReassigned = true;
         }
     }
 
     protected Logger createPoorMansLogger_Boot()
     {
         Logger bootLogger = new PoorMansLoggerImpl(BOOT_STR);
         // allow user to set boot log level via system property
         String level = System.getProperty(BOOT_LOG_LEVEL_STR, LoggingConfiguration.OJB_DEFAULT_BOOT_LOG_LEVEL);
         ((PoorMansLoggerImpl) bootLogger).setLevel(level);
         return bootLogger;
     }
 
     protected Logger createStringBufferLogger_Boot()
     {
         Logger bootLogger = new StringBufferLoggerImpl(BOOT_STR);
         // allow user to set boot log level via system property
         String level = System.getProperty(BOOT_LOG_LEVEL_STR, LoggingConfiguration.OJB_DEFAULT_BOOT_LOG_LEVEL);
         ((PoorMansLoggerImpl) bootLogger).setLevel(level);
         return bootLogger;
     }
 }

1		package org.apache.ojb.broker.util.logging;
2
3		/* Copyright 2002-2005 The Apache Software Foundation
4		*
5		* Licensed under the Apache License, Version 2.0 (the "License");
6		* you may not use this file except in compliance with the License.
7		* You may obtain a copy of the License at
8		*
9		* http://www.apache.org/licenses/LICENSE-2.0
10		*
11		* Unless required by applicable law or agreed to in writing, software
12		* distributed under the License is distributed on an "AS IS" BASIS,
13		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14		* See the License for the specific language governing permissions and
15		* limitations under the License.
16		*/
17
18		import java.util.HashMap;
19		import java.util.Map;
20
21		import org.apache.ojb.broker.util.ClassHelper;
22		import org.apache.commons.lang.SystemUtils;
23
24		/**
25		* The factory class <code>LoggerFactory</code> can be used
26		* to create <code>Logger</code> instances.
27		* The <code>Logger</code>-implementation class served
28		* by the factory is configured by settings in the
29		* OJB.properties file.
30		*
31		* @author Thomas Mahler
32		* @author <a href="leandro@ibnetwork.com.br">Leandro Rodrigo Saad Cruz</a>
33		* @version $Id: LoggerFactoryImpl.java,v 1.1 2007-08-24 22:17:32 ewestfal Exp $
34		* @see <a href="http://jakarta.apache.org/log4j/docs/index.html">jakarta-log4j</a>
35		*/
36		public class LoggerFactoryImpl
37		{
38		public static final String BOOT_LOG_LEVEL_STR = "OJB.bootLogLevel";
39		protected static final String BOOT_STR = "BOOT";
40		protected static final String DEFAULT_STR = "DEFAULT";
41		protected static final LoggerFactoryImpl INSTANCE = new LoggerFactoryImpl();
42
43		private Logger defaultLogger = null;
44
45		private Logger bootLogger = null;
46
47		private boolean bootLoggerIsReassigned = false;
48
49		/** Used for caching logger instances */
50		private Map cache = new HashMap();
51		/** The configuration */
52		private LoggingConfiguration conf;
53
54		// yes. it's a singleton !
55		private LoggerFactoryImpl()
56		{
57		}
58
59		public static LoggerFactoryImpl getInstance()
60		{
61		return INSTANCE;
62		}
63
64		private LoggingConfiguration getConfiguration()
65		{
66		if(conf == null)
67		{
68		// this will load the configuration
69		conf = new LoggingConfiguration();
70		}
71		return conf;
72		}
73
74		/**
75		* returns a minimal logger that needs no configuration
76		* and can thus be safely used during OJB boot phase
77		* (i.e. when OJB.properties have not been loaded).
78		*
79		* @return Logger the OJB BootLogger
80		*/
81		public Logger getBootLogger()
82		{
83		if(bootLogger == null)
84		{
85		// create a StringBuffer based Logger for boot log operations
86		bootLogger = createStringBufferLogger_Boot();
87		}
88		return bootLogger;
89		}
90
91
92		/**
93		* returns the default logger. This Logger can
94		* be used when it is not appropriate to use a
95		* dedicated fresh Logger instance.
96		*
97		* @return default Logger
98		*/
99		public Logger getDefaultLogger()
100		{
101		if(defaultLogger == null)
102		{
103		defaultLogger = getLogger(DEFAULT_STR);
104		}
105		return defaultLogger;
106		}
107
108
109		/**
110		* returns a Logger. The Logger is named
111		* after the full qualified name of input parameter clazz
112		*
113		* @param clazz the Class which name is to be used as name
114		* @return Logger the returned Logger
115		*/
116		public Logger getLogger(Class clazz)
117		{
118		return getLogger(clazz.getName());
119		}
120
121
122		/**
123		* returns a Logger.
124		*
125		* @param loggerName the name of the Logger
126		* @return Logger the returned Logger
127		*/
128		public Logger getLogger(String loggerName)
129		{
130		Logger logger;
131		//lookup in the cache first
132		logger = (Logger) cache.get(loggerName);
133
134		if(logger == null)
135		{
136		try
137		{
138		// get the configuration (not from the configurator because this is independent)
139		logger = createLoggerInstance(loggerName);
140		if(getBootLogger().isDebugEnabled())
141		{
142		getBootLogger().debug("Using logger class '"
143		+ (getConfiguration() != null ? getConfiguration().getLoggerClass() : null)
144		+ "' for " + loggerName);
145		}
146		// configure the logger
147		getBootLogger().debug("Initializing logger instance " + loggerName);
148		logger.configure(conf);
149		}
150		catch(Throwable t)
151		{
152		// do reassign check and signal logger creation failure
153		reassignBootLogger(true);
154		logger = getBootLogger();
155		getBootLogger().error("[" + this.getClass().getName()
156		+ "] Could not initialize logger " + (conf != null ? conf.getLoggerClass() : null), t);
157		}
158		//cache it so we can get it faster the next time
159		cache.put(loggerName, logger);
160		// do reassign check
161		reassignBootLogger(false);
162		}
163		return logger;
164		}
165
166		/**
167		* Creates a new Logger instance for the specified name.
168		*/
169		private Logger createLoggerInstance(String loggerName) throws Exception
170		{
171		Class loggerClass = getConfiguration().getLoggerClass();
172		Logger log = (Logger) ClassHelper.newInstance(loggerClass, String.class, loggerName);
173		log.configure(getConfiguration());
174		return log;
175		}
176
177		/**
178		*
179		* @param forceError
180		*/
181		protected synchronized void reassignBootLogger(boolean forceError)
182		{
183		// if the boot logger was already reassigned do nothing
184		if(!bootLoggerIsReassigned)
185		{
186		Logger newBootLogger = null;
187		String name = getBootLogger().getName();
188		try
189		{
190		// 1. try to use a Logger instance based on the configuration files
191		newBootLogger = createLoggerInstance(name);
192		}
193		catch(Exception e) {/ignore/}
194		if(newBootLogger == null)
195		{
196		// 2. if no logging library can be found, use OJB's console logger
197		newBootLogger = createPoorMansLogger_Boot();
198		}
199		if(getBootLogger() instanceof StringBufferLoggerImpl)
200		{
201		/*
202		if the StringBuffer based Logger was used for OJB bootstrap process
203		get the logging statement string and log it on the "real" Logger instance
204		*/
205		StringBufferLoggerImpl strLogger = (StringBufferLoggerImpl) getBootLogger();
206		String bootMessage = strLogger.flushLogBuffer();
207		String eol = SystemUtils.LINE_SEPARATOR;
208		if(forceError \|\| strLogger.isErrorLog())
209		{
210		newBootLogger.error("-- boot log messages -->" + eol + bootMessage);
211		}
212		else
213		{
214		newBootLogger.info("-- boot log messages -->" + eol + bootMessage);
215		}
216		}
217		bootLogger = newBootLogger;
218		bootLoggerIsReassigned = true;
219		}
220		}
221
222		protected Logger createPoorMansLogger_Boot()
223		{
224		Logger bootLogger = new PoorMansLoggerImpl(BOOT_STR);
225		// allow user to set boot log level via system property
226		String level = System.getProperty(BOOT_LOG_LEVEL_STR, LoggingConfiguration.OJB_DEFAULT_BOOT_LOG_LEVEL);
227		((PoorMansLoggerImpl) bootLogger).setLevel(level);
228		return bootLogger;
229		}
230
231		protected Logger createStringBufferLogger_Boot()
232		{
233		Logger bootLogger = new StringBufferLoggerImpl(BOOT_STR);
234		// allow user to set boot log level via system property
235		String level = System.getProperty(BOOT_LOG_LEVEL_STR, LoggingConfiguration.OJB_DEFAULT_BOOT_LOG_LEVEL);
236		((PoorMansLoggerImpl) bootLogger).setLevel(level);
237		return bootLogger;
238		}
239		}