ch.qos.logback.classic.LoggerContext.getLogger() is hard to understand; it can be shortend with a little recursion. Just a suggestion. I will have to run this modified code to see whether it works, I haven't done so yet.

Additionally, a few edge cases should be checked, right?

== Original ==

-------------------
public final Logger getLogger(final String name) {

if (name == null)

{ throw new IllegalArgumentException("name argument cannot be null"); }

// if we are asking for the root logger, then let us return it without
// wasting time
if (Logger.ROOT_LOGGER_NAME.equalsIgnoreCase(name))

{ return root; }

int i = 0;
Logger logger = root;

// check if the desired logger exists, if it does, return it
// without further ado.
Logger childLogger = (Logger) loggerCache.get(name);
// if we have the child, then let us return it without wasting time
if (childLogger != null) { return childLogger; }

// if the desired logger does not exist, them create all the loggers
// in between as well (if they don't already exist)
String childName;
while (true) {
int h = LoggerNameUtil.getSeparatorIndexOf(name, i);
if (h == -1) { childName = name; } else { childName = name.substring(0, h); }
// move i left of the last point
i = h + 1;
synchronized (logger) {
childLogger = logger.getChildByName(childName);
if (childLogger == null) { childLogger = logger.createChildByName(childName); loggerCache.put(childName, childLogger); incSize(); }
}
logger = childLogger;
if (h == -1) { return childLogger; }
}
}
-------------------

== With recursion ==


public final Logger getLogger(final String name) {
if (name == null) { throw new IllegalArgumentException("name argument cannot be null"); // can it be empty though?? }
// if we are asking for the root logger, then let us return it without wasting time
// note that this is not the empty name but "ROOT"
if (Logger.ROOT_LOGGER_NAME.equalsIgnoreCase(name)) { return root; }

// check if the desired logger exists, if it does, return it without further ado.
{
Logger childLogger = (Logger) loggerCache.get(name);
if (loggerCache.get(name) != null)

{ return childLogger; }

}
// if the desired logger does not exist, then create all the loggers in between as well (if they don't exist yet)
// this means
// 1) splitting the "name" along the DOT/DOLLAR separators (but refusing the empty string result)
// 2) creating all the loggers along that path if they don't exist yet
createLoggerPathRecursively(name, "", 0, root);
}

/**

• Recursively build logger path
• On the first call, "originalName" is the full logger name, "currentName" is the empty string,
• currentPos (the position beyond which to search for logger name components) is 0 and
• "parentLogger" is the "root"
  */

private void createLoggerPathRecursively(String originalName, String currentName, int currentPos, Logger parentLogger) {
assert originalName != null;
assert currentName != null;
assert currentPos >= 0;
assert parentLogger != null;
if (currentPos >= originalName.length())

{ throw new IllegalArgumentException("The logger name '" + originalName + "' is either empty or ends with a separator"); }

// find the next separator in "originalName" starting from "currentPos"
int ix = getSeparatorIndexOf(originalName, currentPos);
if (ix < 0)

{ // No more separators, so we are done but still need to register this last logger. // So let ix point past the end! ix = originalName.length(); }

String nameComponent = originalName.substring(currentPos, ix);
// Depending on specification use one of the two below:
String childName = currentName + CoreConstants.DOT + nameComponent; // DOTify any DOLLAR
// String childName = originalName.substring(0, ix); // unmodified part of original
// Accept empty components? Nope!
if (nameComponent.isEmpty())

{ throw new IllegalArgumentException("The logger name '" + originalName + "' has an empty component starting at position " + currentPos); }

// See whether the child logger exists, if not, create it
Logger childLogger;
synchronized (parentLogger) {
childLogger = parentLogger.getChildByName(childName); // does not check the childName; returns null if not found
if (childLogger == null)

{ // Depending on taste use this (which dotifies any dollars) // childLogger = parentLogger.createChildByLastNamePart(nameComponent); // checks that name component has no DOT or DOLLAR // or this (which keeps the DOT or DOLLAR as is); this is in the original (this means that the root must have the empty name) childLogger = parentLogger.createChildByName(childName); // checks that name component beyond parent's name has no DOT or DOLLAR loggerCache.put(childName, childLogger); incSize(); }

assert childLogger != null;
}
// (tail)-recursive call if not done
if (ix < originalName.length())

{ createLoggerPathRecursively(originalName, childName, ix + 1, childLogger); }

}