Log4j2 - Logging With Abstract Classes

Question

I have the following codes:

MySuperClass

package com.mypackage;

public abstract class MySuperClass {
    private static final Logger LOGGER = LogManager.getLogger();

    protected void demoLog() {
        LOGGER.debug("My message")
    }
}

MyClass

package com.mypackage;

public class MyClass extends MySuperClass {

    public void executeLog() {
        demoLog();
    }
}

When com.mypackage.MyClass#executeLog method executes it prints:

2018-07-24 10:39:04,964 : DEBUG : : com.mypackage.MySuperClass : demoLog : My message

In the log message, the Emitter is com.mypackage.MySuperClass, but I would like to have com.mypackage.MyClass as the Emitter.

• com.mypackage.MySuperClass is extended by multiple class
• I cannot pass Class as argument to the LogManager.getLogger() by calling getClass() from MySuperClass since it is static. To me using static is a good idea, as the actual implementation is in JSF Managed Bean.

How can I achieve this?

There is a similar question was asked here: Java Logging With Abstract Classes, but it is not providing me with a solution.

Update - 1

• If the Logger in MySuperClass is defined as private final Logger logger = LogManager.getLogger(getClass());, still the Emitter is com.mypackage.MySuperClass.

• If I define

  protected abstract Logger getLogger();
  

  in MySuperClass and implement it as

  private final Logger logger = LogManager.getLogger(getClass());
  
  @Override
  protected Logger getLogger() {
      return logger;
  }
  

  in MyClass the Emitter is the same, i.e., com.mypackage.MySuperClass.

Update - 2

If I define

protected abstract Logger getLogger();

in MySuperClass and implement it as

private final Logger logger = LogManager.getLogger(MyClass.class);

@Override
protected Logger getLogger() {
    return logger;
}

in MyClass the Emitter is the same, i.e., com.mypackage.MySuperClass.

Answer 1

One way to do it would be to migrate the LOGGER constant to all the leaf subclasses, and then make it accessible through a protected abstract method, like below:

public abstract class MySuperClass {

    protected void demoLog() {
        logger().debug("My message");
    }

    protected abstract Logger logger();
}

public class MyClass extends MySuperClass {

    private static final Logger LOGGER = LogManager.getLogger();

    public void executeLog() {
        demoLog();
    }

    @Override
    protected Logger logger() {
        return LOGGER;
    }
}

EDIT: I didn't look at the link you provided, and now that I did I noticed that my answer is an analog of this answer, so - as far as I understand - it's not a solution you look for.

---

The Actual Answer

OK, so what this question is about (and what you mean by "emitter") is the Log4j2 "class" conversion pattern (obtained using %C or %class), and not the Logger-related pattern (obtained using %c or %logger).

Consider this log4j2.xml configuration file related to your example:

<Appenders>
    <Console name="loggerVsClassAppender" target="SYSTEM_OUT">
        <PatternLayout pattern="Logger=%logger | Class: %class | %msg%n"/>
    </Console>
</Appenders>

<Loggers>
    <Logger name="com.mypackage" level="trace">
        <AppenderRef ref="loggerVsClassAppender"/>
    </Logger>
</Loggers>

When you run your code using this configuration, the output you get is:

Logger=com.mypackage.MySuperClass | Class: com.mypackage.MySuperClass | My message

When you run my code using this configuration, the output you get is:

Logger=com.mypackage.MyClass | Class: com.mypackage.MySuperClass | My message

As you can see, appropriate Logger is being used in my code, but Class remains the same.

Now here's an excerpt from the description of the %class conversion pattern:

Outputs the fully qualified class name of the caller issuing the logging request. [...]

Generating the class name of the caller (location information) is an expensive operation and may impact performance. Use with caution.

As you can see, this is the class name as retrieved from the stack trace at call site of the Logger.debug method.

To conclude, you cannot change this particular value because MySuperClass is where the call actually happens. However, what you can do is replacing the %class conversion pattern with the %logger conversion pattern to get the expected result.

Answer 2

Dont make it static. Loggers are shared among the "same key" so they will be shared between instances of the same class.