refactor: Simplifiying Tracing code

Refactor the tracing implementation within the Google ADK to simplify how OpenTelemetry spans are managed, especially within RxJava streams.

The key changes include:

1.  **Introducing `Tracing.TracerProvider`**: A new set of RxJava transformers (`FlowableTransformer`, `SingleTransformer`, `MaybeTransformer`, `CompletableTransformer`) is added in `Tracing.java`. These transformers, created via `Tracing.trace()` methods, handle the lifecycle of OpenTelemetry spans, including span creation, making the span current, and ending the span upon stream completion or error.

2.  **Simplifying Tracing Calls**: Instead of manually creating and managing spans with `Tracer`, `Span`, and `Scope`, various parts of the codebase now use the `.compose(Tracing.trace(...))` operator on RxJava streams. This is applied in:
    *   `BaseAgent.java`: For agent invocations using `Tracing.traceAgent`.
    *   `BaseLlmFlow.java`: For LLM calls (`call_llm`) and sending data (`send_data`).
    *   `Functions.java`: For tool responses and tool calls.
    *   `Runner.java`: For overall invocation spans in `runAsync` and `runLive`.

3.  **Centralized Attribute Setting**: Helper methods like `getValidCurrentSpan`, `setInvocationAttributes`, `setToolExecutionAttributes`, and `setJsonAttribute` are added to `Tracing.java` to encapsulate and standardize how attributes are set on spans, including handling JSON serialization and checks for valid spans.

These changes aim to reduce tracing-related boilerplate, improve consistency, and make the tracing logic more robust by tying span lifetimes to RxJava stream lifecycles.

PiperOrigin-RevId: 869714739

Author: google-genai-bot

core/src/main/java/com/google/adk/agents/BaseAgent.java

@@ -29,9 +29,6 @@
 import com.google.errorprone.annotations.CanIgnoreReturnValue;
 import com.google.errorprone.annotations.DoNotCall;
 import com.google.genai.types.Content;
-import io.opentelemetry.api.trace.Span;
-import io.opentelemetry.api.trace.Tracer;
-import io.opentelemetry.context.Context;
 import io.reactivex.rxjava3.core.Completable;
 import io.reactivex.rxjava3.core.Flowable;
 import io.reactivex.rxjava3.core.Maybe;
@@ -315,44 +312,37 @@ public Flowable<Event> runAsync(InvocationContext parentContext) {
   private Flowable<Event> run(
       InvocationContext parentContext,
       Function<InvocationContext, Flowable<Event>> runImplementation) {
-    Tracer tracer = Tracing.getTracer();
     return Flowable.defer(
         () -> {
           InvocationContext invocationContext = createInvocationContext(parentContext);
-          Span span =
-              tracer.spanBuilder("invoke_agent " + name()).setParent(Context.current()).startSpan();
-          Tracing.traceAgentInvocation(span, name(), description(), invocationContext);
-          Context spanContext = Context.current().with(span);
-
-          return Tracing.traceFlowable(
-              spanContext,
-              span,
-              () ->
-                  callCallback(
-                          beforeCallbacksToFunctions(
-                              invocationContext.pluginManager(), beforeAgentCallback),
-                          invocationContext)
-                      .flatMapPublisher(
-                          beforeEventOpt -> {
-                            if (invocationContext.endInvocation()) {
-                              return Flowable.fromOptional(beforeEventOpt);
-                            }
-
-                            Flowable<Event> beforeEvents = Flowable.fromOptional(beforeEventOpt);
-                            Flowable<Event> mainEvents =
-                                Flowable.defer(() -> runImplementation.apply(invocationContext));
-                            Flowable<Event> afterEvents =
-                                Flowable.defer(
-                                    () ->
-                                        callCallback(
-                                                afterCallbacksToFunctions(
-                                                    invocationContext.pluginManager(),
-                                                    afterAgentCallback),
-                                                invocationContext)
-                                            .flatMapPublisher(Flowable::fromOptional));
-
-                            return Flowable.concat(beforeEvents, mainEvents, afterEvents);
-                          }));
+
+          return callCallback(
+                  beforeCallbacksToFunctions(
+                      invocationContext.pluginManager(), beforeAgentCallback),
+                  invocationContext)
+              .flatMapPublisher(
+                  beforeEventOpt -> {
+                    if (invocationContext.endInvocation()) {
+                      return Flowable.fromOptional(beforeEventOpt);
+                    }
+
+                    Flowable<Event> beforeEvents = Flowable.fromOptional(beforeEventOpt);
+                    Flowable<Event> mainEvents =
+                        Flowable.defer(() -> runImplementation.apply(invocationContext));
+                    Flowable<Event> afterEvents =
+                        Flowable.defer(
+                            () ->
+                                callCallback(
+                                        afterCallbacksToFunctions(
+                                            invocationContext.pluginManager(), afterAgentCallback),
+                                        invocationContext)
+                                    .flatMapPublisher(Flowable::fromOptional));
+
+                    return Flowable.concat(beforeEvents, mainEvents, afterEvents);
+                  })
+              .compose(
+                  Tracing.traceAgent(
+                      "invoke_agent " + name(), name(), description(), invocationContext));
         });
   }
 
@@ -364,11 +354,8 @@ private Flowable<Event> run(
    */
   private ImmutableList<Function<CallbackContext, Maybe<Content>>> beforeCallbacksToFunctions(
       Plugin pluginManager, List<? extends BeforeAgentCallback> callbacks) {
-    return Stream.concat(
-            Stream.of(ctx -> pluginManager.beforeAgentCallback(this, ctx)),
-            callbacks.stream()
-                .map(callback -> (Function<CallbackContext, Maybe<Content>>) callback::call))
-        .collect(toImmutableList());
+    return callbacksToFunctions(
+        ctx -> pluginManager.beforeAgentCallback(this, ctx), callbacks, c -> c::call);
   }
 
   /**
@@ -379,10 +366,15 @@ private ImmutableList<Function<CallbackContext, Maybe<Content>>> beforeCallbacks
    */
   private ImmutableList<Function<CallbackContext, Maybe<Content>>> afterCallbacksToFunctions(
       Plugin pluginManager, List<? extends AfterAgentCallback> callbacks) {
-    return Stream.concat(
-            Stream.of(ctx -> pluginManager.afterAgentCallback(this, ctx)),
-            callbacks.stream()
-                .map(callback -> (Function<CallbackContext, Maybe<Content>>) callback::call))
+    return callbacksToFunctions(
+        ctx -> pluginManager.afterAgentCallback(this, ctx), callbacks, c -> c::call);
+  }
+
+  private <T> ImmutableList<Function<CallbackContext, Maybe<Content>>> callbacksToFunctions(
+      Function<CallbackContext, Maybe<Content>> pluginCallback,
+      List<T> callbacks,
+      Function<T, Function<CallbackContext, Maybe<Content>>> mapper) {
+    return Stream.concat(Stream.of(pluginCallback), callbacks.stream().map(mapper))
         .collect(toImmutableList());
   }
 
@@ -523,8 +515,7 @@ public B subAgents(List<? extends BaseAgent> subAgents) {
 
     @CanIgnoreReturnValue
     public B subAgents(BaseAgent... subAgents) {
-      this.subAgents = ImmutableList.copyOf(subAgents);
-      return self();
+      return subAgents(ImmutableList.copyOf(subAgents));
     }
 
     @CanIgnoreReturnValue