From ef745353d161bf069a95dbc5a2aecb5780a20494 Mon Sep 17 00:00:00 2001
From: Ben Donnelly <b.w.donnelly1@googlemail.com>
Date: Mon, 8 Jan 2024 14:28:45 +0000
Subject: [PATCH] feat(traces): update trace support

 - reviewed and update method entry support
 - update support for line tracepoints

  - fix issues with duplication of data collection
  - fix issues with incorrect data collection
---
 .idea/codeStyles/Project.xml                  |   1 +
 .../deep/agent/api/plugin/ITraceProvider.java |   2 +
 .../com/intergral/deep/agent/DeepAgent.java   |   2 +-
 .../deep/agent/push/PushService.java          |  28 +-
 .../deep/agent/settings/Settings.java         |   3 +
 .../tracepoint/TracepointConfigService.java   |   2 +-
 .../agent/tracepoint/cf/CFFrameProcessor.java |   5 +-
 .../agent/tracepoint/handler/Callback.java    | 462 +++++++----
 .../tracepoint/handler/FrameCollector.java    |  32 +-
 .../agent/tracepoint/handler/FrameConfig.java |  13 +-
 .../tracepoint/handler/FrameProcessor.java    |  64 +-
 .../agent/tracepoint/inst/asm/Visitor.java    | 730 +++++++++++++-----
 .../deep/agent/types/TracePointConfig.java    | 131 +++-
 .../agent/types/snapshot/EventSnapshot.java   |  15 +-
 .../com/intergral/deep/ProxyCallback.java     |  66 +-
 .../deep/agent/push/PushServiceTest.java      |  49 +-
 .../tracepoint/handler/CallbackTest.java      |  11 +-
 .../handler/FrameCollectorTest.java           |   2 +-
 .../handler/FrameProcessorTest.java           |   2 +-
 .../tracepoint/inst/asm/VisitorTest.java      | 655 ++++++++++++++--
 .../deep/agent/types/EStageTest.java          |  33 +
 .../deep/test/MockMixinTemplate.java          |  98 ++-
 .../deep/test/target/BPTestTarget.java        |  40 +-
 .../com/intergral/deep/plugin/OtelPlugin.java |  11 +
 .../deep/tests/snapshot/SnapshotUtils.java    |  20 +
 25 files changed, 1893 insertions(+), 584 deletions(-)
 create mode 100644 agent/src/test/java/com/intergral/deep/agent/types/EStageTest.java

diff --git a/.idea/codeStyles/Project.xml b/.idea/codeStyles/Project.xml
index 5724c65..7308a9f 100644
--- a/.idea/codeStyles/Project.xml
+++ b/.idea/codeStyles/Project.xml
@@ -77,6 +77,7 @@
           <package name="" withSubpackages="true" static="false" />
         </value>
       </option>
+      <option name="ENABLE_JAVADOC_FORMATTING" value="false" />
     </JavaCodeStyleSettings>
     <Objective-C>
       <option name="INDENT_NAMESPACE_MEMBERS" value="0" />
diff --git a/agent-api/src/main/java/com/intergral/deep/agent/api/plugin/ITraceProvider.java b/agent-api/src/main/java/com/intergral/deep/agent/api/plugin/ITraceProvider.java
index db030f0..46de233 100644
--- a/agent-api/src/main/java/com/intergral/deep/agent/api/plugin/ITraceProvider.java
+++ b/agent-api/src/main/java/com/intergral/deep/agent/api/plugin/ITraceProvider.java
@@ -47,5 +47,7 @@ interface ISpan extends AutoCloseable {
     String traceId();
 
     String spanId();
+
+    void addAttribute(String key, String value);
   }
 }
diff --git a/agent/src/main/java/com/intergral/deep/agent/DeepAgent.java b/agent/src/main/java/com/intergral/deep/agent/DeepAgent.java
index 4425501..4215178 100644
--- a/agent/src/main/java/com/intergral/deep/agent/DeepAgent.java
+++ b/agent/src/main/java/com/intergral/deep/agent/DeepAgent.java
@@ -62,7 +62,7 @@ public DeepAgent(final Settings settings,
     this.grpcService = new GrpcService(settings);
     this.pollService = new LongPollService(settings, this.grpcService);
     this.tracepointConfig = new TracepointConfigService(tracepointInstrumentationService);
-    final PushService pushService = new PushService(settings, grpcService);
+    final PushService pushService = new PushService(grpcService);
 
     Callback.init(settings, tracepointConfig, pushService);
   }
diff --git a/agent/src/main/java/com/intergral/deep/agent/push/PushService.java b/agent/src/main/java/com/intergral/deep/agent/push/PushService.java
index ecfb34d..786a22f 100644
--- a/agent/src/main/java/com/intergral/deep/agent/push/PushService.java
+++ b/agent/src/main/java/com/intergral/deep/agent/push/PushService.java
@@ -17,16 +17,11 @@
 
 package com.intergral.deep.agent.push;
 
-import com.intergral.deep.agent.api.plugin.ISnapshotContext;
-import com.intergral.deep.agent.api.plugin.ISnapshotDecorator;
-import com.intergral.deep.agent.api.resource.Resource;
 import com.intergral.deep.agent.grpc.GrpcService;
-import com.intergral.deep.agent.settings.Settings;
 import com.intergral.deep.agent.types.snapshot.EventSnapshot;
 import com.intergral.deep.proto.tracepoint.v1.Snapshot;
 import com.intergral.deep.proto.tracepoint.v1.SnapshotResponse;
 import io.grpc.stub.StreamObserver;
