diff --git a/org.intrace/src/org/intrace/agent/InstrumentedClassWriter.java b/org.intrace/src/org/intrace/agent/InstrumentedClassWriter.java
index 858ee69..2cb0ced 100644
--- a/org.intrace/src/org/intrace/agent/InstrumentedClassWriter.java
+++ b/org.intrace/src/org/intrace/agent/InstrumentedClassWriter.java
@@ -189,11 +189,12 @@ public class InstrumentedClassWriter extends ClassWriter
           opcode = Opcodes.ALOAD;
         }
 
+        mv.visitLdcInsn("Arg");
         mv.visitLdcInsn(className);
         mv.visitLdcInsn(methodName);
         mv.visitVarInsn(opcode, varslot);
-        mv.visitMethodInsn(INVOKESTATIC, HELPER_CLASS, "arg",
-                           "(Ljava/lang/String;Ljava/lang/String;"
+        mv.visitMethodInsn(INVOKESTATIC, HELPER_CLASS, "val",
+                           "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;"
                                + typeDescriptor + ")V");
       }
     }
@@ -285,15 +286,49 @@ public class InstrumentedClassWriter extends ClassWriter
         }
         generateCallToAgentHelper(InstrumentationType.EXIT, lineNumber);
       }
-      else if (xiOpCode == Opcodes.IRETURN)
+      else if ((xiOpCode == Opcodes.IRETURN) ||
+               (xiOpCode == Opcodes.LRETURN) ||
+               (xiOpCode == Opcodes.FRETURN) ||
+               (xiOpCode == Opcodes.DRETURN) ||
+               (xiOpCode == Opcodes.ARETURN))
       {
+        // Duplicate the return value
         mv.visitInsn(Opcodes.DUP);
+        
+        // Push the callname and methodname while keeping the return value#
+        // at the top of the stack
+        mv.visitLdcInsn("Return");
+        mv.visitInsn(Opcodes.SWAP);
         mv.visitLdcInsn(className);
         mv.visitInsn(Opcodes.SWAP);
         mv.visitLdcInsn(methodName);
         mv.visitInsn(Opcodes.SWAP);
-        mv.visitMethodInsn(INVOKESTATIC, HELPER_CLASS, "arg",
-                           "(Ljava/lang/String;Ljava/lang/String;I)V");
+        
+        if (xiOpCode == Opcodes.IRETURN)
+        {
+          mv.visitMethodInsn(INVOKESTATIC, HELPER_CLASS, "val",
+          "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;I)V");
+        }
+        else if (xiOpCode == Opcodes.LRETURN)
+        {
+          mv.visitMethodInsn(INVOKESTATIC, HELPER_CLASS, "val",
+          "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;L)V");
+        }
+        else if (xiOpCode == Opcodes.FRETURN)
+        {
+          mv.visitMethodInsn(INVOKESTATIC, HELPER_CLASS, "val",
+          "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;F)V");
+        } 
+        else if (xiOpCode == Opcodes.DRETURN)
+        {
+          mv.visitMethodInsn(INVOKESTATIC, HELPER_CLASS, "val",
+          "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;D)V");
+        }
+        else if (xiOpCode == Opcodes.ARETURN)
+        {
+          mv.visitMethodInsn(INVOKESTATIC, HELPER_CLASS, "val",
+          "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/Object;)V");
+        }        
         generateCallToAgentHelper(InstrumentationType.EXIT, lineNumber);
       }
       super.visitInsn(xiOpCode);
diff --git a/org.intrace/src/org/intrace/output/AgentHelper.java b/org.intrace/src/org/intrace/output/AgentHelper.java
index 5645d71..849da11 100644
--- a/org.intrace/src/org/intrace/output/AgentHelper.java
+++ b/org.intrace/src/org/intrace/output/AgentHelper.java
@@ -191,173 +191,173 @@ public class AgentHelper
     }
   }
 
-  public static void arg(String className, String methodName, byte byteArg)
+  public static void val(String desc, String className, String methodName, byte byteArg)
   {
     for (IInstrumentationHandler outputHandler : instrumentationHandlers
                                                                         .keySet())
     {
-      outputHandler.arg(className, methodName, byteArg);
+      outputHandler.val(desc, className, methodName, byteArg);
     }
   }
 
