FWD » Core Development » User Interface

package com.goldencode.csvtrace;

import java.io.*;

import java.lang.reflect.Field;

import java.nio.file.*;

import java.util.*;

import java.util.concurrent.atomic.*;

import org.apache.commons.lang.builder.*;

import org.aspectj.lang.*;

import org.aspectj.lang.annotation.*;

/**

 * To use:

 * 1. Copy this class to the project at com/goldencode/csvtrace.

 * 2. Rebuild with AspectJ.

 * 3. When the app is started look for csvtrace.stop in the working dir.

 * 4. Modify csvtrace.stop at your liking.

 * 5. Rename csvtrace.stop to csvtrace.start to activate tracing.

 * 6. Rename csvtrace.start to csvtrace.stop or stop the app to disable tracing.

 * 7. The trace output is saved to csvtrace.csv in the working dir.

 * 8. When no longer needed, delete this class from your project.

 * 

 * This thing is WIP.

 */

@Aspect

public class TraceAspect

{

   private static final String CTRL_FILE_START = "csvtrace.start";

   private static final String CTRL_FILE_STOP = "csvtrace.stop";

   private static final String CSV_FILE = "csvtrace.csv";

   private static boolean traceActive = false;

   private static AtomicReference<List<String>> includes = new AtomicReference<>();

   private static AtomicReference<List<String>> excludes = new AtomicReference<>();

   private static BufferedWriter csvFileWriter = null;

   static

   {

      start();

   }

   @Before("target(o) && execution(* com.goldencode..*(..))&& !cflow(within(TraceAspect))")

   public void traceMethods(JoinPoint joinPoint, Object o)

   {

      if (!traceActive)

      {

         return;

      }

      List<String> incs = includes.get();

      if (incs == null || incs.isEmpty())

      {

         return;

      }

      List<String> excs = excludes.get();

      Signature sig = joinPoint.getStaticPart().getSignature();

      Class<?> declaring = sig.getDeclaringType();

      String declaringName = declaring.getCanonicalName();

      if (declaringName == null)

      {

         return;

      }

      // qualified class name + method name

      declaringName = declaringName + "." + sig.getName();

      // match the declaring class against the list of excludes

      boolean isMatch = false;

      for (String exclude : excs)

      {

         if (exclude.endsWith("*"))

         {

            if (declaringName.startsWith(exclude.substring(0, exclude.length() - 1)))

            {

               isMatch = true;

               break;

            }

         }

         else

         {

            if (declaringName.equals(exclude))

            {

               isMatch = true;

               break;

            }

         }

      }

      if (isMatch)

      {

         // exclude matched - exit

         return;

      }

      // match the declaring class against the list of includes

      for (String include : incs)

      {

         if (include.endsWith("*"))

         {

            if (declaringName.startsWith(include.substring(0, include.length() - 1)))

            {

               isMatch = true;

               break;

            }

         }

         else

         {

            if (declaringName.equals(include))

            {

               isMatch = true;

               break;

            }

         }

      }

      if (!isMatch)

      {

         return;

      }

      Object[] args = joinPoint.getArgs();

      createCSVEntry(declaringName, o, args);

   }

   public void createCSVEntry(String declaringName, Object ref, Object[] args)

   {

      long nanos = System.nanoTime();

      StringBuilder str = new StringBuilder();

      str.append(nanos).append(",");

      str.append(Thread.currentThread().getName()).append(",");

      if (ref != null)

      {

         str.append(declaringName).append("(")

            .append(ref.getClass().getSimpleName())

            .append(")").append(",");

      }

      else

      {

         str.append(declaringName).append(",");

      }

      str.append("@");

      if (ref == null)

      {

         // do the same length as a valid hash code for easier grep

         str.append("00000000");

      }

      else

      {

         str.append(Integer.toHexString(System.identityHashCode(ref)));

      }

      str.append(",");

      // serialize the arguments

      for (Object arg : args)

      {

         String argStr;

         if (arg != null)

         {

            Class<?> argClass = arg.getClass();

            if (isPrimitiveOrWrapper(argClass))

            {

               argStr = arg.toString();

            }

            else

            {

               argStr = toStringReflective(arg, argClass);

            }

         }

         else

         {

            argStr = "<null>";

         }

         // escape control chars

         argStr = argStr.replace("\"", "\"\"");

         argStr = "\"" + argStr + "\"";

         str.append(argStr).append(",");

      }

      String out = str.toString();

      synchronized (this)

      {

         try

         {

            csvFileWriter.write(out);

            csvFileWriter.newLine();

            csvFileWriter.flush();

         }

         catch (IOException e)

         {

            e.printStackTrace();

         }

      }

   }

   private static void start()

