Mercurial Hosting > luan
view src/org/eclipse/jetty/util/log/Log.java @ 815:07c82fabc46b
remove Authentication
author | Franklin Schmidt <fschmidt@gmail.com> |
---|---|
date | Fri, 09 Sep 2016 14:27:05 -0600 |
parents | 3428c60d7cfc |
children |
line wrap: on
line source
// // ======================================================================== // Copyright (c) 1995-2014 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. * <p> * The "org.eclipse.jetty.util.log.class" system property can be used * to select a specific logging implementation. * <p> * 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<String, Logger> __loggers = new ConcurrentHashMap<String, Logger>(); static { /* Instantiate a default configuration properties (empty) */ __props = new Properties(); AccessController.doPrivileged(new PrivilegedAction<Object>() { 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<String> systemKeyEnum = (Enumeration<String>)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. * <p> * 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. * <p> * This should be used if a webapp is using Log, but wishes the logging to be * directed to the containers log. * <p> * If there is not parent Log, then this call is equivalent to<pre> * Log.setLog(Log.getLogger(name)); * </pre> * @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<String, Logger> getMutableLoggers() { return __loggers; } /** * Get a map of all configured {@link Logger} instances. * * @return a map of all configured {@link Logger} instances */ public static Map<String, Logger> getLoggers() { return Collections.unmodifiableMap(__loggers); } }