Come inviare uno stacktrace a log4j?

Supponi di prendere un'eccezione e ottieni quanto segue sull'output standard (come, diciamo, la console) se fai un e.printStackTrace () :

java.io.FileNotFoundException: so.txt
        at java.io.FileInputStream.<init>(FileInputStream.java)
        at ExTest.readMyFile(ExTest.java:19)
        at ExTest.main(ExTest.java:7)

Ora voglio inviare questo invece a un logger come, diciamo, log4j per ottenere quanto segue:

31947 [AWT-EventQueue-0] ERROR Java.io.FileNotFoundException: so.txt
32204 [AWT-EventQueue-0] ERROR    at java.io.FileInputStream.<init>(FileInputStream.java)
32235 [AWT-EventQueue-0] ERROR    at ExTest.readMyFile(ExTest.java:19)
32370 [AWT-EventQueue-0] ERROR    at ExTest.main(ExTest.java:7)

Come posso fare questo?

try {
   ...
} catch (Exception e) {
    final String s;
    ...  // <-- What goes here?
    log.error( s );
}

Si passa l'eccezione direttamente al logger, ad es

try {
   ...
} catch (Exception e) {
    log.error( "failed!", e );
}

Sta a log4j rendere il rendering dello stack stack.

Se si desidera registrare uno stacktrace senza comportare un'eccezione, procedere come segue:

String message = "";

for(StackTraceElement stackTraceElement : Thread.currentThread().getStackTrace()) {                         
    message = message + System.lineSeparator() + stackTraceElement.toString();
}   
log.warn("Something weird happened. I will print the the complete stacktrace even if we have no exception just to help you find the cause" + message);

Puoi anche ottenere la traccia dello stack come stringa tramite ExceptionUtils.getStackTrace.

Vedi: ExceptionUtils.java

Lo uso solo per log.debug, per log.errorsemplicità.

Solo perché è successo a me e può essere utile. Se lo fai

try {
   ...
} catch (Exception e) {
    log.error( "failed! {}", e );
}

otterrai l'intestazione dell'eccezione e non l'intero stacktrace. Perché il logger penserà che stai passando una stringa. Fallo senza {}come ha detto Skaffman

La risposta di Skaffman è sicuramente la risposta corretta. Tutti i metodi di logger, come error(), warn(), info(), debug()prendono Throwable come secondo parametro:

try {
...
 } catch (Exception e) {
logger.error("error: ", e);
}

Tuttavia, è possibile estrarre stacktrace anche come stringa. A volte potrebbe essere utile se si desidera sfruttare la funzionalità di formattazione utilizzando il segnaposto "{}" - vedere il metodo void info(String var1, Object... var2);In questo caso dire che si dispone di uno stacktrace come String, quindi si può effettivamente fare qualcosa del genere:

try {
...
 } catch (Exception e) {
String stacktrace = TextUtils.getStacktrace(e);
logger.error("error occurred for usename {} and group {}, details: {}",username, group, stacktrace);
}

Questo stamperà il messaggio parametrizzato e lo stacktrace alla fine allo stesso modo del metodo: logger.error("error: ", e);

In realtà ho scritto una libreria open source che ha un'utilità per l'estrazione di uno stacktrace come String con un'opzione per filtrare in modo intelligente un po 'di rumore dallo stacktrace. Vale a dire se specifichi il prefisso del pacchetto che ti interessa per il tuo stacktrace estratto verrebbe filtrato da alcune parti irrilevanti e ti lascerebbe con informazioni molto consistenti. Ecco il link all'articolo che spiega quali utilità ha la libreria e dove trovarla (sia come manufatti maven che come fonti git) e come usarla pure. Libreria Java Open Source con filtro di traccia stack, analisi stringhe Silent Convertitore Unicode e confronto versioni Vedi il paragrafo " Filtro rumore Stacktrace "

Questa risposta potrebbe non essere correlata alla domanda posta ma legata al titolo della domanda.

public class ThrowableTest {

    public static void main(String[] args) {

        Throwable createdBy = new Throwable("Created at main()");
        ByteArrayOutputStream os = new ByteArrayOutputStream();
        PrintWriter pw = new PrintWriter(os);
        createdBy.printStackTrace(pw);
        try {
            pw.close();
            os.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        logger.debug(os.toString());
    }
}

O

public static String getStackTrace (Throwable t)
{
    StringWriter stringWriter = new StringWriter();
    PrintWriter  printWriter  = new PrintWriter(stringWriter);
    t.printStackTrace(printWriter);
    printWriter.close();    //surprise no IO exception here
    try {
        stringWriter.close();
    }
    catch (IOException e) {
    }
    return stringWriter.toString();
}

O

StackTraceElement[] stackTraceElements = Thread.currentThread().getStackTrace();
for(StackTraceElement stackTrace: stackTraceElements){
    logger.debug(stackTrace.getClassName()+ "  "+ stackTrace.getMethodName()+" "+stackTrace.getLineNumber());
}

In Log4j 2, è possibile utilizzare Logger.catching () per registrare una stack stack da un'eccezione rilevata.

    try {
        String msg = messages[messages.length];
        logger.error("An exception should have been thrown");
    } catch (Exception ex) {
        logger.catching(ex);
    }

questo sarebbe un buon log4j errore / registrazione delle eccezioni - leggibile da splunk / altra registrazione / monitoraggio s / w. tutto è una forma di coppia chiave-valore. log4j otterrebbe la traccia dello stack dall'eccezione obje

    try {
          ---
          ---
    } catch (Exception e) {
        log.error("api_name={} method={} _message=\"error description.\" msg={}", 
                  new Object[]{"api_name", "method_name", e.getMessage(), e});
    }

Try this:

catch (Throwable t) {
    logger.error("any message" + t);
    StackTraceElement[] s = t.getStackTrace();
    for(StackTraceElement e : s){
        logger.error("\tat " + e);
    }   
}

Puoi usare il seguente codice:

import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;

public class LogWriterUtility {
    Logger log;

    public LogWriterUtility(Class<?> clazz) {
        log = LogManager.getLogger(clazz);
    }

public void errorWithAnalysis( Exception exception) {

        String message="No Message on error";
        StackTraceElement[] stackTrace = exception.getStackTrace();
        if(stackTrace!=null && stackTrace.length>0) {
            message="";
            for (StackTraceElement e : stackTrace) {
                message += "\n" + e.toString();
            }
        }
        log.error(message);


    }

}

Qui puoi semplicemente chiamare: LogWriterUtility.errorWithAnalysis( YOUR_EXCEPTION_INSTANCE);

Stamperà stackTrace nel tuo registro.

Crea questo class:

public class StdOutErrLog {

private static final Logger logger = Logger.getLogger(StdOutErrLog.class);

public static void tieSystemOutAndErrToLog() {
    System.setOut(createLoggingProxy(System.out));
    System.setErr(createLoggingProxy(System.err));
}

public static PrintStream createLoggingProxy(final PrintStream realPrintStream) {
    return new PrintStream(realPrintStream) {
        public void print(final String string) {
            logger.info(string);
        }
        public void println(final String string) {
            logger.info(string);
        }
    };
}
}

Chiamalo nel tuo codice

StdOutErrLog.tieSystemOutAndErrToLog();