feat: Add OpenTelemetry tracing support with comprehensive testing and null safety

Added OpenTelemetry integration for distributed tracing across the A2A SDK:

- Added @trace annotation for CDI interceptors to create spans on method invocations
- Created SpanInterceptor with robust CDI proxy handling supporting 5 proxy patterns
- Added InvocationContext record for capturing method invocation details with:
  * Null safety annotations (@NonNull/@nullable)
  * Comprehensive JavaDoc documentation
  * Specific exception declarations (IllegalAccessException, InvocationTargetException)
- Implemented attribute extractors for all transport types:
  * GrpcAttributeExtractor with null-safe gRPC context key access
  * JsonRPCAttributeExtractor with method name extraction
  * RestAttributeExtractor with conditional attribute building
  * RequestHandlerAttributeExtractor for default request handler

- Added ClientTransportWrapper SPI for wrapping transport operations
- Created OpenTelemetryClientTransport decorator supporting:
  * All A2A client methods (sendMessage, getTask, listTasks, etc.)
  * Streaming operations with event consumer wrapping
  * Error consumer instrumentation
  * Helper methods to eliminate code duplication
- Updated ClientBuilder to apply transport wrappers via ServiceLoader

- Added 21 comprehensive tests for OpenTelemetryClientTransport
- Added 12 tests for SpanInterceptor CDI proxy handling
- Added 10 tests for GrpcAttributeExtractor null safety
- All attribute extractors include defensive null checks preventing NPE
- 244 total tests passing in server-common module

- Updated HelloWorld example with OpenTelemetry integration:
  * Added OTEL dependencies and configuration
  * Configured trace export to console
  * Added README documentation for running with telemetry
  * Server now includes @trace annotation on agent method

- Added extras/opentelemetry module with dependencies
- Updated BOM with OpenTelemetry extras
- Added CDI beans.xml and ServiceLoader configuration
- Updated .gitignore for IDE and build artifacts

Fixes a2aproject#388

Signed-off-by: Emmanuel Hugonnet <[email protected]>

Author: ehsavoie

.gitignore

@@ -6,6 +6,9 @@ pom.xml.versionsBackup
 release.properties
 .flattened-pom.xml
 
+#Claude
+CLAUDE.md
+
 # Eclipse
 .project
 .classpath
@@ -20,6 +23,7 @@ bin/
 
 # NetBeans
 nb-configuration.xml
+nbactions.xml
 
 # Visual Studio Code
 .vscode

boms/extras/pom.xml

@@ -34,6 +34,11 @@
                 <artifactId>a2a-java-extras-common</artifactId>
                 <version>${project.version}</version>
             </dependency>
+            <dependency>
+                <groupId>${project.groupId}</groupId>
+                <artifactId>a2a-java-sdk-opentelemetry</artifactId>
+                <version>${project.version}</version>
+            </dependency>
             <dependency>
                 <groupId>${project.groupId}</groupId>
                 <artifactId>a2a-java-extras-task-store-database-jpa</artifactId>

boms/extras/src/it/extras-usage-test/pom.xml

@@ -44,6 +44,10 @@
             <groupId>io.github.a2asdk</groupId>
             <artifactId>a2a-java-extras-common</artifactId>
         </dependency>
+        <dependency>
+            <groupId>io.github.a2asdk</groupId>
+            <artifactId>a2a-java-sdk-opentelemetry</artifactId>
+        </dependency>
         <dependency>
             <groupId>io.github.a2asdk</groupId>
             <artifactId>a2a-java-extras-task-store-database-jpa</artifactId>

client/base/src/main/java/io/a2a/client/ClientBuilder.java

@@ -6,21 +6,27 @@
 import java.util.List;
 import java.util.Map;
 import java.util.ServiceLoader;
+import java.util.ServiceLoader.Provider;
 import java.util.function.BiConsumer;
 import java.util.function.Consumer;
+import java.util.stream.Collectors;
 
 import io.a2a.client.config.ClientConfig;
 import io.a2a.client.transport.spi.ClientTransport;
 import io.a2a.client.transport.spi.ClientTransportConfig;
 import io.a2a.client.transport.spi.ClientTransportConfigBuilder;
 import io.a2a.client.transport.spi.ClientTransportProvider;
