Stack Trace & Logging Exceptions in Java

A stack trace is a detailed report that shows where an exception occurred and the sequence of method calls that led to it.
It helps developers debug and trace errors easily.

What is a Stack Trace?

A stack trace is a detailed report that shows the sequence of method calls when an exception occurs.

It helps developers identify:

• The type of exception
• The error message
• The exact file & line number
• The call hierarchy (method-by-method stack)

Stack traces are extremely useful for debugging runtime errors.

Example of Stack Trace

public class StackTraceExample {
    public static void main(String[] args) {
        try {
            int a = 10 / 0;  // ArithmeticException
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Output:

java.lang.ArithmeticException: / by zero
    at StackTraceExample.main(StackTraceExample.java:5)

This shows:

• Exception type: ArithmeticException
• Reason: / by zero
• Location: line 5

Ways to Print Stack Trace

1. printStackTrace()

Most common method.

catch (Exception e) {
    e.printStackTrace();
}

2. getMessage()

Prints only error message.

System.out.println(e.getMessage());

3. toString()

Prints exception type + message.

System.out.println(e.toString());

4. Convert Stack Trace to String

Useful for logging.

StringWriter sw = new StringWriter();
PrintWriter pw = new PrintWriter(sw);
e.printStackTrace(pw);
String stackTrace = sw.toString();

Why Stack Trace Is Important?

• Shows exact cause of failure
• Includes line numbers
• Helps debug complex issues
• Very useful in production logs

Logging Exceptions in Java

Printing errors using System.out or printStackTrace() is not recommended in real-world applications.

Logging helps track exceptions in:

• Log files
• Cloud logs
• DB logs
• Consoles

Java supports many logging frameworks.

Logging Using java.util.logging

import java.util.logging.*;

public class LoggingExample {
    private static final Logger logger = Logger.getLogger(LoggingExample.class.getName());

    public static void main(String[] args) {
        try {
            String s = null;
            s.length();
        } catch (Exception e) {
            logger.log(Level.SEVERE, "Exception occurred", e);
        }
    }
}

Logging with Log4j

import org.apache.log4j.Logger;

public class Log4jExample {
    static Logger logger = Logger.getLogger(Log4jExample.class);

    public static void main(String[] args) {
        try {
            int a = 10 / 0;
        } catch (Exception e) {
            logger.error("Error occurred: ", e);
        }
    }
}

Logging with SLF4J + Logback (Most Popular)

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class SLF4JExample {
    private static final Logger logger = LoggerFactory.getLogger(SLF4JExample.class);

    public static void main(String[] args) {
        try {
            int[] arr = new int[3];
            int x = arr[5];
        } catch (Exception e) {
            logger.error("Exception happened: {}", e.getMessage(), e);
        }
    }
}

Why Use Logging Instead of printStackTrace()?

Log Levels in Java

• ERROR → Serious failure
• WARN → Possible problem
• INFO → General information
• DEBUG → Detailed debugging
• TRACE → Very deep debugging

Best Practices for Logging Exceptions

• Always log exceptions with context
• Avoid System.out.println() in production
• Don’t swallow exceptions silently
• Don’t duplicate logs across layers
• Use SLF4J for modern applications

Real-World Logging Example

try {
    processData();
} catch (IOException e) {
    logger.error("Failed to process file", e);
}

Logs include:

• Custom message
• Full stack trace