Attachment 4455 Details for Bug 36056 – Generic trace aspect.

Generic trace aspect.

Trace.aj (text/plain), 16.24 KB, created by Rich Price

on 2003-04-04 02:36:34 EST

(hide)

Description:

Filename:

MIME Type:

Creator: Rich Price

Created: 2003-04-04 02:36:34 EST

Size: 16.24 KB

patch

obsolete

>package com.checkfree.aspects;
>
>import java.io.*;
>import java.util.*;
>import org.aspectj.runtime.*;
>import org.aspectj.lang.*;
>import org.aspectj.lang.reflect.*;
>import java.lang.reflect.*;
>
>/** Trace is an aspect that traces execution through code.  
> * 
> */
>public abstract aspect Trace issingleton()
>{   
>    // our internal instance
>    private static Trace _trace;
>    
>    // Call depth on trace
>    private static final ThreadLocal traceDepths = new ThreadLocal();
>
>    // An object to synchronize on
>    protected static final Object  lock = new Object();
>
>    private static final String NL = System.getProperty("line.separator");
>    
>    // Space indentation increment
>    private static final int INDENT = 4;
>
>    // Used for indentation
>    private static final byte[] SPACES = new byte[100];
>    
>    private static boolean traceActive = true;
>
>    static
>    {
>        Arrays.fill(SPACES,(byte)' ');
>    }
>
>       
>    /** Trace constructor. Since this aspect is a singleton, we can be
>     * assured that only a single instance exists.  
>     */
>    protected Trace() {_trace = this;}
>    
>    /**
>    * This abstract pointcut indicates what classes we should trace.  Typically
>    * you will define this using a within() PCD. We leave that up to concrete aspects.
>    */
>    protected abstract pointcut lexicalScope();
>    
>    /**
>     * Common scope for all traces - includes lexicalScope
>     */
>    final pointcut scope() : if(_trace.canTraceJoinpoint(thisJoinPoint)) && lexicalScope() && !within(Trace+);
>
>    /**
>     * This pointcut designates tracing constructors within lexicalScope()
>     */
>    protected final pointcut constructorTrace() : scope() && (call( new(..) ) || execution( new(..)));
>    /**
>     * This pointcut designates tracing method executions within lexicalScope()
>     */
>    protected final pointcut methodTrace() : scope() && (call(* *(..)) || execution(* *(..)));
>
>    /**
>     * This pointcut designates tracing exception handlers within lexicalScope()
>     */
>    protected final pointcut handlerTrace(Exception e) : scope() &&  args(e) && handler(Exception+);
>
>
>    /**
>     * This pointcut picks out joinpoints within this aspect that implement
>     * the actual tracing.  Since parameters and return values are printed
>     * out via implicit or explicit call to Object.toString(), there is the possibility
>     * of an execution joinpoint on toString() causing the trace logic
>     * to be re-entered. This is undesireable because it makes the trace output
>     * difficult to read and adds unecessary overhead. <p>
>     * This pointcut is used within a cflowbelow pointcut to prevent recursive
>     * trace calls.
>     */
>    private pointcut internalMethods() : 
>        execution( void Trace.trace*(..,(JoinPoint||JoinPoint.StaticPart),..) );
>
>    /**
>     * For methods, we use around() advice to capture calls/executions.
>     */
>    Object around() : methodTrace() && !cflowbelow(internalMethods())
>    {
>        traceEnter(thisJoinPoint); 
>        try
>        {
>            Object result = proceed();
>            traceResult(result,thisJoinPoint);
>            return result;
>        }
>        finally
>        {
>            traceExit(thisJoinPoint);
>        }
>    }
>    
>    /**
>     * For Constructors, we use around() advice to capture calls/executions.
>     */
>    Object around() : constructorTrace() && !cflowbelow(internalMethods())
>    {
>        traceEnter(thisJoinPoint); 
>        try
>        {
>            return proceed();
>        }
>        finally
>        {
>            traceExit(thisJoinPoint);
>        }
>    }
>    
>
>    /**
>     * Trace Exceptions that may occur with constructors or methods
>     */
>    after() throwing(Throwable e): (constructorTrace() || methodTrace()) && !cflowbelow(internalMethods())
>    {   
>        traceThrowable(e,thisJoinPoint);
>    }
>
>
>    /**
>     * Trace Exception handlers entry
>     */    
>    before(Exception e) : handlerTrace(e) && !cflowbelow(internalMethods())
>    {
>        traceHandlerEntry(e,thisJoinPointStaticPart);
>    }
>    /**
>     * Trace Exception handlers exit
>     */
>    after(Exception e) : handlerTrace(e) && !cflowbelow(internalMethods())
>    {
>        traceHandlerExit();
>    }
>
>
>    /**
>     * Subaspects can override this method to log the data as needed. The default
>     * mechanism is to log to System.out
>     * 
>     * Clients should be aware that this method is not synchronized.
>     */
>    protected void log(String data) {System.out.println(data);}
>    
>    /**
>     * Can be overridden by subaspects to filter what constructors/methods should be 
>     * traced at runtime.  This method is always called prior to the log()
>     * method. The default always returns true.<p> Note that exceptions thrown
>     * by constructors/methods are filtered through this method.
>     * @param currentlyExecutingClass The Class that is currently executing.
>     * @param signature The signature of the member being traced
>     * @param traceType The type of trace entry (see AspectJ doc for the available types)
>     */
>    protected boolean isTraceable(Class currentlyExecutingClass, CodeSignature signature,String traceType) {return true;}
>
>    /**
>     * Can be overridden by subaspects to filter what exception handlers should be 
>     * traced at runtime.  This method is always called prior to the log()
>     * method. The default always returns false.<p>
>     * Note that exception handlers are catch(...){} blocks and are filtered
>     * independently from constructor/method calls and execution.
>     * @param currentlyExecutingClass The Class that is currently executing.
>     * @param signature The signature of the member being traced
>     */
>    protected boolean isTraceable(Class currentlyExecutingClass, CatchClauseSignature signature) {return false;}
>    
>    /**
>     * Retrieves the signature of the joinpoint and asks if it can be traced
>     */
>    private boolean canTraceJoinpoint(JoinPoint jp)
>    {
>        if ( !traceActive ) return false;
>        final Signature sig = jp.getSignature();
>        final Object o = jp.getThis();  // current object
>        Class currentType;
>        if ( o == null ) // must be a static
>            currentType = jp.getStaticPart().getSourceLocation().getWithinType();
>        else
>            currentType = o.getClass();
>            
>        // dispatch the correct filter method
>        if ( sig instanceof CodeSignature )            
>            return isTraceable(currentType,(CodeSignature)sig,jp.getKind());
>        else
>            return isTraceable(currentType,(CatchClauseSignature)sig);            
>    }
>    
>
>    /**
>     * This method creates a trace entry line based on information in the
>     * supplied join point.
>     */
>    private void traceEnter(JoinPoint thisJoinPoint)
>    { 
>   
>        // Get the indent level (call depth for current thread * 4).
>        int depth = getTraceDepth(INDENT);
>    
>        Class[] parameterTypes = ((CodeSignature)thisJoinPoint.getSignature()).getParameterTypes();
>        String[] parameterNames = ((CodeSignature)thisJoinPoint.getSignature()).getParameterNames();
>    
>        boolean isCall = thisJoinPoint.getKind().endsWith("call");
>
>        StringBuffer enterPhrase = new StringBuffer(100);
>        enterPhrase.append(getSpaces(depth));
>        if ( isCall )
>            enterPhrase.append("Call ");
>        else
>            enterPhrase.append("Entering ");
>        enterPhrase.append(methodSignature(parameterNames,parameterTypes,thisJoinPoint));
>        
>//        if ( isCall )
>//            enterPhrase.append(" From: ").append(thisJoinPoint.getSourceLocation().getWithinType());
>
>        // Prepare the methods parameter list
>        String parmStr = null;
>        Object[] parameters = thisJoinPoint.getArgs();
>        if (parameters.length > 0)
>        {
>            String spaces = getSpaces(depth + 6);
>            StringBuffer parms = new StringBuffer();
>            for (int i = 0; i < parameters.length; i++)
>            {
>                if (parameters[i] != null && parameters[i].getClass().isArray())
>                {
>                    // arrays can be huge...limit to first 100 elements
>                    final int len = Math.min(Array.getLength(parameters[i]),100);
>                    if ( len == 0 )
>                    {
>                        parms.append(spaces);
>                        parms.append(parameterNames[i]);
>                        parms.append(": 0 length array");
>                        parms.append(NL);
>                    }
>                    else
>                    {
>                        Object o = null;
>                        for ( int x = 0; x < len; x++ )
>                        {
>                            parms.append(spaces);
>                            parms.append(parameterNames[i]);
>                            parms.append("[");
>                            parms.append(x);
>                            parms.append("]:");
>                            o = Array.get(parameters[i],x);
>                            try{parms.append(" " + (o != null?o:"null"));}  // implicit toString()
>                            catch(Throwable t) {parms.append(" " + parameters[i]);}
>                            parms.append(NL);                            
>                        }
>                    }
>                }
>                else
>                {
>                    // Not an array.
>                    parms.append(spaces);
>                    parms.append(parameterNames[i]);
>                    parms.append(": ");
>                    try
>                    {
>                        parms.append("" + parameters[i]);
>                    }
>                    catch (Throwable t ) {parms.append("" + parameters[i].getClass().getName());}
>                }
>
>                parmStr = parms.toString();
>
>            }
>
>        }
>
>        if (parmStr != null)
>            enterPhrase.append(NL).append(parmStr);
>        log(enterPhrase.toString());
>    }
>
>    /**
>     * This method creates an exception handler trace entry based on a Throwable
>     * and information contained in the join point.
>     */
>    private void traceHandlerEntry(Throwable t, JoinPoint.StaticPart thisJoinPoint)
>    {
>
>        int depth = getTraceDepth(INDENT);
>        String phrase = getSpaces(depth) +
>                        "Exception caught at: " +
>                        thisJoinPoint;
>        log(printStackTrace(phrase,t));
>
>    }
>    /**
>     * This method simply adjusts the trace depth - no other information printed.
>     */
>    private void traceHandlerExit()
>    {
>        getTraceDepth(-INDENT);
>    }
>    /**
>     * This method creates a stack trace entry based on a Throwable and
>     * information contained in the join point.
>     */
>    private void traceThrowable(Throwable t, JoinPoint thisJoinPoint)
>    {
>
>        int depth = getTraceDepth(0);
>        String phrase = getSpaces(depth+4) +
>                                        "Throwing Exception at: " +
>                                        thisJoinPoint;
>        log(printStackTrace(phrase,t));
>    }
>
>
>    private String printStackTrace(String phrase, Throwable t)
>      {
>    try {
>      StringWriter sw = new StringWriter(4096);
>      PrintWriter  pw = new PrintWriter(sw,true);
>
>      pw.println(phrase);
>
>      pw.println();
>
>      pw.println("Exception Stack Trace:");
>
>      pw.println();
>
>      t.printStackTrace(pw);
>
>      pw.println();
>
>      pw.flush();
>      sw.flush();
>
>      pw.close();
>      sw.close();
>      return sw.toString();
>    }
>    catch(IOException IOE) {
>      log(IOE.toString());
>      return IOE.getMessage();
>    }
>      }
>
>    /**
>     * This method creates a trace exit entry based on the join point
>     * information.
>     */
>    private void traceExit(JoinPoint thisJoinPoint)
>    {
>
>        int depth = getTraceDepth(-INDENT);
>
>        // Assemble the method's signature.
>        Class[] parameterTypes = ((CodeSignature)thisJoinPoint.getSignature()).getParameterTypes();
>        String[] parameterNames = ((CodeSignature)thisJoinPoint.getSignature()).getParameterNames();
>
>        boolean isCall = thisJoinPoint.getKind().endsWith("call");
>
>        StringBuffer exitPhrase = new StringBuffer(100);
>        exitPhrase.append(getSpaces(depth));
>        if ( isCall )
>            exitPhrase.append("Return ");
>        else
>            exitPhrase.append("Exiting ");
>        exitPhrase.append(methodSignature(parameterNames,parameterTypes,thisJoinPoint)).append(NL);
>        
>
>        log(exitPhrase.toString());
>
>    }
>
>    /**
>     * This method creates a trace result entry based on a result and the
>     * join point.
>     */
>    private void traceResult(Object thisResult, JoinPoint thisJoinPoint)
>    {
>
>        Class returnType = ((MethodSignature)thisJoinPoint.getSignature()).getReturnType();
>        if ( returnType.toString().equals("void") )
>            return;
>
>        int depth = getTraceDepth(0);
>        if ( thisResult == null )
>            thisResult = "null";
>
>        if ( thisResult.getClass().isArray() )
>        {
>            // arrays can be Oprah-sized - limit to 100 elements
>            final int len = Math.min(Array.getLength(thisResult),100);
>            StringBuffer buf = new StringBuffer();
>            if ( len == 0 )
>                buf.append(">>>zero-length array<<<");
>            else
>            {
>                Object o;
>                for ( int i = 0; i < len; i++ )
>                {
>                    o = Array.get(thisResult,i);
>                    buf.append("data[").append(i).append("] ");
>                    try{buf.append(o != null?o:"null");} // implicit toString() 
>                    catch(Throwable t) {buf.append(thisResult);}
>                    buf.append(NL);
>                }
>            }
>            thisResult = buf.toString();                
>        }
>        thisResult = thisResult.toString();
>        
>        StringBuffer returnPhrase = new StringBuffer(100);
>        returnPhrase.append(getSpaces(depth+2)).append(thisJoinPoint);
>        returnPhrase.append(" returned >>>>>>> ").append(thisResult);
>
>        log(returnPhrase.toString());
>    }
>
>    /**
>     * This method returns the current trace line indentation for the
>     * thread.
>     */
>    private int getTraceDepth(int incr)
>    {
>            int rc = 0;
>            Integer depth = (Integer) traceDepths.get();
>            if (depth == null)
>            {
>                if ( incr > 0 )
>                {
>                    traceDepths.set(new Integer(incr));
>                    return incr;
>                }
>                else return rc;
>            }    
>            
>            rc = depth.intValue();
>                            
>            if ( incr > 0 )
>            {
>                depth = new Integer(rc += incr);            
>                traceDepths.set(depth);
>            }
>            else if ( incr < 0 )
>            {
>                depth = new Integer(rc + incr);            
>                traceDepths.set(depth);
>            }
>            
>            return rc;
>    }
>
>    /**
>     * This method returns a String containing the number of spaces desired to
>     * be used as padding for formatting trace log entries.
>     */
>    private String getSpaces(int num)
>    {
>        return new String(SPACES,0,Math.min(num,SPACES.length));
>    }
>
>    /**
>     * Create a method signature
>     */
>    private String methodSignature(String[] parameterNames,
>                    Class[] parameterTypes,
>                    JoinPoint thisJoinPoint)
>    {
>        // Assemble the method's signature.
>        StringBuffer signature = new StringBuffer("(");
>        for (int i = 0; i < parameterTypes.length; i++)
>        {
>            signature.append(parameterTypes[i].getName());
>            signature.append(" ");
>            signature.append(parameterNames[i]);
>            if (i < (parameterTypes.length-1))
>                signature.append(", ");
>        }
>        signature.append(")");
>
>        return thisJoinPoint.getSignature().getDeclaringType().getName() + "." +
>            thisJoinPoint.getSignature().getName() +
>            signature;
>    }
>    
>}
>
>
>

Actions: View

Attachments on bug 36056: 4455 | 4464 | 4465 | 4553