Merge branch 'main' into close-bridged-instruments

Author: trask

.fossa.yml

@@ -1069,6 +1069,9 @@ targets:
     - type: gradle
       path: ./
       target: ':instrumentation:zio:zio-2.0:javaagent'
+    - type: gradle
+      path: ./
+      target: ':instrumentation:zio:zio-http-3.0:javaagent'
     - type: gradle
       path: ./
       target: ':instrumentation:jaxrs:jaxrs-2.0:jaxrs-2.0-annotations:javaagent'

.github/copilot-instructions.md

@@ -28,6 +28,10 @@ Never use the `--rerun-tasks` flag unless explicitly asked to use this option.
 Gradle automatically detects changes and re-runs tasks automatically when needed. Using `--rerun-tasks`
 is wasteful and slows down builds unnecessarily.
 
+Builds and tests in this repository genuinely take a long time (often several minutes).
+When running Gradle commands, use a timeout of 0 (no timeout) and wait for them to complete.
+Do not assume a build has hung or failed just because it takes a while.
+
 ## Throwing exceptions
 
 When writing instrumentation, you have to be really careful about throwing exceptions. For library

benchmark-jfr-analyzer/src/main/java/io/opentelemetry/javaagent/benchmark/jfr/Analyzer.java

@@ -5,14 +5,16 @@
 
 package io.opentelemetry.javaagent.benchmark.jfr;
 
+import static java.util.stream.Collectors.toList;
+import static java.util.stream.Collectors.toSet;
+
 import java.io.File;
 import java.util.Comparator;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
 import java.util.Set;
-import java.util.stream.Collectors;
 import javax.annotation.Nullable;
 import jdk.jfr.consumer.RecordedEvent;
 import jdk.jfr.consumer.RecordedFrame;
