Accessor for the logger associated with the {@code Project}.

@return The {@code BuildLogger}.
969497
public BuildLogger getLogger() {
    @SuppressWarnings("unchecked") final List<? extends BuildListener> listeners = getProject().getBuildListeners();
    assert listeners.size() > 0;
    return (BuildLogger)listeners.get(0);
  }
56785
@SuppressWarnings("unchecked")
	public static <T, L extends LoggerInformer> L getLogger(Class<T> clazz) {
		return (L)SLF4JLoggerFactory.getLogger(clazz);
	}
1199841
private Logger log()
    {

        if (log == null)
        {
            log = Logger.getLogger(_PackageInfo.class.getName());
        }
        return log;

    }
264811
Logger demandLogger(String name, String resourceBundleName, Class<?> caller) {
        Logger result = getLogger(name);
        if (result == null) {
            // only allocate the new logger once
            Logger newLogger = new Logger(name, resourceBundleName, caller);
            do {
                if (addLogger(newLogger)) {
                    // We successfully added the new Logger that we
                    // created above so return it without refetching.
                    return newLogger;
                }

                // We didn't add the new Logger that we created above
                // because another thread added a Logger with the same
                // name after our null check above and before our call
                // to addLogger(). We have to refetch the Logger because
                // addLogger() returns a boolean instead of the Logger
                // reference itself. However, if the thread that created
                // the other Logger is not holding a strong reference to
                // the other Logger, then it is possible for the other
                // Logger to be GC'ed after we saw it in addLogger() and
                // before we can refetch it. If it has been GC'ed then
                // we'll just loop around and try again.
                result = getLogger(name);
            } while (result == null);
        }
        return result;
    }
154590
public Logger getLogger(Class<?> clazz) {
      if (clazz == null) {
         return getGlobalLogger();
      }
      return getLogger(clazz.getName());
   }
366128
public synchronized BuildDiscarder getBuildDiscarder() {
        BuildDiscarderProperty prop = _getProperty(BuildDiscarderProperty.class);
        return prop != null ? prop.getStrategy() : /* settings compatibility */ logRotator;
    }
17725
static InternalLogger wrapLogger(Logger logger) {
        return logger instanceof LocationAwareLogger ?
                new LocationAwareSlf4JLogger((LocationAwareLogger) logger) : new Slf4JLogger(logger);
    }
1044327
@Deprecated
    public LogRotator getLogRotator() {
        BuildDiscarder buildDiscarder = getBuildDiscarder();
        return buildDiscarder instanceof LogRotator ? (LogRotator) buildDiscarder : null;
    }
1203022
public Logger getLogger (String name)
    {
        return new Impl(org.apache.log4j.Logger.getLogger(name));
    }
40130
public static @Nonnull Logger getLogger(@Nonnull Class type) {
        if (ENABLE_CLASS_LOADER_LOGGING) {
            return LoggerFactory.getLogger(type);
        } else {
            return NOPLogger.NOP_LOGGER;
        }
    }
1041301
public static <T> Parameters.Builder<T> logger(Logger logger) {
        return Parameters.<T> builder().logger(logger);
    }
1079570
public static Logger getLogger()
   {
       if (m_logger == null)
       {
           m_logger = Logger.getLogger(Constant.ROOT_PACKAGE.substring(0, Constant.ROOT_PACKAGE.length() - 1));
           try {
               LogManager logManager = LogManager.getLogManager();
               logManager.reset();//removeAllGlobalHandlers();
               ConsoleHandler fh = new ConsoleHandler();
               fh.setFormatter(new SimpleFormatter());
               // Send logger output to our FileHandler.
               m_logger.addHandler(fh);
           } catch (java.security.AccessControlException ex)    {
               // Access error if running in an applet.
        	   m_logger = Logger.getAnonymousLogger();
           } finally {
               try {
	               // Request that every detail gets logged.
//                 m_logger.setLevel(Level.OFF);
//                   m_logger.setLevel(Level.ALL);
	               m_logger.setLevel(Level.WARNING);        	   
               } catch (java.security.AccessControlException ex)    {
            	   ex.printStackTrace();	// Never
               }
           }
       }
       return m_logger;
   }
34544
public synchronized static Logging getLogger(final String name) {
    Logging logger = loggers.get(name);
    if(logger == null) {
      logger = new Logging(Logger.getLogger(name));
      loggers.put(name, logger);
    }
    return logger;
  }
800910
public java.util.logging.Logger getParentLogger() throws java.sql.SQLFeatureNotSupportedException {
        throw new java.sql.SQLFeatureNotSupportedException();
    }
820184
public static Logger getLogger(final Class<?> aClass, final String aBundleName) {
        return getLogger(aClass.getName(), aBundleName);
    }
1297768
def getLogger(name):
    '''  '''

    # Create logger and add a default NULL handler
    log = logging.getLogger(name)
    log.addHandler(_NullHandler())

    return log
660357
protected Logger buildLogger(String fileStr) throws IOException {
		String loggerName = buildLoggerName();
		Appender appender = buildAppender(loggerName, fileStr);

		// Create the logger and add to the map of loggers using our factory
		Logger logger = loggerContext.getLogger(loggerName);
		logger.addAppender(appender);
		logger.setLevel(Level.INFO);
		logger.setAdditive(false);
		return logger;
	}