Logging method calls

Question

Hi all!
I'm working on a complex java system and have problems debugging it. One of the problems is, that sometimes the program stops with a NullPointerException. Unfortunately this happens in third party code, which I do not have as source. However, I'm sure that the bug is caused by a module developed by my as exchanging this module with another implementation stops the problem.
Is there an easy way to generate a list of method calls for an entire run of a program? At the time the exception is raised, none of my methods remains in the call stack, i.e. the exception is triggered by the foreign code, but probably caused by a value returned earlier from one of my methods. I would therefore like to see what methods have been called before the exception is triggered.
I'm currently working with JBuilder 6. It offers a debugger, but this debugger is terrible slow and very bad when the code that is to debug is not available. You could set a method breakpoint for every method I have implemented, but this would take ages. Even with only one such exception defined, the programm takes several minutes in debug mode, while it usually takes only a fraction of a second. This seems to be completely unworkable. Another thing I have tried was the built-in profiler of the JVM, but it shows results in an aggregated and messy way, not much of a help either.
Any better tools/techniques out there?
Thanx in advance,
Mathias

Answer 1

A method for writing to a log file is not a problem, but I would need to add at least one line of code for every
of my methods and, more important, a meaningful log message like the method name and arguments.
One of the reasons I decided not to implement this, was the impossibility to determine the name or signature
of the current method automatically.Below the code I wrote for my dissertation project. I assert my authorship and copyright of this code, and hereby grant anyone who wants it permission to reproduce this and to create derivatives. It determines the name of the current method automatically, and runs under Java 1.1 (Microsoft machine - I think the Sun machine dislikes using null as the argument for the StringStream constructor, but I wasn't worried about fixing that so haven't investigated too closely). The Tracer.enter() method appends the method name and "{" to the log file. It's proof of concept - I may write an improved version after my exams. Comments cut short to avoid annoying people who don't want to scroll too far.
import java.io.*;
public abstract class Tracer
    static File trace_file;
    static FileWriter fw;
    static final int METHOD = 0;
    static final int FLOW = 2;
    static final int MAJOR = 4;
    static final int MINOR = 6;
    static final int trace_level = 7;
    /* Params:    IN  filename    - a String containing the desired name for */
    /*                              the trace file.                          */
    public static void open(String filename)
        try
            trace_file = new File(filename);
            fw = new FileWriter(trace_file);
        catch (IOException ioe)
            System.out.println("IOException in Tracer.open()");  
    /* Params:    IN  s           - the String containing the trace message  */
    /*            IN  level       - the level of detail of the message       */
    /* Operation: If the specified level is sufficiently low, this method    */
    /*            constructs a Throwable and processes its stack trace to    */
    /*            find the name of the method which called trace.  It then   */
    /*            writes this method name and the trace message to the trace */
    /*            file, terminating the line with a Microsoft EOL (LF-CR).   */
    private static void trace(String s, int level)
        if (level <= trace_level)
            StringStream stringStream = new StringStream(null);
            Throwable bomb = new Throwable();
            bomb.printStackTrace(stringStream);
            String method = stringStream.getMethod();
            try
                fw.write(method+"  "+s + "\015\012");
                fw.flush();
            catch (IOException ioe)
                System.out.println("IOException in Tracer.trace()");  
    /* Operation: Closes the FileWriter and sets the File and FileWriter to  */
    /*            null.                                                      */
    public static void close()
        try
            fw.close();
        catch (IOException ioe)
            System.out.println("IOException in Tracer.close()");  
        trace_file = null;
        fw = null;
    /* Operation: Calls trace with message "{" and trace level METHOD.  This */
    /*                method should be called whenever a method is entered.  */
    public static void enter(String method)
        trace("{", METHOD);
    /* Operation: Calls trace with message "}" and trace level METHOD.  This */
    /*            method should be called just before any return statement,  */
    /*            or before the final } of a method with return type void.   */
    public static void exit()
        trace("}", METHOD);
    /* Params:    IN  flow_statement                                         */
    /*                            - a description of the branch just taken   */
    /* Operation: Calls trace with message flow_statement and trace level    */
    /*            FLOW.  NB This method should be called at the start of any */
    /*            block except a method body, when enter should be called.   */
    public static void flow(String flow_statement)
        trace(flow_statement, FLOW);  
    /* Operation: Calls trace with message major_statement and trace level   */
    /*            MAJOR.  This method should be used for displaying the      */
    /*            results of important steps.                                */
    public static void major(String major_statement)
        trace(major_statement, MAJOR);
    /* Operation: Calls trace with message minor_statement and trace level   */
    /*            MINOR.  This method should be used for displaying the      */
    /*            results of minor steps.  It would probably be overkill to  */
    /*            call minor after every single statement.                   */
    public static void minor(String minor_statement)
        trace(minor_statement, MINOR);
import java.io.*;
/* This class, which extends PrintStream, exists to allow me to get the   */
/* name of the method invoking trace by creating a Throwable and          */
/* examining its stack trace.  This is more reliable than tracking the    */
/* stack myself.                                                          */
class StringStream extends PrintStream
    StringBuffer sb = new StringBuffer();
    int state = 0;
    public StringStream(OutputStream out)
        super(out);
    public StringStream(OutputStream out,
                        boolean autoFlush)
        super(out, autoFlush);
    String getMethod()
        String return_value = sb.toString();
        sb = new StringBuffer();
        state = 0;
        return return_value;
    public void print(char[] chars)
        for (int j = 0; j < chars.length; j++)
            print(chars[j]);
    public void print(char ch)
        switch (state)
            case 0:
            case 1:
            case 2:
                if (ch == '\t')
                    state++;
                break;
            case 3:
                if (ch == ' ')
                    state++;
                break;
            case 4:
                if (ch == ' ')
                    state++;
                else if (ch == '/')
                    sb.append('.');
                else
                    sb.append(ch);
                break;
            default:
                // do nothing
}