@@ -31,7 +33,7 @@ public static void main(String[] args) throws Exception {
     List<RecordedEvent> events =
         RecordingFile.readAllEvents(jfrFile.toPath()).stream()
             .filter(e -> e.getEventType().getName().equals("jdk.ExecutionSample"))
-            .collect(Collectors.toList());
+            .collect(toList());
 
     Set<String> agentCallers = getAgentCallers(events);
 
@@ -59,7 +61,7 @@ private static Set<String> getAgentCallers(List<RecordedEvent> events) {
     return events.stream()
         .map(e -> getAgentCaller(e.getStackTrace()))
         .filter(Objects::nonNull)
-        .collect(Collectors.toSet());
+        .collect(toSet());
   }
 
   @Nullable
@@ -171,7 +173,7 @@ private Node recordChildSample(String stackTraceElement) {
     private List<Node> getOrderedChildNodes() {
       return childNodes.values().stream()
           .sorted(Comparator.comparingInt(Node::getCount).reversed())
-          .collect(Collectors.toList());
+          .collect(toList());
     }
 
     private int getCount() {

benchmark-overhead-jmh/build.gradle.kts

@@ -12,7 +12,7 @@ otelJava {
 }
 
 dependencies {
-  jmhImplementation("org.springframework.boot:spring-boot-starter-web:4.0.2")
+  jmhImplementation("org.springframework.boot:spring-boot-starter-web:4.0.3")
 }
 
 tasks {

benchmark-overhead/build.gradle.kts

@@ -25,7 +25,7 @@ dependencies {
   testImplementation("org.junit.jupiter:junit-jupiter-params")
   testImplementation("com.squareup.okhttp3:okhttp:5.3.2")
   testImplementation("org.jooq:joox:2.0.1")
-  testImplementation("com.jayway.jsonpath:json-path:2.10.0")
+  testImplementation("com.jayway.jsonpath:json-path:3.0.0")
   testImplementation("org.slf4j:slf4j-simple:2.0.17")
   testImplementation("org.assertj:assertj-core:3.27.7")
 

benchmark-overhead/src/test/java/io/opentelemetry/results/CsvPersister.java

@@ -5,6 +5,7 @@
 
 package io.opentelemetry.results;
 
+import static java.util.stream.Collectors.toList;
 import static java.util.concurrent.TimeUnit.NANOSECONDS;
 
 import java.io.IOException;
@@ -14,7 +15,6 @@
 import java.util.Arrays;
 import java.util.List;
 import java.util.function.Function;
-import java.util.stream.Collectors;
 
 class CsvPersister implements ResultsPersister {
 
@@ -88,7 +88,7 @@ private String createHeaderLine(List<AppPerfResults> results) {
     // line so that we can create a columnar structure that allows us to more easily compare agent
     // to agent for a given run.
 
-    List<String> agents = results.stream().map(r -> r.agent.getName()).collect(Collectors.toList());
+    List<String> agents = results.stream().map(r -> r.agent.getName()).collect(toList());
     for (FieldSpec field : FIELDS) {
       for (String agent : agents) {
         sb.append(",").append(agent).append(':').append(field.name);

benchmark-overhead/src/test/java/io/opentelemetry/results/ResultsCollector.java

@@ -5,6 +5,7 @@
 
 package io.opentelemetry.results;
 
+import static java.util.stream.Collectors.toList;
 import com.jayway.jsonpath.JsonPath;
 import io.opentelemetry.agents.Agent;
 import io.opentelemetry.config.TestConfig;
@@ -16,7 +17,6 @@
 import java.nio.file.Path;
 import java.util.List;
 import java.util.Map;
-import java.util.stream.Collectors;
 
 public class ResultsCollector {
 
@@ -31,7 +31,7 @@ public ResultsCollector(NamingConvention namingConvention, Map<String, Long> run
   public List<AppPerfResults> collect(TestConfig config) {
     return config.getAgents().stream()
         .map(a -> readAgentResults(a, config))
-        .collect(Collectors.toList());
+        .collect(toList());
   }
 
   private AppPerfResults readAgentResults(Agent agent, TestConfig config) {

buildscripts/checkstyle.xml

@@ -50,20 +50,6 @@
   -->
 
   <module name="TreeWalker">
-    <!-- Enforce static imports for OpenTelemetryAssertions methods (lowercase), but allow inner
-    classes (uppercase). The negative lookahead is needed so we don't match import lines. -->
-    <module name="RegexpSinglelineJava">
-      <property name="format"
-                value="^(?!.*import).*OpenTelemetryAssertions\.[a-z]"/>
-      <property name="message"
-                value="Please statically import methods from OpenTelemetryAssertions"/>
-    </module>
-    <module name="RegexpSinglelineJava">
-      <property name="format"
-                value="(?&lt;!import static org.assertj.core.api.|OpenTelemetry)Assertions.assertThat"/>
-      <property name="message"
-                value="Please statically import methods from Assertions (OpenTelemetryAssertions extends Assertions)"/>
-    </module>
     <module name="OuterTypeFilename"/>
     <module name="IllegalTokenText">
       <property name="tokens" value="STRING_LITERAL, CHAR_LITERAL"/>

conventions/src/main/kotlin/io/opentelemetry/instrumentation/gradle/StaticImportFormatter.kt

@@ -0,0 +1,137 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.instrumentation.gradle
+
+import com.diffplug.spotless.FormatterFunc
+import java.io.Serializable
+
+/**
+ * Spotless custom step that rewrites qualified references (e.g. {@code Objects.requireNonNull})
+ * into unqualified references and adds the corresponding static import. Runs before
+ * googleJavaFormat so that imports are sorted and any newly-unused regular imports are removed.
+ */
+class StaticImportFormatter : FormatterFunc, Serializable {
+
+  override fun apply(input: String): String {
+    // (className, fullyQualifiedName, memberPattern)
+    val rules = listOf(
+      Triple("Objects", "java.util.Objects", "requireNonNull"),
+      Triple(
+        "ElementMatchers",
+        "net.bytebuddy.matcher.ElementMatchers",
+        "[a-z][a-zA-Z0-9]*"
+      ),
+      Triple(
+        "AgentElementMatchers",
+        "io.opentelemetry.javaagent.extension.matcher.AgentElementMatchers",
+        "[a-z][a-zA-Z0-9]*"
+      ),
+      Triple("TimeUnit", "java.util.concurrent.TimeUnit", "[A-Z][A-Z_0-9]*"),
+      Triple(
+        "StandardCharsets",
+        "java.nio.charset.StandardCharsets",
+        "[A-Z][A-Z_0-9]*"
+      ),
+      Triple(
+        "Collections",
+        "java.util.Collections",
+        "singleton[a-zA-Z0-9]*|empty[a-zA-Z0-9]*"
+      ),
+      Triple(
+        "ArgumentMatchers",
+        "org.mockito.ArgumentMatchers",
+        "[a-z][a-zA-Z0-9]*"
+      ),
+      Triple(
+        "Mockito",
+        "org.mockito.Mockito",
+        "mock|mockStatic|spy|when|verify|verifyNoInteractions|verifyNoMoreInteractions|doAnswer|doReturn|doThrow|lenient|never|times|atLeastOnce|withSettings"
+      ),
+      Triple("Assertions", "org.assertj.core.api.Assertions", "assertThat"),
+      Triple(
+        "OpenTelemetryAssertions",
+        "io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions",
+        "[a-z][a-zA-Z0-9]*"
+      ),
+      Triple(
+        "SemconvStability",
+        "io.opentelemetry.instrumentation.api.internal.SemconvStability",
+        "emit[a-zA-Z0-9]*"
+      ),
+    )
+
+    var content = input
+    val importsToAdd = mutableSetOf<String>()
+
+    for ((className, pkg, memberPattern) in rules) {
+      val regex = Regex("\\b${className}\\.(${memberPattern})\\b")
+      val lines = content.lines().toMutableList()
+      for (i in lines.indices) {
+        if (lines[i].trimStart().startsWith("import ")) continue
+        for (match in regex.findAll(lines[i])) {
+          importsToAdd.add("import static ${pkg}.${match.groupValues[1]};")
+        }
+        lines[i] = regex.replace(lines[i], "$1")
+      }
+      content = lines.joinToString("\n")
+    }
+
+    // Handle semconv classes: find all imported semconv classes (except SchemaUrls) and convert
+    // qualified constant references (e.g. HttpAttributes.HTTP_METHOD) to static imports.
+    // Also handles nested value classes (e.g. DbIncubatingAttributes.DbSystemNameIncubatingValues).
+    val semconvImportRegex =
+      Regex(
+        """^import (io\.opentelemetry\.semconv\.(?:[a-z][a-z.]*\.)?([A-Z][a-zA-Z0-9]+)(?:\.([A-Z][a-zA-Z0-9]+))?);"""
+      )
+    val semconvRules =
+      content
+        .lines()
+        .mapNotNull { line -> semconvImportRegex.find(line.trim()) }
+        .filter { it.groupValues[2] != "SchemaUrls" }
+        .map { m ->
+          // If there is a nested class (group 3), use the nested class as the className so that
+          // references like `DbSystemNameIncubatingValues.COUCHBASE` are rewritten correctly.
+          val className = if (m.groupValues[3].isNotEmpty()) m.groupValues[3] else m.groupValues[2]
+          Triple(className, m.groupValues[1], "[A-Z][A-Z_0-9]*")
+        }
+    for ((className, pkg, memberPattern) in semconvRules) {
+      val regex = Regex("\\b${className}\\.(${memberPattern})\\b")
+      val lines = content.lines().toMutableList()
+      var inBlockComment = false
+      for (i in lines.indices) {
+        val trimmed = lines[i].trimStart()
+        if (trimmed.startsWith("/*")) inBlockComment = true
+        if (inBlockComment) {
+          if (trimmed.contains("*/")) inBlockComment = false
+          continue
+        }
+        if (trimmed.startsWith("import ")) continue
+        for (match in regex.findAll(lines[i])) {
+          importsToAdd.add("import static ${pkg}.${match.groupValues[1]};")
+        }
+        lines[i] = regex.replace(lines[i], "$1")
+      }
+      content = lines.joinToString("\n")
+    }
+
+    if (importsToAdd.isNotEmpty()) {
+      val lines = content.lines().toMutableList()
+      val firstImportIndex = lines.indexOfFirst { it.trimStart().startsWith("import ") }
+      if (firstImportIndex >= 0) {
+        for ((offset, imp) in importsToAdd.sorted().withIndex()) {
+          lines.add(firstImportIndex + offset, imp)
+        }
+        content = lines.joinToString("\n")
+      }
+    }
+
+    return content
+  }
+
+  companion object {
+    private const val serialVersionUID = 1L
+  }
+}

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

@@ -58,8 +58,8 @@ tasks {
         // Suggests using Guava types for fields but we don't use Guava
         disable("ImmutableMemberCollection")
 
-        // Fully qualified names may be necessary when deprecating a class to avoid
-        // deprecation warning.
+        // Replaced by custom OtelUnnecessarilyFullyQualified check which handles
+        // application.* and other repo-specific conventions
         disable("UnnecessarilyFullyQualified")
 
         // TODO (trask) use animal sniffer