Returns the logger name from the specified {@code pathish}.
191768
public static String newLoggerName(@Nullable String pathish) {
        if (pathish == null) {
            return UNKNOWN_LOGGER_NAME;
        }

        String normalized = pathish;
        if ("/".equals(normalized)) {
            return ROOT_LOGGER_NAME;
        }

        if (normalized.startsWith("/")) {
            normalized = normalized.substring(1); // Strip the first slash.
        }

        final int end;
        if (normalized.endsWith("/")) {
            end = normalized.length() - 1;
        } else {
            end = normalized.length();
        }

        final StringBuilder buf = new StringBuilder(end);
        boolean start = true;
        for (int i = 0; i < end; i++) {
            final char ch = normalized.charAt(i);
            if (ch != '/') {
                if (start) {
                    start = false;
                    if (Character.isJavaIdentifierStart(ch)) {
                        buf.append(ch);
                    } else {
                        buf.append('_');
                        if (Character.isJavaIdentifierPart(ch)) {
                            buf.append(ch);
                        }
                    }
                } else {
                    if (Character.isJavaIdentifierPart(ch)) {
                        buf.append(ch);
                    } else {
                        buf.append('_');
                    }
                }
            } else {
                start = true;
                buf.append('.');
            }
        }

        return buf.toString();
    }
1041682
def get_logger(name):
    

    log = logging.getLogger(name)
    if not log.handlers:
        log.addHandler(NullHandler())
    return log
279579
public ErrorLogger getLogger(final String name) {
        if (name == null || name.equals("")) return null;
        if (!hasLog(name)) {
            addLog(name);
        }
        return getLog(name);
    }
521878
public static PortLogger getLogger(String name, OutputCollector output) {
    Args.checkNotNull(name, "logger name cannot be null");
    Map<OutputCollector, PortLogger> loggers = PortLoggerFactory.loggers.get(name);
    if (loggers == null) {
      loggers = new HashMap<>();
      PortLoggerFactory.loggers.put(name, loggers);
    }

    PortLogger logger = loggers.get(output);
    if (logger == null) {
      logger = new PortLogger(LoggerFactory.getLogger(name), output);
      loggers.put(output, logger);
    }
    return logger;
  }
1102924
private String getEventLogName(String subject, String id) {
    return String.format("%s-%s", subject, id);
  }
221357
public static String getParentLoggerName(String loggerName) {

        int dotIndex = loggerName.lastIndexOf(".");
        if (dotIndex < 0) {
            return null;
        } else {
            return loggerName.substring(0, dotIndex);
        }

    }
519325
public Logger logger() {
        if (logger == null) {
            logger = LoggerFactory.getLogger(this.getClass().getName());
        }
        return logger;
    }
669198
public synchronized Logger getLogger() {
    if (m_Logger == null) {
      m_Logger = Logger.getLogger(getClass().getName());
      m_Logger.setLevel(LoggingHelper.getLevel(getClass()));
    }
    return m_Logger;
  }
874335
def get_logger(cls, custom_name=None):
        """"""
        name = custom_name or cls.get_name()
        return logging.getLogger(name)
116850
public static String getName(String path)
   {
      int pos = path.lastIndexOf('/');
      return pos >= 0 ? path.substring(pos + 1) : "";
   }
593736
private org.apache.log4j.Logger getLogger()
	{
        /*
        Logger interface extends Serializable, thus Log field is
        declared 'transient' and we have to null-check
		*/
		if (logger == null)
		{
			logger = org.apache.log4j.Logger.getLogger(name);
		}
		return logger;
	}
919788
public String getName()
    {
        if (_name==null)
        {
            _name=this.getClass().getName();
            if (!log.isDebugEnabled())
                _name=_name.substring(_name.lastIndexOf('.')+1);
        }
        return _name;
    }
261454
def getLogger(cls, name=None):
        
        return logging.getLogger("{0}.{1}".format(cls.BASENAME, name) if name else cls.BASENAME)
184150
@Nullable
    public String getLoggerLevel(@Nullable String loggerName) {
        try {
            loggerName = loggerName == null ? "" : loggerName;
            if (loggerName.isEmpty()) {
                return LogManager.getRootLogger().getLevel().toString();
            }

            Logger logger = LogManager.exists(loggerName);
            if (logger == null) {
                return null;
            } else {
                Level level = logger.getLevel();
                if (level == null) {
                    return null;
                }
                return level.toString();
            }
        } catch (RuntimeException e) {
            logger.warn("Exception getting effective logger level " + loggerName, e);
            throw e;
        }
    }
1347173
def get_id_from_cstring(name):
        """"""
        for key in list(LogTocElement.types.keys()):
            if (LogTocElement.types[key][0] == name):
                return key
        raise KeyError('Type [%s] not found in LogTocElement.types!' % name)
1187582
public static String getName(final String path) {

		String cleanedPath = clean(path);

		if (cleanedPath != null && cleanedPath.contains(PATH_SEP)) {

			return StringUtils.substringAfterLast(cleanedPath, PATH_SEP);

		} else {

			return cleanedPath;

		}
	}
1262072
public static Logger getLogger(String name) {
    if (name == null) {
      throw new NullPointerException("Logger name may not be null.");
    }
    init();
    return (instance.internalGetLogger(name));
  }