BigAdmin Submitted Tech Tip: Using Java Stack Trace as an Aid During Development Tasks

Skip to Content Sun and Oracle Channel Sun How to Buy Log In United States [Change] English

BigAdmin System Administration Portal

Community-Submitted Tech Tips

Submit Content | Check BigAdmin Bucks

This content is submitted by a BigAdmin user. It has not been reviewed for technical accuracy by Sun Microsystems, though it may have been lightly edited to improve readability. If you find an error or would like to comment on the article, please contact the submitter or use the comment field at the bottom of the article. Community submissions may not follow Sun trademark guidelines. For information on Sun trademarks, please see http://www.sun.com/suntrademarks/.

Using Java Stack Trace as an Aid During Development Tasks

Thang Minh Le, July 2009

Contents:

Introduction
Platforms and Prerequisites
Creating the Component Audit Tool
Conclusion
Appendix: Sample Code
About the Author

Introduction

This tech tip describes how to use Java stack traces as an aid during development tasks. We explore the use of Java stack trace to build the Component Audit Tool, which reports the audit messages generated while executing a software component.

Java stack trace contains information that is very useful in the process of fixing bugs. When your Java application experiences an unexpected behavior that causes a runtime exception, you expect to receive a Java stack trace in the error output stream. When your server crashes, you search for Java stack traces in the Java core file. A Java stack trace is a piece of information that attracts your attention when you are resolving complex problems. However, the use of Java stack trace does not always relate to bugs and defects. Java stack trace is also useful for development tasks, as we will see in this tech tip.

Platforms and Prerequisites

The code for this tip uses method getId() of the Thread class, which was not available until Java Platform, Standard Edition (Java SE) 5. However, this tip is generally applicable for Java 2 Platform, Standard Edition (J2SE) 1.4.2 and later, because the method getStackTrace() of the Exception class has been valid since J2SE 1.4.2. To use this technical tip in a J2SE 1.4.2 environment, developers can devise their own way to create a replacement for the getId() method of the Thread class.

If you are new to using Java stack trace, you can refer to the article An Introduction to Java Stack Traces on java.sun.com.

Creating the Component Audit Tool

What exactly do we mean by Component Audit Tool?

Your task is to build a new component for your application. A component can be anything, such as a business rule module, a workflow engine, a validation framework, and so on. Then, you want to audit your component by building a text report out of all the audit messages during the execution of the component. Component Audit Tool is built to serve this purpose.

For simplicity, we are going to assume an execution of your component per a request occurs within the same Java thread. Then, we expect this tool to capture all audit messages per thread-based execution.

All audit messages of related classes of a component must be in the same audit report. We don't want audit messages of other components to get into this report even though our component is interacting with the other components.

In the object-oriented world, a class is the most specific entity of software. During the design process, software is broken into different components. Each component is built from a list of related classes. We can think of an audit report for a component as a report of all audit messages for the classes related to the component. ComponentAuditTool.java encapsulates this idea by defining its constructor method with a list of class names as its input parameter:

public class ComponentAuditTool
{
private List<String> componentClassNames;

	  private ComponentAuditTool(List<String> classNames){
	    this.componentClassNames = classNames;
	    auditReport = new StringBuffer();
	  }
	}

Then, a ComponentAuditTool instance is uniquely identified by the value stored in its attribute componentClassNames.

To have a single instance of ComponentAuditTool per thread, we declare:

public class ComponentAuditTool
{
	private static final Hashtable<String,
		List<ComponentAuditTool>>
			auditToolTable = new Hashtable<String,
				List<ComponentAuditTool>>();
}

Hashtable auditToolTable is used to store pairs that consist of the current thread ID (as a hash key) and a corresponding list of ComponentAuditTool instances (as hash values). Since a single thread might execute the code of more than one component, we need to associate each current thread ID with a list of ComponentAuditTool instances.

Below are the method APIs of the ComponentAuditTool class:

public class ComponentAuditTool
{
    /* a dummy exception to get Java stack trace */
    private static final Exception dummyException = new RuntimeException();

    /* a buffered string to store audit report */
    private StringBuffer auditReport = new StringBuffer();

    public synchronized static void createComponentAudit(List<Class> componentClasses);
    public synchronized static void logAudit(String s);
    public synchronized static String getComponentAuditReport(List<Class> componentClasses);
}