-  public static void arg(String className, String methodName,
+  public static void val(String desc, String className, String methodName,
                          byte[] byteArrayArg)
   {
     for (IInstrumentationHandler outputHandler : instrumentationHandlers
                                                                         .keySet())
     {
-      outputHandler.arg(className, methodName, byteArrayArg);
+      outputHandler.val(desc, className, methodName, byteArrayArg);
     }
   }
 
-  public static void arg(String className, String methodName, short shortArg)
+  public static void val(String desc, String className, String methodName, short shortArg)
   {
     for (IInstrumentationHandler outputHandler : instrumentationHandlers
                                                                         .keySet())
     {
-      outputHandler.arg(className, methodName, shortArg);
+      outputHandler.val(desc, className, methodName, shortArg);
     }
   }
 
-  public static void arg(String className, String methodName,
+  public static void val(String desc, String className, String methodName,
                          short[] shortArrayArg)
   {
     for (IInstrumentationHandler outputHandler : instrumentationHandlers
                                                                         .keySet())
     {
-      outputHandler.arg(className, methodName, shortArrayArg);
+      outputHandler.val(desc, className, methodName, shortArrayArg);
     }
   }
 
-  public static void arg(String className, String methodName, int intArg)
+  public static void val(String desc, String className, String methodName, int intArg)
   {
     for (IInstrumentationHandler outputHandler : instrumentationHandlers
                                                                         .keySet())
     {
-      outputHandler.arg(className, methodName, intArg);
+      outputHandler.val(desc, className, methodName, intArg);
     }
   }
 
-  public static void arg(String className, String methodName, int[] intArrayArg)
+  public static void val(String desc, String className, String methodName, int[] intArrayArg)
   {
     for (IInstrumentationHandler outputHandler : instrumentationHandlers
                                                                         .keySet())
     {
-      outputHandler.arg(className, methodName, intArrayArg);
+      outputHandler.val(desc, className, methodName, intArrayArg);
     }
   }
 
-  public static void arg(String className, String methodName, long longArg)
+  public static void val(String desc, String className, String methodName, long longArg)
   {
     for (IInstrumentationHandler outputHandler : instrumentationHandlers
                                                                         .keySet())
     {
-      outputHandler.arg(className, methodName, longArg);
+      outputHandler.val(desc, className, methodName, longArg);
     }
   }
 
-  public static void arg(String className, String methodName,
+  public static void val(String desc, String className, String methodName,
                          long[] longArrayArg)
   {
     for (IInstrumentationHandler outputHandler : instrumentationHandlers
                                                                         .keySet())
     {
-      outputHandler.arg(className, methodName, longArrayArg);
+      outputHandler.val(desc, className, methodName, longArrayArg);
     }
   }
 
-  public static void arg(String className, String methodName, float floatArg)
+  public static void val(String desc, String className, String methodName, float floatArg)
   {
     for (IInstrumentationHandler outputHandler : instrumentationHandlers
                                                                         .keySet())
     {
-      outputHandler.arg(className, methodName, floatArg);
+      outputHandler.val(desc, className, methodName, floatArg);
     }
   }
 
-  public static void arg(String className, String methodName,
+  public static void val(String desc, String className, String methodName,
                          float[] floatArrayArg)
   {
     for (IInstrumentationHandler outputHandler : instrumentationHandlers
                                                                         .keySet())
     {
-      outputHandler.arg(className, methodName, floatArrayArg);
+      outputHandler.val(desc, className, methodName, floatArrayArg);
     }
   }
 
-  public static void arg(String className, String methodName, double doubleArg)
+  public static void val(String desc, String className, String methodName, double doubleArg)
   {
     for (IInstrumentationHandler outputHandler : instrumentationHandlers
                                                                         .keySet())
     {
-      outputHandler.arg(className, methodName, doubleArg);
+      outputHandler.val(desc, className, methodName, doubleArg);
     }
   }
 
-  public static void arg(String className, String methodName,
+  public static void val(String desc, String className, String methodName,
                          double[] doubleArrayArg)
   {
     for (IInstrumentationHandler outputHandler : instrumentationHandlers
                                                                         .keySet())
     {
-      outputHandler.arg(className, methodName, doubleArrayArg);
+      outputHandler.val(desc, className, methodName, doubleArrayArg);
     }
   }
 
-  public static void arg(String className, String methodName, boolean boolArg)
+  public static void val(String desc, String className, String methodName, boolean boolArg)
   {
     for (IInstrumentationHandler outputHandler : instrumentationHandlers
                                                                         .keySet())
     {
-      outputHandler.arg(className, methodName, boolArg);
+      outputHandler.val(desc, className, methodName, boolArg);
     }
   }
 
-  public static void arg(String className, String methodName,
+  public static void val(String desc, String className, String methodName,
                          boolean[] boolArrayArg)
   {
     for (IInstrumentationHandler outputHandler : instrumentationHandlers
                                                                         .keySet())
     {
-      outputHandler.arg(className, methodName, boolArrayArg);
+      outputHandler.val(desc, className, methodName, boolArrayArg);
     }
   }
 
-  public static void arg(String className, String methodName, char charArg)
+  public static void val(String desc, String className, String methodName, char charArg)
   {
     for (IInstrumentationHandler outputHandler : instrumentationHandlers
                                                                         .keySet())
     {
-      outputHandler.arg(className, methodName, charArg);
+      outputHandler.val(desc, className, methodName, charArg);
     }
   }
 
-  public static void arg(String className, String methodName,
+  public static void val(String desc, String className, String methodName,
                          char[] charArrayArg)
   {
     for (IInstrumentationHandler outputHandler : instrumentationHandlers
                                                                         .keySet())
     {
-      outputHandler.arg(className, methodName, charArrayArg);
+      outputHandler.val(desc, className, methodName, charArrayArg);
     }
   }
 
-  public static void arg(String className, String methodName, Object objArg)
+  public static void val(String desc, String className, String methodName, Object objArg)
   {
     for (IInstrumentationHandler outputHandler : instrumentationHandlers
                                                                         .keySet())
     {
-      outputHandler.arg(className, methodName, objArg);
+      outputHandler.val(desc, className, methodName, objArg);
     }
   }
 
-  public static void arg(String className, String methodName,
+  public static void val(String desc, String className, String methodName,
                          Object[] objArrayArg)
   {
     for (IInstrumentationHandler outputHandler : instrumentationHandlers
                                                                         .keySet())
     {
-      outputHandler.arg(className, methodName, objArrayArg);
+      outputHandler.val(desc, className, methodName, objArrayArg);
     }
   }
 
diff --git a/org.intrace/src/org/intrace/output/IInstrumentationHandler.java b/org.intrace/src/org/intrace/output/IInstrumentationHandler.java
index 654c9f6..8e1715b 100644
--- a/org.intrace/src/org/intrace/output/IInstrumentationHandler.java
+++ b/org.intrace/src/org/intrace/output/IInstrumentationHandler.java
@@ -19,41 +19,41 @@ public interface IInstrumentationHandler
   // Output handling methods
   public void enter(String className, String methodName, int lineNo);
 
-  public void arg(String className, String methodName, byte byteArg);
+  public void val(String desc, String className, String methodName, byte byteArg);
 
-  public void arg(String className, String methodName, byte[] byteArrayArg);
+  public void val(String desc, String className, String methodName, byte[] byteArrayArg);
 
-  public void arg(String className, String methodName, short shortArg);
+  public void val(String desc, String className, String methodName, short shortArg);
 
-  public void arg(String className, String methodName, short[] shortArrayArg);
+  public void val(String desc, String className, String methodName, short[] shortArrayArg);
 
-  public void arg(String className, String methodName, int intArg);
+  public void val(String desc, String className, String methodName, int intArg);
 
-  public void arg(String className, String methodName, int[] intArrayArg);
+  public void val(String desc, String className, String methodName, int[] intArrayArg);
 
-  public void arg(String className, String methodName, long longArg);
+  public void val(String desc, String className, String methodName, long longArg);
 
-  public void arg(String className, String methodName, long[] longArrayArg);
+  public void val(String desc, String className, String methodName, long[] longArrayArg);
 
-  public void arg(String className, String methodName, float floatArg);
+  public void val(String desc, String className, String methodName, float floatArg);
 
-  public void arg(String className, String methodName, float[] floatArrayArg);
+  public void val(String desc, String className, String methodName, float[] floatArrayArg);
 
-  public void arg(String className, String methodName, double doubleArg);
+  public void val(String desc, String className, String methodName, double doubleArg);
 
-  public void arg(String className, String methodName, double[] doubleArrayArg);
+  public void val(String desc, String className, String methodName, double[] doubleArrayArg);
 
-  public void arg(String className, String methodName, boolean boolArg);
+  public void val(String desc, String className, String methodName, boolean boolArg);
 
-  public void arg(String className, String methodName, boolean[] boolArrayArg);
+  public void val(String desc, String className, String methodName, boolean[] boolArrayArg);
 
-  public void arg(String className, String methodName, char charArg);
+  public void val(String desc, String className, String methodName, char charArg);
 
-  public void arg(String className, String methodName, char[] charArrayArg);
+  public void val(String desc, String className, String methodName, char[] charArrayArg);
 
-  public void arg(String className, String methodName, Object objArg);
+  public void val(String desc, String className, String methodName, Object objArg);
 
-  public void arg(String className, String methodName, Object[] objArrayArg);
+  public void val(String desc, String className, String methodName, Object[] objArrayArg);
 
   public void branch(String className, String methodName, int lineNo);
 
diff --git a/org.intrace/src/org/intrace/output/IInstrumentationHandlerAdapter.java b/org.intrace/src/org/intrace/output/IInstrumentationHandlerAdapter.java
index 872292e..231623b 100644
--- a/org.intrace/src/org/intrace/output/IInstrumentationHandlerAdapter.java
+++ b/org.intrace/src/org/intrace/output/IInstrumentationHandlerAdapter.java
@@ -7,109 +7,109 @@ public class IInstrumentationHandlerAdapter implements IInstrumentationHandler
 {
 
   @Override
-  public void arg(String className, String methodName, byte byteArg)
+  public void val(String desc, String className, String methodName, byte byteArg)
   {
     // Do nothing
   }
 
   @Override
-  public void arg(String className, String methodName, byte[] byteArrayArg)
+  public void val(String desc, String className, String methodName, byte[] byteArrayArg)
   {
     // Do nothing
   }
 
   @Override
-  public void arg(String className, String methodName, short shortArg)
+  public void val(String desc, String className, String methodName, short shortArg)
   {
     // Do nothing
   }
 
   @Override
-  public void arg(String className, String methodName, short[] shortArrayArg)
+  public void val(String desc, String className, String methodName, short[] shortArrayArg)
   {
     // Do nothing
   }
 
   @Override
-  public void arg(String className, String methodName, int intArg)
+  public void val(String desc, String className, String methodName, int intArg)
   {
     // Do nothing
   }
 
   @Override
-  public void arg(String className, String methodName, int[] intArrayArg)
+  public void val(String desc, String className, String methodName, int[] intArrayArg)
   {
     // Do nothing
   }
 
   @Override
-  public void arg(String className, String methodName, long longArg)
+  public void val(String desc, String className, String methodName, long longArg)
   {
     // Do nothing
   }
 
   @Override
-  public void arg(String className, String methodName, long[] longArrayArg)
+  public void val(String desc, String className, String methodName, long[] longArrayArg)
   {
     // Do nothing
   }
 
   @Override
-  public void arg(String className, String methodName, float floatArg)
+  public void val(String desc, String className, String methodName, float floatArg)
   {
     // Do nothing
   }
 
   @Override
-  public void arg(String className, String methodName, float[] floatArrayArg)
+  public void val(String desc, String className, String methodName, float[] floatArrayArg)
   {
     // Do nothing
   }
 
   @Override
-  public void arg(String className, String methodName, double doubleArg)
+  public void val(String desc, String className, String methodName, double doubleArg)
   {
     // Do nothing
   }
 
   @Override
-  public void arg(String className, String methodName, double[] doubleArrayArg)
+  public void val(String desc, String className, String methodName, double[] doubleArrayArg)
   {
     // Do nothing
   }
 
   @Override
-  public void arg(String className, String methodName, boolean boolArg)
+  public void val(String desc, String className, String methodName, boolean boolArg)
   {
     // Do nothing
   }
 
   @Override
-  public void arg(String className, String methodName, boolean[] boolArrayArg)
+  public void val(String desc, String className, String methodName, boolean[] boolArrayArg)
   {
     // Do nothing
   }
 
   @Override
-  public void arg(String className, String methodName, char charArg)
+  public void val(String desc, String className, String methodName, char charArg)
   {
     // Do nothing
   }
 
   @Override
-  public void arg(String className, String methodName, char[] charArrayArg)
+  public void val(String desc, String className, String methodName, char[] charArrayArg)
   {
     // Do nothing
   }
 
   @Override
-  public void arg(String className, String methodName, Object objArg)
+  public void val(String desc, String className, String methodName, Object objArg)
   {
     // Do nothing
   }
 
   @Override
-  public void arg(String className, String methodName, Object[] objArrayArg)
+  public void val(String desc, String className, String methodName, Object[] objArrayArg)
   {
     // Do nothing
   }
diff --git a/org.intrace/src/org/intrace/output/trace/TraceHandler.java b/org.intrace/src/org/intrace/output/trace/TraceHandler.java
index d6617d2..1e82bae 100644
--- a/org.intrace/src/org/intrace/output/trace/TraceHandler.java
+++ b/org.intrace/src/org/intrace/output/trace/TraceHandler.java
@@ -45,178 +45,183 @@ public class TraceHandler implements IInstrumentationHandler
   }
 
   @Override
-  public void arg(String className, String methodName, byte byteArg)
+  public void val(String desc, String className, String methodName, byte byteArg)
   {
     if (argTrace)
     {
-      AgentHelper.writeOutput(className + ":" + methodName + ": Arg: "
+      AgentHelper.writeOutput(className + ":" + methodName + ": " + desc + ":"
                               + byteArg);
     }
   }
 
-  public void arg(String className, String methodName, byte[] byteArrayArg)
+  public void val(String desc, String className, String methodName, byte[] byteArrayArg)
   {
     if (argTrace)
     {
-      AgentHelper.writeOutput(className + ":" + methodName + ": Arg: "
+      AgentHelper.writeOutput(className + ":" + methodName + ": " + desc + ":"
                               + Arrays.toString(byteArrayArg));
     }
   }
 
   @Override
-  public void arg(String className, String methodName, short shortArg)
+  public void val(String desc, String className, String methodName, short shortArg)
   {
     if (argTrace)
     {
-      AgentHelper.writeOutput(className + ":" + methodName + ": Arg: "
+      AgentHelper.writeOutput(className + ":" + methodName + ": " + desc + ":"
                               + shortArg);
     }
   }
 
-  public void arg(String className, String methodName, short[] shortArrayArg)
+  public void val(String desc, String className, String methodName, short[] shortArrayArg)
   {
     if (argTrace)
     {
-      AgentHelper.writeOutput(className + ":" + methodName + ": Arg: "
+      AgentHelper.writeOutput(className + ":" + methodName + ": " + desc + ":"
                               + Arrays.toString(shortArrayArg));
     }
   }
 
   @Override
-  public void arg(String className, String methodName, int intArg)
+  public void val(String desc, String className, String methodName, int intArg)
   {
     if (argTrace)
     {
       AgentHelper
-                 .writeOutput(className + ":" + methodName + ": Arg: " + intArg);
+                 .writeOutput(className + ":" + methodName + ": " + desc + ":" + intArg);
     }
   }
 
   @Override
-  public void arg(String className, String methodName, int[] intArrayArg)
+  public void val(String desc, String className, String methodName, int[] intArrayArg)
   {
     if (argTrace)
     {
-      AgentHelper.writeOutput(className + ":" + methodName + ": Arg: "
+      AgentHelper.writeOutput(className + ":" + methodName + ": " + desc + ":"
                               + Arrays.toString(intArrayArg));
     }
   }
 
   @Override
-  public void arg(String className, String methodName, long longArg)
+  public void val(String desc, String className, String methodName, long longArg)
   {
     if (argTrace)
     {
-      AgentHelper.writeOutput(className + ":" + methodName + ": Arg: "
+      AgentHelper.writeOutput(className + ":" + methodName + ": " + desc + ":"
                               + longArg);
     }
   }
 
   @Override
-  public void arg(String className, String methodName, long[] longArrayArg)
+  public void val(String desc, String className, String methodName, long[] longArrayArg)
   {
     if (argTrace)
     {
-      AgentHelper.writeOutput(className + ":" + methodName + ": Arg: "
+      AgentHelper.writeOutput(className + ":" + methodName + ": " + desc + ":"
                               + Arrays.toString(longArrayArg));
     }
   }
 
   @Override
-  public void arg(String className, String methodName, float floatArg)
+  public void val(String desc, String className, String methodName, float floatArg)
   {
     if (argTrace)
     {
-      AgentHelper.writeOutput(className + ":" + methodName + ": Arg: "
+      AgentHelper.writeOutput(className + ":" + methodName + ": " + desc + ":"
                               + floatArg);
     }
   }
 
   @Override
-  public void arg(String className, String methodName, float[] floatArrayArg)
+  public void val(String desc, String className, String methodName, float[] floatArrayArg)
   {
     if (argTrace)
     {
-      AgentHelper.writeOutput(className + ":" + methodName + ": Arg: "
+      AgentHelper.writeOutput(className + ":" + methodName + ": " + desc + ":"
                               + Arrays.toString(floatArrayArg));
     }
   }
 
   @Override
-  public void arg(String className, String methodName, double doubleArg)
+  public void val(String desc, String className, String methodName, double doubleArg)
   {
     if (argTrace)
     {
-      AgentHelper.writeOutput(className + ":" + methodName + ": Arg: "
+      AgentHelper.writeOutput(className + ":" + methodName + ": " + desc + ":"
                               + doubleArg);
     }
   }
 
   @Override
-  public void arg(String className, String methodName, double[] doubleArrayArg)
+  public void val(String desc, String className, String methodName, double[] doubleArrayArg)
   {
     if (argTrace)
     {
-      AgentHelper.writeOutput(className + ":" + methodName + ": Arg: "
+      AgentHelper.writeOutput(className + ":" + methodName + ": " + desc + ":"
                               + Arrays.toString(doubleArrayArg));
     }
   }
 
   @Override
-  public void arg(String className, String methodName, boolean boolArg)
+  public void val(String desc, String className, String methodName, boolean boolArg)
   {
     if (argTrace)
     {
-      AgentHelper.writeOutput(className + ":" + methodName + ": Arg: "
+      AgentHelper.writeOutput(className + ":" + methodName + ": " + desc + ":"
                               + boolArg);
     }
   }
 
   @Override
-  public void arg(String className, String methodName, boolean[] boolArrayArg)
+  public void val(String desc, String className, String methodName, boolean[] boolArrayArg)
   {
     if (argTrace)
     {
-      AgentHelper.writeOutput(className + ":" + methodName + ": Arg: "
+      AgentHelper.writeOutput(className + ":" + methodName + ": " + desc + ":"
                               + Arrays.toString(boolArrayArg));
     }
   }
 
   @Override
-  public void arg(String className, String methodName, char charArg)
+  public void val(String desc, String className, String methodName, char charArg)
   {
     if (argTrace)
     {
-      AgentHelper.writeOutput(className + ":" + methodName + ": Arg: "
+      AgentHelper.writeOutput(className + ":" + methodName + ": " + desc + ":"
                               + charArg);
     }
   }
 
   @Override
-  public void arg(String className, String methodName, char[] charArrayArg)
+  public void val(String desc, String className, String methodName, char[] charArrayArg)
   {
     if (argTrace)
     {
-      AgentHelper.writeOutput(className + ":" + methodName + ": Arg: "
+      AgentHelper.writeOutput(className + ":" + methodName + ": " + desc + ":"
                               + Arrays.toString(charArrayArg));
     }
   }
 
   @Override
-  public void arg(String className, String methodName, Object objArg)
+  public void val(String desc, String className, String methodName, Object objArg)
   {
+    // Array return values pass through this arm so we must do something
+    // a bit special - use Arrays.deepToString and discard the surrounding
+    // [] that we add.
     if (argTrace)
     {
+      String objStr = Arrays.deepToString(new Object[] {objArg});
+      objStr = objStr.substring(1, objStr.length() - 1);
       AgentHelper
-                 .writeOutput(className + ":" + methodName + ": Arg: " + objArg);
+                 .writeOutput(className + ":" + methodName + ": " + desc + ":" + objStr);
     }
   }
 
-  public void arg(String className, String methodName, Object[] objArrayArg)
+  public void val(String desc, String className, String methodName, Object[] objArrayArg)
   {
     if (argTrace)
     {
-      AgentHelper.writeOutput(className + ":" + methodName + ": Arg: "
+      AgentHelper.writeOutput(className + ":" + methodName + ": " + desc + ":"
                               + Arrays.deepToString(objArrayArg));
     }
   }
diff --git a/org.intrace/testsrc/org/test/intrace/agent/AgentTest.java b/org.intrace/testsrc/org/test/intrace/agent/AgentTest.java
index 2719f54..76dd37e 100644
--- a/org.intrace/testsrc/org/test/intrace/agent/AgentTest.java
+++ b/org.intrace/testsrc/org/test/intrace/agent/AgentTest.java
@@ -181,11 +181,11 @@ public class AgentTest extends TestCase
     EasyMock.expectLastCall().andAnswer(exitTraceWriter).anyTimes();
 
     testHandler
-               .arg(isA(String.class), isA(String.class), EasyMock.anyBoolean());
+               .val(isA(String.class), isA(String.class), isA(String.class), EasyMock.anyBoolean());
     EasyMock.expectLastCall().anyTimes();
-    testHandler.arg(isA(String.class), isA(String.class), EasyMock.anyObject());
+    testHandler.val(isA(String.class), isA(String.class), isA(String.class), EasyMock.anyObject());
     EasyMock.expectLastCall().anyTimes();
-    testHandler.arg(isA(String.class), isA(String.class), EasyMock.anyInt());
+    testHandler.val(isA(String.class), isA(String.class), isA(String.class), EasyMock.anyInt());
     EasyMock.expectLastCall().anyTimes();
 
     EasyMock.replay(testHandler);
diff --git a/org.intrace/testsrc/org/test/intrace/agent/ArgCapture.java b/org.intrace/testsrc/org/test/intrace/agent/ArgCapture.java
index 20b912e..c8a99ca 100644
--- a/org.intrace/testsrc/org/test/intrace/agent/ArgCapture.java
+++ b/org.intrace/testsrc/org/test/intrace/agent/ArgCapture.java
@@ -22,117 +22,117 @@ public class ArgCapture implements IInstrumentationHandler
   }
 
   @Override
-  public void arg(String className, String methodName, byte byteArg)
+  public void val(String desc, String className, String methodName, byte byteArg)
   {
-    addArg("Arg:##:[" + className + ", " + methodName + ", " + byteArg + "]");
+    addArg(desc + ":##:[" + className + ", " + methodName + ", " + byteArg + "]");
   }
 
-  public void arg(String className, String methodName, byte[] byteArrayArg)
+  public void val(String desc, String className, String methodName, byte[] byteArrayArg)
   {
-    addArg("Arg:##:[" + className + ", " + methodName + ", "
+    addArg(desc + ":##:[" + className + ", " + methodName + ", "
            + Arrays.toString(byteArrayArg) + "]");
   }
 
   @Override
-  public void arg(String className, String methodName, short shortArg)
+  public void val(String desc, String className, String methodName, short shortArg)
   {
-    addArg("Arg:##:[" + className + ", " + methodName + ", " + shortArg + "]");
+    addArg(desc + ":##:[" + className + ", " + methodName + ", " + shortArg + "]");
   }
 
-  public void arg(String className, String methodName, short[] shortArrayArg)
+  public void val(String desc, String className, String methodName, short[] shortArrayArg)
   {
 
-    addArg("Arg:##:[" + className + ", " + methodName + ", "
+    addArg(desc + ":##:[" + className + ", " + methodName + ", "
            + Arrays.toString(shortArrayArg) + "]");
   }
 
   @Override
-  public void arg(String className, String methodName, int intArg)
+  public void val(String desc, String className, String methodName, int intArg)
   {
-    addArg("Arg:##:[" + className + ", " + methodName + ", " + intArg + "]");
+    addArg(desc + ":##:[" + className + ", " + methodName + ", " + intArg + "]");
   }
 
   @Override
-  public void arg(String className, String methodName, int[] intArrayArg)
+  public void val(String desc, String className, String methodName, int[] intArrayArg)
   {
-    addArg("Arg:##:[" + className + ", " + methodName + ", "
+    addArg(desc + ":##:[" + className + ", " + methodName + ", "
            + Arrays.toString(intArrayArg) + "]");
   }
 
   @Override
-  public void arg(String className, String methodName, long longArg)
+  public void val(String desc, String className, String methodName, long longArg)
   {
-    addArg("Arg:##:[" + className + ", " + methodName + ", " + longArg + "]");
+    addArg(desc + ":##:[" + className + ", " + methodName + ", " + longArg + "]");
   }
 
   @Override
-  public void arg(String className, String methodName, long[] longArrayArg)
+  public void val(String desc, String className, String methodName, long[] longArrayArg)
   {
-    addArg("Arg:##:[" + className + ", " + methodName + ", "
+    addArg(desc + ":##:[" + className + ", " + methodName + ", "
            + Arrays.toString(longArrayArg) + "]");
   }
 
   @Override
-  public void arg(String className, String methodName, float floatArg)
+  public void val(String desc, String className, String methodName, float floatArg)
   {
-    addArg("Arg:##:[" + className + ", " + methodName + ", " + floatArg + "]");
+    addArg(desc + ":##:[" + className + ", " + methodName + ", " + floatArg + "]");
   }
 
   @Override
-  public void arg(String className, String methodName, float[] floatArrayArg)
+  public void val(String desc, String className, String methodName, float[] floatArrayArg)
   {
-    addArg("Arg:##:[" + className + ", " + methodName + ", "
+    addArg(desc + ":##:[" + className + ", " + methodName + ", "
            + Arrays.toString(floatArrayArg) + "]");
   }
 
   @Override
-  public void arg(String className, String methodName, double doubleArg)
+  public void val(String desc, String className, String methodName, double doubleArg)
   {
-    addArg("Arg:##:[" + className + ", " + methodName + ", " + doubleArg + "]");
+    addArg(desc + ":##:[" + className + ", " + methodName + ", " + doubleArg + "]");
   }
 
   @Override
-  public void arg(String className, String methodName, double[] doubleArrayArg)
+  public void val(String desc, String className, String methodName, double[] doubleArrayArg)
   {
-    addArg("Arg:##:[" + className + ", " + methodName + ", "
+    addArg(desc + ":##:[" + className + ", " + methodName + ", "
            + Arrays.toString(doubleArrayArg) + "]");
   }
 
   @Override
-  public void arg(String className, String methodName, boolean boolArg)
+  public void val(String desc, String className, String methodName, boolean boolArg)
   {
-    addArg("Arg:##:[" + className + ", " + methodName + ", " + boolArg + "]");
+    addArg(desc + ":##:[" + className + ", " + methodName + ", " + boolArg + "]");
   }
 
   @Override
-  public void arg(String className, String methodName, boolean[] boolArrayArg)
+  public void val(String desc, String className, String methodName, boolean[] boolArrayArg)
   {
-    addArg("Arg:##:[" + className + ", " + methodName + ", "
+    addArg(desc + ":##:[" + className + ", " + methodName + ", "
            + Arrays.toString(boolArrayArg) + "]");
   }
 
   @Override
-  public void arg(String className, String methodName, char charArg)
+  public void val(String desc, String className, String methodName, char charArg)
   {
-    addArg("Arg:##:[" + className + ", " + methodName + ", " + charArg + "]");
+    addArg(desc + ":##:[" + className + ", " + methodName + ", " + charArg + "]");
   }
 
   @Override
-  public void arg(String className, String methodName, char[] charArrayArg)
+  public void val(String desc, String className, String methodName, char[] charArrayArg)
   {
-    addArg("Arg:##:[" + className + ", " + methodName + ", "
+    addArg(desc + ":##:[" + className + ", " + methodName + ", "
            + Arrays.toString(charArrayArg) + "]");
   }
 
   @Override
-  public void arg(String className, String methodName, Object objArg)
+  public void val(String desc, String className, String methodName, Object objArg)
   {
-    addArg("Arg:##:[" + className + ", " + methodName + ", " + objArg + "]");
+    addArg(desc + ":##:[" + className + ", " + methodName + ", " + objArg + "]");
   }
 
-  public void arg(String className, String methodName, Object[] objArrayArg)
+  public void val(String desc, String className, String methodName, Object[] objArrayArg)
   {
-    addArg("Arg:##:[" + className + ", " + methodName + ", "
+    addArg(desc + ":##:[" + className + ", " + methodName + ", "
            + Arrays.deepToString(objArrayArg) + "]");
   }