Profiling - Deduplication and cleanup

sentry-android-core/src/main/java/io/sentry/android/core/AndroidContinuousProfiler.java

@@ -301,7 +301,7 @@ private void stop(final boolean restartProfiler) {
                   endData.measurementsMap,
                   endData.traceFile,
                   startProfileChunkTimestamp,
-                  ProfileChunk.Platform.ANDROID));
+                  ProfileChunk.PLATFORM_ANDROID));
         }
       }
 

sentry-async-profiler/api/sentry-async-profiler.api

@@ -4,10 +4,19 @@ public final class io/sentry/asyncprofiler/BuildConfig {
 }
 
 public final class io/sentry/asyncprofiler/convert/JfrAsyncProfilerToSentryProfileConverter : io/sentry/asyncprofiler/vendor/asyncprofiler/convert/JfrConverter {
-	public fun <init> (Lio/sentry/asyncprofiler/vendor/asyncprofiler/jfr/JfrReader;Lio/sentry/asyncprofiler/vendor/asyncprofiler/convert/Arguments;Lio/sentry/SentryStackTraceFactory;)V
+	public fun <init> (Lio/sentry/asyncprofiler/vendor/asyncprofiler/jfr/JfrReader;Lio/sentry/asyncprofiler/vendor/asyncprofiler/convert/Arguments;Lio/sentry/SentryStackTraceFactory;Lio/sentry/ILogger;)V
 	public static fun convertFromFileStatic (Ljava/nio/file/Path;)Lio/sentry/protocol/profiling/SentryProfile;
 }
 