Method:

public synchronized static void createComponentAudit(List<Class> componentClasses){
    checkInputArgument(componentClasses);
    List<String> classNames = ComponentAuditTool.getClassNames(componentClasses);
    String hashKey = getHashKey();
    if(!auditToolTable.containsKey(hashKey)){
        ComponentAuditTool aTool = new ComponentAuditTool(classNames);
        List<ComponentAuditTool> aList = new ArrayList<ComponentAuditTool>();
        aList.add(aTool);
        auditToolTable.put(hashKey, aList);
    }
    else if(auditToolTable.containsKey(hashKey)){
        ComponentAuditTool existingAuditTool = ComponentAuditTool.getComponentAuditTool(classNames);
        if(existingAuditTool==null){
            ComponentAuditTool aTool = new ComponentAuditTool(classNames);
            auditToolTable.get(hashKey).add(aTool);
        }
    }
}

In method createComponentAudit(), we are going to either create a new entry (if there is no existing current thread ID in the hashtable) or add a new ComponentAuditTool instance into an existing list associated with the current thread ID in the hash table (if there is no existing one in the list associated with the current thread ID). The method uses the parameter List<Class> componentClasses to define whether a ComponentAuditTool instance already exists. Following this methodology, our ComponentAuditTool instances will be able to log all audit messages per thread and per component.

Getting a component audit report is just a task of searching the hashtable for a hash key that is the current thread ID and using List<Class> componentClasses to retrieve the correct ComponentAuditTool instance as it was created in the createComponentAudit() method. Once a match is found, we return the content of auditReport for the ComponentAuditTool instance.

Method:

public synchronized static String getComponentAuditReport(List<Class> componentClasses){
    checkInputArgument(componentClasses);
    List<String> classNames = ComponentAuditTool.getClassNames(componentClasses);
    ComponentAuditTool auditTool = ComponentAuditTool.getComponentAuditTool(classNames);
    if(auditTool==null){
        return "";
    }
    String s = auditTool.getAuditReport().toString();
    auditTool.getAuditReport().delete(0, s.length());
    return s;
}

Now, we come to the method that uses the information of the Java stack trace.

Method:

public synchronized static void logAudit(String s){
    String callerClassName = null;
    String methodName = null;
    dummyException.fillInStackTrace();
    StackTraceElement[] stacks = dummyException.getStackTrace();
    callerClassName = stacks[1].getClassName();
    methodName = stacks[1].getMethodName();
    List<ComponentAuditTool> auditTools = getComponentAuditTools(callerClassName);
    for(int i=0; i<auditTools.size(); i++){
        auditTools.get(i).getAuditReport().append(callerClassName + "." + methodName + " " + s + "\n");
    }
}

Method logAudit() has to know the caller class name so that it can find related ComponentAuditTool instances stored in the hash table. The way to get the caller class name is to do this:

First, execute fillInStackTrace() on the dummyException so that the dummyException obtains the current Java stack trace.
Second, call getStackTrace() on dummyException to get an array of StackTraceElement[], which contains all current Java stack trace information. We are only interested in the second element in this array since this element has all the information for the caller class. We obtain the class name of the caller class by executing stacks[1].getClassName().
Once the caller class name is retrieved, we need to examine the list of ComponentAuditTool instances associated with the current thread ID in the hashtable and get all ComponentAuditTool instances, which have their componentClassNames containing the caller class name. Then, we append the audit message into these ComponentAuditTool objects.

The implementation of ComponentAuditTool.java and the sample code are provided below in the Appendix: Sample Code section. So you can experiment with this tool at your convenience.

Conclusion

We have seen that Java stack trace is not only useful for bug-related issues but also for the development process. In this technical tip, we looked into the use of the second element (stacks[1]) of the Java stack trace (StackTraceElement[] stacks). There is still a lot of information captured in the Java stack trace that was not discussed. I hope that this is a guide to help you further explore the use of Java stack trace in your daily development tasks.

Appendix: Sample Code

To build this tool, copy each of the following sections into a .java file. You will need these six files to build the tool:

ComponentAuditTool.java
ComponentAuditToolTest.java
ComponentClassA.java
ComponentClassB.java
ComponentClassC.java
ComponentClassD.java

Here are the contents of the ComponentAuditTool.java file:

