All Downloads are FREE. Search and download functionalities are using the official Maven repository.

org.eclipse.jetty.util.log.Log Maven / Gradle / Ivy

There is a newer version: 11.0.0.beta1
Show newest version
//
//  ========================================================================
//  Copyright (c) 1995-2013 Mort Bay Consulting Pty. Ltd.
//  ------------------------------------------------------------------------
//  All rights reserved. This program and the accompanying materials
//  are made available under the terms of the Eclipse Public License v1.0
//  and Apache License v2.0 which accompanies this distribution.
//
//      The Eclipse Public License is available at
//      http://www.eclipse.org/legal/epl-v10.html
//
//      The Apache License v2.0 is available at
//      http://www.opensource.org/licenses/apache2.0.php
//
//  You may elect to redistribute this code under either of these licenses.
//  ========================================================================
//

package org.eclipse.jetty.util.log;

import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Method;
import java.net.URL;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.util.Collection;
import java.util.Collections;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;

import org.eclipse.jetty.util.IO;
import org.eclipse.jetty.util.Loader;

/**
 * Logging.
 * This class provides a static logging interface.  If an instance of the
 * org.slf4j.Logger class is found on the classpath, the static log methods
 * are directed to a slf4j logger for "org.eclipse.log".   Otherwise the logs
 * are directed to stderr.
 * 

* The "org.eclipse.jetty.util.log.class" system property can be used * to select a specific logging implementation. *

* If the system property org.eclipse.jetty.util.log.IGNORED is set, * then ignored exceptions are logged in detail. * * @see StdErrLog * @see Slf4jLog */ public class Log { public final static String EXCEPTION= "EXCEPTION "; public final static String IGNORED= "IGNORED "; /** * Logging Configuration Properties */ protected static Properties __props; /** * The {@link Logger} implementation class name */ public static String __logClass; /** * Legacy flag indicating if {@link Log#ignore(Throwable)} methods produce any output in the {@link Logger}s */ public static boolean __ignored; /** * Hold loggers only. */ private final static ConcurrentMap __loggers = new ConcurrentHashMap(); static { /* Instantiate a default configuration properties (empty) */ __props = new Properties(); AccessController.doPrivileged(new PrivilegedAction() { public Object run() { /* First see if the jetty-logging.properties object exists in the classpath. * This is an optional feature used by embedded mode use, and test cases to allow for early * configuration of the Log class in situations where access to the System.properties are * either too late or just impossible. */ URL testProps = Loader.getResource(Log.class,"jetty-logging.properties",true); if (testProps != null) { InputStream in = null; try { in = testProps.openStream(); __props.load(in); } catch (IOException e) { System.err.println("Unable to load " + testProps); e.printStackTrace(System.err); } finally { IO.close(in); } } /* Now load the System.properties as-is into the __props, these values will override * any key conflicts in __props. */ @SuppressWarnings("unchecked") Enumeration systemKeyEnum = (Enumeration)System.getProperties().propertyNames(); while (systemKeyEnum.hasMoreElements()) { String key = systemKeyEnum.nextElement(); String val = System.getProperty(key); //protect against application code insertion of non-String values (returned as null) if (val != null) __props.setProperty(key,val); } /* Now use the configuration properties to configure the Log statics */ __logClass = __props.getProperty("org.eclipse.jetty.util.log.class","org.eclipse.jetty.util.log.Slf4jLog"); __ignored = Boolean.parseBoolean(__props.getProperty("org.eclipse.jetty.util.log.IGNORED","false")); return null; } }); } private static Logger LOG; private static boolean __initialized; public static boolean initialized() { if (LOG != null) { return true; } synchronized (Log.class) { if (__initialized) { return LOG != null; } __initialized = true; } try { Class log_class = Loader.loadClass(Log.class, __logClass); if (LOG == null || !LOG.getClass().equals(log_class)) { LOG = (Logger)log_class.newInstance(); LOG.debug("Logging to {} via {}", LOG, log_class.getName()); } } catch(Throwable e) { // Unable to load specified Logger implementation, default to standard logging. initStandardLogging(e); } return LOG != null; } private static void initStandardLogging(Throwable e) { Class log_class; if(e != null && __ignored) { e.printStackTrace(); } if (LOG == null) { log_class = StdErrLog.class; LOG = new StdErrLog(); LOG.debug("Logging to {} via {}", LOG, log_class.getName()); } } public static void setLog(Logger log) { Log.LOG = log; } /** * @deprecated anonymous logging is deprecated, use a named {@link Logger} obtained from {@link #getLogger(String)} */ @Deprecated public static Logger getLog() { initialized(); return LOG; } /** * Get the root logger. * @return the root logger */ public static Logger getRootLogger() { initialized(); return LOG; } static boolean isIgnored() { return __ignored; } /** * Set Log to parent Logger. *

* If there is a different Log class available from a parent classloader, * call {@link #getLogger(String)} on it and construct a {@link LoggerLog} instance * as this Log's Logger, so that logging is delegated to the parent Log. *

* This should be used if a webapp is using Log, but wishes the logging to be * directed to the containers log. *

* If there is not parent Log, then this call is equivalent to

     *   Log.setLog(Log.getLogger(name));
     * 
* @param name Logger name */ public static void setLogToParent(String name) { ClassLoader loader = Log.class.getClassLoader(); if (loader!=null && loader.getParent()!=null) { try { Class uberlog = loader.getParent().loadClass("org.eclipse.jetty.util.log.Log"); Method getLogger = uberlog.getMethod("getLogger", new Class[]{String.class}); Object logger = getLogger.invoke(null,name); setLog(new LoggerLog(logger)); } catch (Exception e) { e.printStackTrace(); } } else { setLog(getLogger(name)); } } /** * @deprecated anonymous logging is deprecated, use a named {@link Logger} obtained from {@link #getLogger(String)} */ @Deprecated public static void debug(Throwable th) { if (!isDebugEnabled()) return; LOG.debug(EXCEPTION, th); } /** * @deprecated anonymous logging is deprecated, use a named {@link Logger} obtained from {@link #getLogger(String)} */ @Deprecated public static void debug(String msg) { if (!initialized()) return; LOG.debug(msg); } /** * @deprecated anonymous logging is deprecated, use a named {@link Logger} obtained from {@link #getLogger(String)} */ @Deprecated public static void debug(String msg, Object arg) { if (!initialized()) return; LOG.debug(msg, arg); } /** * @deprecated anonymous logging is deprecated, use a named {@link Logger} obtained from {@link #getLogger(String)} */ @Deprecated public static void debug(String msg, Object arg0, Object arg1) { if (!initialized()) return; LOG.debug(msg, arg0, arg1); } /** * Ignore an exception unless trace is enabled. * This works around the problem that log4j does not support the trace level. * @param thrown the Throwable to ignore */ /** * @deprecated anonymous logging is deprecated, use a named {@link Logger} obtained from {@link #getLogger(String)} */ @Deprecated public static void ignore(Throwable thrown) { if (!initialized()) return; LOG.ignore(thrown); } /** * @deprecated anonymous logging is deprecated, use a named {@link Logger} obtained from {@link #getLogger(String)} */ @Deprecated public static void info(String msg) { if (!initialized()) return; LOG.info(msg); } /** * @deprecated anonymous logging is deprecated, use a named {@link Logger} obtained from {@link #getLogger(String)} */ @Deprecated public static void info(String msg, Object arg) { if (!initialized()) return; LOG.info(msg, arg); } /** * @deprecated anonymous logging is deprecated, use a named {@link Logger} obtained from {@link #getLogger(String)} */ @Deprecated public static void info(String msg, Object arg0, Object arg1) { if (!initialized()) return; LOG.info(msg, arg0, arg1); } /** * @deprecated anonymous logging is deprecated, use a named {@link Logger} obtained from {@link #getLogger(String)} */ @Deprecated public static boolean isDebugEnabled() { if (!initialized()) return false; return LOG.isDebugEnabled(); } /** * @deprecated anonymous logging is deprecated, use a named {@link Logger} obtained from {@link #getLogger(String)} */ @Deprecated public static void warn(String msg) { if (!initialized()) return; LOG.warn(msg); } /** * @deprecated anonymous logging is deprecated, use a named {@link Logger} obtained from {@link #getLogger(String)} */ @Deprecated public static void warn(String msg, Object arg) { if (!initialized()) return; LOG.warn(msg, arg); } /** * @deprecated anonymous logging is deprecated, use a named {@link Logger} obtained from {@link #getLogger(String)} */ @Deprecated public static void warn(String msg, Object arg0, Object arg1) { if (!initialized()) return; LOG.warn(msg, arg0, arg1); } /** * @deprecated anonymous logging is deprecated, use a named {@link Logger} obtained from {@link #getLogger(String)} */ @Deprecated public static void warn(String msg, Throwable th) { if (!initialized()) return; LOG.warn(msg, th); } /** * @deprecated anonymous logging is deprecated, use a named {@link Logger} obtained from {@link #getLogger(String)} */ @Deprecated public static void warn(Throwable th) { if (!initialized()) return; LOG.warn(EXCEPTION, th); } /** * Obtain a named Logger based on the fully qualified class name. * * @param clazz * the class to base the Logger name off of * @return the Logger with the given name */ public static Logger getLogger(Class clazz) { return getLogger(clazz.getName()); } /** * Obtain a named Logger or the default Logger if null is passed. * @param name the Logger name * @return the Logger with the given name */ public static Logger getLogger(String name) { if (!initialized()) return null; if(name==null) return LOG; Logger logger = __loggers.get(name); if(logger==null) logger = LOG.getLogger(name); return logger; } static ConcurrentMap getMutableLoggers() { return __loggers; } /** * Get a map of all configured {@link Logger} instances. * * @return a map of all configured {@link Logger} instances */ public static Map getLoggers() { return Collections.unmodifiableMap(__loggers); } }