+public final class io/sentry/asyncprofiler/convert/NonAggregatingEventCollector : io/sentry/asyncprofiler/vendor/asyncprofiler/jfr/event/EventCollector {
+	public fun <init> ()V
+	public fun afterChunk ()V
+	public fun beforeChunk ()V
+	public fun collect (Lio/sentry/asyncprofiler/vendor/asyncprofiler/jfr/event/Event;)V
+	public fun finish ()Z
+	public fun forEach (Lio/sentry/asyncprofiler/vendor/asyncprofiler/jfr/event/EventCollector$Visitor;)V
+}
+
 public final class io/sentry/asyncprofiler/profiling/JavaContinuousProfiler : io/sentry/IContinuousProfiler, io/sentry/transport/RateLimiter$IRateLimitObserver {
 	public fun <init> (Lio/sentry/ILogger;Ljava/lang/String;ILio/sentry/ISentryExecutorService;)V
 	public fun close (Z)V

sentry-async-profiler/src/main/java/io/sentry/asyncprofiler/convert/JfrAsyncProfilerToSentryProfileConverter.java

@@ -1,66 +1,88 @@
 package io.sentry.asyncprofiler.convert;
 
 import io.sentry.DateUtils;
+import io.sentry.ILogger;
 import io.sentry.Sentry;
+import io.sentry.SentryLevel;
 import io.sentry.SentryStackTraceFactory;
 import io.sentry.asyncprofiler.vendor.asyncprofiler.convert.Arguments;
 import io.sentry.asyncprofiler.vendor.asyncprofiler.convert.JfrConverter;
 import io.sentry.asyncprofiler.vendor.asyncprofiler.jfr.JfrReader;
 import io.sentry.asyncprofiler.vendor.asyncprofiler.jfr.StackTrace;
 import io.sentry.asyncprofiler.vendor.asyncprofiler.jfr.event.Event;
+import io.sentry.asyncprofiler.vendor.asyncprofiler.jfr.event.EventCollector;
 import io.sentry.protocol.SentryStackFrame;
 import io.sentry.protocol.profiling.SentryProfile;
 import io.sentry.protocol.profiling.SentrySample;
 import io.sentry.protocol.profiling.SentryThreadMetadata;
 import java.io.IOException;
 import java.nio.file.Path;
 import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 public final class JfrAsyncProfilerToSentryProfileConverter extends JfrConverter {
-  private static final long NANOS_PER_SECOND = 1_000_000_000L;
+  private static final double NANOS_PER_SECOND = 1_000_000_000.0;
+  private static final long UNKNOWN_THREAD_ID = -1;
 
   private final @NotNull SentryProfile sentryProfile = new SentryProfile();
   private final @NotNull SentryStackTraceFactory stackTraceFactory;
+  private final @NotNull ILogger logger;
+  private final @NotNull Map<SentryStackFrame, Integer> frameDeduplicationMap = new HashMap<>();
+  private final @NotNull Map<List<Integer>, Integer> stackDeduplicationMap = new HashMap<>();
 
   public JfrAsyncProfilerToSentryProfileConverter(
-      JfrReader jfr, Arguments args, @NotNull SentryStackTraceFactory stackTraceFactory) {
+      JfrReader jfr,
+      Arguments args,
+      @NotNull SentryStackTraceFactory stackTraceFactory,
+      @NotNull ILogger logger) {
     super(jfr, args);
     this.stackTraceFactory = stackTraceFactory;
+    this.logger = logger;
   }
 
   @Override
   protected void convertChunk() {
     collector.forEach(new ProfileEventVisitor(sentryProfile, stackTraceFactory, jfr, args));
   }
 
+  @Override
+  protected EventCollector createCollector(Arguments args) {
+    return new NonAggregatingEventCollector();
+  }
+
   public static @NotNull SentryProfile convertFromFileStatic(@NotNull Path jfrFilePath)
       throws IOException {
     JfrAsyncProfilerToSentryProfileConverter converter;
     try (JfrReader jfrReader = new JfrReader(jfrFilePath.toString())) {
       Arguments args = new Arguments();
       args.cpu = false;
+      args.wall = true;
       args.alloc = false;
       args.threads = true;
       args.lines = true;
       args.dot = true;
 
       SentryStackTraceFactory stackTraceFactory =
           new SentryStackTraceFactory(Sentry.getGlobalScope().getOptions());
-      converter = new JfrAsyncProfilerToSentryProfileConverter(jfrReader, args, stackTraceFactory);
+      ILogger logger = Sentry.getGlobalScope().getOptions().getLogger();
+      converter =
+          new JfrAsyncProfilerToSentryProfileConverter(jfrReader, args, stackTraceFactory, logger);
       converter.convert();
     }
 
     return converter.sentryProfile;
   }
 
-  private class ProfileEventVisitor extends AggregatedEventVisitor {
+  private class ProfileEventVisitor implements EventCollector.Visitor {
     private final @NotNull SentryProfile sentryProfile;
     private final @NotNull SentryStackTraceFactory stackTraceFactory;
     private final @NotNull JfrReader jfr;
     private final @NotNull Arguments args;
+    private final double ticksPerNanosecond;
 
     public ProfileEventVisitor(
         @NotNull SentryProfile sentryProfile,
@@ -71,25 +93,37 @@ public ProfileEventVisitor(
       this.stackTraceFactory = stackTraceFactory;
       this.jfr = jfr;
       this.args = args;
+      ticksPerNanosecond = jfr.ticksPerSec / NANOS_PER_SECOND;
     }
 
     @Override
-    public void visit(Event event, long value) {
-      StackTrace stackTrace = jfr.stackTraces.get(event.stackTraceId);
-      long threadId = resolveThreadId(event.tid);
-
-      if (stackTrace != null) {
-        if (args.threads) {
-          processThreadMetadata(event, threadId);
-        }
+    public void visit(Event event, long samples, long value) {
+      try {
+        StackTrace stackTrace = jfr.stackTraces.get(event.stackTraceId);
+        long threadId = resolveThreadId(event.tid);
 
-        createSample(event, threadId);
+        if (stackTrace != null) {
+          if (args.threads) {
+            processThreadMetadata(event, threadId);
+          }
 
-        buildStackTraceAndFrames(stackTrace);
+          processSampleWithStack(event, threadId, stackTrace);
+        }
+      } catch (Exception e) {
+        logger.log(SentryLevel.WARNING, "Failed to process JFR event " + event, e);
       }
     }
 
+    private long resolveThreadId(int eventId) {
+      Long javaThreadId = jfr.javaThreads.get(eventId);
+      return javaThreadId != null ? javaThreadId : UNKNOWN_THREAD_ID;
+    }
+
     private void processThreadMetadata(Event event, long threadId) {
+      if (threadId == UNKNOWN_THREAD_ID) {
+        return;
+      }
+
       final String threadName = getPlainThreadName(event.tid);
       sentryProfile
           .getThreadMetadata()
@@ -103,28 +137,72 @@ private void processThreadMetadata(Event event, long threadId) {
               });
     }
 
-    private void buildStackTraceAndFrames(StackTrace stackTrace) {
-      List<Integer> stack = new ArrayList<>();
-      int currentFrame = sentryProfile.getFrames().size();
+    private void processSampleWithStack(Event event, long threadId, StackTrace stackTrace) {
+      int stackIndex = addStackTrace(stackTrace);
+
+      SentrySample sample = new SentrySample();
+      sample.setTimestamp(calculateTimestamp(event));
+      sample.setThreadId(String.valueOf(threadId));
+      sample.setStackId(stackIndex);
+
+      sentryProfile.getSamples().add(sample);
+    }
+
+    private double calculateTimestamp(Event event) {
+      long nanosFromStart = (long) ((event.time - jfr.chunkStartTicks) / ticksPerNanosecond);
+
+      long timeNs = jfr.chunkStartNanos + nanosFromStart;
+
+      return DateUtils.nanosToSeconds(timeNs);
+    }
+
+    private int addStackTrace(StackTrace stackTrace) {
+      List<Integer> callStack = createFramesAndCallStack(stackTrace);
+
+      Integer existingIndex = stackDeduplicationMap.get(callStack);
+      if (existingIndex != null) {
+        return existingIndex;
+      }
+
+      int stackIndex = sentryProfile.getStacks().size();
+      sentryProfile.getStacks().add(callStack);
+      stackDeduplicationMap.put(callStack, stackIndex);
+      return stackIndex;
+    }
+
+    private List<Integer> createFramesAndCallStack(StackTrace stackTrace) {
+      List<Integer> callStack = new ArrayList<>();
 
       long[] methods = stackTrace.methods;
       byte[] types = stackTrace.types;
       int[] locations = stackTrace.locations;
 
       for (int i = 0; i < methods.length; i++) {
         StackTraceElement element = getStackTraceElement(methods[i], types[i], locations[i]);
-        if (element.isNativeMethod()) {
+        if (element.isNativeMethod() || isNativeFrame(types[i])) {
           continue;
         }
 
         SentryStackFrame frame = createStackFrame(element);
-        sentryProfile.getFrames().add(frame);
+        int frameIndex = getOrAddFrame(frame);
+        callStack.add(frameIndex);
+      }
+
+      return callStack;
+    }
+
+    // Get existing frame index or add new frame and return its index
+    private int getOrAddFrame(SentryStackFrame frame) {
+      Integer existingIndex = frameDeduplicationMap.get(frame);
 
-        stack.add(currentFrame);
-        currentFrame++;
+      if (existingIndex != null) {
+        return existingIndex;
       }
 
-      sentryProfile.getStacks().add(stack);
+      int newIndex = sentryProfile.getFrames().size();
+      sentryProfile.getFrames().add(frame);
+      frameDeduplicationMap.put(frame, newIndex);
+      return newIndex;
     }
 
     private SentryStackFrame createStackFrame(StackTraceElement element) {
@@ -176,36 +254,12 @@ private boolean isRegularClassWithoutPackage(String className) {
       return !className.startsWith("[");
     }
 
-    private void createSample(Event event, long threadId) {
-      int stackId = sentryProfile.getStacks().size();
-      SentrySample sample = new SentrySample();
-
-      // Calculate timestamp from JFR event time
-      long nsFromStart =
-          (event.time - jfr.chunkStartTicks)
-              * JfrAsyncProfilerToSentryProfileConverter.NANOS_PER_SECOND
-              / jfr.ticksPerSec;
-      long timeNs = jfr.chunkStartNanos + nsFromStart;
-      sample.setTimestamp(DateUtils.nanosToSeconds(timeNs));
-
-      sample.setThreadId(String.valueOf(threadId));
-      sample.setStackId(stackId);
-
-      sentryProfile.getSamples().add(sample);
-    }
-
     private boolean shouldMarkAsSystemFrame(StackTraceElement element, String className) {
       return element.isNativeMethod() || className.isEmpty();
     }
 
     private @Nullable Integer extractLineNumber(StackTraceElement element) {
       return element.getLineNumber() != 0 ? element.getLineNumber() : null;
     }
-
-    private long resolveThreadId(int eventThreadId) {
-      return jfr.threads.get(eventThreadId) != null
-          ? jfr.javaThreads.get(eventThreadId)
-          : eventThreadId;
-    }
   }
 }

sentry-async-profiler/src/main/java/io/sentry/asyncprofiler/convert/NonAggregatingEventCollector.java

@@ -0,0 +1,37 @@
+package io.sentry.asyncprofiler.convert;
+
+import io.sentry.asyncprofiler.vendor.asyncprofiler.jfr.event.Event;
+import io.sentry.asyncprofiler.vendor.asyncprofiler.jfr.event.EventCollector;
+import java.util.ArrayList;
+import java.util.List;
+
+public final class NonAggregatingEventCollector implements EventCollector {
+  final List<Event> events = new ArrayList<>();
+
+  @Override
+  public void collect(Event e) {
+    events.add(e);
+  }
+
+  @Override
+  public void beforeChunk() {
+    // No-op
+  }
+
+  @Override
+  public void afterChunk() {
+    // No-op
+  }
+
+  @Override
+  public boolean finish() {
+    return false;
+  }
+
+  @Override
+  public void forEach(Visitor visitor) {
+    for (Event event : events) {
+      visitor.visit(event, event.samples(), event.value());
+    }
+  }
+}