/**
 * Created as part of example code of technical tip "Using Java
 * Stack Trace as an Aid During Development Tasks"
 * submitted to the BigAdmin site of Sun Microsystems.
 *
 * Any comments/suggestions regarding this code should be sent
 * directly to the author.
 */

package com.thang.le.util.audit;

import java.util.ArrayList;
import java.util.Hashtable;
import java.util.List;

/**
 * Audit tool for a component. Components are distinguished by
 * a unique list of classes. A given class can be shared
 * among components. This audit tool has the ability to
 * capture all audit messages for a component.
 *
 * Users have to create a component by calling {@link #createComponentAudit(List<Class>)}
 * prior to any audit activities.
 *
 * Get the audit report by calling {@link #getComponentAuditReport(List<Class>)}, which must
 * use the same list content as used in {@link #createComponentAudit(List<Class>)}.
 *
 * @author Thang Minh Le (thangmle@gmail.com)
 * @version 1.0
 * @since 2009-06-17
 *
 */
public class ComponentAuditTool
{
	/* hash table storing all current audit tool based on thread id - collision by chained list*/
	private static final Hashtable<String, List<ComponentAuditTool>>
		auditToolTable = new Hashtable<String, List<ComponentAuditTool>>();

	/* a dummy exception to get stack trace */
	private static final Exception dummyException = new RuntimeException();

	/* list of class names of this audit tool */
	private List<String> componentClassNames;

	/* a buffered string to store audit report */
	private StringBuffer auditReport;

	/**
	 * Create a component audit. The list of classes passed in represents a component
	 * and this list must be used to get audit report in method {@link #getComponentAuditReport(List<Class>)}
	 * @param componentClasses
	 */
	public synchronized static void createComponentAudit(List<Class> componentClasses){
		checkInputArgument(componentClasses);
		List<String> classNames = ComponentAuditTool.getClassNames(componentClasses);
		String hashKey = getHashKey();
		if(!auditToolTable.containsKey(hashKey)){
			ComponentAuditTool aTool = new ComponentAuditTool(classNames);
			List<ComponentAuditTool> aList = new ArrayList<ComponentAuditTool>();
			aList.add(aTool);
			auditToolTable.put(hashKey, aList);
		}
		else if(auditToolTable.containsKey(hashKey)){
			ComponentAuditTool existingAuditTool = ComponentAuditTool.getComponentAuditTool(classNames);
			if(existingAuditTool==null){
				ComponentAuditTool aTool = new ComponentAuditTool(classNames);
				auditToolTable.get(hashKey).add(aTool);
			}
		}
	}

	/**
	 * Log an audit string
	 * @param s
	 */
	public synchronized static void logAudit(String s){
		String callerClassName = null;
		String methodName = null;
		dummyException.fillInStackTrace();
		StackTraceElement[] stacks = dummyException.getStackTrace();
		callerClassName = stacks[1].getClassName();
		methodName = stacks[1].getMethodName();
		List<ComponentAuditTool> auditTools = getComponentAuditTools(callerClassName);
		for(int i=0; i<auditTools.size(); i++){
			auditTools.get(i).getAuditReport().append(callerClassName + "." + methodName + " " + s + "\n");
		}
	}

	/**
	 * Get audit report for a component as a string
	 * @param componentClasses - list of classes represents a component. The content of this
	 * list must be the same as the parameter when calling method {@link #createComponentAudit(List<Class>)}
	 * @return String
	 */
	public synchronized static String getComponentAuditReport(List<Class> componentClasses){
		checkInputArgument(componentClasses);
		List<String> classNames = ComponentAuditTool.getClassNames(componentClasses);
		ComponentAuditTool auditTool = ComponentAuditTool.getComponentAuditTool(classNames);
		if(auditTool==null){
			return "";
		}
		String s = auditTool.getAuditReport().toString();
		auditTool.getAuditReport().delete(0, s.length());
		return s;
	}

	/**
	 * Constructs ComponentAuditTool
	 * @param classNames
	 */
	private ComponentAuditTool(List<String> classNames){
		this.componentClassNames = classNames;
		auditReport = new StringBuffer();
	}

