Implement issue #31

org.intrace/src/org/intrace/agent/ClassTransformer.java

@@ -29,6 +29,8 @@
 import org.intrace.output.trace.TraceHandler;
 import org.intrace.shared.AgentConfigConstants;
 import org.objectweb.asm.ClassReader;
+import org.objectweb.asm.ClassVisitor;
+import org.objectweb.asm.commons.EmptyVisitor;
 
 /**
  * Uses ASM2 to transform class files to add Trace instrumentation.
@@ -139,13 +141,15 @@ private byte[] getInstrumentedClassBytes(String xiClassName,
    * @param klass
    * @param className
    * @param protectionDomain
+   * @param originalClassfile
    * @return True if the Class with name className should be instrumented.
    */
   private boolean isToBeConsideredForInstrumentation(
                                                      Class<?> klass,
                                                      ClassLoader klassloader,
                                                      String className,
-                                                     ProtectionDomain protectionDomain)
+                                                     ProtectionDomain protectionDomain,
+                                                     byte[] originalClassfile)
   {
     ComparableClassName compklass = new ComparableClassName(className,
                                                             klassloader);
@@ -195,18 +199,59 @@ private boolean isToBeConsideredForInstrumentation(
     if ((settings.getClassRegex() == null)
         || !matches(settings.getClassRegex(), className))
     {
-      if (settings.isVerboseMode())
+      // Actually we should modify if any of the interfaces match the regex
+      boolean matchedInterface = false;
+      for(String klassInterface : getInterfaces(className, originalClassfile))
       {
-        TraceHandler.INSTANCE.writeTraceOutput("DEBUG: Ignoring class not matching the active include regex: "
-                           + className);
+        if ((settings.getClassRegex() != null)
+            && matches(settings.getClassRegex(), klassInterface))
+        {
+          matchedInterface |= true;
+        }
+      }
+
+      if(!matchedInterface)
+      {
+        if (settings.isVerboseMode())
+        {
+          TraceHandler.INSTANCE.writeTraceOutput("DEBUG: Ignoring class not matching the active include regex: "
+                             + className);
+        }
+        return false;
       }
-      return false;
     }
 
     // All checks passed - class can be instrumented
     return true;
   }
 
+  private String[] getInterfaces(String className, byte[] originalClassfile)
+  {
+    try
+    {
+      final String[][] interfaceNames = new String[1][];
+      ClassReader cr = new ClassReader(originalClassfile);
+      ClassVisitor cv = new EmptyVisitor() {
+        @Override
+        public void visit(int version, int access, String name,
+            String signature, String superName, String[] interfaces)
+        {
+          interfaceNames[0] = interfaces;
+          super.visit(version, access, name, signature, superName, interfaces);
+        }
+      };
+      cr.accept(cv, 0);
+      return interfaceNames[0];
+    }
+    catch (Throwable th)
+    {
+      System.err.println("Caught Throwable when trying to instrument: "
+                         + className);
+      th.printStackTrace();
+      return new String[0];
+    }
+  }
+
   private boolean matches(String[] strs, String target)
   {
     for (String str : strs)
@@ -259,8 +304,9 @@ public byte[] transform(ClassLoader loader, String internalClassName,
       int allClassesSize = allClasses.size();
 
       boolean shouldInstrument = isToBeConsideredForInstrumentation(classBeingRedefined, loader,
-                                                                    className, protectionDomain);
-      if (shouldInstrument || "java.lang.Thread".equals(className))
+                                                                    className, protectionDomain,
+                                                                    originalClassfile);
+      if (shouldInstrument && !"java.lang.Thread".equals(className))
       {
 //        System.out.println("!! Instrumenting class: " + compclass);
 
@@ -585,8 +631,6 @@ private Set<ComparableClass> getModifiedClasses()
    * <li>Class is an annotation
    * <li>Class is synthetic
    * <li>Class is not modifiable
-   * <li>Class is rejected by
-   * {@link ClassTransformer#isToBeConsideredForInstrumentation(String, ProtectionDomain)}
    * </ul>
    */
   public Set<ComparableClass> getLoadedClassesForModification()
@@ -620,12 +664,7 @@ else if (!inst.isModifiableClass(loadedClass))
                              + loadedClass.getCanonicalName());
         }
       }
-      else if (isToBeConsideredForInstrumentation(
-                                                  loadedClass,
-                                                  loadedClass.getClassLoader(),
-                                                  loadedClass.getName(),
-                                                  loadedClass
-                                                             .getProtectionDomain()))
+      else
       {
         ComparableClass loadedKlass = new ComparableClass(loadedClass);
         unmodifiedKlasses.add(loadedKlass);

org.intrace/testsrc/example/ISomeKindOfInterface.java

@@ -0,0 +1,6 @@
+package example;
+
+public interface ISomeKindOfInterface
+{
+  public void shoutOut();
+}

org.intrace/testsrc/example/ImplWithTerribleName.java

@@ -0,0 +1,10 @@
+package example;
+
+public class ImplWithTerribleName implements ISomeKindOfInterface
+{
+  @Override
+  public void shoutOut()
+  {
+    System.out.println("Woohoo!");
+  }
+}

org.intrace/testsrc/example/TraceExample.java

@@ -6,13 +6,13 @@
 
 public class TraceExample
 {
-  
+
   private static Map<String,String> map = new HashMap<String, String>();
   static
   {
     map.put("foo", "bar");
   }
-  
+
   /**
    * @param args
    * @throws Exception
@@ -23,7 +23,7 @@ public static void main(String[] args)
     try
     {
       otherMain(args[0]);
-    } 
+    }
     catch (Throwable ex)
     {
       ex.printStackTrace();
@@ -38,6 +38,7 @@ public static void otherMain(String arg) throws Exception
       InnerTestClass.foo();
       workMethod("foobar");
       new InnerTestClass().boolMethod(true);
+      new ImplWithTerribleName().shoutOut();
     }
   }
 
@@ -72,7 +73,7 @@ private static String exceptionMethod()
     }
     catch (Exception ex)
     {
-      return "seen exception";      
+      return "seen exception";
     }
     return "no exception";
   }
@@ -89,12 +90,12 @@ private void instanceFoo()
     {
       System.setProperty("a", "foobar");
     }
-    
+
     private void boolMethod(boolean xiArg)
     {
       System.out.println(Boolean.toString(xiArg));
     }
-    
+
     private static void foo()
     {
       System.setProperty("a", "bar");