Lines Matching defs:logger
92 * with the dot-separated name for the handler or logger.
103 * <li>A property "<logger>.handlers". This defines a whitespace or
105 * load and register as handlers to the specified logger. Each class
110 * <li>A property "<logger>.useParentHandlers". This defines a boolean
111 * value. By default every logger calls its parent in addition to
113 * being handled by the root logger as well. When setting this property
114 * to false a Handler needs to be configured for this logger otherwise
122 * setting logger levels, adding handlers, adding filters, etc.
136 * the logger called "foo" and (recursively) for any of its children
199 // flag set - we make sure to add the root logger to
208 // Make sure the global logger will be registered in the
373 // The new logger context has its requiresDefaultLoggers
393 // Find or create a specified logger instance. If a logger has
395 // Otherwise a new logger instance is created and registered
408 // only allocate the new logger once
435 // Add a system logger in the system context's namespace
438 // Add the system logger to the LogManager's namespace if not exist
439 // so that there is only one single logger of the given name.
440 // System loggers are visible to applications unless a logger of
442 Logger logger;
446 // implementation that adds a logger if does not exist
448 // successfully added the new system logger
449 logger = sysLogger;
451 logger = getLogger(name);
453 } while (logger == null);
456 if (logger != sysLogger && sysLogger.getHandlers().length == 0) {
457 // if logger already exists but handlers not set
458 final Logger l = logger;
471 // LoggerContext maintains the logger namespace per context.
474 // all system loggers and is queried by the system code. If a system logger
523 Logger logger = ref.get();
524 if (logger == null) {
526 // to a logger which has been GC-ed.
529 return logger;
532 // This method is called before adding a logger to the
534 // 'logger' is the context that will be added.
536 // before adding 'logger'.
538 private void ensureAllDefaultLoggers(Logger logger) {
540 final String name = logger.getName();
550 private void ensureDefaultLogger(Logger logger) {
551 // Used for lazy addition of root logger and global logger
557 if (!requiresDefaultLoggers || logger == null
558 || logger != Logger.global && logger != manager.rootLogger) {
560 // the case where we have a non null logger which is neither
565 assert logger == null;
570 // Adds the logger if it's not already there.
571 if (!namedLoggers.containsKey(logger.getName())) {
578 addLocalLogger(logger, false);
582 boolean addLocalLogger(Logger logger) {
584 return addLocalLogger(logger, requiresDefaultLoggers);
587 // Add a logger to this context. This method will only set its level
589 synchronized boolean addLocalLogger(Logger logger, boolean addDefaultLoggersIfNeeded) {
600 ensureAllDefaultLoggers(logger);
603 final String name = logger.getName();
616 // We already have a registered logger with the given name.
621 // We're adding a new logger.
623 ref = manager.new LoggerWeakRef(logger);
626 // Apply any initial level defined for the new logger.
629 doSetLevel(logger, level);
632 processParentHandlers(logger, name);
651 doSetParent(logger, parent);
654 node.walkAndSetParent(logger);
668 // returning logger names.
673 // If logger.getUseParentHandlers() returns 'true' and any of the logger's
675 private void processParentHandlers(final Logger logger, final String name) {
678 if (logger != manager.rootLogger) {
681 logger.setUseParentHandlers(false);
705 // Gets a node in our tree of logger nodes.
737 // Add a system logger in the system context's namespace as well as
739 // one single logger of the given name. System loggers are visible
740 // to applications unless a logger of the same name has been added.
744 // only allocate the new system logger once
771 // Add new per logger handlers.
775 private void loadLoggerHandlers(final Logger logger, final String name,
798 // Add this Handler to the logger
799 logger.addHandler(hdl);
842 LoggerWeakRef(Logger logger) {
843 super(logger, loggerRefQueue);
845 name = logger.getName(); // save for namedLoggers cleanup
927 * Add a named logger. This does nothing and returns false if a logger
937 * @param logger the new logger.
938 * @return true if the argument logger was registered successfully,
939 * false if a logger of that name already exists.
940 * @exception NullPointerException if the logger name is null.
942 public boolean addLogger(Logger logger) {
943 final String name = logger.getName();
949 if (cx.addLocalLogger(logger)) {
950 // Do we have a per logger handler too?
952 loadLoggerHandlers(logger, name, name + ".handlers");
959 // Private method to set a level on a logger.
961 private static void doSetLevel(final Logger logger, final Level level) {
965 logger.setLevel(level);
972 logger.setLevel(level);
977 // Private method to set a parent on a logger.
979 private static void doSetParent(final Logger logger, final Logger parent) {
983 logger.setParent(parent);
990 logger.setParent(parent);
996 * Method to find a named logger.
1007 * @param name name of the logger
1008 * @return matching logger or null if none is found
1015 * Get an enumeration of known logger names.
1028 * @return enumeration of logger name strings
1101 * all Handlers and (except for the root logger) sets the level
1102 * to null. The root logger's level is set to Level.INFO.
1120 Logger logger = cx.findLogger(name);
1121 if (logger != null) {
1122 resetLogger(logger);
1128 // Private method to reset an individual target logger.
1129 private void resetLogger(Logger logger) {
1131 Handler[] targets = logger.getHandlers();
1134 logger.removeHandler(h);
1141 String name = logger.getName();
1143 // This is the root logger.
1144 logger.setLevel(defaultLevel);
1146 logger.setLevel(null);
1388 // a new parent logger.
1397 Logger logger = (ref == null) ? null : ref.get();
1398 if (logger == null) {
1401 doSetParent(logger, parent);
1407 // We use a subclass of Logger for the root logger, so