Pin japicmp baseline in version.gradle.kts (atomic with apidiff snapshots)

Replace the dynamic 'latest.release' lookup in otel.japicmp-conventions.gradle.kts with a pinned property declared in version.gradle.kts. The post-release workflow now bumps that property in the same PR that regenerates docs/apidiffs/current_vs_latest/*.txt, so the baseline and the snapshot files always move together.

Without this change, the moment a release is published to Maven Central every PR against main starts failing the apidiff check until the post-release PR lands: the live latest.release resolution flips to the new version, but the apidiff snapshots committed to the repo are still against the previous one.

Author: trask

.github/workflows/release.yml

@@ -267,6 +267,9 @@ jobs:
           PRIOR_VERSION: ${{ needs.release.outputs.prior-version }}
         run: |
           ./gradlew japicmp -PapiBaseVersion=$PRIOR_VERSION -PapiNewVersion=$VERSION
+          # Bump the pinned apidiff baseline so that the next `./gradlew japicmp` invocation
+          # (and every subsequent build on main) compares against the just-released version.
+          sed -i "s/^val apidiffBaselineVersion = .*/val apidiffBaselineVersion = \"$VERSION\"/" version.gradle.kts
           ./gradlew --refresh-dependencies japicmp
 
       - name: Use CLA approved bot
@@ -291,6 +294,7 @@ jobs:
           git checkout -b $branch
           git add CHANGELOG.md
           git add docs/apidiffs
+          git add version.gradle.kts
           git commit -m "$message"
           git push --set-upstream origin $branch
           gh pr create --title "$message" \

conventions/src/main/kotlin/otel.japicmp-conventions.gradle.kts

@@ -11,20 +11,16 @@ plugins {
 }
 
 /**
- * The latest *released* version of the project. Evaluated lazily so the work is only done if necessary.
+ * The baseline version that japicmp compares against. Pinned in version.gradle.kts and bumped by
+ * the post-release "update apidiff baseline" PR (see .github/workflows/release.yml). This avoids
+ * the chicken-and-egg problem of resolving `latest.release` against Maven Central live: with a
+ * dynamic lookup, every PR against main started failing japicmp the moment a new release was
+ * published, until the post-release PR landed. With a pinned baseline, the version that japicmp
+ * uses moves atomically with the docs/apidiffs/current_vs_latest/*.txt snapshots that the
+ * post-release PR regenerates.
  */
-val latestReleasedVersion: String by lazy {
-  // hack to find the current released version of the project
-  val temp: Configuration = configurations.create("tempConfig")
-  temp.resolutionStrategy.cacheDynamicVersionsFor(0, TimeUnit.SECONDS)
-  // pick the bom, since we don't use dependency substitution on it.
-  dependencies.add(temp.name, "io.opentelemetry.instrumentation:opentelemetry-instrumentation-bom:latest.release")
-  val moduleVersion = configurations["tempConfig"].resolvedConfiguration.firstLevelModuleDependencies.elementAt(0).moduleVersion
-
-  configurations.remove(temp)
-  logger.info("Discovered latest release version: $moduleVersion")
-  moduleVersion
-}
+val latestReleasedVersion: String =
+  rootProject.extra["apidiffBaselineVersion"] as String
 
 /**
  * Locate the project's artifact of a particular version.

version.gradle.kts

@@ -1,10 +1,18 @@
 val stableVersion = "2.27.0-SNAPSHOT"
 val alphaVersion = "2.27.0-alpha-SNAPSHOT"
 
+// Baseline for japicmp's API-diff comparison. Bumped to the just-released version by the
+// post-release "update apidiff baseline" PR opened from .github/workflows/release.yml. Until
+// that PR lands, the baseline stays at the previous release so the snapshots checked into
+// docs/apidiffs/current_vs_latest/ continue to match — PRs against main don't break the moment
+// a new version is published to Maven Central.
+val apidiffBaselineVersion = "2.26.1"
+
 allprojects {
   if (findProperty("otel.stable") != "true") {
     version = alphaVersion
   } else {
     version = stableVersion
   }
+  extra["apidiffBaselineVersion"] = apidiffBaselineVersion
 }