	/**
	 * Get component audit tool based on list of class names
	 * @param classNames
	 * @return ComponentAuditTool instance or null.
	 */
	private static ComponentAuditTool getComponentAuditTool(List<String> classNames){
		String hashKey = getHashKey();
		if(auditToolTable.containsKey(hashKey))	{
			List<ComponentAuditTool> toolList = auditToolTable.get(hashKey);
			for(int i=0; i<toolList.size(); i++){
				ComponentAuditTool auditTool = toolList.get(i);
				if(auditTool.getComponentClassNames().size()==classNames.size() &&
						auditTool.getComponentClassNames().containsAll(classNames)){
					return auditTool;
				}
			}
		}
		return null;
	}

	/**
	 * Get all component audit tools that have this className as a member of their
	 * component class names
	 * @param className
	 * @return List<ComponentAuditTool>
	 */
	private static List<ComponentAuditTool> getComponentAuditTools(String className){
		List<ComponentAuditTool> returnedList = new ArrayList<ComponentAuditTool>();
		String hashKey = getHashKey();
		if(auditToolTable.containsKey(hashKey)){
			List<ComponentAuditTool> toolList = auditToolTable.get(hashKey);
			for(int i=0; i<toolList.size(); i++){
				ComponentAuditTool auditTool = toolList.get(i);
				if(auditTool.getComponentClassNames().contains(className)){
					returnedList.add(auditTool);
				}
			}
		}
		return returnedList;
	}

	/**
	 * Check input argument - must not be null or empty
	 * @param componentClasses
	 */
	private static void checkInputArgument(List<Class> componentClasses){
		if(componentClasses==null || componentClasses.isEmpty()){
			throw new IllegalArgumentException("Invalid component");
		}
	}

	/**
	 * Convert list of classes to list of corresponding class names
	 * @param componentClasses
	 * @return List<String>
	 */
	private static List<String> getClassNames(List<Class> componentClasses){
		List<String> classNames = new ArrayList<String>();
		for(int i=0; i<componentClasses.size(); i++){
			classNames.add(componentClasses.get(i).getName());
		}
		return classNames;
	}

	/**
	 * Get hash key to be used in hashtable
	 * @return String - hash key
	 */
	private static String getHashKey(){
		return String.valueOf(Thread.currentThread().getId());
	}

	/**
	 * Getter method to get component class names
	 * @return List<String>
	 */
	private List<String> getComponentClassNames(){
		return componentClassNames;
	}

	/**
	 * Getter method to get audit report buffered string
	 * @return StringBuffer
	 */
	private StringBuffer getAuditReport(){
		return auditReport;
	}
}

Here are the contents of the ComponentAuditToolTest.java file:

/**
 * Created as part of example code of technical tip "Using Java
 * Stack Trace as an Aid During Development Tasks"
 * submitted to the BigAdmin site of Sun Microsystems.
 *
 * Any comments/suggestions regarding this code should be sent
 * directly to the author.
 */
package com.thang.le.util.audit;

import java.util.ArrayList;
import java.util.List;

/**
 * Testing ComponentAuditTool
 *
 * @author Thang Minh Le (thangmle@gmail.com)
 * @version 1.0
 * @since 2009-06-17
 */
public class ComponentAuditToolTest
{
	private static final int MAX_THREAD = 10;

	public static void main (String[] args){
		ComponentAuditToolTest toolTest = new ComponentAuditToolTest();
		List<Thread> threads = new ArrayList<Thread>();
		for(int i=0; i<MAX_THREAD; i++){
			Thread runThread = toolTest.new ThreadRunner();
			threads.add(runThread);
			runThread.start();
		}
	}

	private class ThreadRunner extends Thread{
		public void run(){
			List<Class> componentList1 = new ArrayList<Class>();
			componentList1.add(ComponentClassA.class);
			componentList1.add(ComponentClassB.class);
			componentList1.add(ComponentClassC.class);
			componentList1.add(ComponentClassD.class);

			List<Class> componentList2 = new ArrayList<Class>();
			componentList2.add(ComponentClassA.class);
			componentList2.add(ComponentClassB.class);

			ComponentAuditTool.createComponentAudit(componentList1);
			ComponentAuditTool.createComponentAudit(componentList2);

			new ComponentClassA().action();
			synchronized (ComponentAuditToolTest.class){
				System.out.println("Component 1: ");
				System.out.println(ComponentAuditTool.getComponentAuditReport(componentList1));

				System.out.println("Component 2: ");
				System.out.println(ComponentAuditTool.getComponentAuditReport(componentList2));
			}
		}
	}
}

