Examples of java.util.logging.LogManager$LoggerContext

java.util.logging.LogManager
There is a single global LogManager object that is used to maintain a set of shared state about Loggers and log services.
This LogManager object:
- Manages a hierarchical namespace of Logger objects. All named Loggers are stored in this namespace.
- Manages a set of logging control properties. These are simple key-value pairs that can be used by Handlers and other logging objects to configure themselves.
The global LogManager object can be retrieved using LogManager.getLogManager(). The LogManager object is created during class initialization and cannot subsequently be changed.
At startup the LogManager class is located using the java.util.logging.manager system property.
The LogManager defines two optional system properties that allow control over the initial configuration:
- "java.util.logging.config.class"
- "java.util.logging.config.file"
These two properties may be specified on the command line to the "java" command, or as system property definitions passed to JNI_CreateJavaVM.
If the "java.util.logging.config.class" property is set, then the property value is treated as a class name. The given class will be loaded, an object will be instantiated, and that object's constructor is responsible for reading in the initial configuration. (That object may use other system properties to control its configuration.) The alternate configuration class can use readConfiguration(InputStream) to define properties in the LogManager.
If "java.util.logging.config.class" property is not set, then the "java.util.logging.config.file" system property can be used to specify a properties file (in java.util.Properties format). The initial logging configuration will be read from this file.
If neither of these properties is defined then the LogManager uses its default configuration. The default configuration is typically loaded from the properties file " {@code lib/logging.properties}" in the Java installation directory.
The properties for loggers and Handlers will have names starting with the dot-separated name for the handler or logger.
The global logging properties may include:
- A property "handlers". This defines a whitespace or comma separated list of class names for handler classes to load and register as handlers on the root Logger (the Logger named ""). Each class name must be for a Handler class which has a default constructor. Note that these Handlers may be created lazily, when they are first used.
- A property "<logger>.handlers". This defines a whitespace or comma separated list of class names for handlers classes to load and register as handlers to the specified logger. Each class name must be for a Handler class which has a default constructor. Note that these Handlers may be created lazily, when they are first used.
- A property "<logger>.useParentHandlers". This defines a boolean value. By default every logger calls its parent in addition to handling the logging message itself, this often result in messages being handled by the root logger as well. When setting this property to false a Handler needs to be configured for this logger otherwise no logging messages are delivered.
- A property "config". This property is intended to allow arbitrary configuration code to be run. The property defines a whitespace or comma separated list of class names. A new instance will be created for each named class. The default constructor of each class may execute arbitrary code to update the logging configuration, such as setting logger levels, adding handlers, adding filters, etc.
Note that all classes loaded during LogManager configuration are first searched on the system class path before any user class path. That includes the LogManager class, any config classes, and any handler classes.
Loggers are organized into a naming hierarchy based on their dot separated names. Thus "a.b.c" is a child of "a.b", but "a.b1" and a.b2" are peers.
All properties whose names end with ".level" are assumed to define log levels for Loggers. Thus "foo.level" defines a log level for the logger called "foo" and (recursively) for any of its children in the naming hierarchy. Log Levels are applied in the order they are defined in the properties file. Thus level settings for child nodes in the tree should come after settings for their parents. The property name ".level" can be used to set the level for the root of the tree.
All methods on the LogManager object are multi-thread safe. @since 1.4

            }
            finally
            {
                // If JULI is used, shut JULI down *after* the server shuts down
                // so log messages aren't lost
                LogManager logManager = LogManager.getLogManager();
                if ( logManager instanceof ClassLoaderLogManager )
                {
                    ( (ClassLoaderLogManager) logManager ).shutdown();
                }
            }

View Full Code Here

        activator.start(context);
        
        if (!Boolean.valueOf(context.getProperty("org.ops4j.pax.logging.skipJUL"))) {
            // ensure PAX's JdkHandler is re-installed after JUL reset 
            
            final LogManager manager = LogManager.getLogManager();
            final Handler[] paxHandlers = manager.getLogger("").getHandlers();


            logManagerChangeListener = (new PropertyChangeListener() {
                public void propertyChange(PropertyChangeEvent evt) {
                    Logger rootLogger = manager.getLogger("");
                    Handler[] handlers = rootLogger.getHandlers();
                    List<Handler> handlerList = (handlers == null) ? Collections.<Handler>emptyList() : Arrays.asList(handlers);                    
                    for (Handler h : paxHandlers) {
                        if (!handlerList.contains(h)) {
                            rootLogger.addHandler(h);
                        }
                    }
                    rootLogger.warning("java.util.logging has been reset by application or component");
                }
            });
            
            manager.addPropertyChangeListener(logManagerChangeListener);
        }
    }