+import io.a2a.client.transport.spi.ClientTransportWrapper;
 import io.a2a.spec.A2AClientException;
 import io.a2a.spec.AgentCard;
 import io.a2a.spec.AgentInterface;
 import io.a2a.spec.TransportProtocol;
 import org.jspecify.annotations.NonNull;
 import org.jspecify.annotations.Nullable;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 /**
  * Builder for creating instances of {@link Client} to communicate with A2A agents.
  * <p>
@@ -96,6 +102,7 @@ public class ClientBuilder {
 
     private static final Map<String, ClientTransportProvider<? extends ClientTransport, ? extends ClientTransportConfig<?>>> transportProviderRegistry = new HashMap<>();
     private static final Map<Class<? extends ClientTransport>, String> transportProtocolMapping = new HashMap<>();
+    private static final Logger LOGGER = LoggerFactory.getLogger(ClientBuilder.class);
 
     static {
         ServiceLoader<ClientTransportProvider> loader = ServiceLoader.load(ClientTransportProvider.class);
@@ -108,7 +115,8 @@ public class ClientBuilder {
     private final AgentCard agentCard;
 
     private final List<BiConsumer<ClientEvent, AgentCard>> consumers = new ArrayList<>();
-    private @Nullable Consumer<Throwable> streamErrorHandler;
+    private @Nullable
+    Consumer<Throwable> streamErrorHandler;
     private ClientConfig clientConfig = new ClientConfig.Builder().build();
 
     private final Map<Class<? extends ClientTransport>, ClientTransportConfig<? extends ClientTransport>> clientTransports = new LinkedHashMap<>();
@@ -318,7 +326,7 @@ private ClientTransport buildClientTransport() throws A2AClientException {
             throw new A2AClientException("Missing required TransportConfig for " + agentInterface.protocolBinding());
         }
 
-        return clientTransportProvider.create(clientTransportConfig, agentCard, agentInterface);
+        return wrap(clientTransportProvider.create(clientTransportConfig, agentCard, agentInterface), clientTransportConfig);
     }
 
     private Map<String, String> getServerPreferredTransports() throws A2AClientException {
@@ -373,10 +381,50 @@ private AgentInterface findBestClientTransport() throws A2AClientException {
         if (transportProtocol == null || transportUrl == null) {
             throw new A2AClientException("No compatible transport found");
         }
-        if (! transportProviderRegistry.containsKey(transportProtocol)) {
+        if (!transportProviderRegistry.containsKey(transportProtocol)) {
             throw new A2AClientException("No client available for " + transportProtocol);
         }
 
         return new AgentInterface(transportProtocol, transportUrl);
     }
+
+    /**
+     * Wraps the transport with all available transport wrappers discovered via ServiceLoader.
+     * Wrappers are applied in priority order (highest priority first).
+     *
+     * @param transport the base transport to wrap
+     * @param clientTransportConfig the transport configuration
+     * @return the wrapped transport (or original if no wrappers are available/applicable)
+     */
+    private ClientTransport wrap(ClientTransport transport, ClientTransportConfig<? extends ClientTransport> clientTransportConfig) {
+        ServiceLoader<ClientTransportWrapper> wrapperLoader = ServiceLoader.load(ClientTransportWrapper.class);
+
+        // Collect all wrappers and sort by natural order (uses Comparable implementation)
+        List<ClientTransportWrapper> wrappers = wrapperLoader.stream().map(Provider::get)
+                .sorted()
+                .collect(Collectors.toList());
+
+        if (wrappers.isEmpty()) {
+            LOGGER.debug("No client transport wrappers found via ServiceLoader");
+            return transport;
+        }
+
+        // Apply wrappers in priority order
+        ClientTransport wrapped = transport;
+        for (ClientTransportWrapper wrapper : wrappers) {
+            try {
+                ClientTransport newWrapped = wrapper.wrap(wrapped, clientTransportConfig);
+                if (newWrapped != wrapped) {
+                    LOGGER.debug("Applied transport wrapper: {} (priority: {})",
+                            wrapper.getClass().getName(), wrapper.priority());
+                }
+                wrapped = newWrapped;
+            } catch (Exception e) {
+                LOGGER.warn("Failed to apply transport wrapper {}: {}",
+                        wrapper.getClass().getName(), e.getMessage(), e);
+            }
+        }
+
+        return wrapped;
+    }
 }

client/transport/rest/src/main/java/io/a2a/client/transport/rest/RestTransportConfig.java

@@ -48,7 +48,7 @@
  * @see A2AHttpClient
  * @see io.a2a.client.http.JdkA2AHttpClient
  */