   {

      String workDir = System.getProperty("user.dir");

      Path path = FileSystems.getDefault().getPath(workDir, CSV_FILE);

      File csvFile = path.toFile();

      try

      {

         boolean writeColumns = false;

         if (!csvFile.exists())

         {

            writeColumns = true;

         }

         csvFileWriter = new BufferedWriter(new FileWriter(csvFile, true));

         if (writeColumns)

         {

            csvFileWriter.write("Nanos, Thread, Method, Hashcode, Arg1, Arg2, Arg3, Arg4, Arg5");

            csvFileWriter.newLine();

            csvFileWriter.flush();

         }

      }

      catch (IOException e1)

      {

         e1.printStackTrace();

         return;

      }

      path = FileSystems.getDefault().getPath(workDir, CTRL_FILE_START);

      File startFile = path.toFile();

      path = FileSystems.getDefault().getPath(workDir, CTRL_FILE_STOP);

      File stopFile = path.toFile();

      if (!startFile.exists() && !stopFile.exists())

      {

         // create the default file

         try (BufferedWriter writer = new BufferedWriter(new FileWriter(stopFile)))

         {

            writer.write("# rename this file to csvtrace.start to start tracing, or csvtrace.stop to stop tracing");

            writer.newLine();

            writer.write("# my.name* - all methods of all classes in all the namespaces beginning with 'my.name'");

            writer.newLine();

            writer.write("# my.namespace.* - all methods of all classes in the namespace 'my.namespace' including subspaces");

            writer.newLine();

            writer.write("# my.namespace.MyClass* - all methods of class names beginning with 'my.namespace.MyClass'");

            writer.newLine();

            writer.write("# my.namespace.MyClass.* - all methods of class name equal to 'my.namespace.MyClass'");

            writer.newLine();

            writer.write("# my.namespace.MyClass.foo* - all methods of class 'my.namespace.MyClass' beginning with 'foo'");

            writer.newLine();

            writer.write("# my.namespace.MyClass.fooBar - the method 'fooBar' of class 'my.namespace.MyClass'");

            writer.newLine();

            writer.write("!java.*");

            writer.newLine();

            writer.write("!javax.*");

            writer.newLine();

            writer.write("# make sure to apply some filters in the form above and remove the asterisk");

            writer.write("*");

         }

         catch (IOException e)

         {

            e.printStackTrace();

            throw new RuntimeException(e);

         }

      }

      updateState();

      Thread fileWatcherThread = new Thread(new Runnable()

      {

         @Override

         public void run()

         {

            controlFileWatcher();

         }

      }, "csv-trace");

      fileWatcherThread.setDaemon(true);

      fileWatcherThread.start();

   }

   private static void controlFileWatcher()

   {

      WatchService watcher;

      try

      {

         watcher = FileSystems.getDefault().newWatchService();

      }

      catch (IOException e)

      {

         e.printStackTrace();

         return;

      }

      String workDir = System.getProperty("user.dir");

      Path dir = FileSystems.getDefault().getPath(workDir);

      try

      {

         dir.register(watcher, StandardWatchEventKinds.ENTRY_CREATE,

               StandardWatchEventKinds.ENTRY_MODIFY);

      }

      catch (IOException x)

      {

         System.err.println(x);

      }

      for (;;)

      {

         // wait for key to be signaled

         WatchKey key;

         try

         {

            key = watcher.take();

         }

         catch (InterruptedException x)

         {

            return;

         }

         for (WatchEvent<?> event : key.pollEvents())

         {

            WatchEvent.Kind<?> kind = event.kind();

            if (kind == StandardWatchEventKinds.OVERFLOW)

            {

               continue;

            }

            @SuppressWarnings("unchecked")

            WatchEvent<Path> ev = (WatchEvent<Path>) event;

            Path filename = ev.context();

            if (filename.endsWith(CTRL_FILE_START) || filename.endsWith(CTRL_FILE_STOP))

            {

               updateState();

            }

         }

         try

         {

            // sleep not to consume to much CPU in case the csv file is in the same folder as the

            // control file

            Thread.sleep(1000);

         }

         catch (InterruptedException e)

         {

            break;

         }

         // reset the key to receive further events

         boolean valid = key.reset();

         if (!valid)

         {

            break;

         }

      }

   }

   private static void updateState()

   {

      String workDir = System.getProperty("user.dir");

      Path path = FileSystems.getDefault().getPath(workDir, CTRL_FILE_START);

      File startFile = path.toFile();

      path = FileSystems.getDefault().getPath(workDir, CTRL_FILE_STOP);

      File stopFile = path.toFile();

      if (stopFile.exists())

      {

         includes.set(null);

         return;

      }

      if (startFile.exists())

      {

         processControlFile(startFile);

      }

   }

   private static void processControlFile(File file)

