build(samples): Move the JVM samples to their own build

The 28 JVM samples are now a standalone Gradle build in sentry-samples
that includes the SDK build, like the Android sample and the Android
integration tests. They depend on io.sentry:* coordinates, which Gradle
substitutes with the SDK's projects. The SDK build doesn't include them
back, so the Spring Boot, gretty and shadow plugins the samples apply no
longer load in the SDK build.

The three bootRunWithAgent tasks find the agent jar from the repository
root and take the SDK version from the catalog, since the samples build
has its own root directory and gradle.properties.

With no samples or integration tests left in the SDK build, its
apiValidation list and the name filters that skipped them for publishing
and CodeQL go too.

Root check and spotlessApply no longer reach the samples, so preMerge runs
this build's check, which covers what the root check ran for them:
compilation, jars and spotless. The format workflow runs its
spotlessApply.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: runningcode

.cursor/rules/new_module.mdc

@@ -31,16 +31,10 @@ the release that first ships it. All of the following have to be merged **before
 
 2. Add the module to the include list in `settings.gradle.kts`
 
-If adding a `sentry-samples` module, also add it to the `ignoredProjects` list in the root `build.gradle.kts`:
-
-```kotlin
-ignoredProjects.addAll(
-    listOf(
-        // ... existing projects ...
-        "sentry-samples-{module-name}"
-    )
-)
-```
+If adding a sample, add it to the include list in `sentry-samples/settings.gradle.kts` instead. The
+samples are a separate Gradle build that includes the SDK build, so a sample depends on
+`"io.sentry:sentry-{module-name}:$sentryVersion"` (with `val sentryVersion =
+libs.versions.sentry.get()`), and Gradle substitutes the SDK's project for it.
 
 3. Add a `SENTRY_{MODULE}_SDK_NAME` constant to the `Config.Sentry` block in
    `buildSrc/src/main/java/Config.kt`:

.github/workflows/format-code.yml

@@ -26,6 +26,7 @@ jobs:
       - name: Format with spotlessApply
         run: |
           ./gradlew spotlessApply
+          ./gradlew -p sentry-samples spotlessApply
           ./gradlew -p sentry-samples/sentry-samples-android spotlessApply
           ./gradlew -p sentry-android-integration-tests spotlessApply
 

AGENTS.md

@@ -67,6 +67,9 @@ resolves the per-module test task, including integration test suites, for you.
 
 # Build the Android sample, a separate Gradle build that includes this one
 ./gradlew -p sentry-samples/sentry-samples-android assembleDebug