-public class RestTransportConfig extends ClientTransportConfig<RestTransport>  {
+public class RestTransportConfig extends ClientTransportConfig<RestTransport> {
 
     private final @Nullable A2AHttpClient httpClient;
 

client/transport/spi/src/main/java/io/a2a/client/transport/spi/ClientTransportConfig.java

@@ -1,7 +1,10 @@
 package io.a2a.client.transport.spi;
 
 import java.util.ArrayList;
+
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 
 import io.a2a.client.transport.spi.interceptors.ClientCallInterceptor;
 
@@ -35,6 +38,7 @@
 public abstract class ClientTransportConfig<T extends ClientTransport> {
 
     protected List<ClientCallInterceptor> interceptors = new ArrayList<>();
+    protected Map<String, ? extends Object > parameters = new HashMap<>();
 
     /**
      * Set the list of request/response interceptors.
@@ -63,4 +67,12 @@ public void setInterceptors(List<ClientCallInterceptor> interceptors) {
     public List<ClientCallInterceptor> getInterceptors() {
         return java.util.Collections.unmodifiableList(interceptors);
     }
+
+    public void setParameters(Map<String, ? extends Object > parameters) {
+        this.parameters = new HashMap<>(parameters);
+    }
+
+    public Map<String, ? extends Object > getParameters() {
+        return parameters;
+    }
 }

client/transport/spi/src/main/java/io/a2a/client/transport/spi/ClientTransportWrapper.java

@@ -0,0 +1,81 @@
+package io.a2a.client.transport.spi;
+
+/**
+ * Service provider interface for wrapping client transports with additional functionality.
+ * Implementations can add cross-cutting concerns like tracing, metrics, logging, etc.
+ *
+ * <p>Wrappers are discovered via Java's ServiceLoader mechanism. To register a wrapper,
+ * create a file {@code META-INF/services/io.a2a.client.transport.spi.ClientTransportWrapper}
+ * containing the fully qualified class name of your implementation.
+ *
+ * <p>Wrappers are sorted by priority in descending order (highest priority first).
+ * This interface implements {@link Comparable} to enable natural sorting.
+ *
+ * <p>Example implementation:
+ * <pre>{@code
+ * public class TracingWrapper implements ClientTransportWrapper {
+ *     @Override
+ *     public ClientTransport wrap(ClientTransport transport, ClientTransportConfig<?> config) {
+ *         if (config.getParameters().containsKey("tracer")) {
+ *             return new TracingTransport(transport, (Tracer) config.getParameters().get("tracer"));
+ *         }
+ *         return transport;
+ *     }
+ *
+ *     @Override
+ *     public int priority() {
+ *         return 100; // Higher priority = wraps earlier (outermost)
+ *     }
+ * }
+ * }</pre>
+ */
+public interface ClientTransportWrapper extends Comparable<ClientTransportWrapper> {
+
+    /**
+     * Wraps the given transport with additional functionality.
+     *
+     * <p>Implementations should check the configuration to determine if they should
+     * actually wrap the transport. If the wrapper is not applicable (e.g., required
+     * configuration is missing), return the original transport unchanged.
+     *
+     * @param transport the transport to wrap
+     * @param config the transport configuration, may contain wrapper-specific parameters
+     * @return the wrapped transport, or the original if wrapping is not applicable
+     */
+    ClientTransport wrap(ClientTransport transport, ClientTransportConfig<?> config);
+
+    /**
+     * Returns the priority of this wrapper. Higher priority wrappers are applied first
+     * (wrap the transport earlier, resulting in being the outermost wrapper).
+     *
+     * <p>Default priority is 0. Suggested ranges:
+     * <ul>
+     *   <li>1000+ : Critical infrastructure (security, authentication)
+     *   <li>500-999: Observability (tracing, metrics, logging)
+     *   <li>100-499: Enhancement (caching, retry logic)
+     *   <li>0-99: Optional features
+     * </ul>
+     *
+     * @return the priority value, higher values = higher priority
+     */
+    default int priority() {
+        return 0;
+    }
+
+    /**
+     * Compares this wrapper with another based on priority.
+     * Returns a negative integer, zero, or a positive integer as this wrapper
+     * has higher priority than, equal to, or lower priority than the specified wrapper.
+     *
+     * <p>Note: This comparison is reversed (higher priority comes first) to enable
+     * natural sorting in descending priority order.
+     *
+     * @param other the wrapper to compare to
+     * @return negative if this has higher priority, positive if lower, zero if equal
+     */
+    @Override
+    default int compareTo(ClientTransportWrapper other) {
+        // Reverse comparison: higher priority should come first
+        return Integer.compare(other.priority(), this.priority());
+    }
+}