poner - Registro de Java: Log4j Version2.x: muestra el método de un llamante de cliente final(no un método de ayuda de registro intermedio)

number field java

Question

Los siguientes 3 mensajes ofrecen respuestas sobre cómo usar un asistente de registro intermedio y aún obtener el registrador subyacente para informar desde el método de un cliente a ese asistente de registro (en lugar de informar el método de inicio de sesión como origen):

• Registro de Java: muestra el número de línea de origen de la persona que llama (no el método de ayuda de registro)

• Llamando a los métodos de registro de log4j indirectamente (desde un método auxiliar)

• Imprimir la clase "fuente" en una declaración de registro con un contenedor log4j

Pero parece que solo ofrecen respuestas para Log4j 1.2 , que ofrece lo ahora difunto:

 Category.log(String callerFQCN, Priority level, Object message, Throwable t). 

No parece haber un equivalente obvio para Logger en la API log4J 2.5 .

¿Alguien puede ofrecer una respuesta compatible con el uso directo de Log4J 2.x?

Answer 1

Para Log4j2, la respuesta se proporciona completamente mediante el uso de envoltorios de registrador como se describe en el manual de Log4j2 en Uso de ejemplo de un Contenedor de registrador generado . Uno puede simplemente generar (utilizando las herramientas org.apache.logging.log4j.core.tools.Generate $ ExtendedLogger ilustradas allí) un contenedor logger con un solo nivel STUB, y luego adaptarlo para crear métodos de registro personalizados que imiten el uso del logIfEnabled (FQCN, LEVEL, Marker, message, Throwable) - posiblemente ignorando el nivel de STUB y usando los regulares - luego, si lo desea, eliminando o comentando el nivel de STUB y sus métodos). Para este propósito, FormattedMessage puede ser útil.

Ejemplo:

java -cp log4j-core-2.5.jar org.apache.logging.log4j.core.tools.Generate/$ExtendedLogger com.mycomp.ExtLogger STUB=350 > com/mycomp/ExtLogger.java

Luego, adapte la clase generada (se omiten la mayoría de los métodos de soporte):

public final class ExtLogger extends ExtendedLoggerWrapper {
...
private final ExtendedLoggerWrapper logger;
private static final String FQCN = ExtLogger.class.getName();
private static final Level STUB = Level.forName("STUB", 350);
//Delete this afterwards if level not used.
private ExtLogger(final Logger logger) {
super((AbstractLogger) logger, logger.getName(), logger.getMessageFactory());
this.logger = this;
}
/**
* Returns a custom Logger with the name of the calling class.
*
* @return The custom Logger for the calling class.
*/
public static ExtLogger create() {
final Logger wrapped = LogManager.getLogger();
return new ExtLogger(wrapped);
}
/**
* Returns a custom Logger using the fully qualified name of the Class as
* the Logger name.
*
* @param loggerName The Class whose name should be used as the Logger name.
* If null it will default to the calling class.
* @return The custom Logger.
*/
public static ExtLogger create(final Class<?> loggerName) {
final Logger wrapped = LogManager.getLogger(loggerName);
return new ExtLogger(wrapped);
}
...
/**
* Logs a message object with the {@code STUB} level.
*
* @param message the message object to log.
*/
public void stub(final String message) {
logger.logIfEnabled(FQCN, STUB, null, message, (Throwable) null);
}
/**
* Example: Adapt with custom formatting.
* Here DEBUG level is used just as an example.
*
* @param name
* @param value
*/
public void echo(final String name, Object value) {
Message m = new FormattedMessage("echo: %s(%s)",name,value);
logger.logIfEnabled(FQCN, Level.DEBUG, null, m, (Throwable) null);
}
...
}

Luego, en una clase de cliente, ahora registrará "en nombre" de ese cliente correctamente a través de los métodos de ayuda del registrador, en este caso, el ejemplo de formato echo (name, value):

public class TestLog4j {
private static final ExtLogger extLogger = ExtLogger.create(TestLog4j.class);
public static void elseWhere() {
extLogger.echo("aVariableName", 4);
}
public static void main(String[] args) {
extLogger.echo("aStringVariableName","from main");
elseWhere();
}
}

Patrón simpleDisposición:

 <PatternLayout pattern=" %-5level [%C{1}::%M(%L)] %logger{36} - %msg%n"/>

Salida:

 DEBUG [TestLog4j::main(63)] testlogging.TestLog4j - echo: aStringVariableName(from main)
DEBUG [TestLog4j::elseWhere(42)] testlogging.TestLog4j - echo: aVariableName(4)

Una vez que tenga el truco de usar logger.logIfEnabled (FQCN, ...) con el FQCN (que log4j busca en el seguimiento de la pila) es posible que desee eliminar o comentar los métodos stub (..) y el nivel STUB. si no usas un nivel adicional.

Answer 2

Si está construyendo un nuevo sistema, quédese con la respuesta de Webel.

Si tiene un sistema existente, está migrando a log4j2, probablemente aún deba ejecutar los métodos de generación (pero incluyo una clase de trabajo mínima a continuación), y puede agregar esta función que proporciona la forma de hacer llamadas de 1.2 llamadas anteriores (más o menos) )

public void log(Class ignoreClassFQCN, Level level, Marker marker, String msg, Throwable throwable){
logger.logIfEnabled(ignoreClassFQCN.getName(), level, marker, msg, throwable);
}

Luego, a partir de sus clases existentes de ajuste de registro, puede hacer algo como esto:

// inside ThisClass.java, denoting an old logger such as one that used log4j 1.2 with the callerFQCN parameter, or just an old logger that''s naive and custom built.
private static final MyLog4j2WrapperClass newLogger = MyLog4j2WrapperClass.create();
public static void debug(String message) {
// basic example
newLogger.log(ThisClass.class, Level.DEBUG, null, message, null);
}
public static void logFailure(String message) {
// example of using a custom log level
newLogger.log(ThisClass.class, MyLog4j2WrapperClass.FAILURE, null, message, null);
}

Pasé a eliminar un montón de otras funciones generadas que no estoy usando, ya que planeé hacer un ajuste simple para un sistema de registro mal diseñado (personalizado). Eliminé un montón de métodos de create () que no planeaba usar. Entonces aquí hay una clase trabajadora (las partes que vale la pena compartir):

public final class MyLog4j2WrapperClass extends ExtendedLoggerWrapper {
private static final long serialVersionUID = 1L;
private final ExtendedLoggerWrapper logger;
private static final String FQCN = MyLog4j2WrapperClass.class.getName();
public static final Level FAILURE = Level.forName("FAILURE", 150);
public void log(Class ignoreClass, Level level, Marker marker, String msg, Throwable throwable){
logger.logIfEnabled(ignoreClass.getName(), level, marker, msg, throwable);
}
private MyLog4j2WrapperClass(final Logger logger) {
super((AbstractLogger) logger, logger.getName(), logger.getMessageFactory());
this.logger = this;
}
/**
* Returns a custom Logger with the name of the calling class.
*
* @return The custom Logger for the calling class.
*/
public static MyLog4j2WrapperClass create() {
final Logger wrapped = LogManager.getLogger();
return new MyLog4j2WrapperClass(wrapped);
}

Debo señalar que considero que esto es un calcetín, es algo que lo guiará, pero recomiendo seguir alejándose del viejo sistema de registro una vez que tenga el calce en su lugar. Esto le permitirá hacer más cambios de código incrementales sin tener que realizar una migración completa de inmediato.