+
+# Build the JVM samples, another separate Gradle build that includes this one
+./gradlew -p sentry-samples assemble
 ```
 
 ## Development Workflow Rules
@@ -113,7 +116,7 @@ The repository is organized into multiple modules:
 
 ### Utility Modules
 - **`sentry-test-support`** - Shared test utilities, including `MockSentryServer` and envelope matchers
-- **`sentry-samples`** - Example applications. `sentry-samples-android` is a separate Gradle build that includes this one, so root tasks such as `check` and `spotlessApply` don't reach it
+- **`sentry-samples`** - Example applications, in two separate Gradle builds that include this one: `sentry-samples` (JVM) and `sentry-samples/sentry-samples-android`. Root tasks such as `check` and `spotlessApply` don't reach them, and `sentry-android-integration-tests` is a separate build too
 - **`sentry-bom`** - Bill of Materials for dependency management
 
 ### Key Architectural Patterns

Makefile

@@ -1,8 +1,8 @@
-.PHONY: all clean compile javadocs dryRelease update checkFormat api assembleUiTestRelease assembleUiTestCriticalRelease runUiTestCritical check checkSampleAndroid checkIntegrationTests preMerge publish
+.PHONY: all clean compile javadocs dryRelease update checkFormat api assembleUiTestRelease assembleUiTestCriticalRelease runUiTestCritical check checkSamples checkSampleAndroid checkIntegrationTests preMerge publish
 
 all: stop clean javadocs compile
 assembleUiTests: assembleUiTestRelease
-preMerge: check checkSampleAndroid checkIntegrationTests
+preMerge: check checkSamples checkSampleAndroid checkIntegrationTests
 publish: clean dryRelease
 
 # deep clean
@@ -29,6 +29,7 @@ update:
 # Spotless check's code
 checkFormat:
 	./gradlew spotlessJavaCheck spotlessKotlinCheck
+	./gradlew -p sentry-samples spotlessJavaCheck spotlessKotlinCheck
 	./gradlew -p sentry-samples/sentry-samples-android spotlessJavaCheck spotlessKotlinCheck
 	./gradlew -p sentry-android-integration-tests spotlessJavaCheck spotlessKotlinCheck
 
@@ -52,6 +53,10 @@ runUiTestCritical:
 check:
 	./gradlew check
 
+# The samples are separate builds, so the root `check` doesn't reach them
+checkSamples:
+	./gradlew -p sentry-samples check
+
 # The Android sample is a separate build, so the root `check` doesn't reach it
 checkSampleAndroid:
 	./gradlew -p sentry-samples/sentry-samples-android check

build.gradle.kts

@@ -50,34 +50,6 @@ apiValidation {
     )
     ignoredProjects.addAll(
         listOf(
-            "sentry-samples-console",
-            "sentry-samples-console-opentelemetry-noagent",
-            "sentry-samples-jul",
-            "sentry-samples-log4j2",
-            "sentry-samples-logback",
-            "sentry-samples-openfeign",
-            "sentry-samples-servlet",
-            "sentry-samples-spring",
-            "sentry-samples-spring-jakarta",
-            "sentry-samples-spring-7",
-            "sentry-samples-spring-boot",
-            "sentry-samples-spring-boot-opentelemetry",
-            "sentry-samples-spring-boot-opentelemetry-noagent",
-            "sentry-samples-spring-boot-jakarta",
-            "sentry-samples-spring-boot-jakarta-log4j2",
-            "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-samples-spring-boot-4",
-            "sentry-samples-spring-boot-4-log4j2",
-            "sentry-samples-spring-boot-4-opentelemetry",
-            "sentry-samples-spring-boot-4-opentelemetry-noagent",
-            "sentry-samples-spring-boot-4-otlp",
-            "sentry-samples-spring-boot-4-webflux",
-            "sentry-samples-ktor-client",
-            "sentry-samples-netflix-dgs",
-            "sentry-samples-console-otlp",
             "sentry-test-support"
         )
     )
@@ -113,7 +85,7 @@ subprojects {
         }
     }
 
-    if (!this.name.contains("sample") && !this.name.contains("integration-tests") && this.name != "sentry-test-support") {
+    if (this.name != "sentry-test-support") {
         apply<DistributionPlugin>()
         apply<com.vanniktech.maven.publish.MavenPublishPlugin>()
 
@@ -187,9 +159,7 @@ subprojects {
 tasks.register("buildForCodeQL") {
     subprojects
         .filter {
-            !it.displayName.contains("sample") &&
-                !it.displayName.contains("integration-tests") &&
-                !it.displayName.contains("bom") &&
+            !it.displayName.contains("bom") &&
                 it.name != "sentry-opentelemetry"
         }
         .forEach { proj ->

sentry-samples/build.gradle.kts

@@ -0,0 +1,15 @@
+// Loads the shared plugins once for every sample, so they all share one classpath. The Spring Boot
+// plugin is applied in each sample instead, because the samples use different versions of it.
+plugins {
+  alias(libs.plugins.kotlin.jvm) apply false
+  alias(libs.plugins.kotlin.spring) apply false
+  alias(libs.plugins.spring.dependency.management) apply false
+  alias(libs.plugins.gradle.versions) apply false
+  id("io.sentry.spotless") apply false
+  id("io.sentry.jdk-target") apply false
+}
+
+subprojects {
+  apply(plugin = "io.sentry.spotless")
+  apply(plugin = "io.sentry.jdk-target")
+}

sentry-samples/gradle.properties

@@ -0,0 +1,13 @@
+# Gradle properties are per build, so this repeats what the samples need from the SDK build's
+# gradle.properties. settings.gradle.kts reads the SDK version from that file.
+
+org.gradle.jvmargs=-Xmx6g -XX:MaxMetaspaceSize=2g -XX:+CrashOnOutOfMemoryError -Dfile.encoding=UTF-8 -XX:+UseParallelGC
+org.gradle.caching=true
+org.gradle.parallel=true
+org.gradle.configureondemand=true
+org.gradle.configuration-cache=true
+org.gradle.configuration-cache.parallel=true
+
+kotlin.stdlib.default.dependency=false
+
+systemProp.org.gradle.internal.http.socketTimeout=120000

sentry-samples/sentry-samples-console-opentelemetry-noagent/build.gradle.kts

@@ -5,11 +5,13 @@ plugins {
   alias(libs.plugins.shadow)
 }
 
+val sentryVersion = libs.versions.sentry.get()
+
 application { mainClass.set("io.sentry.samples.console.Main") }
 
 dependencies {
-  implementation(projects.sentryOpentelemetry.sentryOpentelemetryAgentless)
-  implementation(projects.sentryAsyncProfiler)
+  implementation("io.sentry:sentry-opentelemetry-agentless:$sentryVersion")
+  implementation("io.sentry:sentry-async-profiler:$sentryVersion")
 }
 
 // Configure the Shadow JAR (executable JAR with all dependencies)

sentry-samples/sentry-samples-console-otlp/build.gradle.kts

@@ -5,11 +5,13 @@ plugins {
   alias(libs.plugins.shadow)
 }
 
+val sentryVersion = libs.versions.sentry.get()
+
 application { mainClass.set("io.sentry.samples.console.Main") }
 
 dependencies {
-  implementation(projects.sentryOpentelemetry.sentryOpentelemetryOtlp)
-  implementation(projects.sentryAsyncProfiler)
+  implementation("io.sentry:sentry-opentelemetry-otlp:$sentryVersion")
+  implementation("io.sentry:sentry-async-profiler:$sentryVersion")
   implementation(libs.otel.semconv)
   implementation(libs.otel.semconv.incubating)
   implementation(libs.otel.exporter.logging)

sentry-samples/sentry-samples-console/build.gradle.kts

@@ -5,13 +5,15 @@ plugins {
   alias(libs.plugins.shadow)
 }
 
+val sentryVersion = libs.versions.sentry.get()
+
 application { mainClass.set("io.sentry.samples.console.Main") }
 
 dependencies {
-  implementation(projects.sentry)
-  implementation(projects.sentryAsyncProfiler)
-  implementation(projects.sentryJcache)
-  implementation(projects.sentryKafka)
+  implementation("io.sentry:sentry:$sentryVersion")
+  implementation("io.sentry:sentry-async-profiler:$sentryVersion")
+  implementation("io.sentry:sentry-jcache:$sentryVersion")
+  implementation("io.sentry:sentry-kafka:$sentryVersion")
   implementation(libs.jcache)
   implementation(libs.caffeine.jcache)
   implementation(libs.kafka.clients)