Làm thế nào để gửi một stacktrace đến log4j?

Giả sử bạn bắt một ngoại lệ và nhận thông tin sau về đầu ra tiêu chuẩn (như, giả sử, bàn điều khiển) nếu bạn thực hiện 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)

Bây giờ tôi muốn gửi cái này thay cho một logger như, giả sử, log4j để có được những điều sau:

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)

Tôi có thể làm cái này như thế nào?

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

Bạn chuyển ngoại lệ trực tiếp đến logger, vd

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

Nó lên đến log4j để hiển thị dấu vết ngăn xếp.

Nếu bạn muốn đăng nhập stacktrace mà không liên quan đến ngoại lệ, chỉ cần làm điều này:

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);

Bạn cũng có thể lấy theo dõi ngăn xếp dưới dạng chuỗi thông qua ExceptionUtils.getStackTrace.

Xem: ExceptionUtils.java

Tôi chỉ sử dụng nó cho log.debug, để giữ cho log.errorđơn giản.

Chỉ vì nó xảy ra với tôi và có thể hữu ích. Nếu bạn làm điều này

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

bạn sẽ nhận được tiêu đề của ngoại lệ chứ không phải toàn bộ stacktrace. Bởi vì bộ ghi sẽ nghĩ rằng bạn đang truyền Chuỗi. Làm điều đó mà không {}như skaffman nói

Câu trả lời từ skaffman chắc chắn là câu trả lời đúng. Tất cả các phương pháp logger như error(), warn(), info(), debug()lấy Throwable như một tham số thứ hai:

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

Tuy nhiên, bạn cũng có thể trích xuất stacktrace dưới dạng String. Đôi khi nó có thể hữu ích nếu bạn muốn tận dụng tính năng định dạng bằng cách sử dụng trình giữ chỗ "{}" - xem phương thức void info(String var1, Object... var2);Trong trường hợp này nói rằng bạn có một stacktrace là String, thì bạn thực sự có thể làm một cái gì đó như thế này:

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

Điều này sẽ in thông báo tham số và stacktrace ở cuối giống như cách thực hiện đối với phương thức: logger.error("error: ", e);

Tôi thực sự đã viết một thư viện mã nguồn mở có Tiện ích để trích xuất stacktrace dưới dạng String với tùy chọn lọc thông minh một số nhiễu ra khỏi stacktrace. Tức là nếu bạn chỉ định tiền tố gói mà bạn quan tâm đến stacktrace được trích xuất của bạn sẽ được lọc ra khỏi một số phần không liên quan và để lại cho bạn thông tin rất hợp lý. Dưới đây là liên kết đến bài viết giải thích những tiện ích mà thư viện có và nơi để có được nó (cả dưới dạng tạo tác maven và nguồn git) và cách sử dụng nó. Thư viện Java mã nguồn mở với bộ lọc theo dõi ngăn xếp, bộ chuyển đổi Unicode phân tích chuỗi im lặng và so sánh phiên bản Xem đoạn " Bộ lọc nhiễu Stacktrace "

Câu trả lời này có thể không liên quan đến câu hỏi được hỏi nhưng liên quan đến tiêu đề của câu hỏi.

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());
    }
}

HOẶC LÀ

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();
}

HOẶC LÀ

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

Trong Log4j 2, bạn có thể sử dụng Logger.catching () để ghi nhật ký ngăn xếp từ một ngoại lệ đã bị bắt.

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

đây sẽ là lỗi log4j tốt / ghi nhật ký ngoại lệ - có thể đọc được bằng cách tách / ghi nhật ký / giám sát khác s / w. tất cả mọi thứ là hình thức của cặp khóa-giá trị. log4j sẽ nhận được dấu vết ngăn xếp từ Exception 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);
    }   
}

Bạn có thể sử dụng mã dưới đây:

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);


    }

}

Ở đây bạn chỉ có thể gọi: LogWriterUtility.errorWithAnalysis( YOUR_EXCEPTION_INSTANCE);

Nó sẽ in stackTrace vào nhật ký của bạn.

Tạo cái này 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);
        }
    };
}
}

Gọi đây trong mã của bạn

StdOutErrLog.tieSystemOutAndErrToLog();