View Full Code Here


    // delete file if it exists
    this.logFile.delete();


    // initialize log framework
    LogManager logManager = LogManager.getLogManager();
    try {
      InputStream ins = ClassLoader.getSystemResourceAsStream(loggerPropertiesFileName);
      // Try the current class loader if system one cannot find the file
      if (ins == null) {
      ins = this.getClass().getClassLoader().getResourceAsStream(loggerPropertiesFileName);
      }
      if (ins != null) {
      logManager.readConfiguration(ins);
      } else {
      System.out.println("WARNING: failed to load "+loggerPropertiesFileName);
      }
    } catch (SecurityException e) {
      handleException(e);

View Full Code Here

import org.apache.metamodel.MetaModelException;


public class JdbcUtilsTest extends TestCase {


  public void testConvertToMetaModelException() throws Exception {
    LogManager logManager = LogManager.getLogManager();
    File logConfigFile = new File("src/test/resources/logconfig.txt");
    assertTrue(logConfigFile.exists());
    logManager.readConfiguration(new FileInputStream(logConfigFile));


    assertTrue(JdbcUtils.wrapException(new SQLException("msg"), "foo") instanceof MetaModelException);
    assertTrue(JdbcUtils.wrapException(
        new SQLException("msg", "sql state"), "foo") instanceof MetaModelException);
    assertTrue(JdbcUtils.wrapException(new SQLException("msg", "sql state",

View Full Code Here




  public void install()
  {
    // Make sure the LogManager is fully installed first.
    LogManager lm = LogManager.getLogManager();


    SecurityManager oldsm = System.getSecurityManager();
    
    if (oldsm == this)
      throw new IllegalStateException("already installed");

View Full Code Here




  public void install()
  {
    // Make sure the LogManager is fully installed first.
    LogManager lm = LogManager.getLogManager();


    SecurityManager oldsm = System.getSecurityManager();
    
    if (oldsm == this)
      throw new IllegalStateException("already installed");

View Full Code Here

     * Keep LOGGING_LOOP_COUNT console.* files around
     */
    protected void configureLogging()
    {
        // Read configuration from specified file or default resource
        LogManager lm = LogManager.getLogManager();
        String fname = System.getProperty(KEY_LOGGING_CONFIG_FILE);


        boolean inited = false;
        if (fname != null && new File(fname).exists())
        {
            try
            {
                // default configuration reader will examine the property and load configuration
                lm.readConfiguration();
                inited = true;
            } catch (IOException e)
            {
                System.err.println(Strings.error("logging.using.overriden.configuration.errored"));
                e.printStackTrace();
            }
        }


        // If configuration still not read use internal production configuration
        if (!inited)
        {
            final InputStream url =
                this.getClass().getClassLoader().getResourceAsStream(RESOURCE_LOGGING_PROPERTIES);
            try
            {
                lm.readConfiguration(url);
            } catch (IOException e)
            {
                System.err.println(Strings.error("logging.unable.to.use.production.configuration"));
                e.printStackTrace();
            }

View Full Code Here

            return;
        }
        InputStream istream = null;


        try {
            LogManager lm = LogManager.getLogManager();
            String path =
                "/org/hsqldb/resources/jdklogging-default.properties";


            if (isDefaultJdkConfig()) {
                lm.reset();


                ConsoleHandler consoleHandler = new ConsoleHandler();


                consoleHandler.setFormatter(
                    new BasicTextJdkLogFormatter(false));
                consoleHandler.setLevel(Level.INFO);
                istream = FrameworkLogger.class.getResourceAsStream(path);
                lm.readConfiguration(istream);


                Logger cmdlineLogger = Logger.getLogger("org.hsqldb.cmdline");


                cmdlineLogger.addHandler(consoleHandler);
                cmdlineLogger.setUseParentHandlers(false);
            } else {


                // Do not intervene.  Use JDK logging exactly as configured
                // by user.
                lm.readConfiguration();


                // The only bad thing about doing this is that if the app
                // has programmatically changed the logging config after
                // starting the program but before using FrameworkLogger,
                // we will clobber those customizations.

View Full Code Here

        if (!globalCfgFile.isFile()) {
            return false;
        }


        FileInputStream fis = null;
        LogManager      lm  = LogManager.getLogManager();


        try {
            fis = new FileInputStream(globalCfgFile);


            Properties defaultProps = new Properties();


            defaultProps.load(fis);


            Enumeration names = defaultProps.propertyNames();
            int         i     = 0;
            String      name;
            String      liveVal;


            while (names.hasMoreElements()) {
                i++;


                name    = (String) names.nextElement();
                liveVal = lm.getProperty(name);


                if (liveVal == null) {
                    return false;
                }


                if (!lm.getProperty(name).equals(liveVal)) {
                    return false;
                }
            }


            return true;

View Full Code Here

            Runtime.getRuntime().addShutdownHook(shutdownHook);


            // If JULI is being used, disable JULI's shutdown hook since
            // shutdown hooks run in parallel and log messages may be lost
            // if JULI's hook completes before the CatalinaShutdownHook()
            LogManager logManager = LogManager.getLogManager();
            if (logManager instanceof ClassLoaderLogManager) {
                ((ClassLoaderLogManager) logManager).setUseShutdownHook(
                        false);
            }
        }

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of java.util.logging.LogManager$LoggerContext

ch.qos.logback.classic.jul.LevelChangePropagator

ch.rasc.embeddedtc.runner.Runner

ch.rasc.embeddedtc.runner.Runner$RunnerShutdownHook

com.google.gwt.core.client.JavaScriptObject

com.google.gwt.logging.impl.LoggerImplRegular

com.google.gwt.user.client.WindowCloseListener

com.mycila.jdk.logging.ContextualLogManager

com.redhat.rcm.maven.plugin.buildmetadata.util.SunLoggerConfigurator

com.sun.enterprise.server.logging.GFFileHandler

com.sun.jdo.spi.persistence.utility.logging.LoggerFactoryJDK14

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.