Author: cziegeler Date: Mon Jan 17 14:28:43 2005 New Revision: 125448 URL: http://svn.apache.org/viewcvs?view=rev&rev=125448 Log: Start adding logging helper Added: cocoon/trunk/src/java/org/apache/cocoon/components/container/LoggingHelper.java (contents, props changed) Modified: cocoon/trunk/src/core/java/org/apache/cocoon/configuration/ConfigurationBuilder.java (contents, props changed) cocoon/trunk/src/core/java/org/apache/cocoon/configuration/Settings.java (contents, props changed)
Modified: cocoon/trunk/src/core/java/org/apache/cocoon/configuration/ConfigurationBuilder.java Url: http://svn.apache.org/viewcvs/cocoon/trunk/src/core/java/org/apache/cocoon/configuration/ConfigurationBuilder.java?view=diff&rev=125448&p1=cocoon/trunk/src/core/java/org/apache/cocoon/configuration/ConfigurationBuilder.java&r1=125447&p2=cocoon/trunk/src/core/java/org/apache/cocoon/configuration/ConfigurationBuilder.java&r2=125448 ============================================================================== --- cocoon/trunk/src/core/java/org/apache/cocoon/configuration/ConfigurationBuilder.java (original) +++ cocoon/trunk/src/core/java/org/apache/cocoon/configuration/ConfigurationBuilder.java Mon Jan 17 14:28:43 2005 @@ -69,7 +69,7 @@ * in that case the whitespace is left intact. * </p> * - * @version CVS $Revision: 1.33 $ $Date: 2004/04/03 23:55:54 $ + * @version SVN $Id$ */ public class ConfigurationBuilder extends DefaultHandler Modified: cocoon/trunk/src/core/java/org/apache/cocoon/configuration/Settings.java Url: http://svn.apache.org/viewcvs/cocoon/trunk/src/core/java/org/apache/cocoon/configuration/Settings.java?view=diff&rev=125448&p1=cocoon/trunk/src/core/java/org/apache/cocoon/configuration/Settings.java&r1=125447&p2=cocoon/trunk/src/core/java/org/apache/cocoon/configuration/Settings.java&r2=125448 ============================================================================== --- cocoon/trunk/src/core/java/org/apache/cocoon/configuration/Settings.java (original) +++ cocoon/trunk/src/core/java/org/apache/cocoon/configuration/Settings.java Mon Jan 17 14:28:43 2005 @@ -19,7 +19,7 @@ /** * - * @version CVS $Revision: 1.33 $ $Date: 2004/04/03 23:55:54 $ + * @version SVN $Id$ */ public class Settings { @@ -45,8 +45,295 @@ protected boolean showTime; protected boolean manageExceptions; protected String formEncoding; - + protected String log4jConfiguration; + public Settings(Properties properties) { // ignore + } + + + /** + * @return Returns the allowReload. + */ + public boolean isAllowReload() { + return this.allowReload; + } + /** + * @param allowReload The allowReload to set. + */ + public void setAllowReload(boolean allowReload) { + this.allowReload = allowReload; + } + /** + * @return Returns the autosaveUploads. + */ + public boolean isAutosaveUploads() { + return this.autosaveUploads; + } + /** + * @param autosaveUploads The autosaveUploads to set. + */ + public void setAutosaveUploads(boolean autosaveUploads) { + this.autosaveUploads = autosaveUploads; + } + /** + * @return Returns the cacheDirectory. + */ + public String getCacheDirectory() { + return this.cacheDirectory; + } + /** + * @param cacheDirectory The cacheDirectory to set. + */ + public void setCacheDirectory(String cacheDirectory) { + this.cacheDirectory = cacheDirectory; + } + /** + * @return Returns the classloaderClassName. + */ + public String getClassloaderClassName() { + return this.classloaderClassName; + } + /** + * @param classloaderClassName The classloaderClassName to set. + */ + public void setClassloaderClassName(String classloaderClassName) { + this.classloaderClassName = classloaderClassName; + } + /** + * @return Returns the cocoonLogger. + */ + public String getCocoonLogger() { + return this.cocoonLogger; + } + /** + * @param cocoonLogger The cocoonLogger to set. + */ + public void setCocoonLogger(String cocoonLogger) { + this.cocoonLogger = cocoonLogger; + } + /** + * @return Returns the configuration. + */ + public String getConfiguration() { + return this.configuration; + } + /** + * @param configuration The configuration to set. + */ + public void setConfiguration(String configuration) { + this.configuration = configuration; + } + /** + * @return Returns the enableUploads. + */ + public boolean isEnableUploads() { + return this.enableUploads; + } + /** + * @param enableUploads The enableUploads to set. + */ + public void setEnableUploads(boolean enableUploads) { + this.enableUploads = enableUploads; + } + /** + * @return Returns the extraClasspaths. + */ + public String[] getExtraClasspaths() { + return this.extraClasspaths; + } + /** + * @param extraClasspaths The extraClasspaths to set. + */ + public void setExtraClasspaths(String[] extraClasspaths) { + this.extraClasspaths = extraClasspaths; + } + /** + * @return Returns the forceProperties. + */ + public String[] getForceProperties() { + return this.forceProperties; + } + /** + * @param forceProperties The forceProperties to set. + */ + public void setForceProperties(String[] forceProperties) { + this.forceProperties = forceProperties; + } + /** + * @return Returns the formEncoding. + */ + public String getFormEncoding() { + return this.formEncoding; + } + /** + * @param formEncoding The formEncoding to set. + */ + public void setFormEncoding(String formEncoding) { + this.formEncoding = formEncoding; + } + /** + * @return Returns the initClassloader. + */ + public boolean isInitClassloader() { + return this.initClassloader; + } + /** + * @param initClassloader The initClassloader to set. + */ + public void setInitClassloader(boolean initClassloader) { + this.initClassloader = initClassloader; + } + /** + * @return Returns the loadClasses. + */ + public String[] getLoadClasses() { + return this.loadClasses; + } + /** + * @param loadClasses The loadClasses to set. + */ + public void setLoadClasses(String[] loadClasses) { + this.loadClasses = loadClasses; + } + /** + * @return Returns the loggerClassName. + */ + public String getLoggerClassName() { + return this.loggerClassName; + } + /** + * @param loggerClassName The loggerClassName to set. + */ + public void setLoggerClassName(String loggerClassName) { + this.loggerClassName = loggerClassName; + } + /** + * @return Returns the loggingConfiguration. + */ + public String getLoggingConfiguration() { + return this.loggingConfiguration; + } + /** + * @param loggingConfiguration The loggingConfiguration to set. + */ + public void setLoggingConfiguration(String loggingConfiguration) { + this.loggingConfiguration = loggingConfiguration; + } + /** + * @return Returns the logLevel. + */ + public String getLogLevel() { + return this.logLevel; + } + /** + * @param logLevel The logLevel to set. + */ + public void setLogLevel(String logLevel) { + this.logLevel = logLevel; + } + /** + * @return Returns the manageExceptions. + */ + public boolean isManageExceptions() { + return this.manageExceptions; + } + /** + * @param manageExceptions The manageExceptions to set. + */ + public void setManageExceptions(boolean manageExceptions) { + this.manageExceptions = manageExceptions; + } + /** + * @return Returns the maxUploadSize. + */ + public long getMaxUploadSize() { + return this.maxUploadSize; + } + /** + * @param maxUploadSize The maxUploadSize to set. + */ + public void setMaxUploadSize(long maxUploadSize) { + this.maxUploadSize = maxUploadSize; + } + /** + * @return Returns the overwriteUploads. + */ + public boolean isOverwriteUploads() { + return this.overwriteUploads; + } + /** + * @param overwriteUploads The overwriteUploads to set. + */ + public void setOverwriteUploads(boolean overwriteUploads) { + this.overwriteUploads = overwriteUploads; + } + /** + * @return Returns the parentServiceManagerClassName. + */ + public String getParentServiceManagerClassName() { + return this.parentServiceManagerClassName; + } + /** + * @param parentServiceManagerClassName The parentServiceManagerClassName to set. + */ + public void setParentServiceManagerClassName( + String parentServiceManagerClassName) { + this.parentServiceManagerClassName = parentServiceManagerClassName; + } + /** + * @return Returns the showTime. + */ + public boolean isShowTime() { + return this.showTime; + } + /** + * @param showTime The showTime to set. + */ + public void setShowTime(boolean showTime) { + this.showTime = showTime; + } + /** + * @return Returns the uploadDirectory. + */ + public String getUploadDirectory() { + return this.uploadDirectory; + } + /** + * @param uploadDirectory The uploadDirectory to set. + */ + public void setUploadDirectory(String uploadDirectory) { + this.uploadDirectory = uploadDirectory; + } + /** + * @return Returns the workDirectory. + */ + public String getWorkDirectory() { + return this.workDirectory; + } + /** + * @param workDirectory The workDirectory to set. + */ + public void setWorkDirectory(String workDirectory) { + this.workDirectory = workDirectory; + } + + /** + * @return Returns the log4jConfiguration. + */ + public String getLog4jConfiguration() { + return this.log4jConfiguration; + } + /** + * @param log4jConfiguration The log4jConfiguration to set. + */ + public void setLog4jConfiguration(String log4jConfiguration) { + this.log4jConfiguration = log4jConfiguration; + } + public String get(String property, String defaultValue) { + if ( property == null ) { + return defaultValue; + } + return property; } } Added: cocoon/trunk/src/java/org/apache/cocoon/components/container/LoggingHelper.java Url: http://svn.apache.org/viewcvs/cocoon/trunk/src/java/org/apache/cocoon/components/container/LoggingHelper.java?view=auto&rev=125448 ============================================================================== --- (empty file) +++ cocoon/trunk/src/java/org/apache/cocoon/components/container/LoggingHelper.java Mon Jan 17 14:28:43 2005 @@ -0,0 +1,159 @@ +/* + * Copyright 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. + */ +package org.apache.cocoon.components.container; + +import org.apache.avalon.excalibur.logger.Log4JLoggerManager; +import org.apache.avalon.excalibur.logger.LogKitLoggerManager; +import org.apache.avalon.excalibur.logger.LoggerManager; +import org.apache.avalon.framework.configuration.Configurable; +import org.apache.avalon.framework.configuration.Configuration; +import org.apache.avalon.framework.container.ContainerUtil; +import org.apache.avalon.framework.context.Context; +import org.apache.avalon.framework.logger.LogKitLogger; +import org.apache.avalon.framework.logger.Logger; +import org.apache.cocoon.configuration.ConfigurationBuilder; +import org.apache.cocoon.configuration.Settings; +import org.apache.cocoon.util.log.CocoonLogFormatter; +import org.apache.cocoon.util.log.Log4JConfigurator; +import org.apache.excalibur.source.Source; +import org.apache.excalibur.source.SourceResolver; +import org.apache.log.ErrorHandler; +import org.apache.log.Hierarchy; +import org.apache.log.LogTarget; +import org.apache.log.Priority; +import org.apache.log.util.DefaultErrorHandler; +import org.apache.log4j.LogManager; + +/** +* +* @version SVN $Id$ +*/ +public class LoggingHelper { + + protected final Settings settings; + protected Logger log; + protected LoggerManager loggerManager; + protected final SourceResolver resolver; + + public LoggingHelper(Settings settings, SourceResolver resolver) { + this.settings = settings; + this.resolver = resolver; + } + + /** + * Set up the log level and path. The default log level is + * Priority.ERROR, although it can be overwritten by the parameter + * "log-level". The log system goes to both a file and the Servlet + * container's log system. Only messages that are Priority.ERROR + * and above go to the servlet context. The log messages can + * be as restrictive (Priority.FATAL_ERROR and above) or as liberal + * (Priority.DEBUG and above) as you want that get routed to the + * file. + */ + protected void initLogger(LogTarget defaultTarget, Context context) { + final String logLevel = this.settings.get(this.settings.getLogLevel(), "INFO"); + + final String accesslogger = this.settings.get(this.settings.getCocoonLogger(), "cocoon"); + + final Priority logPriority = Priority.getPriorityForName(logLevel); + + final CocoonLogFormatter formatter = new CocoonLogFormatter(); + formatter.setFormat("%7.7{priority} %{time} [%8.8{category}] " + + "(%{uri}) %{thread}/%{class:short}: %{message}\\n%{throwable}"); + final Hierarchy defaultHierarchy = Hierarchy.getDefaultHierarchy(); + final ErrorHandler errorHandler = new DefaultErrorHandler(); + defaultHierarchy.setErrorHandler(errorHandler); + defaultHierarchy.setDefaultLogTarget(defaultTarget); + defaultHierarchy.setDefaultPriority(logPriority); + final Logger logger = new LogKitLogger(Hierarchy.getDefaultHierarchy().getLoggerFor("")); + final String loggerManagerClass = + this.settings.get(this.settings.getLoggerClassName(), LogKitLoggerManager.class.getName()); + + // the log4j support requires currently that the log4j system is already configured elsewhere + + final LoggerManager loggerManager = newLoggerManager(loggerManagerClass, defaultHierarchy); + ContainerUtil.enableLogging(loggerManager, logger); + + try { + ContainerUtil.contextualize(loggerManager, context); + this.loggerManager = loggerManager; + + if (loggerManager instanceof Configurable) { + //Configure the logkit management + String logkitConfig = this.settings.get(this.settings.getLoggingConfiguration(), "/WEB-INF/logkit.xconf"); + + Source source = null; + try { + source = this.resolver.resolveURI(logkitConfig); + final ConfigurationBuilder builder = new ConfigurationBuilder(); + final Configuration conf = builder.build(source.getInputStream()); + ContainerUtil.configure(loggerManager, conf); + } finally { + this.resolver.release(source); + } + } + + // let's configure log4j + final String log4jConfig = this.settings.getLog4jConfiguration(); + if ( log4jConfig != null ) { + final Log4JConfigurator configurator = new Log4JConfigurator(context); + + Source source = null; + try { + source = this.resolver.resolveURI(log4jConfig); + configurator.doConfigure(source.getInputStream(), LogManager.getLoggerRepository()); + } finally { + this.resolver.release(source); + } + } + + ContainerUtil.initialize(loggerManager); + } catch (Exception e) { + errorHandler.error("Could not set up Cocoon Logger, will use screen instead", e, null); + } + + this.log = this.loggerManager.getLoggerForCategory(accesslogger); + } + + private LoggerManager newLoggerManager(String loggerManagerClass, Hierarchy hierarchy) { + if (loggerManagerClass.equals(LogKitLoggerManager.class.getName())) { + return new LogKitLoggerManager(hierarchy); + } else if (loggerManagerClass.equals(Log4JLoggerManager.class.getName()) || + loggerManagerClass.equalsIgnoreCase("LOG4J")) { + return new Log4JLoggerManager(); + } else { + try { + Class clazz = Class.forName(loggerManagerClass); + return (LoggerManager)clazz.newInstance(); + } catch (Exception e) { + return new LogKitLoggerManager(hierarchy); + } + } + } + + /** + * @return Returns the log. + */ + public Logger getLog() { + return this.log; + } + /** + * @return Returns the loggerManager. + */ + public LoggerManager getLoggerManager() { + return this.loggerManager; + } +}