   {

      List<String> tempIncludes = new ArrayList<>();

      List<String> tempExcludes = new ArrayList<>();

      try (BufferedReader br = new BufferedReader(new FileReader(file)))

      {

         String line = null;

         while ((line = br.readLine()) != null)

         {

            line = line.trim();

            if (line.startsWith("#"))

            {

               continue;

            }

            // anything else than # is considered an include pattern

            line = line.trim();

            if (line.startsWith("!"))

            {

               tempExcludes.add(line.substring(1));

            }

            else

            {

               tempIncludes.add(line.trim());

            }

         }

      }

      catch (IOException e)

      {

         e.printStackTrace();

      }

      excludes.set(tempExcludes);

      includes.set(tempIncludes);

      traceActive = !tempIncludes.isEmpty();

   }

   private static boolean isPrimitiveOrWrapper(Class<?> clazz)

   {

      return clazz.isPrimitive() || 

             clazz.equals(Boolean.class) ||

             clazz.equals(Character.class) ||

             clazz.equals(Short.class) ||

             clazz.equals(Integer.class) ||

             clazz.equals(Long.class) ||

             clazz.equals(Float.class) ||

             clazz.equals(Double.class) ||

             CharSequence.class.isAssignableFrom(clazz);

   }

   private static String toStringReflective(Object value, Class<?> clazz)

   {

      if (value == null)

      {

         return "<null>";

      }

      if (isPrimitiveOrWrapper(clazz))

      {

         return value.toString();

      }

      StringBuilder b = new StringBuilder();

      b.append(clazz.getSimpleName());

      b.append("@");

      b.append(System.identityHashCode(value));

      b.append("[");

      boolean first = true;

      Class<?> parent = clazz;

      while(parent != null && !parent.getClass().equals(Object.class))

      {

         Field[] fields = parent.getDeclaredFields();

         for(Field f : fields)

         {

            String fName = f.getName();

            if (fName.startsWith("ajc$"))

            {

               // don't care for aspectj internals

               continue;

            }

            if (!first)

            {

               b.append(",");

            }

            first = false;

            f.setAccessible(true);

            b.append(fName);

            b.append("=");

            Object fValue;

            try

            {

               fValue = f.get(value);

               if (fValue == null)

               {

                  b.append("<null>");

               }

               else if (isPrimitiveOrWrapper(f.getType()))

               {

                  b.append(fValue.toString());

               }

               else

               {

                  b.append("[" + fValue.toString() + "]");

               }

            }

            catch (Exception e)

            {

               b.append("<error>");

            }

         }

         parent = parent.getSuperclass();

      }

      b.append("]");

      return b.toString();

   }

   @SuppressWarnings("serial")

   private static class TwoLevelsToStringStyle extends ToStringStyle

   {

      private static final int MAX_DEPTH = 1;

      private int depth = 0;

      /**

       * <p>

       * Constructor.

       * </p>

       */

      public TwoLevelsToStringStyle()

      {

         super();

         this.setUseShortClassName(true);

         this.setUseIdentityHashCode(true);

      }

      @Override

      public void appendDetail(StringBuffer buffer, String fieldName, Object value)

      {

         if (depth > MAX_DEPTH)

         {

            return;

         }

         Class<?> valueClass = value.getClass();

         if (valueClass.isPrimitive() || 

               valueClass.equals(Boolean.class) ||

               valueClass.equals(Character.class) ||

               valueClass.equals(Short.class) ||

               valueClass.equals(Integer.class) ||

               valueClass.equals(Long.class) ||

               valueClass.equals(Float.class) ||

               valueClass.equals(Double.class) ||

               CharSequence.class.isAssignableFrom(valueClass))

         {

            super.appendDetail(buffer, fieldName, value);

         }

         else if (accept(valueClass))

         {

            depth++;

            try

            {

               buffer.append(ToStringBuilder.reflectionToString(value, this));

            }

            finally

            {

               depth--;

            }

         }

      }

//      @Override

//      protected void appendDetail(StringBuffer buffer, String fieldName, Collection<?> coll)

//      {

//         if (depth > MAX_DEPTH)

//         {

//            return;

//         }

   //

//         appendClassName(buffer, coll);

//         appendIdentityHashCode(buffer, coll);

//         appendDetail(buffer, fieldName, coll.toArray());

//      }

      /**

       * Returns whether or not to recursively format the given <code>Class</code>. By default, this

       * method always returns {@code true}, but may be overwritten by sub-classes to filter specific

       * classes.

       *

       * @param clazz

       *           The class to test.

       * @return Whether or not to recursively format the given <code>Class</code>.

       */

      protected boolean accept(final Class<?> clazz)

      {

         // TODO: WeakHasMap is internally used in ToStringBuilder implementation 

         //       and causes infinite recursion 

         return !WeakHashMap.class.isAssignableFrom(clazz);

      }

   }

}