Here are the contents of the ComponentClassA.java file:

/**
 * Created as part of example code of technical tip "Using Java
 * Stack Trace as an Aid During Development Tasks"
 * submitted to the BigAdmin site of Sun Microsystems.
 *
 * Any comments/suggestions regarding this code should be sent
 * directly to the author.
 */
package com.thang.le.util.audit;

/**
 * ComponentClassA
 *
 * @author Thang Minh Le (thangmle@gmail.com)
 * @version 1.0
 * @since 2009-06-17
 */
public class ComponentClassA
{
	public void action(){
		ComponentAuditTool.logAudit("Thread id: " + Thread.currentThread().getId());
		ComponentAuditTool.logAudit("Do something in class A");
		new ComponentClassB().action1();
		new ComponentClassC().action();
		new ComponentClassD().action();
	}
}

Here are the contents of the ComponentClassB.java file:

/**
 * Created as part of example code of technical tip "Using Java
 * Stack Trace as an Aid During Development Tasks"
 * submitted to the BigAdmin site of Sun Microsystems.
 *
 * Any comments/suggestions regarding this code should be sent
 * directly to the author.
 */
package com.thang.le.util.audit;

/**
 * ComponentClassB
 *
 * @author Thang Minh Le (thangmle@gmail.com)
 * @version 1.0
 * @since 2009-06-17
 */
public class ComponentClassB
{
	public void action1(){
		ComponentAuditTool.logAudit("Start action in B - Action 1");
		this.action2();
		ComponentAuditTool.logAudit("End action in B - Action 1");
	}

	public void action2(){
		ComponentAuditTool.logAudit("Action in B - Action 2");
	}
}

Here are the contents of the ComponentClassC.java file:

/**
 * Created as part of example code of technical tip "Using Java
 * Stack Trace as an Aid During Development Tasks"
 * submitted to the BigAdmin site of Sun Microsystems.
 *
 * Any comments/suggestions regarding this code should be sent
 * directly to the author.
 */
package com.thang.le.util.audit;

/**
 * ComponentClassC
 *
 * @author Thang Minh Le (thangmle@gmail.com)
 * @version 1.0
 * @since 2009-06-17
 */
public class ComponentClassC
{
	public void action(){
		ComponentAuditTool.logAudit("Action in C");
		new ComponentClassB().action2();
	}
}

Here are the contents of the ComponentClassD.java file:

/**
 * Created as part of example code of technical tip "Using Java
 * Stack Trace as an Aid During Development Tasks"
 * submitted to the BigAdmin site of Sun Microsystems.
 *
 * Any comments/suggestions regarding this code should be sent
 * directly to the author.
 */
package com.thang.le.util.audit;

/**
 * ComponentClassD
 *
 * @author Thang Minh Le (thangmle@gmail.com)
 * @version 1.0
 * @since 2009-06-17
 */
public class ComponentClassD
{
	public void action(){
		ComponentAuditTool.logAudit("Action in D");
		new ComponentClassC().action();
	}
}

About the Author

Thang Minh Le has been working with Java technology for more than five years. He is currently working as a solution developer at The Economical Insurance Group, an insurance company located in Waterloo, Ontario. He can be contacted at thangmle [at] gmail.com.

The information and links on this page have been provided by a BigAdmin user. The submitter is solely responsible for such information and links. Sun is not responsible for the availability of external sites or resources, and does not endorse and is not responsible or liable for any content, advertising, products, or other materials on or available from such sites or resources. Sun will not be responsible or liable, directly or indirectly, for any actual or alleged damage or loss caused by or in connection with use of or reliance on the information posted here, or goods or services available on or through any external site or resource.

Comments (latest comments first)

Discuss and comment on this resource in the BigAdmin Wiki

Unless otherwise licensed, code in all technical manuals herein (including articles, FAQs, samples) is provided under this License.

Search BigAdmin

» Search the HCL

BigAdmin Wiki
Discuss and comment on this resource in the wiki.

Using Java Stack Trace as an Aid During Development Tasks

Introduction

Platforms and Prerequisites

Creating the Component Audit Tool

Conclusion

Appendix: Sample Code

About the Author

Comments (latest comments first)

BigAdmin Subscriptions

BigAdmin Areas

BigAdmin Sun Center

BigAdmin Topics