Return ``list`` of names of all loggers than have been accessed.

    Warning: this is sensitive to internal structures in the standard logging module.
335079
def get_all_logger_names(include_root=False):
    
    # noinspection PyUnresolvedReferences
    rv = list(logging.Logger.manager.loggerDict.keys())
    if include_root:
        rv.insert(0, '')
    return rv
500889
function getLoggers() {
    return _.sortBy(
        loggers.map(function (logger) {
            return {
                name: logger.name,
                level: logger.getLevel(),
                parent: logger.getParent() ? logger.getParent().name : ''
            };
        }),
        function (logger) {
            return logger.name.toUpperCase();
        });
}
7662
@SuppressWarnings("unchecked")
	private static Enumeration<LogEntry> getLogEntries(LogReaderService lrs)
	{
		return (Enumeration<LogEntry>)lrs.getLog();
	}
371176
def has_logs(self):
        
        found_files = []
        if self.logpath is None:
            return found_files
        if os.path.exists(self.logpath):
            for root, _, files in os.walk(os.path.abspath(self.logpath)):

                for fil in files:
                    found_files.append(os.path.join(root, fil))
        return found_files
985557
def name(self):
        """"""
        try:
            return self._name
        except AttributeError:
            self._name = "%s.%s[%i]" % (self.__module__,
                                        self.__class__.__name__,
                                        next(Loggable.__ids))
            return self._name
102495
function getHierarchy(loggerName) {
    if (!loggerName) {
        return [];
    }
    var names = [];
    var p = 0;
    while (p !== -1) {
        p = loggerName.indexOf('/', p);
        if (p !== -1) {
            names.push(loggerName.substring(0, p));
            // loggerName = loggerName.substring(p + 1);
            p++;
        }
    }
    return names;
}
1101908
public List<String> getLoggerNames() {
      return Collections.list(java.util.logging.LogManager.getLogManager().getLoggerNames());
   }
957060
def remove_all_logger_handlers(logger: logging.Logger) -> None:
    
    while logger.handlers:
        h = logger.handlers[0]
        logger.removeHandler(h)
477963
def logs(self):
        """"""
        url = self._url + "/logs"
        return _log(url=url,
                    securityHandler=self._securityHandler,
                    proxy_url=self._proxy_url,
                    proxy_port=self._proxy_port)
802609
def prior_names(self):
        
        return list(self.prior_information.groupby(
                self.prior_information.index).groups.keys())
1046816
def log_daemons_list(self):
        
        daemons = [self.arbiters, self.schedulers, self.pollers,
                   self.brokers, self.reactionners, self.receivers]
        for daemons_list in daemons:
            if not daemons_list:
                logger.debug("- %ss: None", daemons_list.inner_class.my_type)
            else:
                logger.debug("- %ss: %s", daemons_list.inner_class.my_type,
                             ','.join([daemon.get_name() for daemon in daemons_list]))
1048018
def get_logs(self):
        """"""
        # Implemented from kitosid template for -
        # osid.resource.BinLookupSession.get_bins_template
        catalogs = self._get_provider_session('log_lookup_session').get_logs()
        cat_list = []
        for cat in catalogs:
            cat_list.append(Log(self._provider_manager, cat, self._runtime, self._proxy))
        return LogList(cat_list)
49999
def _get_names(self):
        
        names = self._read_name_file('names.json')
        names = self._compute_weights(names)

        return names
1356615
def names(self) -> [str]:
        
        return sorted([name for name in self.axes_by_sname.keys() if name is not ''])
368664
public Collection<String> getAllLoggerNames() {
		Set<String> loggerNames = new TreeSet<>();
		for (Logger logger : getParentLoggers()) {
			loggerNames.add(logger.getName());
		}
		for (Logger logger : getLoggers()) {
			loggerNames.add(logger.getName());
		}
		if (!customLoggers.isEmpty()) {
			for (Entry<LoggerConfig, String> entry : customLoggers.entrySet()) {
				loggerNames.add(entry.getKey().getName());
			}
		}
		if (!customParentLoggers.isEmpty()) {
			for (Entry<LoggerConfig, String> entry : customParentLoggers.entrySet()) {
				loggerNames.add(entry.getKey().getName());
			}
		}
		return loggerNames;
	}
572854
def layers_names(self):
		
		return list(self.__class__.__builtin_layers__.keys()) + list(self.__layers.keys())
1110858
def names():
    '''
    
    '''
    global blacklist
    if blacklist is None:
        # not yet loaded
        path = os.path.join(os.path.dirname(__file__), 'names.yaml')
        f = open(path, 'r')
        blacklist = yaml.safe_load(f)
        f.close()
    return blacklist