Merge branch 'main' into feat/profiling-remove-vendored-code

Author: lbloder

CHANGELOG.md

@@ -15,6 +15,8 @@
 - Only set `DefaultReplayBreadcrumbConverter` if replay is available ([#4888](https://github.com/getsentry/sentry-java/pull/4888))
 - Session Replay: Cache connection status instead of using blocking calls ([#4891](https://github.com/getsentry/sentry-java/pull/4891))
 - Fix log count in client reports ([#4869](https://github.com/getsentry/sentry-java/pull/4869))
+- Fix profilerId propagation ([#4833](https://github.com/getsentry/sentry-java/pull/4833))
+- Fix profiling init for Spring and Spring Boot w Agent auto-init ([#4815](https://github.com/getsentry/sentry-java/pull/4815))
 
 ### Improvements
 

sentry-async-profiler/src/main/java/io/sentry/asyncprofiler/provider/AsyncProfilerProfileConverterProvider.java

@@ -5,7 +5,6 @@
 import io.sentry.profiling.JavaProfileConverterProvider;
 import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
 
 /**
  * AsyncProfiler implementation of {@link JavaProfileConverterProvider}. This provider integrates
@@ -15,7 +14,7 @@
 public final class AsyncProfilerProfileConverterProvider implements JavaProfileConverterProvider {
 
   @Override
-  public @Nullable IProfileConverter getProfileConverter() {
+  public @NotNull IProfileConverter getProfileConverter() {
     return new AsyncProfilerProfileConverter();
   }
 

sentry-async-profiler/src/test/java/io/sentry/asyncprofiler/init/AsyncProfilerInitUtilTest.kt

@@ -0,0 +1,96 @@
+package io.sentry.asyncprofiler.init
+
+import io.sentry.ILogger
+import io.sentry.ISentryExecutorService
+import io.sentry.NoOpContinuousProfiler
+import io.sentry.NoOpProfileConverter
+import io.sentry.SentryOptions
+import io.sentry.asyncprofiler.profiling.JavaContinuousProfiler
+import io.sentry.asyncprofiler.provider.AsyncProfilerProfileConverterProvider
+import io.sentry.util.InitUtil
+import kotlin.test.Test
+import kotlin.test.assertNotNull
+import kotlin.test.assertSame
+import org.mockito.kotlin.mock
+
+class AsyncProfilerInitUtilTest {
+
+  @Test
+  fun `initialize Profiler returns no-op profiler if profiling disabled`() {
+    val options = SentryOptions()
+    val profiler = InitUtil.initializeProfiler(options)
+    assert(profiler is NoOpContinuousProfiler)
+  }
+
+  @Test
+  fun `initialize Converter returns no-op converter if profiling disabled`() {
+    val options = SentryOptions()
+    val converter = InitUtil.initializeProfileConverter(options)
+    assert(converter is NoOpProfileConverter)
+  }
+
+  @Test
+  fun `initialize profiler returns the existing profiler from options if already initialized`() {
+    val initialProfiler =
+      JavaContinuousProfiler(mock<ILogger>(), "", 10, mock<ISentryExecutorService>())
+    val options =
+      SentryOptions().also {
+        it.setProfileSessionSampleRate(1.0)
+        it.setContinuousProfiler(initialProfiler)
+      }
+
+    val profiler = InitUtil.initializeProfiler(options)
+    assertSame(initialProfiler, profiler)
+  }
+
+  @Test
+  fun `initialize converter returns the existing converter from options if already initialized`() {
+    val initialConverter = AsyncProfilerProfileConverterProvider.AsyncProfilerProfileConverter()
+    val options =
+      SentryOptions().also {
+        it.setProfileSessionSampleRate(1.0)
+        it.profilerConverter = initialConverter
+      }
+
+    val converter = InitUtil.initializeProfileConverter(options)
+    assertSame(initialConverter, converter)
+  }
+
+  @Test
+  fun `initialize Profiler returns JavaContinuousProfiler if profiling enabled but profiler not yet initialized`() {
+    val options = SentryOptions().also { it.setProfileSessionSampleRate(1.0) }
+    val profiler = InitUtil.initializeProfiler(options)
+    assertSame(profiler, options.continuousProfiler)
+    assert(profiler is JavaContinuousProfiler)
+  }
+
+  @Test
+  fun `initialize Converter returns AsyncProfilerProfileConverterProvider if profiling enabled but profiler not yet initialized`() {
+    val options = SentryOptions().also { it.setProfileSessionSampleRate(1.0) }
+    val converter = InitUtil.initializeProfileConverter(options)
+    assertSame(converter, options.profilerConverter)
+    assert(converter is AsyncProfilerProfileConverterProvider.AsyncProfilerProfileConverter)
+  }
+
+  @Test
+  fun `initialize profiler uses existing profilingTracesDirPath when set`() {
+    val customPath = "/custom/path/to/traces"
+    val options =
+      SentryOptions().also {
+        it.setProfileSessionSampleRate(1.0)
+        it.profilingTracesDirPath = customPath
+      }
+    val profiler = InitUtil.initializeProfiler(options)
+    assert(profiler is JavaContinuousProfiler)
+    assertSame(customPath, options.profilingTracesDirPath)
+  }
+
+  @Test
+  fun `initialize profiler creates and sets profilingTracesDirPath when null`() {
+    val options = SentryOptions().also { it.setProfileSessionSampleRate(1.0) }
+    val profiler = InitUtil.initializeProfiler(options)
+    assert(profiler is JavaContinuousProfiler)
+    assertNotNull(options.profilingTracesDirPath)
+    assert(options.profilingTracesDirPath!!.contains("sentry_profiling_traces"))
+  }
+}

sentry-opentelemetry/sentry-opentelemetry-core/src/main/java/io/sentry/opentelemetry/SentrySpanExporter.java

@@ -297,6 +297,7 @@ private void transferSpanDetails(
     @NotNull TransactionNameSource transactionNameSource = spanInfo.getTransactionNameSource();
     @Nullable SpanId parentSpanId = null;
     @Nullable Baggage baggage = null;
+    @NotNull SentryId profilerId = SentryId.EMPTY_ID;
 
     if (sentrySpanMaybe != null) {
       final @NotNull IOtelSpanWrapper sentrySpan = sentrySpanMaybe;
@@ -312,6 +313,7 @@ private void transferSpanDetails(
       final @NotNull SpanContext spanContext = sentrySpan.getSpanContext();
       parentSpanId = spanContext.getParentSpanId();
       baggage = spanContext.getBaggage();
+      profilerId = spanContext.getProfilerId();
     }
 
     final @NotNull TransactionContext transactionContext =
@@ -324,6 +326,7 @@ private void transferSpanDetails(
     transactionContext.setTransactionNameSource(transactionNameSource);
     transactionContext.setOperation(spanInfo.getOp());
     transactionContext.setInstrumenter(Instrumenter.SENTRY);
+    transactionContext.setProfilerId(profilerId);
     if (sentrySpanMaybe != null) {
       transactionContext.setSamplingDecision(sentrySpanMaybe.getSamplingDecision());
       transactionOptions.setOrigin(sentrySpanMaybe.getSpanContext().getOrigin());

sentry-spring-7/api/sentry-spring-7.api

@@ -42,6 +42,12 @@ public class io/sentry/spring7/SentryInitBeanPostProcessor : org/springframework
 	public fun setApplicationContext (Lorg/springframework/context/ApplicationContext;)V
 }
 
+public class io/sentry/spring7/SentryProfilerConfiguration {
+	public fun <init> ()V
+	public fun sentryOpenTelemetryProfilerConfiguration ()Lio/sentry/IContinuousProfiler;
+	public fun sentryOpenTelemetryProfilerConverterConfiguration ()Lio/sentry/IProfileConverter;
+}
+
 public class io/sentry/spring7/SentryRequestHttpServletRequestProcessor : io/sentry/EventProcessor {
 	public fun <init> (Lio/sentry/spring7/tracing/TransactionNameProvider;Ljakarta/servlet/http/HttpServletRequest;)V
 	public fun getOrder ()Ljava/lang/Long;

sentry-spring-7/src/main/java/io/sentry/spring7/SentryProfilerConfiguration.java

@@ -0,0 +1,50 @@
+package io.sentry.spring7;
+
+import com.jakewharton.nopen.annotation.Open;
+import io.sentry.IContinuousProfiler;
+import io.sentry.IProfileConverter;
+import io.sentry.NoOpContinuousProfiler;
+import io.sentry.NoOpProfileConverter;
+import io.sentry.Sentry;
+import io.sentry.SentryOptions;
+import io.sentry.util.InitUtil;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+/**
+ * Handles late initialization of the profiler if the application is run with the Opentelemetry
+ * Agent in auto-init mode. In that case the agent cannot initialize the profiler yet and falls back
+ * to No-Op implementations. This Configuration sets the profiler and converter on the options if
+ * that was the case.
+ */
+@Configuration(proxyBeanMethods = false)
+@Open
+public class SentryProfilerConfiguration {
+
+  @Bean
+  @ConditionalOnMissingBean(name = "sentryOpenTelemetryProfilerConfiguration")
+  public IContinuousProfiler sentryOpenTelemetryProfilerConfiguration() {
+    SentryOptions options = Sentry.getGlobalScope().getOptions();
+    IContinuousProfiler profiler = NoOpContinuousProfiler.getInstance();
+
+    if (Sentry.isEnabled()) {
+      return InitUtil.initializeProfiler(options);
+    } else {
+      return profiler;
+    }
+  }
+
+  @Bean
+  @ConditionalOnMissingBean(name = "sentryOpenTelemetryProfilerConverterConfiguration")
+  public IProfileConverter sentryOpenTelemetryProfilerConverterConfiguration() {
+    SentryOptions options = Sentry.getGlobalScope().getOptions();
+    IProfileConverter converter = NoOpProfileConverter.getInstance();
+
+    if (Sentry.isEnabled()) {
+      return InitUtil.initializeProfileConverter(options);
+    } else {
+      return converter;
+    }
+  }
+}

sentry-spring-boot-4/api/sentry-spring-boot-4.api

@@ -24,6 +24,10 @@ public class io/sentry/spring/boot4/SentryLogbackInitializer : org/springframewo
 	public fun supportsEventType (Lorg/springframework/core/ResolvableType;)Z
 }
 
+public class io/sentry/spring/boot4/SentryProfilerAutoConfiguration {
+	public fun <init> ()V
+}
+
 public class io/sentry/spring/boot4/SentryProperties : io/sentry/SentryOptions {
 	public fun <init> ()V
 	public fun getExceptionResolverOrder ()I

sentry-spring-boot-4/build.gradle.kts

@@ -85,6 +85,7 @@ dependencies {
   testImplementation(libs.okhttp.mockwebserver)
   testImplementation(libs.otel)
   testImplementation(libs.otel.extension.autoconfigure.spi)
+  testImplementation(projects.sentryAsyncProfiler)
   /**
    * Adding a version of opentelemetry-spring-boot-starter that doesn't support Spring Boot 4 causes
    * java.lang.IllegalArgumentException: Could not find class

sentry-spring-boot-4/src/main/java/io/sentry/spring/boot4/SentryProfilerAutoConfiguration.java

@@ -0,0 +1,17 @@
+package io.sentry.spring.boot4;
+
+import com.jakewharton.nopen.annotation.Open;
+import io.sentry.spring7.SentryProfilerConfiguration;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Import;
+
+@Configuration(proxyBeanMethods = false)
+@ConditionalOnClass(
+    name = {
+      "io.sentry.opentelemetry.agent.AgentMarker",
+      "io.sentry.asyncprofiler.profiling.JavaContinuousProfiler"
+    })
+@Open
+@Import(SentryProfilerConfiguration.class)
+public class SentryProfilerAutoConfiguration {}

sentry-spring-boot-4/src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports

@@ -1,3 +1,4 @@
 io.sentry.spring.boot4.SentryAutoConfiguration
+io.sentry.spring.boot4.SentryProfilerAutoConfiguration
 io.sentry.spring.boot4.SentryLogbackAppenderAutoConfiguration
 io.sentry.spring.boot4.SentryWebfluxAutoConfiguration