sort modules and enable spans for a few more exmaples

Author: jaydeluca

docs/instrumentation-list.yaml

@@ -21,6 +21,7 @@ readonly INSTRUMENTATIONS=(
   "apache-dbcp-2.0:javaagent:test"
   "apache-dbcp-2.0:javaagent:testStableSemconv"
   "apache-httpclient:apache-httpclient-5.0:javaagent:test"
+  "apache-dubbo-2.7:javaagent:testDubbo"
   "c3p0-0.9:javaagent:test"
   "c3p0-0.9:javaagent:testStableSemconv"
   "clickhouse-client-0.5:javaagent:test"

instrumentation-docs/collect.sh

@@ -5,6 +5,8 @@
 
 package io.opentelemetry.instrumentation.docs.internal;
 
+import java.util.Objects;
+
 /**
  * This class is internal and is hence not for public use. Its APIs are unstable and can change at
  * any time.
@@ -38,4 +40,22 @@ public String getType() {
   public void setType(String type) {
     this.type = type;
   }
+
+  // Overriding equals and hashCode to compare TelemetryAttribute objects based on name and type
+  // This is important for our deduplication logic in the documentation generation process.
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) {
+      return true;
+    }
+    if (!(o instanceof TelemetryAttribute that)) {
+      return false;
+    }
+    return Objects.equals(name, that.name) && Objects.equals(type, that.type);
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(name, type);
+  }
 }

instrumentation-docs/src/main/java/io/opentelemetry/instrumentation/docs/internal/TelemetryAttribute.java

@@ -23,6 +23,9 @@
  */
 public class SpanParser {
 
+  // We want to ignore test related attributes
+  private static final List<String> EXCLUDED_ATTRIBUTES = List.of("x-test-", "test-baggage-");
+
   /**
    * Pull spans from the `.telemetry` directory, filter them by scope, and set them in the module.
    *
@@ -107,7 +110,10 @@ private static void addSpanAttributes(
       }
 
       for (TelemetryAttribute attr : span.getAttributes()) {
-        attributes.add(new TelemetryAttribute(attr.getName(), attr.getType()));
+        boolean excluded = EXCLUDED_ATTRIBUTES.stream().anyMatch(ex -> attr.getName().contains(ex));
+        if (!excluded) {
+          attributes.add(new TelemetryAttribute(attr.getName(), attr.getType()));
+        }
       }
     }
 

instrumentation-docs/src/main/java/io/opentelemetry/instrumentation/docs/parsers/SpanParser.java

@@ -77,7 +77,16 @@ private static Map<String, Object> getLibraryInstrumentations(List<Instrumentati
                         .equals(InstrumentationClassification.LIBRARY))
             .collect(
                 Collectors.groupingBy(
-                    InstrumentationModule::getGroup, TreeMap::new, Collectors.toList()));
+                    InstrumentationModule::getGroup,
+                    TreeMap::new,
+                    Collectors.collectingAndThen(
+                        Collectors.toList(),
+                        modules ->
+                            modules.stream()
+                                .sorted(
+                                    Comparator.comparing(
+                                        InstrumentationModule::getInstrumentationName))
+                                .collect(Collectors.toList()))));
 
     Map<String, Object> output = new TreeMap<>();
     libraryInstrumentations.forEach(
@@ -146,7 +155,7 @@ private static Map<String, Object> baseProperties(InstrumentationModule module)
             new ArrayList<>(module.getMetrics().getOrDefault(group, Collections.emptyList()));
         List<Map<String, Object>> metricsList = new ArrayList<>();
 
-        // sort metrics by name for some determinism in the order
+        // sort by name for determinism in the order
         metrics.sort(Comparator.comparing(EmittedMetrics.Metric::getName));
 
         for (EmittedMetrics.Metric metric : metrics) {
@@ -160,7 +169,7 @@ private static Map<String, Object> baseProperties(InstrumentationModule module)
             new ArrayList<>(module.getSpans().getOrDefault(group, Collections.emptyList()));
         List<Map<String, Object>> spanList = new ArrayList<>();
 
-        // sort metrics by name for some determinism in the order
+        // sort by name for determinism in the order
         spans.sort(Comparator.comparing(EmittedSpans.Span::getSpanKind));
 
         for (EmittedSpans.Span span : spans) {

instrumentation-docs/src/main/java/io/opentelemetry/instrumentation/docs/utils/YamlHelper.java

@@ -78,22 +78,21 @@ void testModuleConverterCreatesUniqueModules() {
             new InstrumentationPath(
                 "same-name",
                 "instrumentation/test1/same-name/library",
-                "group1",
                 "namespace1",
+                "group1",
                 InstrumentationType.LIBRARY),
             new InstrumentationPath(
                 "same-name",
                 "instrumentation/test2/same-name/library",
-                "group2",
                 "namespace2",
+                "group2",
                 InstrumentationType.LIBRARY));
 
     List<InstrumentationModule> modules = ModuleParser.convertToModules("test", paths);
 
     // Should create 2 separate modules because they have different group/namespace combinations
     assertThat(modules.size()).isEqualTo(2);
 
-    // Verify both modules exist with correct properties
     assertThat(
             modules.stream()
                 .anyMatch(

instrumentation-docs/src/test/java/io/opentelemetry/instrumentation/docs/InstrumentationAnalyzerTest.java

@@ -58,18 +58,4 @@ void testSanitizePathNameRemovesRootAndKnownFolders() throws Exception {
     sanitized = ModuleParser.sanitizePathName("/root", "/root/other");
     assertThat(sanitized).isEqualTo("/other");
   }
-
-  @Test
-  void testCreateModuleKeyIsConsistent() throws Exception {
-    InstrumentationPath path = mock(InstrumentationPath.class);
-    when(path.group()).thenReturn("g");
-    when(path.namespace()).thenReturn("n");
-    when(path.instrumentationName()).thenReturn("i");
-
-    var method = ModuleParser.class.getDeclaredMethod("createModuleKey", InstrumentationPath.class);
-    method.setAccessible(true);
-
-    String key = (String) method.invoke(null, path);
-    assertThat(key).isEqualTo("g:n:i");
-  }
 }

instrumentation-docs/src/test/java/io/opentelemetry/instrumentation/docs/ModuleConverterTest.java

@@ -72,6 +72,8 @@ void getSpansFromFilesCombinesFilesCorrectly(@TempDir Path tempDir) throws IOExc
 
     Files.writeString(telemetryDir.resolve("spans-1.yaml"), file1Content);
     Files.writeString(telemetryDir.resolve("spans-2.yaml"), file2Content);
+    // duplicate span contents to test deduplication
+    Files.writeString(telemetryDir.resolve("spans-3.yaml"), file2Content);
 
     try (MockedStatic<FileManager> fileManagerMock = mockStatic(FileManager.class)) {
       fileManagerMock
@@ -80,6 +82,9 @@ void getSpansFromFilesCombinesFilesCorrectly(@TempDir Path tempDir) throws IOExc
       fileManagerMock
           .when(() -> FileManager.readFileToString(telemetryDir.resolve("spans-2.yaml").toString()))
           .thenReturn(file2Content);
+      fileManagerMock
+          .when(() -> FileManager.readFileToString(telemetryDir.resolve("spans-3.yaml").toString()))
+          .thenReturn(file2Content);
 
       Map<String, EmittedSpans> result =
           EmittedSpanParser.getSpansByScopeFromFiles(tempDir.toString(), "");
@@ -95,6 +100,20 @@ void getSpansFromFilesCombinesFilesCorrectly(@TempDir Path tempDir) throws IOExc
               .orElse(null);
       assertThat(clickHouseSpans).hasSize(2);
 
+      EmittedSpans.Span serverSpan =
+          clickHouseSpans.stream()
+              .filter(item -> item.getSpanKind().equals("SERVER"))
+              .findFirst()
+              .orElse(null);
+      EmittedSpans.Span clientSpan =
+          clickHouseSpans.stream()
+              .filter(item -> item.getSpanKind().equals("CLIENT"))
+              .findFirst()
+              .orElse(null);
+
+      assertThat(serverSpan.getAttributes()).hasSize(1);
+      assertThat(clientSpan.getAttributes()).hasSize(6);
+
       List<EmittedSpans.Span> testSpans =
           spans.getSpansByScope().stream()
               .filter(item -> item.getScope().equals("test"))
@@ -111,9 +130,19 @@ void testSpanAggregatorFiltersAndAggregatesCorrectly() {
     String targetScopeName = "my-instrumentation-scope";
 
     EmittedSpans.Span span1 =
-        new EmittedSpans.Span("CLIENT", List.of(new TelemetryAttribute("my.operation", "STRING")));
+        new EmittedSpans.Span(
+            "CLIENT",
+            List.of(
+                new TelemetryAttribute("my.operation", "STRING"),
+                new TelemetryAttribute("http.request.header.x-test-request", "STRING_ARRAY"),
+                new TelemetryAttribute("http.response.header.x-test-response", "STRING_ARRAY")));
     EmittedSpans.Span span2 =
-        new EmittedSpans.Span("SERVER", List.of(new TelemetryAttribute("my.operation", "STRING")));
+        new EmittedSpans.Span(
+            "SERVER",
+            List.of(
+                new TelemetryAttribute("my.operation", "STRING"),
+                new TelemetryAttribute("test-baggage-key-1", "STRING"),
+                new TelemetryAttribute("test-baggage-key-2", "STRING")));
 
     // Create test span for a different scope (should be filtered out)
     EmittedSpans.Span testSpan =
@@ -143,5 +172,27 @@ void testSpanAggregatorFiltersAndAggregatesCorrectly() {
     List<String> spanKinds =
         result.get("default").stream().map(EmittedSpans.Span::getSpanKind).toList();
     assertThat(spanKinds).containsExactlyInAnyOrder("CLIENT", "SERVER");
+
+    // Verify test attributes are filtered out
+    List<TelemetryAttribute> clientAttributes =
+        result.get("default").stream()
+            .filter(span -> span.getSpanKind().equals("CLIENT"))
+            .flatMap(span -> span.getAttributes().stream())
+            .toList();
+    assertThat(clientAttributes)
+        .hasSize(1)
+        .extracting(TelemetryAttribute::getName)
+        .containsExactly("my.operation");
+
+    List<TelemetryAttribute> serverAttributes =
+        result.get("default").stream()
+            .filter(span -> span.getSpanKind().equals("SERVER"))
+            .flatMap(span -> span.getAttributes().stream())
+            .toList();
+
+    assertThat(serverAttributes)
+        .hasSize(1)
+        .extracting(TelemetryAttribute::getName)
+        .containsExactly("my.operation");
   }
 }

instrumentation-docs/src/test/java/io/opentelemetry/instrumentation/docs/parsers/SpanParserTest.java

@@ -66,6 +66,7 @@ tasks {
 
     systemProperty("testLatestDeps", findProperty("testLatestDeps") as Boolean)
     systemProperty("collectMetadata", findProperty("collectMetadata")?.toString() ?: "false")
+    systemProperty("collectSpans", true)
   }
 
   check {

instrumentation/akka/akka-http-10.0/javaagent/build.gradle.kts

@@ -45,6 +45,9 @@ tasks.withType<Test>().configureEach {
   jvmArgs("--add-opens=java.base/java.math=ALL-UNNAMED")
   // required on jdk17
   jvmArgs("--add-opens=java.base/java.lang=ALL-UNNAMED")
+
+  systemProperty("collectMetadata", findProperty("collectMetadata")?.toString() ?: "false")
+  systemProperty("collectSpans", true)
 }
 
 tasks {