Add arch test to detect usage of shared internal code

all/build.gradle.kts

@@ -5,30 +5,13 @@ plugins {
 description = "OpenTelemetry All"
 otelJava.moduleName.set("io.opentelemetry.all")
 
-tasks {
-  // We don't compile much here, just some API boundary tests. This project is mostly for
-  // aggregating jacoco reports and it doesn't work if this isn't at least as high as the
-  // highest supported Java version in any of our projects. All of our
-  // projects target Java 8 except :exporters:http-sender:jdk, which targets
-  // Java 11
-  withType(JavaCompile::class) {
-    options.release.set(11)
-  }
-
-  val testJavaVersion: String? by project
-  if (testJavaVersion == "8") {
-    test {
-      enabled = false
-    }
-  }
-}
-
 // Skip OWASP dependencyCheck task on test module
 dependencyCheck {
   skip = true
 }
 
 val testTasks = mutableListOf<Task>()
+val jarTasks = mutableListOf<Jar>()
 
 dependencies {
   rootProject.subprojects.forEach { subproject ->
@@ -41,13 +24,68 @@ dependencies {
         subproject.tasks.withType<Test>().configureEach {
           testTasks.add(this)
         }
+        subproject.tasks.withType<Jar>().forEach {
+          if (it.archiveClassifier.get().isEmpty() && !it.name.contains("jmh")) {
+            jarTasks.add(it)
+          }
+        }
       }
     }
   }
 
   testImplementation("com.tngtech.archunit:archunit-junit5")
 }
 
