POTEL 52 - Do not ignore certain span origins for OTel without Agent (#3856)

* Auto config for Spring Boot combined with OTel but without agent

* try to cleanup otel classloader

* make agent, no agent and agent without auto init work for spring boot

* Fix ignored instrumentation for OTel without agent; separate sample for no agent

* fix test result upload on CI

* changelog

Author: adinauer

.github/workflows/system-tests-backend.yml

@@ -21,12 +21,18 @@ jobs:
       matrix:
         sample: [ "sentry-samples-spring-boot-jakarta" ]
         agent: [ "0" ]
+        agent-auto-init: [ "true" ]
         include:
           - sample: "sentry-samples-spring-boot"
           - sample: "sentry-samples-spring-boot-webflux-jakarta"
           - sample: "sentry-samples-spring-boot-webflux"
+          - sample: "sentry-samples-spring-boot-jakarta-opentelemetry-noagent"
           - sample: "sentry-samples-spring-boot-jakarta-opentelemetry"
             agent: "1"
+            agent-auto-init: "true"
+          - sample: "sentry-samples-spring-boot-jakarta-opentelemetry"
+            agent: "1"
+            agent-auto-init: "false"
     steps:
       - uses: actions/checkout@v4
         with:
@@ -86,18 +92,13 @@ jobs:
 
       - name: Start server and run integration test for sentry-cli commands
         run: |
-          test/system-test-sentry-server-start.sh \
-            > sentry-mock-server.txt 2>&1 & \
-          test/system-test-spring-server-start.sh "${{ matrix.sample }}" "${{ matrix.agent }}" \
-            > spring-server.txt 2>&1 & \
-          test/wait-for-spring.sh && \
-          ./gradlew :sentry-samples:${{ matrix.sample }}:systemTest
+          test/system-test-sentry-server-start.sh > sentry-mock-server.txt 2>&1 & test/system-test-spring-server-start.sh "${{ matrix.sample }}" "${{ matrix.agent }}" "${{ matrix.agent-auto-init }}" > spring-server.txt 2>&1 & test/wait-for-spring.sh && ./gradlew :sentry-samples:${{ matrix.sample }}:systemTest
 
       - name: Upload test results
         if: always()
         uses: actions/upload-artifact@v4
         with:
-          name: test-results-${{ matrix.sample }}-system-test
+          name: test-results-${{ matrix.sample }}-${{ matrix.agent }}-${{ matrix.agent-auto-init }}-system-test
           path: |
             **/build/reports/*
             sentry-mock-server.txt

CHANGELOG.md

@@ -22,6 +22,8 @@
   - The `sentry-opentelemetry-extra` module has been removed again, most classes have been moved to `sentry-opentelemetry-bootstrap` which is loaded into the bootstrap classloader (i.e. `null`) when our Java agent is used. The rest has been moved into `sentry-opentelemetry-agentcustomization` and is loaded into the agent classloader when our Java agent is used.
   - The `sentry-opentelemetry-bootstrap` and `sentry-opentelemetry-agentcustomization` modules can be used without the agent as well, in which case all classes are loaded into the application classloader. Check out our `sentry-samples-spring-boot-jakarta-opentelemetry-noagent` sample.
   - In this mode the SDK makes use of `GlobalOpenTelemetry`
+- Add a sample for showcasing Sentry with OpenTelemetry for Spring Boot 3 with our Java agent (`sentry-samples-spring-boot-jakarta-opentelemetry`) ([#3856](https://github.com/getsentry/sentry-java/pull/3828))
+- Add a sample for showcasing Sentry with OpenTelemetry for Spring Boot 3 without our Java agent (`sentry-samples-spring-boot-jakarta-opentelemetry-noagent`) ([#3856](https://github.com/getsentry/sentry-java/pull/3856))
 - Add `globalHubMode` to options ([#3805](https://github.com/getsentry/sentry-java/pull/3805))
   - `globalHubMode` used to only be a param on `Sentry.init`. To make it easier to be used in e.g. Desktop environments, we now additionally added it as an option on SentryOptions that can also be set via `sentry.properties`.
   - If both the param on `Sentry.init` and the option are set, the option will win. By default the option is set to `null` meaning whatever is passed to `Sentry.init` takes effect.
@@ -37,6 +39,7 @@
 
 - The Sentry OpenTelemetry Java agent now makes sure Sentry `Scopes` storage is initialized even if the agents auto init is disabled ([#3848](https://github.com/getsentry/sentry-java/pull/3848))
   - This is required for all integrations to work together with our OpenTelemetry Java agent if its auto init has been disabled and the SDKs init should be used instead.
+- Do not ignore certain span origins for OpenTelemetry without agent ([#3856](https://github.com/getsentry/sentry-java/pull/3856))
 - Add `auto.graphql.graphql22` to ignored span origins when using OpenTelemetry ([#3828](https://github.com/getsentry/sentry-java/pull/3828))
 - The Spring Boot 3 WebFlux sample now uses our GraphQL v22 integration ([#3828](https://github.com/getsentry/sentry-java/pull/3828))
 - Accept manifest integer values when requiring floating values ([#3823](https://github.com/getsentry/sentry-java/pull/3823))

build.gradle.kts

@@ -61,6 +61,7 @@ apiValidation {
             "sentry-samples-spring-boot",
             "sentry-samples-spring-boot-jakarta",
             "sentry-samples-spring-boot-jakarta-opentelemetry",
+            "sentry-samples-spring-boot-jakarta-opentelemetry-noagent",
             "sentry-samples-spring-boot-webflux",
             "sentry-samples-spring-boot-webflux-jakarta",
             "sentry-uitest-android",

sentry-opentelemetry/sentry-opentelemetry-agentcustomization/src/main/java/io/sentry/opentelemetry/SentryAutoConfigurationCustomizerProvider.java

@@ -42,7 +42,7 @@ public void customize(AutoConfigurationCustomizer autoConfiguration) {
           options -> {
             options.setEnableExternalConfiguration(true);
             options.setInitPriority(InitPriority.HIGH);
-            OpenTelemetryUtil.applyOpenTelemetryOptions(options);
+            OpenTelemetryUtil.applyOpenTelemetryOptions(options, true);
             final @Nullable SdkVersion sdkVersion = createSdkVersion(options, versionInfoHolder);
             if (sdkVersion != null) {
               options.setSdkVersion(sdkVersion);

sentry-opentelemetry/sentry-opentelemetry-bootstrap/api/sentry-opentelemetry-bootstrap.api

@@ -25,7 +25,7 @@ public final class io/sentry/opentelemetry/InternalSemanticAttributes {
 
 public final class io/sentry/opentelemetry/OpenTelemetryUtil {
 	public fun <init> ()V
-	public static fun applyOpenTelemetryOptions (Lio/sentry/SentryOptions;)V
+	public static fun applyOpenTelemetryOptions (Lio/sentry/SentryOptions;Z)V
 }
 
 public final class io/sentry/opentelemetry/OtelContextScopesStorage : io/sentry/IScopesStorage {

sentry-opentelemetry/sentry-opentelemetry-bootstrap/src/main/java/io/sentry/opentelemetry/OpenTelemetryUtil.java

@@ -9,10 +9,11 @@
 @ApiStatus.Experimental
 public final class OpenTelemetryUtil {
 
-  public static void applyOpenTelemetryOptions(final @Nullable SentryOptions options) {
+  public static void applyOpenTelemetryOptions(
+      final @Nullable SentryOptions options, final boolean isAgent) {
     if (options != null) {
       options.setSpanFactory(SentrySpanFactoryHolder.getSpanFactory());
-      options.setIgnoredSpanOrigins(SpanUtils.ignoredSpanOriginsForOpenTelemetry());
+      options.setIgnoredSpanOrigins(SpanUtils.ignoredSpanOriginsForOpenTelemetry(isAgent));
     }
   }
 }

sentry-opentelemetry/sentry-opentelemetry-extra/api/sentry-opentelemetry-extra.api

@@ -0,0 +1,122 @@
+# Sentry Sample Spring Boot 3.0+
+
+Sample application showing how to use Sentry with [Spring boot](http://spring.io/projects/spring-boot) from version `3.0` onwards.
+
+## How to run? 
+
+To see events triggered in this sample application in your Sentry dashboard, go to `src/main/resources/application.properties` and replace the test DSN with your own DSN.
+
+Then, execute a command from the module directory:
+
+```
+../../gradlew bootRun
+```
+
+Make an HTTP request that will trigger events:
+
+```
+curl -XPOST --user user:password http://localhost:8080/person/ -H "Content-Type:application/json" -d '{"firstName":"John","lastName":"Smith"}'
+```
+
+## GraphQL
+
+The following queries can be used to test the GraphQL integration.
+
+### Greeting
+```
+{
+    greeting(name: "crash")
+}
+```
+
+### Greeting with variables
+
+```
+query GreetingQuery($name: String) {
+    greeting(name: $name)
+}
+```
+variables:
+```
+{
+    "name": "crash"
+}
+```
+
+### Project
+
+```
+query ProjectQuery($slug: ID!) {
+    project(slug: $slug) {
+        slug
+        name
+        repositoryUrl
+        status
+    }
+}
+```
+variables:
+```
+{
+    "slug": "statuscrash"
+}
+```
+
+### Mutation
+
+```
+mutation AddProjectMutation($slug: ID!) {
+    addProject(slug: $slug)
+}
+```
+variables:
+```
+{
+    "slug": "nocrash",
+    "name": "nocrash"
+}
+```
+
+### Subscription
+
+```
+subscription SubscriptionNotifyNewTask($slug: ID!) {
+    notifyNewTask(projectSlug: $slug) {
+        id
+        name
+        assigneeId
+        assignee {
+            id
+            name
+        }
+    }
+}
+```
+variables:
+```
+{
+    "slug": "crash"
+}
+```
+
+### Data loader
+
+```
+query TasksAndAssigneesQuery($slug: ID!) {
+    tasks(projectSlug: $slug) {
+        id
+        name
+        assigneeId
+        assignee {
+            id
+            name
+        }
+    }
+}
+```
+variables:
+```
+{
+    "slug": "crash"
+}
+```

sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/README.md

@@ -0,0 +1,116 @@
+import org.jetbrains.kotlin.config.KotlinCompilerVersion
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
+
+plugins {
+    id(Config.BuildPlugins.springBoot) version Config.springBoot3Version
+    id(Config.BuildPlugins.springDependencyManagement) version Config.BuildPlugins.springDependencyManagementVersion
+    kotlin("jvm")
+    kotlin("plugin.spring") version Config.kotlinVersion
+    id("com.apollographql.apollo3") version "3.8.2"
+}
+
+group = "io.sentry.sample.spring-boot-jakarta"
+version = "0.0.1-SNAPSHOT"
+java.sourceCompatibility = JavaVersion.VERSION_17
+java.targetCompatibility = JavaVersion.VERSION_17
+
+repositories {
+    mavenCentral()
+}
+
+configure<JavaPluginExtension> {
+    sourceCompatibility = JavaVersion.VERSION_17
+    targetCompatibility = JavaVersion.VERSION_17
+}
+
+tasks.withType<KotlinCompile>().configureEach {
+    kotlinOptions.jvmTarget = JavaVersion.VERSION_17.toString()
+}
+
+tasks.withType<KotlinCompile> {
+    kotlinOptions {
+        freeCompilerArgs = listOf("-Xjsr305=strict")
+        jvmTarget = JavaVersion.VERSION_17.toString()
+    }
+}
+
+dependencies {
+    implementation(Config.Libs.springBoot3StarterSecurity)
+    implementation(Config.Libs.springBoot3StarterActuator)
+    implementation(Config.Libs.springBoot3StarterWeb)
+    implementation(Config.Libs.springBoot3StarterWebsocket)
+    implementation(Config.Libs.springBoot3StarterGraphql)
+    implementation(Config.Libs.springBoot3StarterQuartz)
+    implementation(Config.Libs.springBoot3StarterWebflux)
+    implementation(Config.Libs.springBoot3StarterAop)
+    implementation(Config.Libs.aspectj)
+    implementation(Config.Libs.springBoot3Starter)
+    implementation(Config.Libs.kotlinReflect)
+    implementation(Config.Libs.springBootStarterJdbc)
+    implementation(kotlin(Config.kotlinStdLib, KotlinCompilerVersion.VERSION))
+    implementation(projects.sentrySpringBootStarterJakarta)
+    implementation(projects.sentryLogback)
+    implementation(projects.sentryGraphql22)
+    implementation(projects.sentryQuartz)
+    implementation(Config.Libs.springBoot3StarterOpenTelemetry)
+    implementation(projects.sentryOpentelemetry.sentryOpentelemetryBootstrap)
+    implementation(projects.sentryOpentelemetry.sentryOpentelemetryAgentcustomization)
+
+    // database query tracing
+    implementation(projects.sentryJdbc)
+    runtimeOnly(Config.TestLibs.hsqldb)
+    testImplementation(Config.Libs.springBoot3StarterTest) {
+        exclude(group = "org.junit.vintage", module = "junit-vintage-engine")
+    }
+    testImplementation(kotlin(Config.kotlinStdLib))
+    testImplementation(Config.TestLibs.kotlinTestJunit)
+    testImplementation("ch.qos.logback:logback-classic:1.3.5")
+    testImplementation(Config.Libs.slf4jApi2)
+    testImplementation(Config.Libs.apolloKotlin)
+}
+
+dependencyManagement {
+    imports {
+        mavenBom("io.opentelemetry.instrumentation:opentelemetry-instrumentation-bom:2.7.0")
+    }
+}
+
+configure<SourceSetContainer> {
+    test {
+        java.srcDir("src/test/java")
+    }
+}
+
+tasks.register<Test>("systemTest").configure {
+    group = "verification"
+    description = "Runs the System tests"
+
+//    maxParallelForks = Runtime.getRuntime().availableProcessors() / 2
+    maxParallelForks = 1
+
+    // Cap JVM args per test
+    minHeapSize = "128m"
+    maxHeapSize = "1g"
+
+    filter {
+        includeTestsMatching("io.sentry.systemtest*")
+    }
+}
+
+tasks.named("test").configure {
+    require(this is Test)
+
+    filter {
+        excludeTestsMatching("io.sentry.systemtest.*")
+    }
+}
+
+apollo {
+    service("service") {
+        srcDir("src/test/graphql")
+        packageName.set("io.sentry.samples.graphql")
+        outputDirConnection {
+            connectToKotlinSourceSet("test")
+        }
+    }
+}

sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/build.gradle.kts

@@ -0,0 +1,35 @@
+package io.sentry.samples.spring.boot.jakarta;
+
+import io.sentry.EventProcessor;
+import io.sentry.Hint;
+import io.sentry.SentryEvent;
+import io.sentry.protocol.SentryRuntime;
+import org.jetbrains.annotations.NotNull;
+import org.springframework.boot.SpringBootVersion;
+import org.springframework.stereotype.Component;
+
+/**
+ * Custom {@link EventProcessor} implementation lets modifying {@link SentryEvent}s before they are
+ * sent to Sentry.
+ */
+@Component
+public class CustomEventProcessor implements EventProcessor {
+  private final String springBootVersion;
+
+  public CustomEventProcessor(String springBootVersion) {
+    this.springBootVersion = springBootVersion;
+  }
+
+  public CustomEventProcessor() {
+    this(SpringBootVersion.getVersion());
+  }
+
+  @Override
+  public @NotNull SentryEvent process(@NotNull SentryEvent event, @NotNull Hint hint) {
+    final SentryRuntime runtime = new SentryRuntime();
+    runtime.setVersion(springBootVersion);
+    runtime.setName("Spring Boot");
+    event.getContexts().setRuntime(runtime);
+    return event;
+  }
+}