-import java.util.Collection;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -36,12 +31,10 @@
 public class PushService {
 
   private static final Logger LOGGER = LoggerFactory.getLogger(PushService.class);
-  private final Settings settings;
   private final GrpcService grpcService;
 
 
-  public PushService(final Settings settings, final GrpcService grpcService) {
-    this.settings = settings;
+  public PushService(final GrpcService grpcService) {
     this.grpcService = grpcService;
   }
 
@@ -49,29 +42,12 @@ public PushService(final Settings settings, final GrpcService grpcService) {
    * Decorate and push the provided snapshot.
    *
    * @param snapshot the snapshot to push
-   * @param context  the context of where the snapshot is collected
    */
-  public void pushSnapshot(final EventSnapshot snapshot, final ISnapshotContext context) {
-    decorate(snapshot, context);
+  public void pushSnapshot(final EventSnapshot snapshot) {
     final Snapshot grpcSnapshot = PushUtils.convertToGrpc(snapshot);
     this.grpcService.snapshotService().send(grpcSnapshot, new LoggingObserver(snapshot.getID()));
   }
 
-  private void decorate(final EventSnapshot snapshot, final ISnapshotContext context) {
-    final Collection<ISnapshotDecorator> plugins = this.settings.getPlugins(ISnapshotDecorator.class);
-    for (ISnapshotDecorator plugin : plugins) {
-      try {
-        final Resource decorate = plugin.decorate(this.settings, context);
-        if (decorate != null) {
-          snapshot.mergeAttributes(decorate);
-        }
-      } catch (Throwable t) {
-        LOGGER.error("Error processing plugin {}", plugin.getClass().getName());
-      }
-    }
-    snapshot.close();
-  }
-
   static class LoggingObserver implements StreamObserver<SnapshotResponse> {
 
     private final String id;
diff --git a/agent/src/main/java/com/intergral/deep/agent/settings/Settings.java b/agent/src/main/java/com/intergral/deep/agent/settings/Settings.java
index 653eee4..5f0f3b0 100644
--- a/agent/src/main/java/com/intergral/deep/agent/settings/Settings.java
+++ b/agent/src/main/java/com/intergral/deep/agent/settings/Settings.java
@@ -23,6 +23,7 @@
 import com.intergral.deep.agent.api.resource.Resource;
 import com.intergral.deep.agent.api.settings.ISettings;
 import com.intergral.deep.agent.api.spi.IDeepPlugin;
+import com.intergral.deep.agent.types.TracePointConfig.EStage;
 import java.io.FileInputStream;
 import java.io.FileNotFoundException;
 import java.io.IOException;
@@ -182,6 +183,8 @@ public static <T> T coerc(final String str, final Class<T> type) {
       return (T) Level.parse(str);
     } else if (type == Pattern.class) {
       return (T) Pattern.compile(str);
+    } else if (type == EStage.class) {
+      return (T) EStage.fromArg(str);
     } else if (type == URL.class) {
       try {
         return (T) new URL(str);
diff --git a/agent/src/main/java/com/intergral/deep/agent/tracepoint/TracepointConfigService.java b/agent/src/main/java/com/intergral/deep/agent/tracepoint/TracepointConfigService.java
index c62d3c0..cdadaa1 100644
--- a/agent/src/main/java/com/intergral/deep/agent/tracepoint/TracepointConfigService.java
+++ b/agent/src/main/java/com/intergral/deep/agent/tracepoint/TracepointConfigService.java
@@ -39,7 +39,7 @@ public class TracepointConfigService implements ITracepointConfig {
   private final TracepointInstrumentationService tracepointInstrumentationService;
   private String currentHash = null;
   private final Collection<TracePointConfig> customTracepoints = new ArrayList<>();
-  private Collection<TracePointConfig> installedTracepoints = new ArrayList<>();
+  protected Collection<TracePointConfig> installedTracepoints = new ArrayList<>();
   @SuppressWarnings("unused")
   private long lastUpdate;
 
diff --git a/agent/src/main/java/com/intergral/deep/agent/tracepoint/cf/CFFrameProcessor.java b/agent/src/main/java/com/intergral/deep/agent/tracepoint/cf/CFFrameProcessor.java
index c43ca80..f0cd9b9 100644
--- a/agent/src/main/java/com/intergral/deep/agent/tracepoint/cf/CFFrameProcessor.java
+++ b/agent/src/main/java/com/intergral/deep/agent/tracepoint/cf/CFFrameProcessor.java
@@ -38,8 +38,9 @@ public CFFrameProcessor(final Settings settings,
       final IEvaluator evaluator,
       final Map<String, Object> variables,
       final Collection<TracePointConfig> tracePointConfigs,
-      final long[] lineStart, final StackTraceElement[] stack) {
-    super(settings, evaluator, variables, tracePointConfigs, lineStart, stack);
+      final long[] lineStart, final StackTraceElement[] stack,
+      final String methodName) {
+    super(settings, evaluator, variables, tracePointConfigs, lineStart, stack, methodName);
   }
 
   @Override
diff --git a/agent/src/main/java/com/intergral/deep/agent/tracepoint/handler/Callback.java b/agent/src/main/java/com/intergral/deep/agent/tracepoint/handler/Callback.java
index 2b9fa21..b0587d1 100644
--- a/agent/src/main/java/com/intergral/deep/agent/tracepoint/handler/Callback.java
+++ b/agent/src/main/java/com/intergral/deep/agent/tracepoint/handler/Callback.java
@@ -19,23 +19,36 @@
 
 import com.intergral.deep.agent.Utils;
 import com.intergral.deep.agent.api.plugin.IEvaluator;
+import com.intergral.deep.agent.api.plugin.ISnapshotContext;
+import com.intergral.deep.agent.api.plugin.ISnapshotDecorator;
 import com.intergral.deep.agent.api.plugin.ITraceProvider;
 import com.intergral.deep.agent.api.plugin.ITraceProvider.ISpan;
 import com.intergral.deep.agent.api.plugin.LazyEvaluator;
+import com.intergral.deep.agent.api.resource.Resource;
 import com.intergral.deep.agent.push.PushService;
 import com.intergral.deep.agent.settings.Settings;
 import com.intergral.deep.agent.tracepoint.TracepointConfigService;
 import com.intergral.deep.agent.tracepoint.cf.CFEvaluator;
 import com.intergral.deep.agent.tracepoint.cf.CFFrameProcessor;
 import com.intergral.deep.agent.tracepoint.evaluator.EvaluatorService;
+import com.intergral.deep.agent.tracepoint.handler.FrameProcessor.IFactory;
 import com.intergral.deep.agent.types.TracePointConfig;
+import com.intergral.deep.agent.types.TracePointConfig.EStage;
 import com.intergral.deep.agent.types.snapshot.EventSnapshot;
+import com.intergral.deep.agent.types.snapshot.Variable;
+import com.intergral.deep.agent.types.snapshot.VariableID;
+import com.intergral.deep.agent.types.snapshot.WatchResult;
 import java.io.Closeable;
+import java.io.IOException;
+import java.util.ArrayDeque;
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
+import java.util.Collections;
+import java.util.Deque;
 import java.util.List;
 import java.util.Map;
-import java.util.Set;
+import java.util.stream.Collectors;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -47,23 +60,9 @@ public final class Callback {
   private Callback() {
   }
 
-  //    @SuppressWarnings("AnonymousHasLambdaAlternative")
-  //    public static final ThreadLocal<Deque<CallbackHook>> CALLBACKS = new ThreadLocal<Deque<CallbackHook>>()
-  //    {
-  //        @Override
-  //        protected Deque<CallbackHook> initialValue()
-  //        {
-  //            return new ArrayDeque<>();
-  //        }
-  //    };
+  private static final ThreadLocal<Deque<CallbackHook>> CALLBACKS = ThreadLocal.withInitial(ArrayDeque::new);
   private static final Logger LOGGER = LoggerFactory.getLogger(Callback.class);
-  @SuppressWarnings("AnonymousHasLambdaAlternative")
-  private static final ThreadLocal<Boolean> FIRING = new ThreadLocal<Boolean>() {
-    @Override
-    protected Boolean initialValue() {
-      return Boolean.FALSE;
-    }
-  };
+  private static final ThreadLocal<Boolean> FIRING = ThreadLocal.withInitial(() -> Boolean.FALSE);
   private static Settings SETTINGS;
 
   private static TracepointConfigService TRACEPOINT_SERVICE;
@@ -108,7 +107,7 @@ public static void callBackCF(final List<String> bpIds,
       final Map<String, Object> variables) {
     try {
       final IEvaluator evaluator = new LazyEvaluator(new CFEvaluator.Loader(variables));
-      commonCallback(bpIds, filename, lineNo, variables, evaluator, CFFrameProcessor::new);
+      commonCallback(bpIds, filename, lineNo, null, variables, evaluator, CFFrameProcessor::new, null);
     } catch (Throwable t) {
       LOGGER.debug("Unable to process tracepoint {}:{}", filename, lineNo, t);
     }
@@ -129,22 +128,42 @@ public static void callBack(final List<String> bpIds,
       final Map<String, Object> variables) {
     try {
       final IEvaluator evaluator = new LazyEvaluator(EvaluatorService::createEvaluator);
-      commonCallback(bpIds, filename, lineNo, variables, evaluator, FrameProcessor::new);
+      final ICallbackResult callbackResult = commonCallback(bpIds, filename, lineNo, null, variables, evaluator,
+          FrameProcessor::new, null);
+      if (callbackResult != null) {
+        final String spans = callbackResult.tracepoints().stream()
+            .filter(tracePointConfig -> TracePointConfig.LINE.equals(tracePointConfig.getArg(TracePointConfig.SPAN, String.class, null)))
+            .map(TracePointConfig::getId).collect(Collectors.joining(","));
+        final Closeable span;
+        if (!spans.isEmpty()) {
+          span = span(filename + lineNo, spans);
+        } else {
+          span = null;
+        }
+        CALLBACKS.get().add(new CallbackHook(span, callbackResult.deferred(), callbackResult.frameProcessor(),
+            callbackResult.frameProcessor().getLineStart()[1]));
+      }
     } catch (Throwable t) {
       LOGGER.debug("Unable to process tracepoint {}:{}", filename, lineNo, t);
     }
   }
 
 
-  private static void commonCallback(final List<String> tracepointIds,
+  private static ICallbackResult commonCallback(final List<String> tracepointIds,
       final String filename,
       final int lineNo,
+      final String methodName,
       final Map<String, Object> variables,
-      final IEvaluator evaluator, final FrameProcessor.IFactory factory) {
+      final IEvaluator evaluator,
+      final IFactory factory,
+      final CallbackHook callbackHook) {
+    if (tracepointIds.isEmpty()) {
+      return null;
+    }
     final long[] lineStart = Utils.currentTimeNanos();
     if (FIRING.get()) {
       LOGGER.debug("hit - skipping as we are already firing");
-      return;
+      return null;
     }
 
     try {
@@ -153,7 +172,7 @@ private static void commonCallback(final List<String> tracepointIds,
 
       // possible race condition but unlikely
       if (Callback.TRACEPOINT_SERVICE == null) {
-        return;
+        return null;
       }
 
       final Collection<TracePointConfig> tracePointConfigs = Callback.TRACEPOINT_SERVICE.loadTracepointConfigs(
@@ -170,154 +189,122 @@ private static void commonCallback(final List<String> tracepointIds,
           variables,
           tracePointConfigs,
           lineStart,
-          stack);
+          stack,
+          methodName);
 
+      final ArrayList<EventSnapshot> deferredSnapshots = new ArrayList<>();
       if (frameProcessor.canCollect()) {
         frameProcessor.configureSelf();
-
         try {
-          final Collection<EventSnapshot> snapshots = frameProcessor.collect();
-          for (EventSnapshot snapshot : snapshots) {
-            Callback.PUSH_SERVICE.pushSnapshot(snapshot, frameProcessor);
+          final Collection<EventSnapshot> collect = frameProcessor.collect();
+          for (EventSnapshot eventSnapshot : collect) {
+            decorate(eventSnapshot, frameProcessor);
+            if (isDeferred(eventSnapshot)) {
+              deferredSnapshots.add(eventSnapshot);
+              continue;
+            }
+            // if we have a callback hook then decorate snapshot with details
+            if (callbackHook != null) {
+              callbackHook.decorate(eventSnapshot, frameProcessor);
+            }
+            Callback.PUSH_SERVICE.pushSnapshot(eventSnapshot);
           }
         } catch (Exception e) {
           LOGGER.debug("Error processing snapshot", e);
         }
       }
+
+      if (callbackHook != null) {
+        callbackHook.close(Callback.PUSH_SERVICE);
+      }
+      return new ICallbackResult() {
+        @Override
+        public Collection<EventSnapshot> deferred() {
+          return deferredSnapshots;
+        }
+
+        @Override
+        public Collection<TracePointConfig> tracepoints() {
+          return frameProcessor.getFilteredTracepoints();
+        }
+
+        @Override
+        public FrameProcessor frameProcessor() {
+          frameProcessor.closeLookup();
+          return frameProcessor;
+        }
+      };
     } finally {
       FIRING.set(false);
     }
   }
 
-  // the below methods are here as they are called from instrumented classes.
-  // This is a throwback to NV that we will address in later releases
-  public static void callBackException(final Throwable t) {
-    //        System.out.println( "callBackException" );
-    //        try
-    //        {
-    //            LOGGER.debug( "Capturing throwable", t );
-    //            final CallbackHook element = CALLBACKS.get().peekLast();
-    //            if( element != null && element.isHook())
-    //            {
-    //                element.setThrowable( t );
-    //            }
-    //        }
-    //        catch( Throwable tt )
-    //        {
-    //            LOGGER.debug( "Error processing callback", tt );
-    //        }
+  private interface ICallbackResult {
 
+    Collection<EventSnapshot> deferred();
+
+    Collection<TracePointConfig> tracepoints();
+
+    FrameProcessor frameProcessor();
   }
 
+  private static boolean isDeferred(final EventSnapshot eventSnapshot) {
+    final EStage arg = eventSnapshot.getTracepoint().getArg(TracePointConfig.STAGE, EStage.class, null);
+    return arg == EStage.LINE_CAPTURE || arg == EStage.METHOD_CAPTURE;
+  }
 
-  public static void callBackFinally(final Set<String> breakpointIds,
-      final Map<String, Object> map) {
-    //        System.out.println( "callBackFinally" );
-    //        for( String breakpointId : breakpointIds )
-    //        {
-    //            try
-    //            {
-    //                LOGGER.debug( "{}: Processing finally", breakpointId );
-    //                final Deque<CallbackHook> hooks = CALLBACKS.get();
-    //                final CallbackHook pop = hooks.pollLast();
-    //                LOGGER.debug( "Dequeue state: {}", hooks );
-    //                if( pop == null || !pop.isHook() )
-    //                {
-    //                    LOGGER.debug( "No callback pending. {}", pop );
-    //                    continue;
-    //                }
-    //
-    //                final boolean processFrameStack = (pop.value.getType().equals( ITracepoint.STACK_TYPE )) || pop.value.getType()
-    //                        .equals( ITracepoint.FRAME_TYPE ) || pop.value.getType().equals( ITracepoint.LOG_POINT_TYPE )
-    //                        || pop.value.getType().equals( ITracepoint.NO_FRAME_TYPE );
-    //
-    //                final List<IStackFrame> frames;
-    //                if( pop.value.getArg( ITracepoint.LINE_HOOK_ARG_KEY ).equals( ITracepoint.LINE_HOOK_DATA_RIGHT ) )
-    //                {
-    //                    frames = pop.snapshotHandler.processFrames( map, processFrameStack, System.currentTimeMillis() );
-    //                }
-    //                else
-    //                {
-    //                    frames = pop.frames;
-    //                }
-    //
-    //                // trim frames to our type
-    //                @SuppressWarnings({ "RedundantTypeArguments", "Convert2Diamond" })
-    //                final IRequestDecorator iRequestDecorator = pop.snapshotHandler.generateSnapshotData( pop.watchValues, pop.value,
-    //                        frames, Collections.<String>emptySet(),
-    //                        NVError.fromThrowable( pop.throwable, new HashMap<String, String>() ),
-    //                        System.currentTimeMillis(), Callback.CLIENT_CONFIG.getTags() );
-    //
-    //                final EventSnapshot eventSnapshot = iRequestDecorator.getBody();
-    //                addDynamicTags( pop.value, eventSnapshot );
-    //
-    //                sendEvent( iRequestDecorator, eventSnapshot );
-    //            }
-    //            catch( Throwable t )
-    //            {
-    //                LOGGER.debug( "Error processing callback", t );
-    //            }
-    //        }
+  private static void decorate(final EventSnapshot snapshot, final ISnapshotContext context) {
+    final Collection<ISnapshotDecorator> plugins = Callback.SETTINGS.getPlugins(ISnapshotDecorator.class);
+    for (ISnapshotDecorator plugin : plugins) {
+      try {
+        final Resource decorate = plugin.decorate(Callback.SETTINGS, context);
+        if (decorate != null) {
+          snapshot.mergeAttributes(decorate);
+        }
+      } catch (Throwable t) {
+        LOGGER.error("Error processing plugin {}", plugin.getClass().getName());
+      }
+    }
+    snapshot.close();
   }
 
-  //    public static class CallbackHook
-  //    {
-  //
-  //        private final SnapshotHandler snapshotHandler;
-  //        private final List<IWatcherResult> watchValues;
-  //        private final ITracepoint value;
-  //        private final List<IStackFrame> frames;
-  //        private Throwable throwable;
-  //
-  //
-  //        public CallbackHook( final SnapshotHandler snapshotHandler,
-  //                             final List<IWatcherResult> watchValues,
-  //                             final ITracepoint value,
-  //                             final List<IStackFrame> frames )
-  //        {
-  //            this.snapshotHandler = snapshotHandler;
-  //            this.watchValues = watchValues;
-  //            this.value = value;
-  //            this.frames = frames;
-  //        }
-  //
-  //
-  //        public CallbackHook()
-  //        {
-  //            this.snapshotHandler = null;
-  //            this.watchValues = null;
-  //            this.value = null;
-  //            this.frames = null;
-  //        }
-  //
-  //
-  //        /**
-  //         * This will return {@code true} when there is a live hook for this.
-  //         *
-  //         * @return {@code true} if this is a hook else {@code false}.
-  //         */
-  //        public boolean isHook()
-  //        {
-  //            return this.snapshotHandler != null;
-  //        }
-  //
-  //
-  //        void setThrowable( final Throwable t )
-  //        {
-  //            this.throwable = t;
-  //        }
-  //
-  //
-  //        @Override
-  //        public String toString()
-  //        {
-  //            if( value == null )
-  //            {
-  //                return "Marker for non callback";
-  //            }
-  //            return String.format( "%s:%s", value.getRelPath(), value.getLineNo() );
-  //        }
-  //    }
+  /**
+   * This is called when an exception is captured on the visited line.
+   *
+   * @param t the exception that was captured.
+   */
+  public static void callBackException(final Throwable t) {
+    try {
+      LOGGER.debug("Capturing throwable", t);
+      final CallbackHook element = CALLBACKS.get().peekLast();
+      if (element != null) {
+        element.setThrowable(t);
+      }
+    } catch (Throwable tt) {
+      LOGGER.debug("Error processing callback", tt);
+    }
+  }
+
+  /**
+   * This is called when the visited line is completed.
+   *
+   * @param bpIds the tracepoint ids that triggered this
+   * @param filename the source file name
+   * @param lineNo the line number we are on
+   * @param variables the captured local variables
+   */
+  public static void callBackFinally(final List<String> bpIds,
+      final String filename,
+      final int lineNo,
+      final Map<String, Object> variables) {
+    try {
+      final IEvaluator evaluator = new LazyEvaluator(EvaluatorService::createEvaluator);
+      final CallbackHook callbackHook = CALLBACKS.get().pollLast();
+      commonCallback(bpIds, filename, lineNo, null, variables, evaluator, FrameProcessor::new, callbackHook);
+    } catch (Throwable t) {
+      LOGGER.debug("Unable to process tracepoint {}:{}", filename, lineNo, t);
+    }
+  }
 
   /**
    * Create a span using the tracepoint callback.
@@ -328,9 +315,10 @@ public static void callBackFinally(final Set<String> breakpointIds,
    * We use {@link Closeable} here, so we can stick to java types in the injected code. This makes testing and injected code simpler.
    *
    * @param name the name of the span
+   * @param bps  the tracepoints that triggered this span
    * @return a {@link Closeable} to close the span
    */
-  public static Closeable span(final String name) {
+  public static Closeable span(final String name, final String bps) {
     try {
       final ITraceProvider plugin = SETTINGS.getPlugin(ITraceProvider.class);
       if (plugin == null) {
@@ -343,6 +331,7 @@ public static Closeable span(final String name) {
         return () -> {
         };
       }
+      span.addAttribute("tracepoint", bps);
       return () -> {
         try {
           span.close();
@@ -356,4 +345,173 @@ public static Closeable span(final String name) {
       };
     }
   }
+
+  /**
+   * This method is called when a tracepoint has triggered a method entry type.
+   * <p>
+   * This method will <b>Always</b> return a closable. This way the injected code never deals with anything but calling close. Even if close
+   * doesn't do anything.
+   * <p>
+   * We use {@link Closeable} here, so we can stick to java types in the injected code. This makes testing and injected code simpler.
+   *
+   * @param methodName the method name we have entered
+   * @param filename   the file name the method is in
+   * @param lineNo     the line number the method is on
+   * @param bpIds      the tracepoint ids that have been triggered by this entry
+   * @param variables  the map of variables captured
+   * @param spanOnlyIds the CSV of the tracepoints ids that just want a span
+   */
+  public static void methodEntry(final String methodName, final String filename, final int lineNo, final List<String> bpIds,
+      final Map<String, Object> variables, final String spanOnlyIds) {
+    try {
+      final IEvaluator evaluator = new LazyEvaluator(EvaluatorService::createEvaluator);
+      final ICallbackResult callbackResult = commonCallback(bpIds, filename, lineNo, methodName, variables, evaluator,
+          FrameProcessor::new, null);
+      if (callbackResult != null) {
+        final String spans = callbackResult.tracepoints().stream()
+            .filter(tracePointConfig -> TracePointConfig.METHOD.equals(tracePointConfig.getArg(TracePointConfig.SPAN, String.class, null)))
+            .map(TracePointConfig::getId).collect(Collectors.joining(","));
+        final Closeable span;
+        if (!spans.isEmpty()) {
+          span = span(methodName, spans + "," + spanOnlyIds);
+        } else {
+          span = null;
+        }
+        CALLBACKS.get().add(new CallbackHook(span, callbackResult.deferred(), callbackResult.frameProcessor(),
+            callbackResult.frameProcessor().getLineStart()[1]));
+      } else if (spanOnlyIds != null && !spanOnlyIds.isEmpty()) {
+        final Closeable span = span(methodName, spanOnlyIds);
+        CALLBACKS.get().add(new CallbackHook(span, Collections.emptyList(), null, Utils.currentTimeNanos()[1]));
+      } else {
+        // we need a callback as we need to capture error/return
+        // we would only get this far if we are a method exit capture tp
+        CALLBACKS.get().add(new CallbackHook(null, Collections.emptyList(), null, Utils.currentTimeNanos()[1]));
+      }
+
+    } catch (Throwable t) {
+      LOGGER.debug("Unable to process tracepoint {}:{}", filename, lineNo, t);
+    }
+  }
+
+  /**
+   * This is called when an exception is captured from a wrapped method.
+   *
+   * @param t the captured throwable
+   */
+  public static void methodException(final Throwable t) {
+    try {
+      LOGGER.debug("Capturing throwable", t);
+      final CallbackHook element = CALLBACKS.get().peekLast();
+      if (element != null) {
+        element.setThrowable(t);
+      }
+    } catch (Throwable tt) {
+      LOGGER.debug("Error processing callback", tt);
+    }
+  }
+
+  /**
+   * This is called when the returned value from the wrapped method is captured.
+   * <p>
+   * This method is not called on void methods.
+   *
+   * @param value the captured return value.
+   */
+  public static void methodRet(final Object value) {
+    try {
+      LOGGER.debug("Capturing ret: {}", value);
+      final CallbackHook element = CALLBACKS.get().peekLast();
+      if (element != null) {
+        element.setReturn(value);
+      }
+    } catch (Throwable tt) {
+      LOGGER.debug("Error processing callback", tt);
+    }
+  }
+
+  /**
+   * This method is called when a wrapped method has completed.
+   *
+   * @param methodName the method name
+   * @param filename the source file name
+   * @param lineNo the line number
+   * @param bpIds the triggering tracepoints ids
+   * @param variables the captured local variables
+   */
+  public static void methodEnd(final String methodName, final String filename, final int lineNo, final List<String> bpIds,
+      final Map<String, Object> variables) {
+    try {
+      final IEvaluator evaluator = new LazyEvaluator(EvaluatorService::createEvaluator);
+      final CallbackHook callbackHook = CALLBACKS.get().pollLast();
+      commonCallback(bpIds, filename, lineNo, methodName, variables, evaluator, FrameProcessor::new, callbackHook);
+    } catch (Throwable t) {
+      LOGGER.debug("Unable to process tracepoint {}:{}", filename, lineNo, t);
+    }
+  }
+
+  private static class CallbackHook {
+
+    private final Closeable span;
+    private final Collection<EventSnapshot> deferred;
+    private final FrameProcessor frameProcessor;
+    private final long ts;
+    private Throwable throwable;
+    private boolean isSet = false;
+    private Object value;
+
+    public CallbackHook(final Closeable span, final Collection<EventSnapshot> deferred, final FrameProcessor frameProcessor,
+        final long ts) {
+      this.span = span;
+      this.deferred = deferred;
+      this.frameProcessor = frameProcessor;
+      this.ts = ts;
+    }
+
+    public void setThrowable(final Throwable throwable) {
+      this.throwable = throwable;
+    }
+
+    public void setReturn(final Object value) {
+      isSet = true;
+      this.value = value;
+    }
+
+    public void close(final PushService pushService) {
+      if (span != null) {
+        try {
+          span.close();
+        } catch (IOException e) {
+          throw new RuntimeException(e);
+        }
+      }
+
+      for (EventSnapshot eventSnapshot : deferred) {
+        decorate(eventSnapshot, frameProcessor);
+        pushService.pushSnapshot(eventSnapshot);
+      }
+    }
+
+    public void decorate(final EventSnapshot eventSnapshot, final FrameProcessor frameProcessor) {
+      final long nanos = Utils.currentTimeNanos()[1];
+      final long durationNs = nanos - this.ts;
+      if (this.throwable != null) {
+        final List<VariableID> variableIds = frameProcessor.processVars(Collections.singletonMap("thrown", this.throwable));
+        final Map<String, Variable> watchLookup = frameProcessor.closeLookup();
+        eventSnapshot.addWatchResult(new WatchResult("thrown", variableIds.get(0), WatchResult.WATCH));
+        eventSnapshot.mergeVariables(watchLookup);
+      }
+
+      if (this.isSet) {
+        final List<VariableID> variableIds = frameProcessor.processVars(Collections.singletonMap("return", this.value));
+        final Map<String, Variable> watchLookup = frameProcessor.closeLookup();
+        eventSnapshot.addWatchResult(new WatchResult("return", variableIds.get(0), WatchResult.WATCH));
+        eventSnapshot.mergeVariables(watchLookup);
+      }
+
+      final List<VariableID> variableIds = frameProcessor.processVars(Collections.singletonMap("runtime", durationNs));
+      final Map<String, Variable> watchLookup = frameProcessor.closeLookup();
+      eventSnapshot.addWatchResult(new WatchResult("runtime", variableIds.get(0), WatchResult.WATCH));
+      eventSnapshot.mergeVariables(watchLookup);
+    }
+  }
 }
diff --git a/agent/src/main/java/com/intergral/deep/agent/tracepoint/handler/FrameCollector.java b/agent/src/main/java/com/intergral/deep/agent/tracepoint/handler/FrameCollector.java
index 1165b56..924fdf0 100644
--- a/agent/src/main/java/com/intergral/deep/agent/tracepoint/handler/FrameCollector.java
+++ b/agent/src/main/java/com/intergral/deep/agent/tracepoint/handler/FrameCollector.java
@@ -78,6 +78,11 @@ public class FrameCollector extends VariableProcessor {
    */
   private final List<String> jspPackages;
 
+  /**
+   * The name of the method we are wrapping, or {@code null} if not a method wrapped collection.
+   */
+  private final String methodName;
+
   /**
    * Create a frame collector to collect the frame data.
    *
@@ -85,18 +90,21 @@ public class FrameCollector extends VariableProcessor {
    * @param evaluator the evaluator to use for this callback
    * @param variables the variables captured by the callback
    * @param stack     the stack captured by the callback
+   * @param methodName the name of the method we are wrapping, or {@code null} if not a method wrapped collection
    */
   public FrameCollector(
       final Settings settings,
       final IEvaluator evaluator,
       final Map<String, Object> variables,
-      final StackTraceElement[] stack) {
+      final StackTraceElement[] stack,
+      final String methodName) {
     this.settings = settings;
     this.evaluator = evaluator;
     this.variables = variables;
     this.stack = stack;
     this.jspSuffix = settings.getSettingAs(ISettings.JSP_SUFFIX, String.class);
     this.jspPackages = settings.getAsList(ISettings.JSP_PACKAGES);
+    this.methodName = methodName;
   }
 
   /**
@@ -105,6 +113,21 @@ public FrameCollector(
    * @return the result of the process {@link IFrameResult}
    */
   protected IFrameResult processFrame() {
+    // if all tracepoints are no collect then skip collection
+    if (this.frameConfig.isNoCollect()) {
+      return new IFrameResult() {
+        @Override
+        public Collection<StackFrame> frames() {
+          return Collections.emptyList();
+        }
+
+        @Override
+        public Map<String, Variable> variables() {
+          return Collections.emptyMap();
+        }
+      };
+    }
+
     final ArrayList<StackFrame> frames = new ArrayList<>();
 
     for (int i = 0; i < stack.length; i++) {
@@ -356,10 +379,9 @@ protected String getMethodName(final StackTraceElement stackTraceElement,
    * <p>
    * So if we cannot get a result from the {@link IEvaluator} then we return an error result.
    *
-   * @param watch the watch expression to evaluate
+   * @param watch  the watch expression to evaluate
    * @param source the source of the watch expression
    * @return a {@link IExpressionResult}
-   *
    * @see WatchResult#LOG
    * @see WatchResult#METRIC
    * @see WatchResult#WATCH
@@ -460,6 +482,10 @@ protected Resource processAttributes(final TracePointConfig tracepoint) {
     attributes.put("stack", tracepoint.getStackType());
     attributes.put("frame", tracepoint.getFrameType());
 
+    if (this.methodName != null) {
+      attributes.put("method_name", this.methodName);
+    }
+
     if (!tracepoint.getWatches().isEmpty()) {
       attributes.put("has_watches", true);
     }
diff --git a/agent/src/main/java/com/intergral/deep/agent/tracepoint/handler/FrameConfig.java b/agent/src/main/java/com/intergral/deep/agent/tracepoint/handler/FrameConfig.java
index c3bc06d..c9e29a3 100644
--- a/agent/src/main/java/com/intergral/deep/agent/tracepoint/handler/FrameConfig.java
+++ b/agent/src/main/java/com/intergral/deep/agent/tracepoint/handler/FrameConfig.java
@@ -41,6 +41,7 @@ public class FrameConfig {
   private int maxWatchVars = -1;
   private int maxTpProcessTime = -1;
 
+  private boolean noCollect = true;
   private boolean cfRaw = false;
 
   /**
@@ -62,6 +63,11 @@ public void process(final TracePointConfig tracePointConfig) {
     maxTpProcessTime = Math.max(tracePointConfig.getArg("MAX_TP_PROCESS_TIME", Integer.class, -1),
         maxTpProcessTime);
 
+    // if any tracepoint is set to collect then we need to collect
+    if (tracePointConfig.getArg(TracePointConfig.SNAPSHOT, String.class, TracePointConfig.COLLECT).equals(TracePointConfig.COLLECT)) {
+      noCollect = false;
+    }
+
     final String frameType = tracePointConfig.getFrameType();
     if (frameType != null) {
       if (this.frameType == null) {
@@ -157,12 +163,15 @@ public int maxCollectionSize() {
   }
 
   /**
-   * Is this frame set to cf raw.
-   * cf raw allows the collection of the java variables instead of the mapped cf variables.
+   * Is this frame set to cf raw. cf raw allows the collection of the java variables instead of the mapped cf variables.
    *
    * @return {@code true} if we want to collect the raw cf variables.
    */
   public boolean isCfRaw() {
     return this.cfRaw;
   }
+
+  public boolean isNoCollect() {
+    return noCollect;
+  }
 }
diff --git a/agent/src/main/java/com/intergral/deep/agent/tracepoint/handler/FrameProcessor.java b/agent/src/main/java/com/intergral/deep/agent/tracepoint/handler/FrameProcessor.java
index ec95f07..1f7f063 100644
--- a/agent/src/main/java/com/intergral/deep/agent/tracepoint/handler/FrameProcessor.java
+++ b/agent/src/main/java/com/intergral/deep/agent/tracepoint/handler/FrameProcessor.java
@@ -73,13 +73,15 @@ public class FrameProcessor extends FrameCollector implements ISnapshotContext {
    * @param tracePointConfigs the tracepoints that are part of this Callback
    * @param lineStart         the Tuple of the time this Callback started
    * @param stack             the stack trace to use
+   * @param methodName        the name of the method we are wrapping, or {@code null} if not a method wrapped collection
    */
   public FrameProcessor(final Settings settings,
       final IEvaluator evaluator,
       final Map<String, Object> variables,
       final Collection<TracePointConfig> tracePointConfigs,
-      final long[] lineStart, final StackTraceElement[] stack) {
-    super(settings, evaluator, variables, stack);
+      final long[] lineStart, final StackTraceElement[] stack,
+      final String methodName) {
+    super(settings, evaluator, variables, stack, methodName);
     this.tracePointConfigs = tracePointConfigs;
     this.lineStart = lineStart;
   }
@@ -137,6 +139,9 @@ public Collection<EventSnapshot> collect() {
     final IFrameResult processedFrame = processFrame();
 
     for (final TracePointConfig tracepoint : filteredTracepoints) {
+      final boolean doCollect = TracePointConfig.COLLECT.equals(
+          tracepoint.getArg(TracePointConfig.SNAPSHOT, String.class, TracePointConfig.COLLECT));
+
       try {
         final EventSnapshot snapshot = new EventSnapshot(tracepoint,
             this.lineStart[1],
@@ -144,38 +149,54 @@ public Collection<EventSnapshot> collect() {
             processedFrame.frames(),
             processedFrame.variables());
 
-        for (String watch : tracepoint.getWatches()) {
-          final FrameCollector.IExpressionResult result = evaluateWatchExpression(watch, WatchResult.WATCH);
-          snapshot.addWatchResult(result.result());
-          snapshot.mergeVariables(result.variables());
+        // do not process watches if we are not a collecting tracepoint
+        if (doCollect) {
+          for (String watch : tracepoint.getWatches()) {
+            final FrameCollector.IExpressionResult result = evaluateWatchExpression(watch, WatchResult.WATCH);
+            snapshot.addWatchResult(result.result());
+            snapshot.mergeVariables(result.variables());
+          }
         }
 
+        // always process log message
         final String logMsg = tracepoint.getArg(TracePointConfig.LOG_MSG, String.class, null);
         if (logMsg != null) {
           final ILogProcessResult result = this.processLogMsg(tracepoint, logMsg);
-          snapshot.setLogMsg(result.processedLog());
-          for (WatchResult watchResult : result.result()) {
-            snapshot.addWatchResult(watchResult);
+          // only collect data if we are a collection tracepoint
+          if (doCollect) {
+            snapshot.setLogMsg(result.processedLog());
+            for (WatchResult watchResult : result.result()) {
+              snapshot.addWatchResult(watchResult);
+            }
+            snapshot.mergeVariables(result.variables());
           }
-          snapshot.mergeVariables(result.variables());
           this.logTracepoint(result.processedLog(), tracepoint.getId(), snapshot.getID());
         }
 
+        // always process metrics
         final Collection<MetricDefinition> metricDefinitions = tracepoint.getMetricDefinitions();
         if (!metricDefinitions.isEmpty()) {
           for (MetricDefinition metricDefinition : metricDefinitions) {
             final List<FrameCollector.IExpressionResult> watchResults = processMetric(tracepoint, metricDefinition);
-            for (FrameCollector.IExpressionResult watchResult : watchResults) {
-              snapshot.addWatchResult(watchResult.result());
-              snapshot.mergeVariables(watchResult.variables());
+            // only collect data if we are a collection tracepoint
+            if (doCollect) {
+              for (FrameCollector.IExpressionResult watchResult : watchResults) {
+                snapshot.addWatchResult(watchResult.result());
+                snapshot.mergeVariables(watchResult.variables());
+              }
             }
           }
         }
+        // if we are not a collection tracepoint, then record fire and continue. Do not collect.
+        if (!doCollect) {
+          tracepoint.fired(this.lineStart[0]);
+          continue;
+        }
 
         final Resource attributes = processAttributes(tracepoint);
         snapshot.mergeAttributes(attributes);
-
         snapshots.add(snapshot);
+
         tracepoint.fired(this.lineStart[0]);
       } catch (Exception e) {
         throw new RuntimeException(e);
@@ -276,6 +297,14 @@ public IReflection reflectionService() {
     return Reflection.getInstance();
   }
 
+  public Collection<TracePointConfig> getFilteredTracepoints() {
+    return filteredTracepoints;
+  }
+
+  public long[] getLineStart() {
+    return lineStart;
+  }
+
   /**
    * This defines a functional interface to allow for creating difference processors in the Callback.
    */
@@ -290,12 +319,13 @@ public interface IFactory {
      * @param tracePointConfigs the tracepoints that are part of this Callback
      * @param lineStart         the Tuple of the time this Callback started
      * @param stack             the stack trace to use
+     * @param methodName        the name of the method we are wrapping, or {@code null} if not a method wrapped collection
      * @return the new {@link FrameProcessor}
      * @see FrameProcessor
      * @see com.intergral.deep.agent.tracepoint.cf.CFFrameProcessor
      */
-    FrameProcessor provide(Settings settings, IEvaluator evaluator, Map<String, Object> variables,
-        Collection<TracePointConfig> tracePointConfigs, long[] lineStart,
-        StackTraceElement[] stack);
+    FrameProcessor provide(final Settings settings, final IEvaluator evaluator, final Map<String, Object> variables,
+        final Collection<TracePointConfig> tracePointConfigs, final long[] lineStart,
+        final StackTraceElement[] stack, final String methodName);
   }
 }
diff --git a/agent/src/main/java/com/intergral/deep/agent/tracepoint/inst/asm/Visitor.java b/agent/src/main/java/com/intergral/deep/agent/tracepoint/inst/asm/Visitor.java
index 3b55320..0a51715 100644
--- a/agent/src/main/java/com/intergral/deep/agent/tracepoint/inst/asm/Visitor.java
+++ b/agent/src/main/java/com/intergral/deep/agent/tracepoint/inst/asm/Visitor.java
@@ -32,9 +32,7 @@
 import static org.objectweb.asm.Opcodes.FSTORE;
 import static org.objectweb.asm.Opcodes.GETSTATIC;
 import static org.objectweb.asm.Opcodes.GOTO;
-import static org.objectweb.asm.Opcodes.IFNULL;
 import static org.objectweb.asm.Opcodes.ILOAD;
-import static org.objectweb.asm.Opcodes.INVOKEINTERFACE;
 import static org.objectweb.asm.Opcodes.INVOKESPECIAL;
 import static org.objectweb.asm.Opcodes.INVOKESTATIC;
 import static org.objectweb.asm.Opcodes.INVOKEVIRTUAL;
@@ -47,7 +45,9 @@
 import static org.objectweb.asm.Opcodes.RETURN;
 
 import com.google.common.collect.Sets;
+import com.intergral.deep.agent.tracepoint.inst.asm.Visitor.MappedMethod.MappedVar;
 import com.intergral.deep.agent.types.TracePointConfig;
+import com.intergral.deep.agent.types.TracePointConfig.EStage;
 import java.com.intergral.deep.ProxyCallback;
 import java.io.PrintWriter;
 import java.io.StringWriter;
@@ -55,11 +55,12 @@
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.HashMap;
-import java.util.HashSet;
 import java.util.List;
 import java.util.ListIterator;
 import java.util.Map;
 import java.util.Set;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.stream.Collectors;
 import org.objectweb.asm.ClassVisitor;
 import org.objectweb.asm.Label;
 import org.objectweb.asm.MethodVisitor;
@@ -351,11 +352,11 @@ static int replacedMethodAcc(final boolean isStatic) {
 
   @Override
   public MethodVisitor visitMethod(int access, String name, String desc, String signature,
-      String[] exceptions) {
+      String[] exps) {
 
     // if the method is abstract then we cannot inject tracepoints - so skip it
     if (TransformerUtils.isAbstract(access)) {
-      return super.visitMethod(access, name, desc, signature, exceptions);
+      return super.visitMethod(access, name, desc, signature, exps);
     }
 
     LOGGER.debug("visitMethod {} {}", classname, name);
@@ -363,27 +364,45 @@ public MethodVisitor visitMethod(int access, String name, String desc, String si
     // if we have a method tracepoint for this method name then rename the method
     final String methodName;
     final int methodAccess;
+    // we use atomic as we have to update this later
+    final AtomicBoolean isMapped = new AtomicBoolean(false);
     final List<TracePointConfig> tracePointConfigs = this.methodBPs.get(name);
+    final MappedMethod mappedMethod = new MappedMethod(access, name, desc, signature, exps, -1);
     // if we have a method tracepoint for this method name then rename the method.
     if (tracePointConfigs != null) {
       // rename the method and make it private synthetic $deep$..
       methodName = determineNewMethodName(name);
       methodAccess = replacedMethodAcc(TransformerUtils.isStatic(access));
       // record the change so we can fix them up later
-      this.mappedMethods.add(new MappedMethod(access, name, desc, signature, exceptions));
+      this.mappedMethods.add(mappedMethod);
+      isMapped.set(true);
     } else {
       methodName = name;
       methodAccess = access;
     }
 
-    final MethodVisitor methodVisitor = super.visitMethod(methodAccess, methodName, desc, signature,
-        exceptions);
-    final JSRInlinerAdapter jsrInlinerAdapter = new JSRInlinerAdapter(methodVisitor, methodAccess, methodName,
-        desc, signature,
-        exceptions);
-
     // MethodNode used to handle the maxes for us to make it simpler
-    return new MethodNode(ASM7, methodAccess, methodName, desc, signature, exceptions) {
+    return new MethodNode(ASM7, methodAccess, methodName, desc, signature, exps) {
+
+      Label startLabel;
+
+      @Override
+      public void visitLocalVariable(final String name, final String descriptor, final String signature, final Label start, final Label end,
+          final int index) {
+        if (startLabel != null && startLabel.equals(start)) {
+          mappedMethod.acceptVariable(name, descriptor, index);
+        }
+        super.visitLocalVariable(name, descriptor, signature, start, end, index);
+      }
+
+      @Override
+      public void visitLineNumber(final int line, final Label start) {
+        mappedMethod.acceptLine(line);
+        if (startLabel == null) {
+          startLabel = start;
+        }
+        super.visitLineNumber(line, start);
+      }
 
       @Override
       public void visitEnd() {
@@ -398,6 +417,7 @@ public void visitEnd() {
 
         // the start label for the line to wrap
         LabelNode start = null;
+        LineNumberNode ln = null;
 
         // we need to handle constructors a little differently
         final boolean isConstructor = name.equals("<init>");
@@ -479,21 +499,31 @@ public void visitEnd() {
             }
             hook.add(new LabelNode(endOfTry));
 
-            // set = new HashSet()
-            hook.add(new TypeInsnNode(NEW, Type.getInternalName(HashSet.class)));
+            // list = new ArrayList()
+            hook.add(new TypeInsnNode(NEW, Type.getInternalName(ArrayList.class)));
             hook.add(new InsnNode(DUP));
             hook.add(
-                new MethodInsnNode(INVOKESPECIAL, Type.getInternalName(HashSet.class), "<init>",
+                new MethodInsnNode(INVOKESPECIAL, Type.getInternalName(ArrayList.class), "<init>",
                     "()V", false));
 
             for (final TracePointConfig bp : iBreakpoints) {
-              // set.add(bp.getId());
+              if (!bp.acceptStage(EStage.LINE_END)) {
+                continue;
+              }
+              // list.add(bp.getId());
               hook.add(new InsnNode(DUP)); // we need a ptr to our map
               hook.add(new LdcInsnNode(bp.getId())); // bp id
-              hook.add(new MethodInsnNode(INVOKEVIRTUAL, Type.getInternalName(HashSet.class), "add",
+              hook.add(new MethodInsnNode(INVOKEVIRTUAL, Type.getInternalName(ArrayList.class), "add",
                   "(Ljava/lang/Object;)Z"));
               hook.add(new InsnNode(POP)); // dont care about return
             }
+
+            hook.add(new LdcInsnNode(filename));
+            if (ln != null) {
+              hook.add(new LdcInsnNode(ln.line));
+            } else {
+              hook.add(new LdcInsnNode(-1));
+            }
             // if we are a next line then we need to remove the start line label from the seen labels so
             // the variable capture in the finally does not capture variables defined on the line we are wrapping
             if (isNextLine) {
@@ -510,7 +540,9 @@ public void visitEnd() {
                 Type.getInternalName(CALLBACK_CLASS),
                 "callBackFinally",
                 Type.getMethodDescriptor(Type.VOID_TYPE,
-                    Type.getType(Set.class),
+                    Type.getType(List.class),
+                    Type.getType(String.class),
+                    Type.getType(int.class),
                     Type.getType(Map.class)),
                 false));
             if (isReturnNode) {
@@ -590,20 +622,30 @@ public void visitEnd() {
             hook.add(new LabelNode(endCatch));
 
             // set = new HashSet()
-            hook.add(new TypeInsnNode(NEW, Type.getInternalName(HashSet.class)));
+            hook.add(new TypeInsnNode(NEW, Type.getInternalName(ArrayList.class)));
             hook.add(new InsnNode(DUP));
             hook.add(
-                new MethodInsnNode(INVOKESPECIAL, Type.getInternalName(HashSet.class), "<init>",
+                new MethodInsnNode(INVOKESPECIAL, Type.getInternalName(ArrayList.class), "<init>",
                     "()V", false));
 
             for (final TracePointConfig bp : iBreakpoints) {
+              if (!bp.acceptStage(EStage.LINE_END)) {
+                continue;
+              }
               // set.add(bp.getId());
               hook.add(new InsnNode(DUP)); // we need a ptr to our map
               hook.add(new LdcInsnNode(bp.getId())); // bp id
-              hook.add(new MethodInsnNode(INVOKEVIRTUAL, Type.getInternalName(HashSet.class), "add",
+              hook.add(new MethodInsnNode(INVOKEVIRTUAL, Type.getInternalName(ArrayList.class), "add",
                   "(Ljava/lang/Object;)Z"));
               hook.add(new InsnNode(POP)); // don't care about return
             }
+
+            hook.add(new LdcInsnNode(filename));
+            if (ln != null) {
+              hook.add(new LdcInsnNode(ln.line));
+            } else {
+              hook.add(new LdcInsnNode(-1));
+            }
             // if we are a next line then we need to remove the start line label from the seen labels so
             // the variable capture in the finally does not capture variables defined on the line we are wrapping
             if (isNextLine) {
@@ -619,7 +661,9 @@ public void visitEnd() {
                 Type.getInternalName(CALLBACK_CLASS),
                 "callBackFinally",
                 Type.getMethodDescriptor(Type.VOID_TYPE,
-                    Type.getType(Set.class),
+                    Type.getType(List.class),
+                    Type.getType(String.class),
+                    Type.getType(int.class),
                     Type.getType(Map.class)),
                 false));
             // load exception back
@@ -664,7 +708,7 @@ public void visitEnd() {
 
           if (node.getType() == AbstractInsnNode.LINE) {
             //noinspection DataFlowIssue
-            LineNumberNode ln = (LineNumberNode) node;
+            ln = (LineNumberNode) node;
             // if we are a constructor and have not called super yet - the cache the line for later
             if (isConstructor && !hasCalledSuper) {
               constructorLine = ln;
@@ -679,10 +723,33 @@ public void visitEnd() {
               // but we might need to use them in forth coming instructions for line end etc
               iBreakpoints.clear();
               iBreakpoints.addAll(thisLineBps);
+              // if we are not already mapped then check if we need to map it
+              if (!isMapped.get()) {
+                // do we need to wrap the method later
+                final List<TracePointConfig> collect = thisLineBps.stream().filter(
+                        tracePointConfig -> TracePointConfig.METHOD.equals(tracePointConfig.getArg(TracePointConfig.SPAN, String.class, null)))
+                    .collect(Collectors.toList());
+                if (!collect.isEmpty()) {
+                  // we have a tracepoint on this line that is set to 'method' span type. So add the method to the mapped methods, then rename this method.
+                  Visitor.this.mappedMethods.add(mappedMethod);
+                  // track the mapped tracepoints, so we can pass them back later
+                  final List<TracePointConfig> mappedTps = Visitor.this.methodBPs.computeIfAbsent(this.name,
+                      k -> new ArrayList<>());
+                  mappedTps.addAll(collect);
+
+                  // rename the method and make it private synthetic $deep$..
+                  this.name = determineNewMethodName(name);
+                  this.access = replacedMethodAcc(TransformerUtils.isStatic(access));
+
+                  // set is mapped so we do not check again
+                  isMapped.set(true);
+                }
+              }
             }
 
             // check if we have any Bps for the constructor
             if (constructorLine != null) {
+              // todo  how do we want to deal with method entry in constructors
               // add any bps for the constructor call into the list to be processed
               final List<TracePointConfig> constructorBps = lineNos.remove(
                   (long) constructorLine.line);
@@ -720,6 +787,13 @@ public void visitEnd() {
           }
         }
 
+        // now apply the modified instructions using the original class writer
+        final MethodVisitor methodVisitor = Visitor.this.cv.visitMethod(this.access, this.name, desc, signature,
+            exps);
+        final JSRInlinerAdapter jsrInlinerAdapter = new JSRInlinerAdapter(methodVisitor, this.access, this.name,
+            desc, signature,
+            exps);
+
         this.accept(jsrInlinerAdapter);
 
         super.visitEnd();
@@ -751,6 +825,9 @@ private InsnList getAbstractInsnNodes(final Set<Label> seenLabels,
             "()V", false));
 
         for (final TracePointConfig bp : breakpoints) {
+          if (!bp.acceptStage(EStage.LINE_START)) {
+            continue;
+          }
           // list.add(bp.getId());
           hook.add(new InsnNode(DUP)); // we need a ptr to our map
           hook.add(new LdcInsnNode(bp.getId())); // bp id
@@ -872,139 +949,321 @@ public void visitEnd() {
       } else {
         createMappedReturnMethod(mappedMethod);
       }
+      changed = true;
     }
+
     super.visitEnd();
   }
 
   private void createMappedReturnMethod(final MappedMethod mappedMethod) {
+
+    final List<TracePointConfig> breakpoints = this.methodBPs.get(mappedMethod.name);
+
     final MethodVisitor methodVisitor = this.cv.visitMethod(mappedMethod.access, mappedMethod.name, mappedMethod.desc, mappedMethod.sign,
         mappedMethod.excp);
     final Type[] argumentTypes = Type.getArgumentTypes(mappedMethod.desc);
     final int offset = argumentTypes.length;
     final Type returnType = Type.getReturnType(mappedMethod.desc);
 
-    methodVisitor.visitCode();
+    // setup try/catch label blocks
     Label label0 = new Label();
     Label label1 = new Label();
     Label label2 = new Label();
-    methodVisitor.visitTryCatchBlock(label0, label1, label2, "java/io/IOException");
+    methodVisitor.visitTryCatchBlock(label0, label1, label2, "java/lang/Throwable");
     Label label3 = new Label();
+    methodVisitor.visitTryCatchBlock(label0, label1, label3, null);
     Label label4 = new Label();
-    methodVisitor.visitTryCatchBlock(label3, label0, label4, null);
-    Label label5 = new Label();
-    Label label6 = new Label();
-    Label label7 = new Label();
-    methodVisitor.visitTryCatchBlock(label5, label6, label7, "java/io/IOException");
-    methodVisitor.visitTryCatchBlock(label4, label5, label4, null);
+    methodVisitor.visitTryCatchBlock(label2, label4, label3, null);
 
-    Label label8 = new Label();
-    methodVisitor.visitLabel(label8);
+    Label label5 = new Label();
+    methodVisitor.visitLabel(label5);
     if (TransformerUtils.ALLOW_LINE_NUMBERS) {
-      methodVisitor.visitLineNumber(49 + TransformerUtils.LINE_OFFSET, label8);
+      methodVisitor.visitLineNumber(70 + TransformerUtils.LINE_OFFSET, label5);
     }
-    methodVisitor.visitLdcInsn(mappedMethod.name);
-    methodVisitor.visitMethodInsn(INVOKESTATIC, Type.getInternalName(CALLBACK_CLASS), "span",
-        "(Ljava/lang/String;)Ljava/io/Closeable;", false);
-    methodVisitor.visitVarInsn(ASTORE, 1 + offset);
-    methodVisitor.visitLabel(label3);
+
+    //methodName = "intTemplate()I"
+    methodVisitor.visitLdcInsn(mappedMethod.name + mappedMethod.desc);
+    // filename = "MockMixinTemplate.java"
+    methodVisitor.visitLdcInsn(filename);
+    // lineNo = 79
+    methodVisitor.visitLdcInsn(mappedMethod.line);
+    // list = new ArrayList();
+    methodVisitor.visitTypeInsn(NEW, Type.getInternalName(ArrayList.class));
+    methodVisitor.visitInsn(DUP);
+    methodVisitor.visitMethodInsn(INVOKESPECIAL, Type.getInternalName(ArrayList.class), "<init>", "()V", false);
+
+    final StringBuilder spanOnlyIds = new StringBuilder();
+    for (final TracePointConfig bp : breakpoints) {
+      if (!bp.acceptStage(EStage.METHOD_START)) {
+        if (TracePointConfig.METHOD.equals(bp.getArg(TracePointConfig.SPAN, String.class, null))) {
+          spanOnlyIds.append(bp.getId()).append(",");
+        }
+        continue;
+      }
+      // list.add(bp.getId());
+      methodVisitor.visitInsn(DUP);
+      methodVisitor.visitLdcInsn(bp.getId());
+      methodVisitor.visitMethodInsn(INVOKEVIRTUAL, Type.getInternalName(ArrayList.class), "add",
+          "(Ljava/lang/Object;)Z", false);
+      methodVisitor.visitInsn(POP); // dont care about return
+    }
+
+    // Make a map of locals
+    // vars = new HashMap()
+    processMethodArguments(mappedMethod.access, mappedMethod.vars, methodVisitor); // attach ids of tracepoints that just want a span crated
+    if (spanOnlyIds.length() > 0) {
+      spanOnlyIds.deleteCharAt(spanOnlyIds.length() - 1);
+    }
+    methodVisitor.visitLdcInsn(spanOnlyIds.toString());
+
+    // Callback.methodEntry(mehodName, filename, lineNo, list, vars);
+    methodVisitor.visitMethodInsn(INVOKESTATIC, Type.getInternalName(CALLBACK_CLASS), "methodEntry",
+        Type.getMethodDescriptor(Type.VOID_TYPE,
+            Type.getType(String.class),
+            Type.getType(String.class),
+            Type.getType(int.class),
+            Type.getType(List.class),
+            Type.getType(Map.class),
+            Type.getType(String.class)), false);
+
+    // try {
+    methodVisitor.visitLabel(label0);
     if (TransformerUtils.ALLOW_LINE_NUMBERS) {
-      methodVisitor.visitLineNumber(51 + TransformerUtils.LINE_OFFSET, label3);
+      methodVisitor.visitLineNumber(72 + TransformerUtils.LINE_OFFSET, label0);
     }
-    // load 'this'
-    methodVisitor.visitVarInsn(ALOAD, 0);
-    // load all the parameters
+    // i = this.$deep$intTemplate()
+    methodVisitor.visitVarInsn(ALOAD, 0); // load all the parameters
     for (int i = 0; i < argumentTypes.length; i++) {
       final Type argumentType = argumentTypes[i];
       methodVisitor.visitVarInsn(argumentType.getOpcode(ILOAD), i + 1);
     }
-    // call original method with all parameters
     methodVisitor.visitMethodInsn(INVOKEVIRTUAL, this.classname, determineNewMethodName(mappedMethod.name), mappedMethod.desc,
         false);
-    methodVisitor.visitVarInsn(returnType.getOpcode(ISTORE), 2 + offset);
-    methodVisitor.visitLabel(label0);
+    methodVisitor.visitVarInsn(returnType.getOpcode(ISTORE), 1 + offset);
+
+    Label label6 = new Label();
+    methodVisitor.visitLabel(label6);
     if (TransformerUtils.ALLOW_LINE_NUMBERS) {
-      methodVisitor.visitLineNumber(54 + TransformerUtils.LINE_OFFSET, label0);
+      methodVisitor.visitLineNumber(73 + TransformerUtils.LINE_OFFSET, label6);
     }
-    methodVisitor.visitVarInsn(ALOAD, 1 + offset);
-    methodVisitor.visitJumpInsn(IFNULL, label1);
-    Label label9 = new Label();
-    methodVisitor.visitLabel(label9);
+    // ret = new Integer(i);
+    final InsnList abstractInsnNodes = loadVariable(returnType, 1 + offset);
+    appendToVisitor(methodVisitor, abstractInsnNodes);
+
+    // Callback.methodRet(ret);
+    methodVisitor.visitMethodInsn(INVOKESTATIC, Type.getInternalName(CALLBACK_CLASS), "methodRet",
+        Type.getMethodDescriptor(Type.VOID_TYPE, Type.getType(Object.class)), false);
+    // -- start good finally (ie the code in the finally block is run here if there is no exception)
+    Label label7 = new Label();
+    methodVisitor.visitLabel(label7);
     if (TransformerUtils.ALLOW_LINE_NUMBERS) {
-      methodVisitor.visitLineNumber(55 + TransformerUtils.LINE_OFFSET, label9);
+      methodVisitor.visitLineNumber(74 + TransformerUtils.LINE_OFFSET, label7);
     }
-    methodVisitor.visitVarInsn(ALOAD, 1 + offset);
-    methodVisitor.visitMethodInsn(INVOKEINTERFACE, "java/io/Closeable", "close", "()V", true);
+    // load and store ret
+    // ret2 = ret;
+    methodVisitor.visitVarInsn(returnType.getOpcode(ILOAD), 1 + offset);
+    methodVisitor.visitVarInsn(returnType.getOpcode(ISTORE), 2 + offset);
     methodVisitor.visitLabel(label1);
+
     if (TransformerUtils.ALLOW_LINE_NUMBERS) {
-      methodVisitor.visitLineNumber(59 + TransformerUtils.LINE_OFFSET, label1);
+      methodVisitor.visitLineNumber(79 + TransformerUtils.LINE_OFFSET, label1);
     }
 
-    Label label10 = new Label();
-    methodVisitor.visitJumpInsn(GOTO, label10);
-    methodVisitor.visitLabel(label2);
-    if (TransformerUtils.ALLOW_LINE_NUMBERS) {
-      methodVisitor.visitLineNumber(57 + TransformerUtils.LINE_OFFSET, label2);
+    //methodName = "intTemplate()I"
+    methodVisitor.visitLdcInsn(mappedMethod.name + mappedMethod.desc);
+    // filename = "MockMixinTemplate.java"
+    methodVisitor.visitLdcInsn(filename);
+    // lineNo = 79
+    methodVisitor.visitLdcInsn(mappedMethod.line);
+    // list = new ArrayList();
+    methodVisitor.visitTypeInsn(NEW, Type.getInternalName(ArrayList.class));
+    methodVisitor.visitInsn(DUP);
+    methodVisitor.visitMethodInsn(INVOKESPECIAL, Type.getInternalName(ArrayList.class), "<init>", "()V", false);
+
+    for (final TracePointConfig bp : breakpoints) {
+      if (!bp.acceptStage(EStage.METHOD_END)) {
+        continue;
+      }
+      // list.add(bp.getId());
+      methodVisitor.visitInsn(DUP);
+      methodVisitor.visitLdcInsn(bp.getId());
+      methodVisitor.visitMethodInsn(INVOKEVIRTUAL, Type.getInternalName(ArrayList.class), "add",
+          "(Ljava/lang/Object;)Z", false);
+      methodVisitor.visitInsn(POP); // dont care about return
     }
 
-    methodVisitor.visitVarInsn(ASTORE, 3 + offset);
-    methodVisitor.visitLabel(label10);
+    // Make a map of locals
+    // vars = new HashMap()
+    processMethodArguments(mappedMethod.access, mappedMethod.vars, methodVisitor);
+    methodVisitor.visitMethodInsn(INVOKESTATIC, Type.getInternalName(CALLBACK_CLASS), "methodEnd",
+        Type.getMethodDescriptor(Type.VOID_TYPE,
+            Type.getType(String.class),
+            Type.getType(String.class),
+            Type.getType(int.class),
+            Type.getType(List.class),
+            Type.getType(Map.class)), false);
+
+    // reload ret and return
+    Label label8 = new Label();
+    methodVisitor.visitLabel(label8);
+
     if (TransformerUtils.ALLOW_LINE_NUMBERS) {
-      methodVisitor.visitLineNumber(51 + TransformerUtils.LINE_OFFSET, label10);
+      methodVisitor.visitLineNumber(74 + TransformerUtils.LINE_OFFSET, label8);
     }
-
-    // change return/load opcodes based on return type of method
+    // return ret2;
     methodVisitor.visitVarInsn(returnType.getOpcode(ILOAD), 2 + offset);
     methodVisitor.visitInsn(returnType.getOpcode(IRETURN));
-
-    methodVisitor.visitLabel(label4);
+    methodVisitor.visitLabel(label2);
+    // catch block
     if (TransformerUtils.ALLOW_LINE_NUMBERS) {
-      methodVisitor.visitLineNumber(53 + TransformerUtils.LINE_OFFSET, label4);
+      methodVisitor.visitLineNumber(75 + TransformerUtils.LINE_OFFSET, label2);
     }
+    // throwable = thrownException (store thrown exception into slot 1)
+    methodVisitor.visitVarInsn(ASTORE, 1 + offset);
+    Label label9 = new Label();
+    methodVisitor.visitLabel(label9);
 
-    methodVisitor.visitVarInsn(ASTORE, 4 + offset);
-    methodVisitor.visitLabel(label5);
     if (TransformerUtils.ALLOW_LINE_NUMBERS) {
-      methodVisitor.visitLineNumber(54 + TransformerUtils.LINE_OFFSET, label5);
+      methodVisitor.visitLineNumber(76 + TransformerUtils.LINE_OFFSET, label9);
     }
+    // t = throwable
     methodVisitor.visitVarInsn(ALOAD, 1 + offset);
-    methodVisitor.visitJumpInsn(IFNULL, label6);
-    Label label11 = new Label();
-    methodVisitor.visitLabel(label11);
+    // Callback.methodException(t)
+    methodVisitor.visitMethodInsn(INVOKESTATIC, Type.getInternalName(CALLBACK_CLASS), "methodException",
+        Type.getMethodDescriptor(Type.VOID_TYPE, Type.getType(Throwable.class)), false);
+
+    Label label10 = new Label();
+    methodVisitor.visitLabel(label10);
     if (TransformerUtils.ALLOW_LINE_NUMBERS) {
-      methodVisitor.visitLineNumber(55 + TransformerUtils.LINE_OFFSET, label11);
+      methodVisitor.visitLineNumber(77 + TransformerUtils.LINE_OFFSET, label10);
     }
+    // throw t;
     methodVisitor.visitVarInsn(ALOAD, 1 + offset);
-    methodVisitor.visitMethodInsn(INVOKEINTERFACE, "java/io/Closeable", "close", "()V", true);
-    methodVisitor.visitLabel(label6);
+    methodVisitor.visitInsn(ATHROW);
+
+    // -- start bad finally (ie the finally block when an exception was thrown)
+    methodVisitor.visitLabel(label3);
     if (TransformerUtils.ALLOW_LINE_NUMBERS) {
-      methodVisitor.visitLineNumber(59 + TransformerUtils.LINE_OFFSET, label6);
+      methodVisitor.visitLineNumber(79 + TransformerUtils.LINE_OFFSET, label3);
     }
+    // store thrown
+    // t2 = t;
+    methodVisitor.visitVarInsn(ASTORE, 3 + offset);
+    methodVisitor.visitLabel(label4);
 
-    Label label12 = new Label();
-    methodVisitor.visitJumpInsn(GOTO, label12);
-    methodVisitor.visitLabel(label7);
-    if (TransformerUtils.ALLOW_LINE_NUMBERS) {
-      methodVisitor.visitLineNumber(57 + TransformerUtils.LINE_OFFSET, label7);
+    //methodName = "intTemplate()I"
+    methodVisitor.visitLdcInsn(mappedMethod.name + mappedMethod.desc);
+    // filename = "MockMixinTemplate.java"
+    methodVisitor.visitLdcInsn(filename);
+    // lineNo = 79
+    methodVisitor.visitLdcInsn(mappedMethod.line);
+    // list = new ArrayList();
+    methodVisitor.visitTypeInsn(NEW, Type.getInternalName(ArrayList.class));
+    methodVisitor.visitInsn(DUP);
+    methodVisitor.visitMethodInsn(INVOKESPECIAL, Type.getInternalName(ArrayList.class), "<init>", "()V", false);
+
+    for (final TracePointConfig bp : breakpoints) {
+      if (!bp.acceptStage(EStage.METHOD_END)) {
+        continue;
+      }
+      // list.add(bp.getId());
+      methodVisitor.visitInsn(DUP);
+      methodVisitor.visitLdcInsn(bp.getId());
+      methodVisitor.visitMethodInsn(INVOKEVIRTUAL, Type.getInternalName(ArrayList.class), "add",
+          "(Ljava/lang/Object;)Z", false);
+      methodVisitor.visitInsn(POP); // dont care about return
     }
 
-    methodVisitor.visitVarInsn(ASTORE, 5 + offset);
-    methodVisitor.visitLabel(label12);
+    // Make a map of locals
+    // vars = new HashMap()
+    processMethodArguments(mappedMethod.access, mappedMethod.vars, methodVisitor);
+    methodVisitor.visitMethodInsn(INVOKESTATIC, Type.getInternalName(CALLBACK_CLASS), "methodEnd",
+        Type.getMethodDescriptor(Type.VOID_TYPE,
+            Type.getType(String.class),
+            Type.getType(String.class),
+            Type.getType(int.class),
+            Type.getType(List.class),
+            Type.getType(Map.class)), false);
+    Label label11 = new Label();
+    methodVisitor.visitLabel(label11);
+
     if (TransformerUtils.ALLOW_LINE_NUMBERS) {
-      methodVisitor.visitLineNumber(60 + TransformerUtils.LINE_OFFSET, label12);
+      methodVisitor.visitLineNumber(80 + TransformerUtils.LINE_OFFSET, label11);
     }
-
-    methodVisitor.visitVarInsn(ALOAD, 4 + offset);
+    // throw t2;
+    methodVisitor.visitVarInsn(ALOAD, 3 + offset);
     methodVisitor.visitInsn(ATHROW);
-    Label label13 = new Label();
-    methodVisitor.visitLabel(label13);
+    Label label12 = new Label();
+    methodVisitor.visitLabel(label12);
 
     // no need to visit local vars as this code is synthetic we won't be debugging it anyway
-
-    methodVisitor.visitMaxs(1 + offset, 6 + offset);
+    // the max/frames should be calculated for us
+    methodVisitor.visitMaxs(0, 0);
     methodVisitor.visitEnd();
   }
 
+  private void processMethodArguments(final int access, final List<MappedMethod.MappedVar> vars, final MethodVisitor methodVisitor) {
+    // map = new HashMap()
+    methodVisitor.visitTypeInsn(NEW, Type.getInternalName(HashMap.class));
+    methodVisitor.visitInsn(DUP);
+    methodVisitor.visitMethodInsn(INVOKESPECIAL, Type.getInternalName(HashMap.class), "<init>",
+        "()V", false);
+
+    // add this
+    final boolean isStatic = isStatic(access);
+    if (!isStatic) {
+      // map.put("this", this)
+      methodVisitor.visitInsn(DUP); // we need a ptr to our map
+      methodVisitor.visitLdcInsn("this"); // key
+      methodVisitor.visitVarInsn(ALOAD, 0); // value
+
+      // call map.put(name, value)
+      methodVisitor.visitMethodInsn(INVOKEVIRTUAL, Type.getInternalName(HashMap.class),
+          "put",
+          Type.getMethodDescriptor(Type.getType(Object.class),
+              Type.getType(Object.class), Type.getType(Object.class)),
+          false);
+      methodVisitor.visitInsn(POP); // dont care about return
+    }
+
+    for (MappedVar var : vars) {
+
+      // map.put('param name', param);
+      final Type argumentType = Type.getType(var.desc);
+      final String pramName = var.name;
+
+      methodVisitor.visitInsn(DUP); // we need a ptr to our map
+      methodVisitor.visitLdcInsn(pramName); // key
+      // use the loadVariable method to ensure boxing
+      final InsnList abstractInsnNodes = loadVariable(argumentType, var.index);
+      // now convert to methodvisitor calls
+      appendToVisitor(methodVisitor, abstractInsnNodes);
+      // call map.put(name, value)
+      methodVisitor.visitMethodInsn(INVOKEVIRTUAL, Type.getInternalName(HashMap.class),
+          "put",
+          Type.getMethodDescriptor(Type.getType(Object.class),
+              Type.getType(Object.class), Type.getType(Object.class)),
+          false);
+      methodVisitor.visitInsn(POP); // dont care about return
+    }
+  }
+
+  private static void appendToVisitor(final MethodVisitor methodVisitor, final InsnList abstractInsnNodes) {
+    for (AbstractInsnNode abstractInsnNode : abstractInsnNodes) {
+      if (abstractInsnNode instanceof VarInsnNode) {
+        methodVisitor.visitVarInsn(abstractInsnNode.getOpcode(), ((VarInsnNode) abstractInsnNode).var);
+      } else if (abstractInsnNode instanceof MethodInsnNode) {
+        final MethodInsnNode methodInstNode = (MethodInsnNode) abstractInsnNode;
+        methodVisitor.visitMethodInsn(abstractInsnNode.getOpcode(), methodInstNode.owner, methodInstNode.name, methodInstNode.desc,
+            methodInstNode.itf);
+      } else if (abstractInsnNode instanceof LdcInsnNode) {
+        methodVisitor.visitLdcInsn(((LdcInsnNode) abstractInsnNode).cst);
+      }
+    }
+  }
+
   private void createMappedVoidMethod(final MappedMethod mappedMethod) {
+    final List<TracePointConfig> breakpoints = this.methodBPs.get(mappedMethod.name);
     final MethodVisitor methodVisitor = this.cv.visitMethod(mappedMethod.access, mappedMethod.name, mappedMethod.desc, mappedMethod.sign,
         mappedMethod.excp);
     final Type[] argumentTypes = Type.getArgumentTypes(mappedMethod.desc);
@@ -1015,127 +1274,214 @@ private void createMappedVoidMethod(final MappedMethod mappedMethod) {
     Label label0 = new Label();
     Label label1 = new Label();
     Label label2 = new Label();
-    methodVisitor.visitTryCatchBlock(label0, label1, label2, "java/io/IOException");
+    methodVisitor.visitTryCatchBlock(label0, label1, label2, "java/lang/Throwable");
     Label label3 = new Label();
+    methodVisitor.visitTryCatchBlock(label0, label1, label3, null);
     Label label4 = new Label();
-    methodVisitor.visitTryCatchBlock(label3, label0, label4, null);
+    methodVisitor.visitTryCatchBlock(label2, label4, label3, null);
     Label label5 = new Label();
-    Label label6 = new Label();
-    Label label7 = new Label();
-    methodVisitor.visitTryCatchBlock(label5, label6, label7, "java/io/IOException");
-
-    Label label8 = new Label();
-    methodVisitor.visitLabel(label8);
+    methodVisitor.visitLabel(label5);
     if (TransformerUtils.ALLOW_LINE_NUMBERS) {
-      methodVisitor.visitLineNumber(30 + TransformerUtils.LINE_OFFSET, label8);
+      methodVisitor.visitLineNumber(38 + TransformerUtils.LINE_OFFSET, label5);
     }
-    methodVisitor.visitLdcInsn(mappedMethod.name);
-    // Closable closable = Callback.span(method.name)
-    methodVisitor.visitMethodInsn(INVOKESTATIC, Type.getInternalName(CALLBACK_CLASS), "span",
-        "(Ljava/lang/String;)Ljava/io/Closeable;", false);
-    methodVisitor.visitVarInsn(ASTORE, 1 + offset);
-    // try {
-    methodVisitor.visitLabel(label3);
-    if (TransformerUtils.ALLOW_LINE_NUMBERS) {
-      methodVisitor.visitLineNumber(32 + TransformerUtils.LINE_OFFSET, label3);
+
+    //methodName = "intTemplate()I"
+    methodVisitor.visitLdcInsn(mappedMethod.name + mappedMethod.desc);
+    // filename = "MockMixinTemplate.java"
+    methodVisitor.visitLdcInsn(filename);
+    // lineNo = 79
+    methodVisitor.visitLdcInsn(mappedMethod.line);
+    // list = new ArrayList();
+    methodVisitor.visitTypeInsn(NEW, Type.getInternalName(ArrayList.class));
+    methodVisitor.visitInsn(DUP);
+    methodVisitor.visitMethodInsn(INVOKESPECIAL, Type.getInternalName(ArrayList.class), "<init>", "()V", false);
+
+    final StringBuilder spanOnlyIds = new StringBuilder();
+    for (final TracePointConfig bp : breakpoints) {
+      if (!bp.acceptStage(EStage.METHOD_START)) {
+        if (TracePointConfig.METHOD.equals(bp.getArg(TracePointConfig.SPAN, String.class, null))) {
+          spanOnlyIds.append(bp.getId()).append(",");
+        }
+        continue;
+      }
+      // list.add(bp.getId());
+      methodVisitor.visitInsn(DUP);
+      methodVisitor.visitLdcInsn(bp.getId());
+      methodVisitor.visitMethodInsn(INVOKEVIRTUAL, Type.getInternalName(ArrayList.class), "add",
+          "(Ljava/lang/Object;)Z", false);
+      methodVisitor.visitInsn(POP); // dont care about return
     }
 
-    // load 'this'
-    methodVisitor.visitVarInsn(ALOAD, 0);
-    // load all the parameters
+    // Make a map of locals
+    // vars = new HashMap()
+    processMethodArguments(mappedMethod.access, mappedMethod.vars, methodVisitor);
+    // attach ids of tracepoints that just want a span crated
+    if (spanOnlyIds.length() > 0) {
+      spanOnlyIds.deleteCharAt(spanOnlyIds.length() - 1);
+    }
+    methodVisitor.visitLdcInsn(spanOnlyIds.toString());
+
+    // Callback.methodEntry(mehodName, filename, lineNo, list, vars);
+    methodVisitor.visitMethodInsn(INVOKESTATIC, Type.getInternalName(CALLBACK_CLASS), "methodEntry",
+        Type.getMethodDescriptor(Type.VOID_TYPE,
+            Type.getType(String.class),
+            Type.getType(String.class),
+            Type.getType(int.class),
+            Type.getType(List.class),
+            Type.getType(Map.class),
+            Type.getType(String.class)), false);
+
+    methodVisitor.visitLabel(label0);
+    if (TransformerUtils.ALLOW_LINE_NUMBERS) {
+      methodVisitor.visitLineNumber(40 + TransformerUtils.LINE_OFFSET, label0);
+    }
+    // this.$deep$voidTemplate();
+    methodVisitor.visitVarInsn(ALOAD, 0); // load all the parameters
     for (int i = 0; i < argumentTypes.length; i++) {
       final Type argumentType = argumentTypes[i];
       methodVisitor.visitVarInsn(argumentType.getOpcode(ILOAD), i + 1);
     }
-    // call original method
     methodVisitor.visitMethodInsn(INVOKEVIRTUAL, this.classname, determineNewMethodName(mappedMethod.name), mappedMethod.desc,
         false);
-    methodVisitor.visitLabel(label0);
-    if (TransformerUtils.ALLOW_LINE_NUMBERS) {
-      methodVisitor.visitLineNumber(35 + TransformerUtils.LINE_OFFSET, label0);
-    }
-    methodVisitor.visitVarInsn(ALOAD, 1 + offset);
-    methodVisitor.visitJumpInsn(IFNULL, label1);
-    // } finally {
-    Label label9 = new Label();
-    methodVisitor.visitLabel(label9);
-    // try {
-    if (TransformerUtils.ALLOW_LINE_NUMBERS) {
-      methodVisitor.visitLineNumber(36 + TransformerUtils.LINE_OFFSET, label9);
-    }
-    methodVisitor.visitVarInsn(ALOAD, 1 + offset);
-    // closable.close()
-    methodVisitor.visitMethodInsn(INVOKEINTERFACE, "java/io/Closeable", "close", "()V", true);
+    // -- start good finally (ie the code in the finally block is run here if there is no exception)
     methodVisitor.visitLabel(label1);
     if (TransformerUtils.ALLOW_LINE_NUMBERS) {
-      methodVisitor.visitLineNumber(40 + TransformerUtils.LINE_OFFSET, label1);
+      methodVisitor.visitLineNumber(45 + TransformerUtils.LINE_OFFSET, label1);
     }
-    methodVisitor.visitFrame(Opcodes.F_APPEND, 1, new Object[]{"java/io/Closeable"}, 0, null);
-    Label label10 = new Label();
-    methodVisitor.visitJumpInsn(GOTO, label10);
-    methodVisitor.visitLabel(label2);
-    if (TransformerUtils.ALLOW_LINE_NUMBERS) {
-      methodVisitor.visitLineNumber(38 + TransformerUtils.LINE_OFFSET, label2);
+
+    //methodName = "intTemplate()I"
+    methodVisitor.visitLdcInsn(mappedMethod.name + mappedMethod.desc);
+    // filename = "MockMixinTemplate.java"
+    methodVisitor.visitLdcInsn(filename);
+    // lineNo = 79
+    methodVisitor.visitLdcInsn(mappedMethod.line);
+    // list = new ArrayList();
+    methodVisitor.visitTypeInsn(NEW, Type.getInternalName(ArrayList.class));
+    methodVisitor.visitInsn(DUP);
+    methodVisitor.visitMethodInsn(INVOKESPECIAL, Type.getInternalName(ArrayList.class), "<init>", "()V", false);
+
+    for (final TracePointConfig bp : breakpoints) {
+      if (!bp.acceptStage(EStage.METHOD_END)) {
+        continue;
+      }
+      // list.add(bp.getId());
+      methodVisitor.visitInsn(DUP);
+      methodVisitor.visitLdcInsn(bp.getId());
+      methodVisitor.visitMethodInsn(INVOKEVIRTUAL, Type.getInternalName(ArrayList.class), "add",
+          "(Ljava/lang/Object;)Z", false);
+      methodVisitor.visitInsn(POP); // dont care about return
     }
-    methodVisitor.visitFrame(Opcodes.F_SAME1, 0, null, 1, new Object[]{"java/io/IOException"});
-    // } catch (IOException ignored) {
-    methodVisitor.visitVarInsn(ASTORE, 2 + offset);
-    Label label11 = new Label();
-    methodVisitor.visitLabel(label11);
+
+    // Make a map of locals
+    // vars = new HashMap()
+    processMethodArguments(mappedMethod.access, mappedMethod.vars, methodVisitor);
+    methodVisitor.visitMethodInsn(INVOKESTATIC, Type.getInternalName(CALLBACK_CLASS), "methodEnd",
+        Type.getMethodDescriptor(Type.VOID_TYPE,
+            Type.getType(String.class),
+            Type.getType(String.class),
+            Type.getType(int.class),
+            Type.getType(List.class),
+            Type.getType(Map.class)), false);
+
+    // catch(Throwable t)
+    Label label6 = new Label();
+    methodVisitor.visitLabel(label6);
     if (TransformerUtils.ALLOW_LINE_NUMBERS) {
-      methodVisitor.visitLineNumber(41 + TransformerUtils.LINE_OFFSET, label11);
+      methodVisitor.visitLineNumber(46 + TransformerUtils.LINE_OFFSET, label6);
     }
-    methodVisitor.visitJumpInsn(GOTO, label10);
-    methodVisitor.visitLabel(label4);
+    Label label7 = new Label();
+    methodVisitor.visitJumpInsn(GOTO, label7);
+    methodVisitor.visitLabel(label2);
     if (TransformerUtils.ALLOW_LINE_NUMBERS) {
-      methodVisitor.visitLineNumber(34 + TransformerUtils.LINE_OFFSET, label4);
+      methodVisitor.visitLineNumber(41 + TransformerUtils.LINE_OFFSET, label2);
     }
-    methodVisitor.visitFrame(Opcodes.F_SAME1, 0, null, 1, new Object[]{"java/lang/Throwable"});
-    methodVisitor.visitVarInsn(ASTORE, 3 + offset);
-    methodVisitor.visitLabel(label5);
+    // throwable = thrownException (store thrown exception into slot 1)
+    methodVisitor.visitVarInsn(ASTORE, 1 + offset);
+    Label label8 = new Label();
+    methodVisitor.visitLabel(label8);
     if (TransformerUtils.ALLOW_LINE_NUMBERS) {
-      methodVisitor.visitLineNumber(35 + TransformerUtils.LINE_OFFSET, label5);
+      methodVisitor.visitLineNumber(42 + TransformerUtils.LINE_OFFSET, label8);
     }
+
+    // Callback.methodException(throwable)
     methodVisitor.visitVarInsn(ALOAD, 1 + offset);
-    methodVisitor.visitJumpInsn(IFNULL, label6);
-    Label label12 = new Label();
-    methodVisitor.visitLabel(label12);
+    methodVisitor.visitMethodInsn(INVOKESTATIC, Type.getInternalName(CALLBACK_CLASS), "methodException",
+        Type.getMethodDescriptor(Type.VOID_TYPE, Type.getType(Throwable.class)), false);
+
+    Label label9 = new Label();
+    methodVisitor.visitLabel(label9);
     if (TransformerUtils.ALLOW_LINE_NUMBERS) {
-      methodVisitor.visitLineNumber(36 + TransformerUtils.LINE_OFFSET, label12);
+      methodVisitor.visitLineNumber(43 + TransformerUtils.LINE_OFFSET, label9);
     }
+    // throw throwable
     methodVisitor.visitVarInsn(ALOAD, 1 + offset);
-    methodVisitor.visitMethodInsn(INVOKEINTERFACE, "java/io/Closeable", "close", "()V", true);
-    methodVisitor.visitLabel(label6);
+    methodVisitor.visitInsn(ATHROW);
+
+    methodVisitor.visitLabel(label3);
     if (TransformerUtils.ALLOW_LINE_NUMBERS) {
-      methodVisitor.visitLineNumber(40 + TransformerUtils.LINE_OFFSET, label6);
+      methodVisitor.visitLineNumber(45 + TransformerUtils.LINE_OFFSET, label3);
     }
-    methodVisitor.visitFrame(Opcodes.F_APPEND, 2, new Object[]{Opcodes.TOP, "java/lang/Throwable"}, 0, null);
-    Label label13 = new Label();
-    methodVisitor.visitJumpInsn(GOTO, label13);
-    methodVisitor.visitLabel(label7);
-    if (TransformerUtils.ALLOW_LINE_NUMBERS) {
-      methodVisitor.visitLineNumber(38 + TransformerUtils.LINE_OFFSET, label7);
+
+    // -- start bad finally (ie the code in the finally block is run here if there is an exception)
+    // t2 = throwable;
+    methodVisitor.visitVarInsn(ASTORE, 2 + offset);
+    methodVisitor.visitLabel(label4);
+
+    //methodName = "intTemplate()I"
+    methodVisitor.visitLdcInsn(mappedMethod.name + mappedMethod.desc);
+    // filename = "MockMixinTemplate.java"
+    methodVisitor.visitLdcInsn(filename);
+    // lineNo = 79
+    methodVisitor.visitLdcInsn(mappedMethod.line);
+    // list = new ArrayList();
+    methodVisitor.visitTypeInsn(NEW, Type.getInternalName(ArrayList.class));
+    methodVisitor.visitInsn(DUP);
+    methodVisitor.visitMethodInsn(INVOKESPECIAL, Type.getInternalName(ArrayList.class), "<init>", "()V", false);
+
+    for (final TracePointConfig bp : breakpoints) {
+      if (!bp.acceptStage(EStage.METHOD_END)) {
+        continue;
+      }
+      // list.add(bp.getId());
+      methodVisitor.visitInsn(DUP);
+      methodVisitor.visitLdcInsn(bp.getId());
+      methodVisitor.visitMethodInsn(INVOKEVIRTUAL, Type.getInternalName(ArrayList.class), "add",
+          "(Ljava/lang/Object;)Z", false);
+      methodVisitor.visitInsn(POP); // dont care about return
     }
-    methodVisitor.visitFrame(Opcodes.F_SAME1, 0, null, 1, new Object[]{"java/io/IOException"});
-    methodVisitor.visitVarInsn(ASTORE, 4 + offset);
-    methodVisitor.visitLabel(label13);
+
+    // Make a map of locals
+    // vars = new HashMap()
+    processMethodArguments(mappedMethod.access, mappedMethod.vars, methodVisitor);
+    // Callback.methodEnd(methodName, filename, lineNo, list, vars);
+    methodVisitor.visitMethodInsn(INVOKESTATIC, Type.getInternalName(CALLBACK_CLASS), "methodEnd",
+        Type.getMethodDescriptor(Type.VOID_TYPE,
+            Type.getType(String.class),
+            Type.getType(String.class),
+            Type.getType(int.class),
+            Type.getType(List.class),
+            Type.getType(Map.class)), false);
+
+    Label label10 = new Label();
+    methodVisitor.visitLabel(label10);
     if (TransformerUtils.ALLOW_LINE_NUMBERS) {
-      methodVisitor.visitLineNumber(41 + TransformerUtils.LINE_OFFSET, label13);
+      methodVisitor.visitLineNumber(46 + TransformerUtils.LINE_OFFSET, label10);
     }
-    methodVisitor.visitFrame(Opcodes.F_SAME, 0, null, 0, null);
-    methodVisitor.visitVarInsn(ALOAD, 3 + offset);
+    // throw t2;
+    methodVisitor.visitVarInsn(ALOAD, 2 + offset);
     methodVisitor.visitInsn(ATHROW);
-    methodVisitor.visitLabel(label10);
+    methodVisitor.visitLabel(label7);
     if (TransformerUtils.ALLOW_LINE_NUMBERS) {
-      methodVisitor.visitLineNumber(42 + TransformerUtils.LINE_OFFSET, label10);
+      methodVisitor.visitLineNumber(47 + TransformerUtils.LINE_OFFSET, label7);
     }
-    methodVisitor.visitFrame(Opcodes.F_CHOP, 2, null, 0, null);
+    methodVisitor.visitFrame(Opcodes.F_SAME, 0, null, 0, null);
     methodVisitor.visitInsn(RETURN);
-    Label label14 = new Label();
-    methodVisitor.visitLabel(label14);
-    methodVisitor.visitLocalVariable("this", "L" + this.classname + ";", null, label8, label14, 0);
-    methodVisitor.visitLocalVariable("closeable", "Ljava/io/Closeable;", null, label3, label14, 1);
-    methodVisitor.visitMaxs(1 + offset, 5 + offset);
+    Label label11 = new Label();
+    methodVisitor.visitLabel(label11);
+
+    // no need to visit local vars as this code is synthetic we won't be debugging it anyway
+    // the max/frames should be calculated for us
+    methodVisitor.visitMaxs(0, 0);
     methodVisitor.visitEnd();
   }
 
@@ -1161,18 +1507,44 @@ static String prettyPrint(AbstractInsnNode insnNode) {
 
   static class MappedMethod {
 
+
     final int access;
     final String name;
     final String desc;
     final String sign;
     final String[] excp;
+    int line;
+    final List<MappedVar> vars;
 
-    public MappedMethod(final int access, final String name, final String desc, final String sign, final String[] excp) {
+    public MappedMethod(final int access, final String name, final String desc, final String sign, final String[] excp, final int line) {
       this.access = access;
       this.name = name;
       this.desc = desc;
       this.sign = sign;
       this.excp = excp;
+      this.line = line;
+      this.vars = new ArrayList<>();
+    }
+
+    void acceptLine(final int line) {
+      this.line = Math.max(this.line, line);
+    }
+
+    void acceptVariable(final String name, final String desc, final int index) {
+      this.vars.add(new MappedVar(name, desc, index));
+    }
+
+    static class MappedVar {
+
+      final String name;
+      final String desc;
+      final int index;
+
+      public MappedVar(final String name, final String desc, final int index) {
+        this.name = name;
+        this.desc = desc;
+        this.index = index;
+      }
     }
   }
 }
diff --git a/agent/src/main/java/com/intergral/deep/agent/types/TracePointConfig.java b/agent/src/main/java/com/intergral/deep/agent/types/TracePointConfig.java
index 444f5a6..7e40946 100644
--- a/agent/src/main/java/com/intergral/deep/agent/types/TracePointConfig.java
+++ b/agent/src/main/java/com/intergral/deep/agent/types/TracePointConfig.java
@@ -50,7 +50,7 @@ public class TracePointConfig {
   /**
    * The number of times this tracepoint should fire.
    */
-  private static final String FIRE_COUNT = "fire_count";
+  public static final String FIRE_COUNT = "fire_count";
   /**
    * The start of the time period this tracepoint can fire in.
    */
@@ -62,7 +62,7 @@ public class TracePointConfig {
   /**
    * The minimum time between successive triggers, in ms.
    */
-  private static final String FIRE_PERIOD = "fire_period";
+  public static final String FIRE_PERIOD = "fire_period";
   /**
    * This is the key to indicate the frame collection type.
    */
@@ -82,6 +82,48 @@ public class TracePointConfig {
    */
   public static final String METHOD_NAME = "method_name";
 
+  /**
+   * This is the key for the arg that defines a span type.
+   */
+  public static final String SPAN = "span";
+
+  /**
+   * This is used for SPAN type.
+   * <p>
+   * This type means we should wrap the method the tracepoint is in.
+   */
+  public static final String METHOD = "method";
+  /**
+   * This is used for SPAN type.
+   * <p>
+   * This type means we should only wrap the line the tracepoint is on.
+   */
+  @SuppressWarnings("unused")
+  public static final String LINE = "line";
+
+  /**
+   * This is the key to determine the collection state of the snapshot.
+   */
+  public static final String SNAPSHOT = "snapshot";
+
+  /**
+   * This is the default collection type and tells Deep to collect and send the snapshot.
+   */
+  public static final String COLLECT = "collect";
+
+  /**
+   * This type tells Deep to not collect any data and not to send the sanpshot.
+   */
+  public static final String NO_COLLECT = "no_collect";
+
+  public static final String STAGE = "stage";
+  public static final String LINE_START = "line_start";
+  public static final String LINE_END = "line_end";
+  public static final String LINE_CAPTURE = "line_capture";
+  public static final String METHOD_START = "method_start";
+  public static final String METHOD_END = "method_end";
+  public static final String METHOD_CAPTURE = "method_capture";
+
   private final String id;
   private final String path;
   private final int lineNo;
@@ -280,6 +322,44 @@ public void fired(final long ts) {
     this.stats.fired(ts);
   }
 
+  /**
+   * Does this tracepoint accept the provided stage.
+   * <p>
+   * We can run tracepoints at start or end of line (or method), as well as collecting at start but defer send to end. Here we
+   * want to check the current visitor stage (where we are modifying the code), with the config of the tracepoint.
+   * <p>
+   * We should return {@code true} if the tracepoint should collect data at this stage.
+   *
+   * @param currentStage the stage we are trying to visit
+   * @return {@code true} if this tracepoint accepts this stage, else {@code false}.
+   */
+  public boolean acceptStage(final EStage currentStage) {
+    // if method name is set then we default to method start
+    final String methodName = getArg(METHOD_NAME, String.class, null);
+    final EStage targetStage;
+    if (methodName != null) {
+      targetStage = getArg(STAGE, EStage.class, EStage.METHOD_START);
+    } else {
+      targetStage = getArg(STAGE, EStage.class, EStage.LINE_START);
+    }
+
+    if (targetStage == currentStage) {
+      return true;
+    }
+
+    switch (currentStage) {
+      // if we are at line start - and we are line capture then capture
+      case LINE_START:
+      case LINE_END:
+        return targetStage == EStage.LINE_CAPTURE;
+      case METHOD_START:
+      case METHOD_END:
+        return targetStage == EStage.METHOD_CAPTURE;
+      default:
+        return false;
+    }
+  }
+
   private static class TracepointWindow {
 
     private final Integer start;
@@ -325,4 +405,51 @@ void fired(final long ts) {
       this.fireCount++;
     }
   }
+
+  /**
+   * This type describes the different stages that tracepoints can trigger at.
+   */
+  public enum EStage {
+    LINE_START(TracePointConfig.LINE_START),
+    LINE_END(TracePointConfig.LINE_END),
+    LINE_CAPTURE(TracePointConfig.LINE_CAPTURE),
+    METHOD_START(TracePointConfig.METHOD_START),
+    METHOD_END(TracePointConfig.METHOD_END),
+    METHOD_CAPTURE(TracePointConfig.METHOD_CAPTURE),
+    ;
+
+    private final String name;
+
+    EStage(final String name) {
+      this.name = name;
+    }
+
+    @Override
+    public String toString() {
+      return this.name;
+    }
+
+    /**
+     * Convert a string into the equivalent {@link EStage} value.
+     *
+     * @param arg the string to convert
+     * @return the {@link EStage} value.
+     */
+    public static EStage fromArg(final String arg) {
+      switch (arg) {
+        case TracePointConfig.LINE_END:
+          return EStage.LINE_END;
+        case TracePointConfig.LINE_CAPTURE:
+          return EStage.LINE_CAPTURE;
+        case TracePointConfig.METHOD_START:
+          return EStage.METHOD_START;
+        case TracePointConfig.METHOD_END:
+          return EStage.METHOD_END;
+        case TracePointConfig.METHOD_CAPTURE:
+          return EStage.METHOD_CAPTURE;
+        default:
+          return EStage.LINE_START;
+      }
+    }
+  }
 }
diff --git a/agent/src/main/java/com/intergral/deep/agent/types/snapshot/EventSnapshot.java b/agent/src/main/java/com/intergral/deep/agent/types/snapshot/EventSnapshot.java
index ddbbf9b..54ae2f0 100644
--- a/agent/src/main/java/com/intergral/deep/agent/types/snapshot/EventSnapshot.java
+++ b/agent/src/main/java/com/intergral/deep/agent/types/snapshot/EventSnapshot.java
@@ -41,7 +41,6 @@ public class EventSnapshot {
   private long durationNanos;
   private final Resource resource;
   private Resource attributes;
-  private boolean open;
   private String logMsg;
 
   /**
@@ -67,7 +66,6 @@ public EventSnapshot(final TracePointConfig tracepoint,
     this.attributes = Resource.create(Collections.emptyMap());
     this.durationNanos = 0;
     this.resource = Resource.create(resource.getAttributes(), resource.getSchemaUrl());
-    this.open = true;
   }
 
   /**
@@ -76,9 +74,7 @@ public EventSnapshot(final TracePointConfig tracepoint,
    * @param result the watch result
    */
   public void addWatchResult(final WatchResult result) {
-    if (this.open) {
-      this.watches.add(result);
-    }
+    this.watches.add(result);
   }
 
   /**
@@ -87,9 +83,7 @@ public void addWatchResult(final WatchResult result) {
    * @param variables the variables to merge in
    */
   public void mergeVariables(final Map<String, Variable> variables) {
-    if (this.open) {
-      this.varLookup.putAll(variables);
-    }
+    this.varLookup.putAll(variables);
   }
 
   /**
@@ -98,9 +92,7 @@ public void mergeVariables(final Map<String, Variable> variables) {
    * @param attributes the additional attributes
    */
   public void mergeAttributes(final Resource attributes) {
-    if (this.open) {
-      this.attributes = this.attributes.merge(attributes);
-    }
+    this.attributes = this.attributes.merge(attributes);
   }
 
   /**
@@ -156,7 +148,6 @@ public Resource getAttributes() {
    * Close the snapshot to prevent further changes.
    */
   public void close() {
-    this.open = false;
     final long currentTimeNano = Utils.currentTimeNanos()[1];
     this.durationNanos = currentTimeNano - this.nanoTs;
   }
diff --git a/agent/src/main/java/java/com/intergral/deep/ProxyCallback.java b/agent/src/main/java/java/com/intergral/deep/ProxyCallback.java
index 41bafd4..17803ac 100644
--- a/agent/src/main/java/java/com/intergral/deep/ProxyCallback.java
+++ b/agent/src/main/java/java/com/intergral/deep/ProxyCallback.java
@@ -21,7 +21,6 @@
 import java.io.Closeable;
 import java.util.List;
 import java.util.Map;
-import java.util.Set;
 
 /**
  * This type is here to allow us to access it from anywhere (once it is loaded into the boot class path).
@@ -76,28 +75,71 @@ public static void callBackException(final Throwable e) {
 
 
   /**
-   * This is called when a tracepoint 'finally' wrap is called.
+   * This is called when the visited line is completed.
    *
-   * @param breakpointIds the ids for the tracepoints that are complete
-   * @param map           the variables at this point
+   * @param bpIds the tracepoint ids that triggered this
+   * @param filename the source file name
+   * @param lineNo the line number we are on
+   * @param variables the captured local variables
    */
-  public static void callBackFinally(final Set<String> breakpointIds,
-      final Map<String, Object> map) {
-    Callback.callBackFinally(breakpointIds, map);
+  public static void callBackFinally(final List<String> bpIds,
+      final String filename,
+      final int lineNo,
+      final Map<String, Object> variables) {
+    Callback.callBackFinally(bpIds, filename, lineNo, variables);
   }
 
   /**
-   * Create a span using the tracepoint callback.
+   * This method is called when a tracepoint has triggered a method entry type.
    * <p>
    * This method will <b>Always</b> return a closable. This way the injected code never deals with anything but calling close. Even if close
    * doesn't do anything.
    * <p>
    * We use {@link Closeable} here, so we can stick to java types in the injected code. This makes testing and injected code simpler.
    *
-   * @param name the name of the span
-   * @return a {@link Closeable} to close the span
+   * @param methodName the method name we have entered
+   * @param filename   the file name the method is in
+   * @param lineNo     the line number the method is on
+   * @param bpIds      the tracepoint ids that have been triggered by this entry
+   * @param variables  the map of variables captured
+   * @param spanOnlyIds the CSV of the tracepoints ids that just want a span
+   */
+  public static void methodEntry(final String methodName, final String filename, final int lineNo, final List<String> bpIds,
+      final Map<String, Object> variables, final String spanOnlyIds) {
+    Callback.methodEntry(methodName, filename, lineNo, bpIds, variables, spanOnlyIds);
+  }
+
+  /**
+   * This is called when an exception is captured from a wrapped method.
+   *
+   * @param t the captured throwable
+   */
+  public static void methodException(final Throwable t) {
+    Callback.methodException(t);
+  }
+
+  /**
+   * This is called when the returned value from the wrapped method is captured.
+   * <p>
+   * This method is not called on void methods.
+   *
+   * @param value the captured return value.
+   */
+  public static void methodRet(final Object value) {
+    Callback.methodRet(value);
+  }
+
+  /**
+   * This method is called when a wrapped method has completed.
+   *
+   * @param methodName the method name
+   * @param filename the source file name
+   * @param lineNo the line number
+   * @param bpIds the triggering tracepoints ids
+   * @param variables the captured local variables
    */
-  public static Closeable span(final String name) {
-    return Callback.span(name);
+  public static void methodEnd(final String methodName, final String filename, final int lineNo, final List<String> bpIds,
+      final Map<String, Object> variables) {
+    Callback.methodEnd(methodName, filename, lineNo, bpIds, variables);
   }
 }
diff --git a/agent/src/test/java/com/intergral/deep/agent/push/PushServiceTest.java b/agent/src/test/java/com/intergral/deep/agent/push/PushServiceTest.java
index 83f0a25..d76caf6 100644
--- a/agent/src/test/java/com/intergral/deep/agent/push/PushServiceTest.java
+++ b/agent/src/test/java/com/intergral/deep/agent/push/PushServiceTest.java
@@ -18,46 +18,30 @@
 package com.intergral.deep.agent.push;
 
 import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
-import com.intergral.deep.agent.api.plugin.ISnapshotContext;
-import com.intergral.deep.agent.api.plugin.ISnapshotDecorator;
-import com.intergral.deep.agent.api.resource.Resource;
-import com.intergral.deep.agent.api.settings.ISettings;
-import com.intergral.deep.agent.api.spi.IDeepPlugin;
 import com.intergral.deep.agent.grpc.GrpcService;
 import com.intergral.deep.agent.push.PushService.LoggingObserver;
-import com.intergral.deep.agent.settings.Settings;
-import com.intergral.deep.proto.common.v1.KeyValue;
-import com.intergral.deep.proto.tracepoint.v1.Snapshot;
 import com.intergral.deep.proto.tracepoint.v1.SnapshotServiceGrpc.SnapshotServiceStub;
 import com.intergral.deep.test.MockEventSnapshot;
-import java.util.Collections;
-import java.util.HashMap;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
-import org.mockito.ArgumentCaptor;
 import org.mockito.Mockito;
 
 class PushServiceTest {
 
   private PushService pushService;
   private SnapshotServiceStub snapshotServiceStub;
-  private Settings settings;
 
   @BeforeEach
   void setUp() {
     final GrpcService grpcService = Mockito.mock(GrpcService.class);
     snapshotServiceStub = Mockito.mock(SnapshotServiceStub.class);
     when(grpcService.snapshotService()).thenReturn(snapshotServiceStub);
-    final HashMap<String, String> map = new HashMap<>();
 
-    settings = Settings.build(map);
-    pushService = new PushService(settings, grpcService);
+    pushService = new PushService(grpcService);
   }
 
   @Test
@@ -70,37 +54,8 @@ void snapshotLogger() {
 
   @Test
   void canPushSnapshot() {
-    final ISnapshotContext context = Mockito.mock(ISnapshotContext.class);
-    pushService.pushSnapshot(new MockEventSnapshot(), context);
+    pushService.pushSnapshot(new MockEventSnapshot());
 
     verify(snapshotServiceStub).send(any(), any());
   }
-
-  @Test
-  void doesDecorate() {
-
-    settings.setPlugins(Collections.singleton(new TestDecorator()));
-
-    final ISnapshotContext context = Mockito.mock(ISnapshotContext.class);
-    pushService.pushSnapshot(new MockEventSnapshot(), context);
-
-    final ArgumentCaptor<Snapshot> argumentCaptor = ArgumentCaptor.forClass(Snapshot.class);
-    verify(snapshotServiceStub).send(argumentCaptor.capture(), any());
-
-    final Snapshot value = argumentCaptor.getValue();
-
-    assertNotNull(value);
-
-    final KeyValue attributes = value.getAttributes(0);
-    assertEquals("decorated", attributes.getKey());
-    assertEquals("value", attributes.getValue().getStringValue());
-  }
-
-  public static class TestDecorator implements IDeepPlugin, ISnapshotDecorator {
-
-    @Override
-    public Resource decorate(final ISettings settings, final ISnapshotContext snapshot) {
-      return Resource.create(Collections.singletonMap("decorated", "value"));
-    }
-  }
 }
\ No newline at end of file
diff --git a/agent/src/test/java/com/intergral/deep/agent/tracepoint/handler/CallbackTest.java b/agent/src/test/java/com/intergral/deep/agent/tracepoint/handler/CallbackTest.java
index c883e2f..55981a7 100644
--- a/agent/src/test/java/com/intergral/deep/agent/tracepoint/handler/CallbackTest.java
+++ b/agent/src/test/java/com/intergral/deep/agent/tracepoint/handler/CallbackTest.java
@@ -37,6 +37,7 @@ class CallbackTest {
   private final Settings settings = Mockito.mock(Settings.class);
   private final TracepointConfigService tracepointConfigService = Mockito.mock(TracepointConfigService.class);
   private final PushService pushService = Mockito.mock(PushService.class);
+  private final String collect = "";
 
   @BeforeEach
   void setUp() {
@@ -47,7 +48,7 @@ void setUp() {
   @ValueSource(strings = {"test", ""})
   @NullSource()
   void spanMustAlwaysReturn(final String name) {
-    final Closeable test = Callback.span(name);
+    final Closeable test = Callback.span(name, collect);
     assertNotNull(test);
     assertDoesNotThrow(test::close);
   }
@@ -58,7 +59,7 @@ void spanMustAlwaysReturn(final String name) {
   void spanMustAlwaysReturn2(final String name) {
     final ITraceProvider iTraceProvider = Mockito.mock(ITraceProvider.class);
     Mockito.when(settings.getPlugin(ITraceProvider.class)).thenReturn(iTraceProvider);
-    final Closeable test = Callback.span(name);
+    final Closeable test = Callback.span(name, collect);
     assertNotNull(test);
     assertDoesNotThrow(test::close);
   }
@@ -71,7 +72,7 @@ void spanMustAlwaysReturn3(final String name) {
     final ISpan iSpan = Mockito.mock(ISpan.class);
     Mockito.when(iTraceProvider.createSpan(name)).thenReturn(iSpan);
     Mockito.when(settings.getPlugin(ITraceProvider.class)).thenReturn(iTraceProvider);
-    final Closeable test = Callback.span(name);
+    final Closeable test = Callback.span(name, collect);
     assertNotNull(test);
     assertDoesNotThrow(test::close);
   }
@@ -85,7 +86,7 @@ void spanMustAlwaysReturn4(final String name) throws Exception {
     Mockito.doThrow(new RuntimeException("test")).when(iSpan).close();
     Mockito.when(iTraceProvider.createSpan(name)).thenReturn(iSpan);
     Mockito.when(settings.getPlugin(ITraceProvider.class)).thenReturn(iTraceProvider);
-    final Closeable test = Callback.span(name);
+    final Closeable test = Callback.span(name, collect);
     assertNotNull(test);
     assertDoesNotThrow(test::close);
   }
@@ -97,7 +98,7 @@ void spanMustAlwaysReturn5(final String name) {
     final ITraceProvider iTraceProvider = Mockito.mock(ITraceProvider.class);
     Mockito.doThrow(new RuntimeException("test")).when(iTraceProvider).createSpan(name);
     Mockito.when(settings.getPlugin(ITraceProvider.class)).thenReturn(iTraceProvider);
-    final Closeable test = Callback.span(name);
+    final Closeable test = Callback.span(name, collect);
     assertNotNull(test);
     assertDoesNotThrow(test::close);
   }
diff --git a/agent/src/test/java/com/intergral/deep/agent/tracepoint/handler/FrameCollectorTest.java b/agent/src/test/java/com/intergral/deep/agent/tracepoint/handler/FrameCollectorTest.java
index 4bb7027..ffa3955 100644
--- a/agent/src/test/java/com/intergral/deep/agent/tracepoint/handler/FrameCollectorTest.java
+++ b/agent/src/test/java/com/intergral/deep/agent/tracepoint/handler/FrameCollectorTest.java
@@ -44,7 +44,7 @@ class FrameCollectorTest {
   void setUp() {
     Mockito.when(settings.getResource()).thenReturn(Resource.DEFAULT);
     frameCollector = new FrameCollector(settings, evaluator, Collections.singletonMap("this", new ConditionTarget()),
-        Thread.currentThread().getStackTrace());
+        Thread.currentThread().getStackTrace(), null);
     frameCollector.configureSelf(Collections.singletonList(new MockTracepointConfig()));
   }
 
diff --git a/agent/src/test/java/com/intergral/deep/agent/tracepoint/handler/FrameProcessorTest.java b/agent/src/test/java/com/intergral/deep/agent/tracepoint/handler/FrameProcessorTest.java
index ac96fdf..45a7ab0 100644
--- a/agent/src/test/java/com/intergral/deep/agent/tracepoint/handler/FrameProcessorTest.java
+++ b/agent/src/test/java/com/intergral/deep/agent/tracepoint/handler/FrameProcessorTest.java
@@ -55,7 +55,7 @@ void setUp() {
     Mockito.when(settings.getResource()).thenReturn(Resource.DEFAULT);
     tracepoints.clear();
     frameProcessor = new FrameProcessor(settings, evaluator, Collections.singletonMap("this", new ConditionTarget()), tracepoints,
-        Utils.currentTimeNanos(), Thread.currentThread().getStackTrace());
+        Utils.currentTimeNanos(), Thread.currentThread().getStackTrace(), null);
   }
 
   @Test
diff --git a/agent/src/test/java/com/intergral/deep/agent/tracepoint/inst/asm/VisitorTest.java b/agent/src/test/java/com/intergral/deep/agent/tracepoint/inst/asm/VisitorTest.java
index e7ab14d..a3429ec 100644
--- a/agent/src/test/java/com/intergral/deep/agent/tracepoint/inst/asm/VisitorTest.java
+++ b/agent/src/test/java/com/intergral/deep/agent/tracepoint/inst/asm/VisitorTest.java
@@ -40,6 +40,7 @@
 import com.intergral.deep.agent.types.TracePointConfig;
 import com.intergral.deep.agent.types.snapshot.EventSnapshot;
 import com.intergral.deep.agent.types.snapshot.StackFrame;
+import com.intergral.deep.agent.types.snapshot.WatchResult;
 import com.intergral.deep.proto.tracepoint.v1.Snapshot;
 import com.intergral.deep.proto.tracepoint.v1.Variable;
 import com.intergral.deep.test.MockTracepointConfig;
@@ -54,12 +55,17 @@
 import java.net.URL;
 import java.nio.file.Paths;
 import java.security.ProtectionDomain;
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
 import java.util.concurrent.atomic.AtomicReference;
+import java.util.function.Consumer;
 import java.util.logging.Level;
+import java.util.stream.Stream;
 import javax.servlet.DispatcherType;
 import javax.servlet.Servlet;
 import javax.servlet.ServletRequest;
@@ -70,8 +76,12 @@
 import javax.servlet.jsp.JspWriter;
 import javax.servlet.jsp.PageContext;
 import lucee.runtime.PageSource;
+import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
 import org.mockito.ArgumentCaptor;
 import org.mockito.Mockito;
 
@@ -88,21 +98,25 @@
 class VisitorTest {
 
   private final Settings settings = Mockito.mock(Settings.class);
-  private final TracepointConfigService tracepointConfigService = Mockito.mock(TracepointConfigService.class);
   private final PushService pushService = Mockito.mock(PushService.class);
   private final Instrumentation instrumentation = Mockito.mock(Instrumentation.class);
   private final String disPath = Paths.get(Paths.get(".").normalize().toAbsolutePath().getParent().toString(), "dispath").toString();
 
   private final AtomicReference<Collection<TracePointConfig>> tracepointRef = new AtomicReference<>();
   private final AtomicReference<URL> cfUrl = new AtomicReference<>();
+  private TracepointConfigService tracepointConfigService;
   private TracepointInstrumentationService instrumentationService;
 
-  @BeforeEach
-  void setUp() {
+  @BeforeAll
+  static void beforeAll() {
+    final Settings settings = Mockito.mock(Settings.class);
     // set up logging to help with debugging tests
     Mockito.when(settings.getSettingAs("logging.level", Level.class)).thenReturn(Level.FINEST);
     Logger.configureLogging(settings);
+  }
 
+  @BeforeEach
+  void setUp() {
     Mockito.when(settings.getResource()).thenReturn(Resource.DEFAULT);
 
     // for these tests we do not care about these (they are tested in the TracepointInstrumentationServiceTest)
@@ -115,14 +129,6 @@ void setUp() {
     Mockito.when(settings.getSettingAs("jsp.packages", List.class)).thenReturn(Arrays.asList("org.apache.jsp", "jsp"));
     Mockito.when(settings.getSettingAs("jsp.suffix", String.class)).thenReturn("_jsp");
 
-    Mockito.when(tracepointConfigService.loadTracepointConfigs(Mockito.any())).thenAnswer(invocationOnMock -> {
-      final Collection<TracePointConfig> tracePointConfig = tracepointRef.get();
-      if (tracePointConfig == null) {
-        return Collections.emptyList();
-      }
-      return tracePointConfig;
-    });
-
     instrumentationService = new TracepointInstrumentationService(instrumentation, settings) {
       @Override
       protected URL getLocation(final ProtectionDomain protectionDomain) {
@@ -133,6 +139,14 @@ protected URL getLocation(final ProtectionDomain protectionDomain) {
         return url;
       }
     };
+    tracepointConfigService = new TracepointConfigService(instrumentationService) {
+      @Override
+      public Collection<TracePointConfig> loadTracepointConfigs(final Collection<String> tracepointId) {
+        this.installedTracepoints.clear();
+        this.installedTracepoints.addAll(tracepointRef.get());
+        return super.loadTracepointConfigs(tracepointId);
+      }
+    };
 
     Callback.init(settings, tracepointConfigService, pushService);
   }
@@ -154,7 +168,8 @@ void constructor() throws Exception {
     final byte[] transformed = instrumentationService.transform(null, name, null, null, originalBytes);
 
     // we do this here so each test can save the modified bytes, else as they all use the same target class they would stomp over each other
-    TransformerUtils.storeUnsafe(disPath, originalBytes, transformed, name + Thread.currentThread().getStackTrace()[1].getMethodName());
+    TransformerUtils.storeUnsafe(disPath, originalBytes, transformed,
+        name + "_" + Thread.currentThread().getStackTrace()[1].getMethodName());
 
     assertNotNull(transformed, "Failed to transform the test class!");
     assertNotEquals(originalBytes.length, transformed.length);
@@ -172,7 +187,7 @@ void constructor() throws Exception {
     final ArgumentCaptor<EventSnapshot> argumentCaptor = ArgumentCaptor.forClass(EventSnapshot.class);
 
     Mockito.verify(pushService, times(1))
-        .pushSnapshot(argumentCaptor.capture(), Mockito.any());
+        .pushSnapshot(argumentCaptor.capture());
 
     final EventSnapshot value = argumentCaptor.getValue();
     assertEquals(tracepointConfig.getId(), value.getTracepoint().getId());
@@ -202,7 +217,8 @@ void constructor_end_line() throws Exception {
     final byte[] originalBytes = classLoader.getBytes(name);
     final byte[] transformed = instrumentationService.transform(null, name, null, null, originalBytes);
     // we do this here so each test can save the modified bytes, else as they all use the same target class they would stomp over each other
-    TransformerUtils.storeUnsafe(disPath, originalBytes, transformed, name + Thread.currentThread().getStackTrace()[1].getMethodName());
+    TransformerUtils.storeUnsafe(disPath, originalBytes, transformed,
+        name + "_" + Thread.currentThread().getStackTrace()[1].getMethodName());
 
     assertNotNull(transformed, "Failed to transform the test class!");
     assertNotEquals(originalBytes.length, transformed.length);
@@ -220,7 +236,7 @@ void constructor_end_line() throws Exception {
     final ArgumentCaptor<EventSnapshot> argumentCaptor = ArgumentCaptor.forClass(EventSnapshot.class);
 
     Mockito.verify(pushService, times(1))
-        .pushSnapshot(argumentCaptor.capture(), Mockito.any());
+        .pushSnapshot(argumentCaptor.capture());
 
     final EventSnapshot value = argumentCaptor.getValue();
     assertEquals(tracepointConfig.getId(), value.getTracepoint().getId());
@@ -268,7 +284,8 @@ void constructor_start_line() throws Exception {
     final byte[] originalBytes = classLoader.getBytes(name);
     final byte[] transformed = instrumentationService.transform(null, name, null, null, originalBytes);
     // we do this here so each test can save the modified bytes, else as they all use the same target class they would stomp over each other
-    TransformerUtils.storeUnsafe(disPath, originalBytes, transformed, name + Thread.currentThread().getStackTrace()[1].getMethodName());
+    TransformerUtils.storeUnsafe(disPath, originalBytes, transformed,
+        name + "_" + Thread.currentThread().getStackTrace()[1].getMethodName());
 
     assertNotNull(transformed, "Failed to transform the test class!");
     assertNotEquals(originalBytes.length, transformed.length);
@@ -286,7 +303,7 @@ void constructor_start_line() throws Exception {
     final ArgumentCaptor<EventSnapshot> argumentCaptor = ArgumentCaptor.forClass(EventSnapshot.class);
 
     Mockito.verify(pushService, times(1))
-        .pushSnapshot(argumentCaptor.capture(), Mockito.any());
+        .pushSnapshot(argumentCaptor.capture());
 
     final EventSnapshot value = argumentCaptor.getValue();
     assertEquals(tracepointConfig.getId(), value.getTracepoint().getId());
@@ -334,7 +351,8 @@ void setName() throws Exception {
     final byte[] originalBytes = classLoader.getBytes(name);
     final byte[] transformed = instrumentationService.transform(null, name, null, null, originalBytes);
     // we do this here so each test can save the modified bytes, else as they all use the same target class they would stomp over each other
-    TransformerUtils.storeUnsafe(disPath, originalBytes, transformed, name + Thread.currentThread().getStackTrace()[1].getMethodName());
+    TransformerUtils.storeUnsafe(disPath, originalBytes, transformed,
+        name + "_" + Thread.currentThread().getStackTrace()[1].getMethodName());
 
     assertNotNull(transformed, "Failed to transform the test class!");
     assertNotEquals(originalBytes.length, transformed.length);
@@ -355,7 +373,7 @@ void setName() throws Exception {
     final ArgumentCaptor<EventSnapshot> argumentCaptor = ArgumentCaptor.forClass(EventSnapshot.class);
 
     Mockito.verify(pushService, times(1))
-        .pushSnapshot(argumentCaptor.capture(), Mockito.any());
+        .pushSnapshot(argumentCaptor.capture());
 
     final EventSnapshot value = argumentCaptor.getValue();
     assertEquals(tracepointConfig.getId(), value.getTracepoint().getId());
@@ -403,7 +421,8 @@ void getName_null_return() throws Exception {
     final byte[] originalBytes = classLoader.getBytes(name);
     final byte[] transformed = instrumentationService.transform(null, name, null, null, originalBytes);
     // we do this here so each test can save the modified bytes, else as they all use the same target class they would stomp over each other
-    TransformerUtils.storeUnsafe(disPath, originalBytes, transformed, name + Thread.currentThread().getStackTrace()[1].getMethodName());
+    TransformerUtils.storeUnsafe(disPath, originalBytes, transformed,
+        name + "_" + Thread.currentThread().getStackTrace()[1].getMethodName());
 
     assertNotNull(transformed, "Failed to transform the test class!");
     assertNotEquals(originalBytes.length, transformed.length);
@@ -424,7 +443,7 @@ void getName_null_return() throws Exception {
     final ArgumentCaptor<EventSnapshot> argumentCaptor = ArgumentCaptor.forClass(EventSnapshot.class);
 
     Mockito.verify(pushService, times(1))
-        .pushSnapshot(argumentCaptor.capture(), Mockito.any());
+        .pushSnapshot(argumentCaptor.capture());
 
     final EventSnapshot value = argumentCaptor.getValue();
     assertEquals(tracepointConfig.getId(), value.getTracepoint().getId());
@@ -471,7 +490,8 @@ void getName_non_null_return() throws Exception {
     final byte[] originalBytes = classLoader.getBytes(name);
     final byte[] transformed = instrumentationService.transform(null, name, null, null, originalBytes);
     // we do this here so each test can save the modified bytes, else as they all use the same target class they would stomp over each other
-    TransformerUtils.storeUnsafe(disPath, originalBytes, transformed, name + Thread.currentThread().getStackTrace()[1].getMethodName());
+    TransformerUtils.storeUnsafe(disPath, originalBytes, transformed,
+        name + "_" + Thread.currentThread().getStackTrace()[1].getMethodName());
 
     assertNotNull(transformed, "Failed to transform the test class!");
     assertNotEquals(originalBytes.length, transformed.length);
@@ -492,7 +512,7 @@ void getName_non_null_return() throws Exception {
     final ArgumentCaptor<EventSnapshot> argumentCaptor = ArgumentCaptor.forClass(EventSnapshot.class);
 
     Mockito.verify(pushService, times(1))
-        .pushSnapshot(argumentCaptor.capture(), Mockito.any());
+        .pushSnapshot(argumentCaptor.capture());
 
     final EventSnapshot value = argumentCaptor.getValue();
     assertEquals(tracepointConfig.getId(), value.getTracepoint().getId());
@@ -539,7 +559,8 @@ void errorSomething() throws Exception {
     final byte[] originalBytes = classLoader.getBytes(name);
     final byte[] transformed = instrumentationService.transform(null, name, null, null, originalBytes);
     // we do this here so each test can save the modified bytes, else as they all use the same target class they would stomp over each other
-    TransformerUtils.storeUnsafe(disPath, originalBytes, transformed, name + Thread.currentThread().getStackTrace()[1].getMethodName());
+    TransformerUtils.storeUnsafe(disPath, originalBytes, transformed,
+        name + "_" + Thread.currentThread().getStackTrace()[1].getMethodName());
 
     assertNotNull(transformed, "Failed to transform the test class!");
     assertNotEquals(originalBytes.length, transformed.length);
@@ -562,7 +583,7 @@ void errorSomething() throws Exception {
     final ArgumentCaptor<EventSnapshot> argumentCaptor = ArgumentCaptor.forClass(EventSnapshot.class);
 
     Mockito.verify(pushService, times(1))
-        .pushSnapshot(argumentCaptor.capture(), Mockito.any());
+        .pushSnapshot(argumentCaptor.capture());
 
     final EventSnapshot value = argumentCaptor.getValue();
     assertEquals(tracepointConfig.getId(), value.getTracepoint().getId());
@@ -609,7 +630,8 @@ void throwSomething() throws Exception {
     final byte[] originalBytes = classLoader.getBytes(name);
     final byte[] transformed = instrumentationService.transform(null, name, null, null, originalBytes);
     // we do this here so each test can save the modified bytes, else as they all use the same target class they would stomp over each other
-    TransformerUtils.storeUnsafe(disPath, originalBytes, transformed, name + Thread.currentThread().getStackTrace()[1].getMethodName());
+    TransformerUtils.storeUnsafe(disPath, originalBytes, transformed,
+        name + "_" + Thread.currentThread().getStackTrace()[1].getMethodName());
 
     assertNotNull(transformed, "Failed to transform the test class!");
     assertNotEquals(originalBytes.length, transformed.length);
@@ -632,7 +654,7 @@ void throwSomething() throws Exception {
     final ArgumentCaptor<EventSnapshot> argumentCaptor = ArgumentCaptor.forClass(EventSnapshot.class);
 
     Mockito.verify(pushService, times(1))
-        .pushSnapshot(argumentCaptor.capture(), Mockito.any());
+        .pushSnapshot(argumentCaptor.capture());
 
     final EventSnapshot value = argumentCaptor.getValue();
     assertEquals(tracepointConfig.getId(), value.getTracepoint().getId());
@@ -679,7 +701,8 @@ void catchSomething() throws Exception {
     final byte[] originalBytes = classLoader.getBytes(name);
     final byte[] transformed = instrumentationService.transform(null, name, null, null, originalBytes);
     // we do this here so each test can save the modified bytes, else as they all use the same target class they would stomp over each other
-    TransformerUtils.storeUnsafe(disPath, originalBytes, transformed, name + Thread.currentThread().getStackTrace()[1].getMethodName());
+    TransformerUtils.storeUnsafe(disPath, originalBytes, transformed,
+        name + "_" + Thread.currentThread().getStackTrace()[1].getMethodName());
 
     assertNotNull(transformed, "Failed to transform the test class!");
     assertNotEquals(originalBytes.length, transformed.length);
@@ -700,7 +723,7 @@ void catchSomething() throws Exception {
     final ArgumentCaptor<EventSnapshot> argumentCaptor = ArgumentCaptor.forClass(EventSnapshot.class);
 
     Mockito.verify(pushService, times(1))
-        .pushSnapshot(argumentCaptor.capture(), Mockito.any());
+        .pushSnapshot(argumentCaptor.capture());
 
     final EventSnapshot value = argumentCaptor.getValue();
     assertEquals(tracepointConfig.getId(), value.getTracepoint().getId());
@@ -747,7 +770,8 @@ void finallySomething() throws Exception {
     final byte[] originalBytes = classLoader.getBytes(name);
     final byte[] transformed = instrumentationService.transform(null, name, null, null, originalBytes);
     // we do this here so each test can save the modified bytes, else as they all use the same target class they would stomp over each other
-    TransformerUtils.storeUnsafe(disPath, originalBytes, transformed, name + Thread.currentThread().getStackTrace()[1].getMethodName());
+    TransformerUtils.storeUnsafe(disPath, originalBytes, transformed,
+        name + "_" + Thread.currentThread().getStackTrace()[1].getMethodName());
 
     assertNotNull(transformed, "Failed to transform the test class!");
     assertNotEquals(originalBytes.length, transformed.length);
@@ -768,7 +792,7 @@ void finallySomething() throws Exception {
     final ArgumentCaptor<EventSnapshot> argumentCaptor = ArgumentCaptor.forClass(EventSnapshot.class);
 
     Mockito.verify(pushService, times(1))
-        .pushSnapshot(argumentCaptor.capture(), Mockito.any());
+        .pushSnapshot(argumentCaptor.capture());
 
     final EventSnapshot value = argumentCaptor.getValue();
     assertEquals(tracepointConfig.getId(), value.getTracepoint().getId());
@@ -815,7 +839,8 @@ void conditionalThrow() throws Exception {
     final byte[] originalBytes = classLoader.getBytes(name);
     final byte[] transformed = instrumentationService.transform(null, name, null, null, originalBytes);
     // we do this here so each test can save the modified bytes, else as they all use the same target class they would stomp over each other
-    TransformerUtils.storeUnsafe(disPath, originalBytes, transformed, name + Thread.currentThread().getStackTrace()[1].getMethodName());
+    TransformerUtils.storeUnsafe(disPath, originalBytes, transformed,
+        name + "_" + Thread.currentThread().getStackTrace()[1].getMethodName());
 
     assertNotNull(transformed, "Failed to transform the test class!");
     assertNotEquals(originalBytes.length, transformed.length);
@@ -836,11 +861,11 @@ void conditionalThrow() throws Exception {
     final ArgumentCaptor<EventSnapshot> argumentCaptor = ArgumentCaptor.forClass(EventSnapshot.class);
 
     Mockito.verify(pushService, Mockito.never())
-        .pushSnapshot(argumentCaptor.capture(), Mockito.any());
+        .pushSnapshot(argumentCaptor.capture());
 
     assertThrows(InvocationTargetException.class, () -> method.invoke(myTest, 3, 2));
     Mockito.verify(pushService, times(1))
-        .pushSnapshot(argumentCaptor.capture(), Mockito.any());
+        .pushSnapshot(argumentCaptor.capture());
 
     final EventSnapshot value = argumentCaptor.getValue();
     assertEquals(tracepointConfig.getId(), value.getTracepoint().getId());
@@ -887,7 +912,8 @@ void breakSomething() throws Exception {
     final byte[] originalBytes = classLoader.getBytes(name);
     final byte[] transformed = instrumentationService.transform(null, name, null, null, originalBytes);
     // we do this here so each test can save the modified bytes, else as they all use the same target class they would stomp over each other
-    TransformerUtils.storeUnsafe(disPath, originalBytes, transformed, name + Thread.currentThread().getStackTrace()[1].getMethodName());
+    TransformerUtils.storeUnsafe(disPath, originalBytes, transformed,
+        name + "_" + Thread.currentThread().getStackTrace()[1].getMethodName());
 
     assertNotNull(transformed, "Failed to transform the test class!");
     assertNotEquals(originalBytes.length, transformed.length);
@@ -908,7 +934,7 @@ void breakSomething() throws Exception {
     final ArgumentCaptor<EventSnapshot> argumentCaptor = ArgumentCaptor.forClass(EventSnapshot.class);
 
     Mockito.verify(pushService, times(1))
-        .pushSnapshot(argumentCaptor.capture(), Mockito.any());
+        .pushSnapshot(argumentCaptor.capture());
 
     final EventSnapshot value = argumentCaptor.getValue();
     assertEquals(tracepointConfig.getId(), value.getTracepoint().getId());
@@ -955,7 +981,8 @@ void continueSomething() throws Exception {
     final byte[] originalBytes = classLoader.getBytes(name);
     final byte[] transformed = instrumentationService.transform(null, name, null, null, originalBytes);
     // we do this here so each test can save the modified bytes, else as they all use the same target class they would stomp over each other
-    TransformerUtils.storeUnsafe(disPath, originalBytes, transformed, name + Thread.currentThread().getStackTrace()[1].getMethodName());
+    TransformerUtils.storeUnsafe(disPath, originalBytes, transformed,
+        name + "_" + Thread.currentThread().getStackTrace()[1].getMethodName());
 
     assertNotNull(transformed, "Failed to transform the test class!");
     assertNotEquals(originalBytes.length, transformed.length);
@@ -976,7 +1003,7 @@ void continueSomething() throws Exception {
     final ArgumentCaptor<EventSnapshot> argumentCaptor = ArgumentCaptor.forClass(EventSnapshot.class);
 
     Mockito.verify(pushService, times(1))
-        .pushSnapshot(argumentCaptor.capture(), Mockito.any());
+        .pushSnapshot(argumentCaptor.capture());
 
     final EventSnapshot value = argumentCaptor.getValue();
     assertEquals(tracepointConfig.getId(), value.getTracepoint().getId());
@@ -1049,7 +1076,7 @@ void superConstructor() throws Exception {
     final ArgumentCaptor<EventSnapshot> argumentCaptor = ArgumentCaptor.forClass(EventSnapshot.class);
 
     Mockito.verify(pushService, times(1))
-        .pushSnapshot(argumentCaptor.capture(), Mockito.any());
+        .pushSnapshot(argumentCaptor.capture());
 
     final EventSnapshot value = argumentCaptor.getValue();
     assertEquals(tracepointConfig.getId(), value.getTracepoint().getId());
@@ -1092,7 +1119,8 @@ void multipleTps_oneLine() throws Exception {
     final byte[] originalBytes = classLoader.getBytes(name);
     final byte[] transformed = instrumentationService.transform(null, name, null, null, originalBytes);
     // we do this here so each test can save the modified bytes, else as they all use the same target class they would stomp over each other
-    TransformerUtils.storeUnsafe(disPath, originalBytes, transformed, name + Thread.currentThread().getStackTrace()[1].getMethodName());
+    TransformerUtils.storeUnsafe(disPath, originalBytes, transformed,
+        name + "_" + Thread.currentThread().getStackTrace()[1].getMethodName());
 
     assertNotNull(transformed, "Failed to transform the test class!");
     assertNotEquals(originalBytes.length, transformed.length);
@@ -1113,7 +1141,7 @@ void multipleTps_oneLine() throws Exception {
     final ArgumentCaptor<EventSnapshot> argumentCaptor = ArgumentCaptor.forClass(EventSnapshot.class);
 
     Mockito.verify(pushService, times(2))
-        .pushSnapshot(argumentCaptor.capture(), Mockito.any());
+        .pushSnapshot(argumentCaptor.capture());
 
     final EventSnapshot value = argumentCaptor.getValue();
     assertEquals(tracepointConfig.getId(), value.getTracepoint().getId());
@@ -1161,7 +1189,8 @@ void multipleTps_nextLine() throws Exception {
     final byte[] originalBytes = classLoader.getBytes(name);
     final byte[] transformed = instrumentationService.transform(null, name, null, null, originalBytes);
     // we do this here so each test can save the modified bytes, else as they all use the same target class they would stomp over each other
-    TransformerUtils.storeUnsafe(disPath, originalBytes, transformed, name + Thread.currentThread().getStackTrace()[1].getMethodName());
+    TransformerUtils.storeUnsafe(disPath, originalBytes, transformed,
+        name + "_" + Thread.currentThread().getStackTrace()[1].getMethodName());
 
     assertNotNull(transformed, "Failed to transform the test class!");
     assertNotEquals(originalBytes.length, transformed.length);
@@ -1182,7 +1211,7 @@ void multipleTps_nextLine() throws Exception {
     final ArgumentCaptor<EventSnapshot> argumentCaptor = ArgumentCaptor.forClass(EventSnapshot.class);
 
     Mockito.verify(pushService, times(2))
-        .pushSnapshot(argumentCaptor.capture(), Mockito.any());
+        .pushSnapshot(argumentCaptor.capture());
 
     final EventSnapshot value = argumentCaptor.getValue();
     assertEquals(tracepointConfig.getId(), value.getTracepoint().getId());
@@ -1228,7 +1257,8 @@ void someFunctionWithABody() throws Exception {
     final byte[] originalBytes = classLoader.getBytes(name);
     final byte[] transformed = instrumentationService.transform(null, name, null, null, originalBytes);
     // we do this here so each test can save the modified bytes, else as they all use the same target class they would stomp over each other
-    TransformerUtils.storeUnsafe(disPath, originalBytes, transformed, name + Thread.currentThread().getStackTrace()[1].getMethodName());
+    TransformerUtils.storeUnsafe(disPath, originalBytes, transformed,
+        name + "_" + Thread.currentThread().getStackTrace()[1].getMethodName());
 
     assertNotNull(transformed, "Failed to transform the test class!");
     assertNotEquals(originalBytes.length, transformed.length);
@@ -1249,7 +1279,7 @@ void someFunctionWithABody() throws Exception {
     final ArgumentCaptor<EventSnapshot> argumentCaptor = ArgumentCaptor.forClass(EventSnapshot.class);
 
     Mockito.verify(pushService, times(1))
-        .pushSnapshot(argumentCaptor.capture(), Mockito.any());
+        .pushSnapshot(argumentCaptor.capture());
 
     final EventSnapshot value = argumentCaptor.getValue();
     assertEquals(tracepointConfig.getId(), value.getTracepoint().getId());
@@ -1307,7 +1337,8 @@ void cfVisitor() throws Exception {
 
     final byte[] transformed = instrumentationService.transform(null, name, null, null, originalBytes);
     // we do this here so each test can save the modified bytes, else as they all use the same target class they would stomp over each other
-    TransformerUtils.storeUnsafe(disPath, originalBytes, transformed, name + Thread.currentThread().getStackTrace()[1].getMethodName());
+    TransformerUtils.storeUnsafe(disPath, originalBytes, transformed,
+        name + "_" + Thread.currentThread().getStackTrace()[1].getMethodName());
 
     assertNotNull(transformed, "Failed to transform the test class!");
     assertNotEquals(originalBytes.length, transformed.length);
@@ -1352,7 +1383,8 @@ void jspVisitorTest() throws Exception {
 
     final byte[] transformed = instrumentationService.transform(null, name, null, null, originalBytes);
     // we do this here so each test can save the modified bytes, else as they all use the same target class they would stomp over each other
-    TransformerUtils.storeUnsafe(disPath, originalBytes, transformed, name + Thread.currentThread().getStackTrace()[1].getMethodName());
+    TransformerUtils.storeUnsafe(disPath, originalBytes, transformed,
+        name + "_" + Thread.currentThread().getStackTrace()[1].getMethodName());
 
     assertNotNull(transformed, "Failed to transform the test class!");
     assertNotEquals(originalBytes.length, transformed.length);
@@ -1384,7 +1416,7 @@ void jspVisitorTest() throws Exception {
     final ArgumentCaptor<EventSnapshot> argumentCaptor = ArgumentCaptor.forClass(EventSnapshot.class);
 
     Mockito.verify(pushService, times(1))
-        .pushSnapshot(argumentCaptor.capture(), Mockito.any());
+        .pushSnapshot(argumentCaptor.capture());
 
     final EventSnapshot value = argumentCaptor.getValue();
 
@@ -1412,7 +1444,8 @@ void luceeVisitorTest() throws Exception {
 
     final byte[] transformed = instrumentationService.transform(null, name, null, null, originalBytes);
     // we do this here so each test can save the modified bytes, else as they all use the same target class they would stomp over each other
-    TransformerUtils.storeUnsafe(disPath, originalBytes, transformed, name + Thread.currentThread().getStackTrace()[1].getMethodName());
+    TransformerUtils.storeUnsafe(disPath, originalBytes, transformed,
+        name + "_" + Thread.currentThread().getStackTrace()[1].getMethodName());
 
     assertNotNull(transformed, "Failed to transform test class.");
     assertNotEquals(originalBytes.length, transformed.length);
@@ -1429,7 +1462,7 @@ void luceeVisitorTest() throws Exception {
     final ArgumentCaptor<EventSnapshot> argumentCaptor = ArgumentCaptor.forClass(EventSnapshot.class);
 
     Mockito.verify(pushService, times(1))
-        .pushSnapshot(argumentCaptor.capture(), Mockito.any());
+        .pushSnapshot(argumentCaptor.capture());
 
     final EventSnapshot value = argumentCaptor.getValue();
     assertNotNull(value);
@@ -1449,7 +1482,7 @@ void methodWrapperTest() throws Exception {
     Mockito.when(settings.getPlugin(ITraceProvider.class)).thenReturn(traceProviderSpy);
     final MockTracepointConfig tracepointConfig = new MockTracepointConfig(
         "/agent/src/test/java/com/intergral/deep/test/target/BPTestTarget.java", 151)
-        .withArg(TracePointConfig.METHOD_NAME, "someFunctionWithABody");
+        .withArg(TracePointConfig.METHOD_NAME, "someFunctionWithABody").withArg(TracePointConfig.SPAN, TracePointConfig.METHOD);
 
     tracepointRef.set(Collections.singletonList(tracepointConfig));
 
@@ -1461,7 +1494,8 @@ void methodWrapperTest() throws Exception {
     final byte[] originalBytes = classLoader.getBytes(name);
     final byte[] transformed = instrumentationService.transform(null, name, null, null, originalBytes);
     // we do this here so each test can save the modified bytes, else as they all use the same target class they would stomp over each other
-    TransformerUtils.storeUnsafe(disPath, originalBytes, transformed, name + Thread.currentThread().getStackTrace()[1].getMethodName());
+    TransformerUtils.storeUnsafe(disPath, originalBytes, transformed,
+        name + "_" + Thread.currentThread().getStackTrace()[1].getMethodName());
 
     assertNotNull(transformed, "Failed to transform the test class!");
     assertNotEquals(originalBytes.length, transformed.length);
@@ -1482,14 +1516,20 @@ void methodWrapperTest() throws Exception {
     final ArgumentCaptor<EventSnapshot> argumentCaptor = ArgumentCaptor.forClass(EventSnapshot.class);
 
     Mockito.verify(pushService, times(1))
-        .pushSnapshot(argumentCaptor.capture(), Mockito.any());
+        .pushSnapshot(argumentCaptor.capture());
 
     final EventSnapshot value = argumentCaptor.getValue();
     assertEquals(tracepointConfig.getId(), value.getTracepoint().getId());
 
     final Snapshot snapshot = PushUtils.convertToGrpc(value);
 
-    Mockito.verify(traceProviderSpy, times(1)).createSpan("someFunctionWithABody");
+    Mockito.verify(traceProviderSpy, times(1)).createSpan("someFunctionWithABody(Ljava/lang/String;)Ljava/lang/String;");
+
+    final IVariableScan someArg = SnapshotUtils.findVarByName("someArg", snapshot);
+
+    assertTrue(someArg.found());
+
+    assertEquals("some string", someArg.variable().getValue());
   }
 
   @Test
@@ -1501,7 +1541,67 @@ void methodWrapperVoidTest() throws Exception {
 
     final MockTracepointConfig tracepointConfig = new MockTracepointConfig(
         "/agent/src/test/java/com/intergral/deep/test/target/BPTestTarget.java", 51)
-        .withArg(TracePointConfig.METHOD_NAME, "setName");
+        .withArg(TracePointConfig.METHOD_NAME, "setName").withArg(TracePointConfig.SPAN, TracePointConfig.METHOD);
+
+    tracepointRef.set(Collections.singletonList(tracepointConfig));
+
+    final String name = "com/intergral/deep/test/target/BPTestTarget";
+    final ByteClassLoader classLoader = ByteClassLoader.forFile(name);
+
+    instrumentationService.processBreakpoints(Collections.singletonList(tracepointConfig));
+
+    final byte[] originalBytes = classLoader.getBytes(name);
+    final byte[] transformed = instrumentationService.transform(null, name, null, null, originalBytes);
+    // we do this here so each test can save the modified bytes, else as they all use the same target class they would stomp over each other
+    TransformerUtils.storeUnsafe(disPath, originalBytes, transformed,
+        name + "_" + Thread.currentThread().getStackTrace()[1].getMethodName());
+
+    assertNotNull(transformed, "Failed to transform the test class!");
+    assertNotEquals(originalBytes.length, transformed.length);
+
+    final String clazzName = InstUtils.externalClassName(name);
+    classLoader.setBytes(clazzName, transformed);
+
+    final Class<?> aClass = classLoader.loadClass(clazzName);
+    assertNotNull(aClass);
+
+    final Constructor<?> constructor = aClass.getConstructor(String.class, int.class);
+    final Object myTest = constructor.newInstance(null, 4);
+    assertNotNull(myTest);
+
+    final Method method = aClass.getDeclaredMethod("setName", String.class);
+    method.invoke(myTest, "some string");
+
+    final ArgumentCaptor<EventSnapshot> argumentCaptor = ArgumentCaptor.forClass(EventSnapshot.class);
+
+    Mockito.verify(pushService, times(1))
+        .pushSnapshot(argumentCaptor.capture());
+
+    final EventSnapshot value = argumentCaptor.getValue();
+    assertEquals(tracepointConfig.getId(), value.getTracepoint().getId());
+
+    final Snapshot snapshot = PushUtils.convertToGrpc(value);
+
+    Mockito.verify(traceProviderSpy, times(1)).createSpan("setName(Ljava/lang/String;)V");
+
+    final IVariableScan someArg = SnapshotUtils.findVarByName("name", snapshot);
+
+    assertTrue(someArg.found());
+
+    assertEquals("some string", someArg.variable().getValue());
+
+  }
+
+  @Test
+  void methodWrapperVoidTestWithTP() throws Exception {
+    final MockTraceProvider traceProvider = new MockTraceProvider();
+    final MockTraceProvider traceProviderSpy = Mockito.spy(traceProvider);
+
+    Mockito.when(settings.getPlugin(ITraceProvider.class)).thenReturn(traceProviderSpy);
+
+    final MockTracepointConfig tracepointConfig = new MockTracepointConfig(
+        "/agent/src/test/java/com/intergral/deep/test/target/BPTestTarget.java", 51)
+        .withArg(TracePointConfig.SPAN, TracePointConfig.METHOD);
 
     tracepointRef.set(Collections.singletonList(tracepointConfig));
 
@@ -1513,7 +1613,8 @@ void methodWrapperVoidTest() throws Exception {
     final byte[] originalBytes = classLoader.getBytes(name);
     final byte[] transformed = instrumentationService.transform(null, name, null, null, originalBytes);
     // we do this here so each test can save the modified bytes, else as they all use the same target class they would stomp over each other
-    TransformerUtils.storeUnsafe(disPath, originalBytes, transformed, name + Thread.currentThread().getStackTrace()[1].getMethodName());
+    TransformerUtils.storeUnsafe(disPath, originalBytes, transformed,
+        name + "_" + Thread.currentThread().getStackTrace()[1].getMethodName());
 
     assertNotNull(transformed, "Failed to transform the test class!");
     assertNotEquals(originalBytes.length, transformed.length);
@@ -1534,15 +1635,320 @@ void methodWrapperVoidTest() throws Exception {
     final ArgumentCaptor<EventSnapshot> argumentCaptor = ArgumentCaptor.forClass(EventSnapshot.class);
 
     Mockito.verify(pushService, times(1))
-        .pushSnapshot(argumentCaptor.capture(), Mockito.any());
+        .pushSnapshot(argumentCaptor.capture());
 
     final EventSnapshot value = argumentCaptor.getValue();
     assertEquals(tracepointConfig.getId(), value.getTracepoint().getId());
 
     final Snapshot snapshot = PushUtils.convertToGrpc(value);
 
-    Mockito.verify(traceProviderSpy, times(1)).createSpan("setName");
+    Mockito.verify(traceProviderSpy, times(1)).createSpan("setName(Ljava/lang/String;)V");
+
+    final IVariableScan someArg = SnapshotUtils.findVarByName("name", snapshot);
+
+    assertTrue(someArg.found());
+
+    assertEquals("some string", someArg.variable().getValue());
+
+  }
+
+  @Test
+  void methodEntryTP() throws Exception {
+    final MockTraceProvider traceProvider = new MockTraceProvider();
+    final MockTraceProvider traceProviderSpy = Mockito.spy(traceProvider);
+
+    Mockito.when(settings.getPlugin(ITraceProvider.class)).thenReturn(traceProviderSpy);
+
+    final MockTracepointConfig tracepointConfig = new MockTracepointConfig(
+        "/agent/src/test/java/com/intergral/deep/test/target/BPTestTarget.java", -1)
+        .withArg(TracePointConfig.METHOD_NAME, "someOverloaded")
+        .withArg(TracePointConfig.SPAN, TracePointConfig.METHOD)
+        .withArg(TracePointConfig.FIRE_COUNT, "-1")
+        .withArg(TracePointConfig.FIRE_PERIOD, "0");
+
+    tracepointRef.set(Collections.singletonList(tracepointConfig));
+
+    final String name = "com/intergral/deep/test/target/BPTestTarget";
+    final ByteClassLoader classLoader = ByteClassLoader.forFile(name);
+
+    instrumentationService.processBreakpoints(Collections.singletonList(tracepointConfig));
+
+    final byte[] originalBytes = classLoader.getBytes(name);
+    final byte[] transformed = instrumentationService.transform(null, name, null, null, originalBytes);
+    // we do this here so each test can save the modified bytes, else as they all use the same target class they would stomp over each other
+    TransformerUtils.storeUnsafe(disPath, originalBytes, transformed,
+        name + "_" + Thread.currentThread().getStackTrace()[1].getMethodName());
+
+    assertNotNull(transformed, "Failed to transform the test class!");
+    assertNotEquals(originalBytes.length, transformed.length);
+
+    final String clazzName = InstUtils.externalClassName(name);
+    classLoader.setBytes(clazzName, transformed);
+
+    final Class<?> aClass = classLoader.loadClass(clazzName);
+    assertNotNull(aClass);
+
+    final Constructor<?> constructor = aClass.getConstructor(String.class, int.class);
+    final Object myTest = constructor.newInstance(null, 4);
+    assertNotNull(myTest);
+
+    final Method method = aClass.getDeclaredMethod("someOverloaded");
+    method.invoke(myTest);
+
+    final ArgumentCaptor<EventSnapshot> argumentCaptor = ArgumentCaptor.forClass(EventSnapshot.class);
+
+    Mockito.verify(pushService, times(2))
+        .pushSnapshot(argumentCaptor.capture());
+
+    Mockito.verify(traceProviderSpy, times(1)).createSpan("someOverloaded()V");
+    Mockito.verify(traceProviderSpy, times(1)).createSpan("someOverloaded(Ljava/lang/String;)V");
+
+    final EventSnapshot first = argumentCaptor.getAllValues().get(0);
+    assertEquals(tracepointConfig.getId(), first.getTracepoint().getId());
+    final Snapshot snapshotTheFirst = PushUtils.convertToGrpc(first);
+
+    final IVariableScan variableScanTheFirst = SnapshotUtils.findVarByName("name", snapshotTheFirst);
+    assertFalse(variableScanTheFirst.found());
+
+    final EventSnapshot second = argumentCaptor.getAllValues().get(1);
+    assertEquals(tracepointConfig.getId(), second.getTracepoint().getId());
+    final Snapshot snapshotTheSecond = PushUtils.convertToGrpc(second);
+
+    final IVariableScan variableScanTheSecond = SnapshotUtils.findVarByName("name", snapshotTheSecond);
+    assertTrue(variableScanTheSecond.found());
+
+    assertEquals("test", variableScanTheSecond.variable().getValue());
+  }
+
+  @Test
+  void methodEntryTPCaptureReturn() throws Exception {
+    final MockTraceProvider traceProvider = new MockTraceProvider();
+    final MockTraceProvider traceProviderSpy = Mockito.spy(traceProvider);
+
+    Mockito.when(settings.getPlugin(ITraceProvider.class)).thenReturn(traceProviderSpy);
+
+    final MockTracepointConfig tracepointConfig = new MockTracepointConfig(
+        "/agent/src/test/java/com/intergral/deep/test/target/BPTestTarget.java", -1)
+        .withArg(TracePointConfig.METHOD_NAME, "getName")
+        .withArg(TracePointConfig.STAGE, TracePointConfig.METHOD_END)
+        .withArg(TracePointConfig.FIRE_COUNT, "-1")
+        .withArg(TracePointConfig.FIRE_PERIOD, "0");
+
+    tracepointRef.set(Collections.singletonList(tracepointConfig));
+
+    final String name = "com/intergral/deep/test/target/BPTestTarget";
+    final ByteClassLoader classLoader = ByteClassLoader.forFile(name);
+
+    instrumentationService.processBreakpoints(Collections.singletonList(tracepointConfig));
+
+    final byte[] originalBytes = classLoader.getBytes(name);
+    final byte[] transformed = instrumentationService.transform(null, name, null, null, originalBytes);
+    // we do this here so each test can save the modified bytes, else as they all use the same target class they would stomp over each other
+    TransformerUtils.storeUnsafe(disPath, originalBytes, transformed,
+        name + "_" + Thread.currentThread().getStackTrace()[1].getMethodName());
+
+    assertNotNull(transformed, "Failed to transform the test class!");
+    assertNotEquals(originalBytes.length, transformed.length);
+
+    final String clazzName = InstUtils.externalClassName(name);
+    classLoader.setBytes(clazzName, transformed);
+
+    final Class<?> aClass = classLoader.loadClass(clazzName);
+    assertNotNull(aClass);
+
+    final Constructor<?> constructor = aClass.getConstructor(String.class, int.class);
+    final Object myTest = constructor.newInstance(null, 4);
+    assertNotNull(myTest);
+
+    final Method method = aClass.getDeclaredMethod("getName");
+    method.invoke(myTest);
+
+    final ArgumentCaptor<EventSnapshot> argumentCaptor = ArgumentCaptor.forClass(EventSnapshot.class);
+
+    Mockito.verify(pushService, times(1))
+        .pushSnapshot(argumentCaptor.capture());
+
+    Mockito.verify(traceProviderSpy, times(0)).createSpan("getName()Ljava/lang/String");
+
+    watchValidator("return").accept(argumentCaptor.getAllValues());
+  }
+
+  @Test
+  void methodEntryTPNoTrace() throws Exception {
+    final MockTraceProvider traceProvider = new MockTraceProvider();
+    final MockTraceProvider traceProviderSpy = Mockito.spy(traceProvider);
+
+    Mockito.when(settings.getPlugin(ITraceProvider.class)).thenReturn(traceProviderSpy);
+
+    final MockTracepointConfig tracepointConfig = new MockTracepointConfig(
+        "/agent/src/test/java/com/intergral/deep/test/target/BPTestTarget.java", -1)
+        .withArg(TracePointConfig.METHOD_NAME, "someOverloaded")
+        .withArg(TracePointConfig.STAGE, TracePointConfig.METHOD_CAPTURE)
+        .withArg(TracePointConfig.FIRE_COUNT, "-1")
+        .withArg(TracePointConfig.FIRE_PERIOD, "0");
+
+    tracepointRef.set(Collections.singletonList(tracepointConfig));
+
+    final String name = "com/intergral/deep/test/target/BPTestTarget";
+    final ByteClassLoader classLoader = ByteClassLoader.forFile(name);
+
+    instrumentationService.processBreakpoints(Collections.singletonList(tracepointConfig));
+
+    final byte[] originalBytes = classLoader.getBytes(name);
+    final byte[] transformed = instrumentationService.transform(null, name, null, null, originalBytes);
+    // we do this here so each test can save the modified bytes, else as they all use the same target class they would stomp over each other
+    TransformerUtils.storeUnsafe(disPath, originalBytes, transformed,
+        name + "_" + Thread.currentThread().getStackTrace()[1].getMethodName());
+
+    assertNotNull(transformed, "Failed to transform the test class!");
+    assertNotEquals(originalBytes.length, transformed.length);
+
+    final String clazzName = InstUtils.externalClassName(name);
+    classLoader.setBytes(clazzName, transformed);
+
+    final Class<?> aClass = classLoader.loadClass(clazzName);
+    assertNotNull(aClass);
+
+    final Constructor<?> constructor = aClass.getConstructor(String.class, int.class);
+    final Object myTest = constructor.newInstance(null, 4);
+    assertNotNull(myTest);
+
+    final Method method = aClass.getDeclaredMethod("someOverloaded");
+    method.invoke(myTest);
+
+    final ArgumentCaptor<EventSnapshot> argumentCaptor = ArgumentCaptor.forClass(EventSnapshot.class);
+
+    Mockito.verify(pushService, times(2))
+        .pushSnapshot(argumentCaptor.capture());
+
+    Mockito.verify(traceProviderSpy, times(0)).createSpan("someOverloaded()V");
+    Mockito.verify(traceProviderSpy, times(0)).createSpan("someOverloaded(Ljava/lang/String;)V");
+
+    final EventSnapshot first = argumentCaptor.getAllValues().get(1);
+    assertEquals(tracepointConfig.getId(), first.getTracepoint().getId());
+    final Snapshot snapshotTheFirst = PushUtils.convertToGrpc(first);
+
+    final IVariableScan variableScanTheFirst = SnapshotUtils.findVarByName("name", snapshotTheFirst);
+    assertFalse(variableScanTheFirst.found());
+
+    final EventSnapshot second = argumentCaptor.getAllValues().get(0);
+    assertEquals(tracepointConfig.getId(), second.getTracepoint().getId());
+    final Snapshot snapshotTheSecond = PushUtils.convertToGrpc(second);
+
+    final IVariableScan variableScanTheSecond = SnapshotUtils.findVarByName("name", snapshotTheSecond);
+    assertTrue(variableScanTheSecond.found());
+
+    assertEquals("test", variableScanTheSecond.variable().getValue());
+  }
+
+  @Test
+  void methodEntryTPTraceOnly() throws Exception {
+    final MockTraceProvider traceProvider = new MockTraceProvider();
+    final MockTraceProvider traceProviderSpy = Mockito.spy(traceProvider);
+
+    Mockito.when(settings.getPlugin(ITraceProvider.class)).thenReturn(traceProviderSpy);
+
+    final MockTracepointConfig tracepointConfig = new MockTracepointConfig(
+        "/agent/src/test/java/com/intergral/deep/test/target/BPTestTarget.java", -1)
+        .withArg(TracePointConfig.METHOD_NAME, "someOverloaded")
+        .withArg(TracePointConfig.SPAN, TracePointConfig.METHOD)
+        .withArg(TracePointConfig.SNAPSHOT, TracePointConfig.NO_COLLECT)
+        .withArg(TracePointConfig.FIRE_COUNT, "-1")
+        .withArg(TracePointConfig.FIRE_PERIOD, "0");
+
+    tracepointRef.set(Collections.singletonList(tracepointConfig));
+
+    final String name = "com/intergral/deep/test/target/BPTestTarget";
+    final ByteClassLoader classLoader = ByteClassLoader.forFile(name);
+
+    instrumentationService.processBreakpoints(Collections.singletonList(tracepointConfig));
+
+    final byte[] originalBytes = classLoader.getBytes(name);
+    final byte[] transformed = instrumentationService.transform(null, name, null, null, originalBytes);
+    // we do this here so each test can save the modified bytes, else as they all use the same target class they would stomp over each other
+    TransformerUtils.storeUnsafe(disPath, originalBytes, transformed,
+        name + "_" + Thread.currentThread().getStackTrace()[1].getMethodName());
+
+    assertNotNull(transformed, "Failed to transform the test class!");
+    assertNotEquals(originalBytes.length, transformed.length);
+
+    final String clazzName = InstUtils.externalClassName(name);
+    classLoader.setBytes(clazzName, transformed);
+
+    final Class<?> aClass = classLoader.loadClass(clazzName);
+    assertNotNull(aClass);
+
+    final Constructor<?> constructor = aClass.getConstructor(String.class, int.class);
+    final Object myTest = constructor.newInstance(null, 4);
+    assertNotNull(myTest);
+
+    final Method method = aClass.getDeclaredMethod("someOverloaded");
+    method.invoke(myTest);
+
+    final ArgumentCaptor<EventSnapshot> argumentCaptor = ArgumentCaptor.forClass(EventSnapshot.class);
+
+    Mockito.verify(pushService, times(0))
+        .pushSnapshot(argumentCaptor.capture());
+
+    Mockito.verify(traceProviderSpy, times(1)).createSpan("someOverloaded()V");
+    Mockito.verify(traceProviderSpy, times(1)).createSpan("someOverloaded(Ljava/lang/String;)V");
+  }
+
+  @Test
+  void methodEntryTPTraceOnlyConditional() throws Exception {
+    final MockTraceProvider traceProvider = new MockTraceProvider();
+    final MockTraceProvider traceProviderSpy = Mockito.spy(traceProvider);
+
+    Mockito.when(settings.getPlugin(ITraceProvider.class)).thenReturn(traceProviderSpy);
+
+    final MockTracepointConfig tracepointConfig = Mockito.spy(new MockTracepointConfig(
+        "/agent/src/test/java/com/intergral/deep/test/target/BPTestTarget.java", -1)
+        .withArg(TracePointConfig.CONDITION, "name == null")
+        .withArg(TracePointConfig.METHOD_NAME, "someOverloaded")
+        .withArg(TracePointConfig.SPAN, TracePointConfig.METHOD)
+        .withArg(TracePointConfig.SNAPSHOT, TracePointConfig.NO_COLLECT)
+        .withArg(TracePointConfig.FIRE_COUNT, "-1")
+        .withArg(TracePointConfig.FIRE_PERIOD, "0"));
+
+    tracepointRef.set(Collections.singletonList(tracepointConfig));
+
+    final String name = "com/intergral/deep/test/target/BPTestTarget";
+    final ByteClassLoader classLoader = ByteClassLoader.forFile(name);
+
+    instrumentationService.processBreakpoints(Collections.singletonList(tracepointConfig));
 
+    final byte[] originalBytes = classLoader.getBytes(name);
+    final byte[] transformed = instrumentationService.transform(null, name, null, null, originalBytes);
+    // we do this here so each test can save the modified bytes, else as they all use the same target class they would stomp over each other
+    TransformerUtils.storeUnsafe(disPath, originalBytes, transformed,
+        name + "_" + Thread.currentThread().getStackTrace()[1].getMethodName());
+
+    assertNotNull(transformed, "Failed to transform the test class!");
+    assertNotEquals(originalBytes.length, transformed.length);
+
+    final String clazzName = InstUtils.externalClassName(name);
+    classLoader.setBytes(clazzName, transformed);
+
+    final Class<?> aClass = classLoader.loadClass(clazzName);
+    assertNotNull(aClass);
+
+    final Constructor<?> constructor = aClass.getConstructor(String.class, int.class);
+    final Object myTest = constructor.newInstance(null, 4);
+    assertNotNull(myTest);
+
+    final Method method = aClass.getDeclaredMethod("someOverloaded");
+    method.invoke(myTest);
+
+    final ArgumentCaptor<EventSnapshot> argumentCaptor = ArgumentCaptor.forClass(EventSnapshot.class);
+
+    Mockito.verify(pushService, times(0))
+        .pushSnapshot(argumentCaptor.capture());
+
+    Mockito.verify(traceProviderSpy, times(0)).createSpan("someOverloaded()V");
+    Mockito.verify(traceProviderSpy, times(0)).createSpan("someOverloaded(Ljava/lang/String;)V");
+
+    // difficult to verify this test - bet we can do is check the tracepoint was used
+    Mockito.verify(tracepointConfig, times(2)).getCondition();
   }
 
   public static class MockTraceProvider implements IDeepPlugin, ITraceProvider {
@@ -1566,7 +1972,12 @@ public String spanId() {
         }
 
         @Override
-        public void close() throws Exception {
+        public void addAttribute(final String key, final String value) {
+
+        }
+
+        @Override
+        public void close() {
 
         }
       };
@@ -1577,4 +1988,130 @@ public ISpan currentSpan() {
       return null;
     }
   }
+
+
+  @ParameterizedTest()
+  @MethodSource("tracepointLocations")
+  void testTracepointLocations(final String testName, final TracePointConfig config, final int snapshots,
+      final Consumer<List<EventSnapshot>> validate)
+      throws Exception {
+    final MockTraceProvider traceProvider = new MockTraceProvider();
+    final MockTraceProvider traceProviderSpy = Mockito.spy(traceProvider);
+
+    Mockito.when(settings.getPlugin(ITraceProvider.class)).thenReturn(traceProviderSpy);
+
+    final TracePointConfig tracepointConfig = Mockito.spy(config);
+
+    tracepointRef.set(Collections.singletonList(tracepointConfig));
+
+    final String name = "com/intergral/deep/test/target/BPTestTarget";
+    final ByteClassLoader classLoader = ByteClassLoader.forFile(name);
+
+    instrumentationService.processBreakpoints(Collections.singletonList(tracepointConfig));
+
+    final byte[] originalBytes = classLoader.getBytes(name);
+    final byte[] transformed = instrumentationService.transform(null, name, null, null, originalBytes);
+    // we do this here so each test can save the modified bytes, else as they all use the same target class they would stomp over each other
+    TransformerUtils.storeUnsafe(disPath, originalBytes, transformed,
+        name + "_" + testName + "_" + Thread.currentThread().getStackTrace()[1].getMethodName());
+
+    assertNotNull(transformed, "Failed to transform the test class!");
+    assertNotEquals(originalBytes.length, transformed.length);
+
+    final String clazzName = InstUtils.externalClassName(name);
+    classLoader.setBytes(clazzName, transformed);
+
+    final Class<?> aClass = classLoader.loadClass(clazzName);
+    assertNotNull(aClass);
+
+    final Constructor<?> constructor = aClass.getConstructor(String.class, int.class);
+    final Object myTest = constructor.newInstance("location test", 4);
+    assertNotNull(myTest);
+
+    final Method method = aClass.getDeclaredMethod("locationTestTarget");
+    try {
+      method.invoke(myTest);
+    } catch (Exception ignored) {
+
+    }
+
+    final ArgumentCaptor<EventSnapshot> argumentCaptor = ArgumentCaptor.forClass(EventSnapshot.class);
+
+    Mockito.verify(pushService, times(snapshots))
+        .pushSnapshot(argumentCaptor.capture());
+
+    validate.accept(argumentCaptor.getAllValues());
+  }
+
+  public static Stream<Arguments> tracepointLocations() {
+    return Stream.of(
+        Arguments.of("StartLine205", new MockTracepointConfig("BPTestTarget.java", 205), 1,
+            variableValidator(Collections.singletonMap("this", "BPTestTarget"))),
+        Arguments.of("EndLine205",
+            new MockTracepointConfig("BPTestTarget.java", 205).withArg(TracePointConfig.STAGE, TracePointConfig.LINE_END), 1,
+            variableValidator(Collections.singletonMap("this", "BPTestTarget"))),
+        Arguments.of("StartLine207", new MockTracepointConfig("BPTestTarget.java", 207), 1,
+            variableValidator(Collections.singletonMap("this.name", "location test"))),
+        Arguments.of("EndLine207",
+            new MockTracepointConfig("BPTestTarget.java", 207).withArg(TracePointConfig.STAGE, TracePointConfig.LINE_END), 1,
+            variableValidator(Collections.singletonMap("this.name", "locationTestTarget"))),
+        Arguments.of("LineCapture207",
+            new MockTracepointConfig("BPTestTarget.java", 207).withArg(TracePointConfig.STAGE, TracePointConfig.LINE_CAPTURE), 1,
+            variableValidator(Collections.singletonMap("this.name", "location test"))),
+        Arguments.of("MethodCapture",
+            new MockTracepointConfig("BPTestTarget.java", -1).withArg(TracePointConfig.METHOD_NAME, "locationTestTarget")
+                .withArg(TracePointConfig.STAGE, TracePointConfig.METHOD_CAPTURE), 1,
+            variableValidator(Collections.singletonMap("this.name", "location test"))),
+        Arguments.of("MethodCapture_thrown",
+            new MockTracepointConfig("BPTestTarget.java", -1).withArg(TracePointConfig.METHOD_NAME, "locationTestTarget")
+                .withArg(TracePointConfig.STAGE, TracePointConfig.METHOD_CAPTURE), 1, watchValidator("thrown")),
+        Arguments.of("MethodEntry",
+            new MockTracepointConfig("BPTestTarget.java", -1).withArg(TracePointConfig.METHOD_NAME, "locationTestTarget"), 1,
+            variableValidator(Collections.singletonMap("this.name", "location test"))),
+        Arguments.of("MethodExit",
+            new MockTracepointConfig("BPTestTarget.java", -1).withArg(TracePointConfig.METHOD_NAME, "locationTestTarget")
+                .withArg(TracePointConfig.STAGE, TracePointConfig.METHOD_END), 1,
+            variableValidator(Collections.singletonMap("this.name", "locationTestTarget"))),
+        Arguments.of("MethodEntry_withLineTP",
+            new MockTracepointConfig("BPTestTarget.java", 207).withArg(TracePointConfig.METHOD_NAME, "locationTestTarget"), 1,
+            variableValidator(Collections.singletonMap("this.name", "location test"))),
+        Arguments.of("MethodExit_withLineTP",
+            new MockTracepointConfig("BPTestTarget.java", 207).withArg(TracePointConfig.METHOD_NAME, "locationTestTarget")
+                .withArg(TracePointConfig.STAGE, TracePointConfig.METHOD_END), 1,
+            variableValidator(Collections.singletonMap("this.name", "locationTestTarget")))
+    );
+  }
+
+  public static Consumer<List<EventSnapshot>> watchValidator(final String name) {
+    return eventSnapshots -> {
+      simpleValidate(eventSnapshots);
+      final EventSnapshot eventSnapshot = eventSnapshots.get(0);
+      final ArrayList<WatchResult> watches = eventSnapshot.getWatches();
+      boolean found = false;
+      for (WatchResult watch : watches) {
+        if (watch.expression().equals(name)) {
+          found = true;
+          break;
+        }
+      }
+      assertTrue(found);
+    };
+  }
+
+  public static Consumer<List<EventSnapshot>> variableValidator(final Map<String, String> vars) {
+    return eventSnapshots -> {
+      simpleValidate(eventSnapshots);
+      final EventSnapshot eventSnapshot = eventSnapshots.get(0);
+      final Snapshot snapshot = PushUtils.convertToGrpc(eventSnapshot);
+      for (Entry<String, String> entry : vars.entrySet()) {
+        final IVariableScan variableScan = SnapshotUtils.findVarByPath(entry.getKey(), snapshot);
+        assertTrue(variableScan.found());
+        assertEquals(entry.getValue(), variableScan.variable().getValue());
+      }
+    };
+  }
+
+  public static void simpleValidate(final List<EventSnapshot> snaps) {
+    assertEquals(1, snaps.size());
+  }
 }
\ No newline at end of file
diff --git a/agent/src/test/java/com/intergral/deep/agent/types/EStageTest.java b/agent/src/test/java/com/intergral/deep/agent/types/EStageTest.java
new file mode 100644
index 0000000..0255814
--- /dev/null
+++ b/agent/src/test/java/com/intergral/deep/agent/types/EStageTest.java
@@ -0,0 +1,33 @@
+/*
+ *     Copyright (C) 2023  Intergral GmbH
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU Affero General Public License as published by
+ *     the Free Software Foundation, either version 3 of the License, or
+ *     (at your option) any later version.
+ *
+ *     This program is distributed in the hope that it will be useful,
+ *     but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *     GNU Affero General Public License for more details.
+ *
+ *     You should have received a copy of the GNU Affero General Public License
+ *     along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.intergral.deep.agent.types;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import com.intergral.deep.agent.types.TracePointConfig.EStage;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.EnumSource;
+
+class EStageTest {
+
+  @ParameterizedTest
+  @EnumSource(EStage.class)
+  void canConvert(EStage stage) {
+    assertEquals(EStage.fromArg(stage.toString()), stage);
+  }
+}
\ No newline at end of file
diff --git a/agent/src/test/java/com/intergral/deep/test/MockMixinTemplate.java b/agent/src/test/java/com/intergral/deep/test/MockMixinTemplate.java
index 2ff8b10..f2450ce 100644
--- a/agent/src/test/java/com/intergral/deep/test/MockMixinTemplate.java
+++ b/agent/src/test/java/com/intergral/deep/test/MockMixinTemplate.java
@@ -18,8 +18,8 @@
 package com.intergral.deep.test;
 
 import com.intergral.deep.agent.tracepoint.handler.Callback;
-import java.io.Closeable;
-import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashMap;
 
 /**
  * This type is used as a template for generating the ASM code used in the {@link com.intergral.deep.agent.tracepoint.inst.asm.Visitor}.
@@ -35,32 +35,26 @@ public class MockMixinTemplate {
   }
 
   public void voidTemplate() {
-    final Closeable closeable = Callback.span("voidTemplate");
+    Callback.methodEntry("voidTemplate", "MockMixinTemplate.java", 40, new ArrayList<>(), new HashMap<>(), "");
     try {
       $deep$voidTemplate();
+    } catch (Throwable t) {
+      Callback.methodException(t);
+      throw t;
     } finally {
-      try {
-        if (closeable != null) {
-          closeable.close();
-        }
-      } catch (IOException ignored) {
-        // we ignore this exception
-      }
+      Callback.methodEnd("voidTemplate", "MockMixinTemplate.java", 40, new ArrayList<>(), new HashMap<>());
     }
   }
 
   public void voidTemplate(final String arg1) {
-    final Closeable closeable = Callback.span("voidTemplate");
+    Callback.methodEntry("voidTemplate", "MockMixinTemplate.java", 40, new ArrayList<>(), new HashMap<>(), "");
     try {
       $deep$voidTemplate(arg1);
+    } catch (Throwable t) {
+      Callback.methodException(t);
+      throw t;
     } finally {
-      try {
-        if (closeable != null) {
-          closeable.close();
-        }
-      } catch (IOException ignored) {
-        // we ignore this exception
-      }
+      Callback.methodEnd("voidTemplate", "MockMixinTemplate.java", 40, new ArrayList<>(), new HashMap<>());
     }
   }
 
@@ -73,33 +67,31 @@ public void voidTemplate(final String arg1) {
   }
 
   public int intTemplate() {
-    final Closeable closeable = Callback.span("intTemplate");
+    Callback.methodEntry("intTemplate", "MockMixinTemplate.java", 78, new ArrayList<>(), new HashMap<>(), "");
     try {
-      return $deep$intTemplate();
+      final int i = $deep$intTemplate();
+      Callback.methodRet(i);
+      return i;
+    } catch (Throwable t) {
+      Callback.methodException(t);
+      throw t;
     } finally {
-      try {
-        if (closeable != null) {
-          closeable.close();
-        }
-      } catch (IOException ignored) {
-        // we ignore this exception
-      }
+      Callback.methodEnd("intTemplate", "MockMixinTemplate.java", 78, new ArrayList<>(), new HashMap<>());
     }
   }
 
 
   public int intTemplate(final String arg1) {
-    final Closeable closeable = Callback.span("intTemplate");
+    Callback.methodEntry("intTemplate", "MockMixinTemplate.java", 94, new ArrayList<>(), new HashMap<>(), "");
     try {
-      return $deep$intTemplate(arg1);
+      final int i = $deep$intTemplate(arg1);
+      Callback.methodRet(i);
+      return i;
+    } catch (Throwable t) {
+      Callback.methodException(t);
+      throw t;
     } finally {
-      try {
-        if (closeable != null) {
-          closeable.close();
-        }
-      } catch (IOException ignored) {
-        // we ignore this exception
-      }
+      Callback.methodEnd("intTemplate", "MockMixinTemplate.java", 94, new ArrayList<>(), new HashMap<>());
     }
   }
 
@@ -112,33 +104,31 @@ public int intTemplate(final String arg1) {
   }
 
   public Object objectTemplate() {
-    final Closeable closeable = Callback.span("objectTemplate");
+    Callback.methodEntry("objectTemplate", "MockMixinTemplate.java", 117, new ArrayList<>(), new HashMap<>(), "");
     try {
-      return $deep$intTemplate();
+      final Object o = $deep$objectTemplate();
+      Callback.methodRet(o);
+      return o;
+    } catch (Throwable t) {
+      Callback.methodException(t);
+      throw t;
     } finally {
-      try {
-        if (closeable != null) {
-          closeable.close();
-        }
-      } catch (IOException ignored) {
-        // we ignore this exception
-      }
+      Callback.methodEnd("objectTemplate", "MockMixinTemplate.java", 117, new ArrayList<>(), new HashMap<>());
     }
   }
 
 
   public Object objectTemplate(final String arg1) {
-    final Closeable closeable = Callback.span("objectTemplate");
+    Callback.methodEntry("objectTemplate", "MockMixinTemplate.java", 133, new ArrayList<>(), new HashMap<>(), "");
     try {
-      return $deep$intTemplate(arg1);
+      final Object o = $deep$objectTemplate(arg1);
+      Callback.methodRet(o);
+      return o;
+    } catch (Throwable t) {
+      Callback.methodException(t);
+      throw t;
     } finally {
-      try {
-        if (closeable != null) {
-          closeable.close();
-        }
-      } catch (IOException ignored) {
-        // we ignore this exception
-      }
+      Callback.methodEnd("objectTemplate", "MockMixinTemplate.java", 133, new ArrayList<>(), new HashMap<>());
     }
   }
 }
diff --git a/agent/src/test/java/com/intergral/deep/test/target/BPTestTarget.java b/agent/src/test/java/com/intergral/deep/test/target/BPTestTarget.java
index fcbd756..04d0499 100644
--- a/agent/src/test/java/com/intergral/deep/test/target/BPTestTarget.java
+++ b/agent/src/test/java/com/intergral/deep/test/target/BPTestTarget.java
@@ -27,14 +27,14 @@ public String getName_visited()
     {
         if( name == null )
         {
-            try{return null;}catch( Throwable t ){ Callback.callBackException( t ); throw t; }finally {Callback.callBackFinally(null,null);}
+            try{return null;}catch( Throwable t ){ Callback.callBackException( t ); throw t; }finally {Callback.callBackFinally(null,null, 1, null);}
         }
         return name;
     }
 
     public void setName_visited( final String name )
     {
-        try{this.name = name;}catch( Throwable t ){ Callback.callBackException( t ); throw t; }finally {Callback.callBackFinally(null,null);}
+        try{this.name = name;}catch( Throwable t ){ Callback.callBackException( t ); throw t; }finally {Callback.callBackFinally(null,null, 1, null);}
     }
 
     public String getName()
@@ -54,7 +54,7 @@ public void setName( final String name )
 
     public String callSomeThing_visited( final String val )
     {
-        try{return getName() + val;}catch( Throwable t ){ Callback.callBackException( t ); throw t; }finally {Callback.callBackFinally(null,null);}
+        try{return getName() + val;}catch( Throwable t ){ Callback.callBackException( t ); throw t; }finally {Callback.callBackFinally(null,null, 1, null);}
     }
 
 
@@ -66,7 +66,7 @@ public String callSomeThing( final String val )
 
     public int errorSomething_visited( final String withargs )
     {
-        try{return withargs.length();}catch( Throwable t ){ Callback.callBackException( t ); throw t; }finally {Callback.callBackFinally(null,null);}
+        try{return withargs.length();}catch( Throwable t ){ Callback.callBackException( t ); throw t; }finally {Callback.callBackFinally(null,null, 1, null);}
     }
 
 
@@ -78,7 +78,7 @@ public int errorSomething( final String withargs )
 
     public int throwSomething_visited( final String withargs )
     {
-        try{throw new RuntimeException(withargs);}catch( Throwable t ){ Callback.callBackException( t ); throw t; }finally {Callback.callBackFinally(null,null);}
+        try{throw new RuntimeException(withargs);}catch( Throwable t ){ Callback.callBackException( t ); throw t; }finally {Callback.callBackFinally(null,null, 1, null);}
     }
 
 
@@ -96,7 +96,7 @@ public String catchSomething_visited( final String withargs )
         }
         catch( RuntimeException re )
         {
-            try{return re.getMessage();}catch( Throwable t ){ Callback.callBackException( t ); throw t; }finally {Callback.callBackFinally(null,null);}
+            try{return re.getMessage();}catch( Throwable t ){ Callback.callBackException( t ); throw t; }finally {Callback.callBackFinally(null,null, 1, null);}
         }
     }
 
@@ -126,7 +126,7 @@ public String finallySomething_visited( final String withargs )
         }
         finally
         {
-            try{System.out.println("something in finally");}catch( Throwable t ){ Callback.callBackException( t ); throw t; }finally {Callback.callBackFinally(null,null);}
+            try{System.out.println("something in finally");}catch( Throwable t ){ Callback.callBackException( t ); throw t; }finally {Callback.callBackFinally(null,null, 1, null);}
         }
     }
 
@@ -147,7 +147,7 @@ public String finallySomething( final String withargs )
         }
     }
 
-    public String someFunctionWithABody(final String someArg){
+    public String someFunctionWithABody(final String someArg) {
         final String name = this.name;
         final String newName = name + someArg;
         final Random random = new Random();
@@ -190,5 +190,29 @@ public void continueSomething()
             System.out.println( "something else" );
         }
     }
+
+    public void someOverloaded()
+    {
+        someOverloaded("test");
+    }
+
+    public void someOverloaded(final String name)
+    {
+        System.out.printf("someOverloaded: %s%n", name);
+    }
+
+    public void locationTestTarget() throws Exception {
+        final String name = this.name;
+        final String someValue = someFunctionWithABody(name);
+        setName("locationTestTarget");
+        for(int i = 0; i < 2; i++) {
+            conditionalThrow(i,0);
+        }
+    }
+
+    @Override
+    public String toString() {
+        return "BPTestTarget";
+    }
 }
 //@formatter:on
diff --git a/plugins/otel-plugin/src/main/java/com/intergral/deep/plugin/OtelPlugin.java b/plugins/otel-plugin/src/main/java/com/intergral/deep/plugin/OtelPlugin.java
index 2c305cf..5eb0aac 100644
--- a/plugins/otel-plugin/src/main/java/com/intergral/deep/plugin/OtelPlugin.java
+++ b/plugins/otel-plugin/src/main/java/com/intergral/deep/plugin/OtelPlugin.java
@@ -118,6 +118,13 @@ public String spanId() {
         return null;
       }
 
+      @Override
+      public void addAttribute(final String key, final String value) {
+        if (span != null) {
+          span.setAttribute(key, value);
+        }
+      }
+
       @Override
       public void close() {
         try {
@@ -150,6 +157,10 @@ public String name() {
         return "unknown";
       }
 
+      @Override
+      public void addAttribute(final String key, final String value) {
+        current.setAttribute(key, value);
+      }
 
       @Override
       public String traceId() {
diff --git a/test-utils/src/main/java/com/intergral/deep/tests/snapshot/SnapshotUtils.java b/test-utils/src/main/java/com/intergral/deep/tests/snapshot/SnapshotUtils.java
index f677ed5..0b73c87 100644
--- a/test-utils/src/main/java/com/intergral/deep/tests/snapshot/SnapshotUtils.java
+++ b/test-utils/src/main/java/com/intergral/deep/tests/snapshot/SnapshotUtils.java
@@ -24,7 +24,9 @@
 import com.intergral.deep.proto.tracepoint.v1.Snapshot;
 import com.intergral.deep.proto.tracepoint.v1.Variable;
 import com.intergral.deep.proto.tracepoint.v1.VariableID;
+import java.util.Arrays;
 import java.util.Collection;
+import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
@@ -128,6 +130,24 @@ private static String keyValueAsString(final AnyValue value) {
     return null;
   }
 
+  public static IVariableScan findVarByPath(final String path, final Snapshot snapshot) {
+    final String[] split = path.split("\\.");
+    final Iterator<String> iterator = Arrays.stream(split).iterator();
+    List<VariableID> vars = snapshot.getFrames(0).getVariablesList();
+    while (iterator.hasNext()) {
+      final String next = iterator.next();
+      final IVariableScan variableScan = findVarByName(next, vars, snapshot.getVarLookupMap());
+      if (!variableScan.found()) {
+        return variableScan;
+      }
+      if (!iterator.hasNext()) {
+        return variableScan;
+      }
+      vars = variableScan.variable().getChildrenList();
+    }
+    return () -> false;
+  }
+
   public interface IVariableScan {
 
     boolean found();