+// Custom task type for writing artifacts and jars - configuration cache compatible
+abstract class WriteArtifactsAndJars : DefaultTask() {
+  @get:Input
+  abstract val artifactData: MapProperty<String, String>
+
+  @get:OutputFile
+  abstract val outputFile: RegularFileProperty
+
+  @TaskAction
+  fun writeFile() {
+    val file = outputFile.get().asFile
+    file.parentFile.mkdirs()
+    val content = artifactData.get().entries.joinToString("\n") { (baseName, filePath) ->
+      "$baseName:$filePath"
+    }
+    file.writeText(content)
+  }
+}
+
+val artifactsAndJarsFile = layout.buildDirectory.file("artifacts_and_jars.txt")
+
+val writeArtifactsAndJars = tasks.register<WriteArtifactsAndJars>("writeArtifactsAndJars") {
+  // Set up task dependencies
+  dependsOn(jarTasks)
+
+  // Configure the task inputs and outputs using providers
+  artifactData.set(provider {
+    jarTasks.associate { jar ->
+      jar.archiveBaseName.get() to jar.archiveFile.get().asFile.absolutePath
+    }
+  })
+  outputFile.set(artifactsAndJarsFile)
+}
+
+tasks {
+  // This module depends on all published subprojects (for JaCoCo coverage aggregation and
+  // arch tests). Since :exporters:http-sender:jdk targets Java 11, the compiler needs
+  // release 11 to resolve its classes on the classpath.
+  withType(JavaCompile::class) {
+    options.release.set(11)
+  }
+
+  val testJavaVersion: String? by project
+  test {
+    enabled = testJavaVersion != "8"
+    dependsOn(writeArtifactsAndJars)
+    environment("ARTIFACTS_AND_JARS", artifactsAndJarsFile.get().asFile.absolutePath)
+  }
+}
+
 // https://docs.gradle.org/current/samples/sample_jvm_multi_project_with_code_coverage.html
 
 val sourcesPath by configurations.creating {

all/src/test/java/io/opentelemetry/all/NoSharedInternalCodeTest.java

@@ -0,0 +1,118 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.all;
+
+import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.noClasses;
+
+import com.tngtech.archunit.base.DescribedPredicate;
+import com.tngtech.archunit.core.domain.JavaClass;
+import com.tngtech.archunit.core.domain.JavaClasses;
+import com.tngtech.archunit.core.importer.ClassFileImporter;
+import com.tngtech.archunit.lang.syntax.elements.ClassesShouldConjunction;
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Set;
+import java.util.jar.JarFile;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+class NoSharedInternalCodeTest {
+
+  private static final Set<String> exemptions =
+      Set.of(
+          "opentelemetry-api-incubator",
+          "opentelemetry-exporter-common",
+          "opentelemetry-exporter-logging",
+          "opentelemetry-exporter-logging-otlp",
+          "opentelemetry-exporter-prometheus",
+          "opentelemetry-exporter-zipkin",
+          "opentelemetry-extension-trace-propagators",
+          "opentelemetry-opencensus-shim",
+          "opentelemetry-sdk-common",
+          "opentelemetry-sdk-logs",
+          "opentelemetry-sdk-metrics",
+          "opentelemetry-sdk-testing",
+          "opentelemetry-sdk-trace",
+          "opentelemetry-sdk-extension-autoconfigure",
+          "opentelemetry-sdk-extension-autoconfigure-spi",
+          "opentelemetry-sdk-extension-incubator",
+          "opentelemetry-sdk-extension-jaeger-remote-sampler",
+          "opentelemetry-exporter-otlp",
+          "opentelemetry-exporter-otlp-common",
+          "opentelemetry-exporter-sender-grpc-managed-channel",
+          "opentelemetry-exporter-sender-jdk",
+          "opentelemetry-exporter-sender-okhttp");
+
+  private static final String OTEL_BASE_PACKAGE = "io.opentelemetry";
+  private static final Logger logger = Logger.getLogger(NoSharedInternalCodeTest.class.getName());
+
+  @ParameterizedTest
+  @MethodSource("artifactsAndJars")
+  void noSharedInternalCode(String artifactId, String absolutePath) throws IOException {
+    try (JarFile jarFile = new JarFile(new File(absolutePath))) {
+      JavaClasses artifactClasses = new ClassFileImporter().importJar(jarFile);
+
+      Set<String> artifactOtelPackages =
+          artifactClasses.stream()
+              .map(JavaClass::getPackageName)
+              .filter(packageName -> packageName.startsWith(OTEL_BASE_PACKAGE))
+              .collect(Collectors.toSet());
+
+      ClassesShouldConjunction noSharedInternalCodeRule =
+          noClasses()
+              .that()
+              .resideInAnyPackage(artifactOtelPackages.toArray(new String[0]))
+              .should()
+              .dependOnClassesThat(
+                  new DescribedPredicate<>(
+                      "are in internal modules of other opentelemetry artifacts") {
+                    @Override
+                    public boolean test(JavaClass javaClass) {
+                      String packageName = javaClass.getPackageName();
+                      return packageName.startsWith(OTEL_BASE_PACKAGE)
+                          && packageName.contains(".internal")
+                          && !artifactOtelPackages.contains(packageName);
+                    }
+                  });
+
+      try {
+        noSharedInternalCodeRule
+            .as(artifactId + " should not use internal code from other artifacts")
+            .check(artifactClasses);
+        // To view artifacts which do not contain shared internal code, change test log level or
+        // increase log level of this statement to WARNING
+        logger.log(Level.INFO, artifactId + " does not contain shared internal code");
+      } catch (AssertionError e) {
+        if (exemptions.contains(artifactId)) {
+          // To view details, remove from exemptions list
+          logger.log(
+              Level.WARNING,
+              artifactId + " contains shared internal code but is temporarily exempt");
+        } else {
+          throw e;
+        }
+      }
+    }
+  }
+
+  private static Stream<Arguments> artifactsAndJars() throws IOException {
+    List<String> lines = Files.readAllLines(Path.of(System.getenv("ARTIFACTS_AND_JARS")));
+    return lines.stream()
+        .map(
+            line -> {
+              String[] parts = line.split(":", 2);
+              return Arguments.of(parts[0], parts[1]);
+            });
+  }
+}