Debug logging

Author: kabir

server-common/src/main/java/io/a2a/server/events/EventConsumer.java

@@ -58,11 +58,15 @@ public Flow.Publisher<EventQueueItem> consumeAll() {
                     EventQueueItem item;
                     Event event;
                     try {
+                        LOGGER.debug("EventConsumer polling queue {} (error={})", System.identityHashCode(queue), error);
                         item = queue.dequeueEventItem(QUEUE_WAIT_MILLISECONDS);
                         if (item == null) {
+                            LOGGER.debug("EventConsumer poll timeout (null item), continuing");
                             continue;
                         }
                         event = item.getEvent();
+                        LOGGER.debug("EventConsumer received event: {} (queue={})",
+                            event.getClass().getSimpleName(), System.identityHashCode(queue));
 
                         // Defensive logging for error handling
                         if (event instanceof Throwable thr) {
@@ -124,8 +128,13 @@ public Flow.Publisher<EventQueueItem> consumeAll() {
 
     public EnhancedRunnable.DoneCallback createAgentRunnableDoneCallback() {
         return agentRunnable -> {
+            LOGGER.info("EventConsumer: Agent done callback invoked (hasError={}, queue={})",
+                agentRunnable.getError() != null, System.identityHashCode(queue));
             if (agentRunnable.getError() != null) {
                 error = agentRunnable.getError();
+                LOGGER.info("EventConsumer: Set error field from agent callback");
+            } else {
+                LOGGER.info("EventConsumer: Agent completed successfully (no error), continuing consumption");
             }
         };
     }

server-common/src/main/java/io/a2a/server/requesthandlers/DefaultRequestHandler.java

@@ -271,6 +271,17 @@ public EventKind onMessageSend(MessageSendParams params, ServerCallContext conte
             blocking = false;
         }
 
+        // Log blocking behavior from client request
+        if (params.configuration() != null && params.configuration().blocking() != null) {
+            LOGGER.info("DefaultRequestHandler: Client requested blocking={} for task {}",
+                params.configuration().blocking(), taskId);
+        } else if (params.configuration() != null) {
+            LOGGER.info("DefaultRequestHandler: Client sent configuration but blocking=null, using default blocking=true for task {}", taskId);
+        } else {
+            LOGGER.info("DefaultRequestHandler: Client sent no configuration, using default blocking=true for task {}", taskId);
+        }
+        LOGGER.info("DefaultRequestHandler: Final blocking decision: {} for task {}", blocking, taskId);
+
         boolean interruptedOrNonBlocking = false;
 
         EnhancedRunnable producerRunnable = registerAndExecuteAgentAsync(taskId, mss.requestContext, queue);
@@ -292,7 +303,8 @@ public EventKind onMessageSend(MessageSendParams params, ServerCallContext conte
                 throw new InternalError("No result");
             }
             interruptedOrNonBlocking = etai.interrupted();
-            LOGGER.debug("Was interrupted or non-blocking: {}", interruptedOrNonBlocking);
+            LOGGER.info("DefaultRequestHandler: interruptedOrNonBlocking={} (blocking={}, eventType={})",
+                interruptedOrNonBlocking, blocking, kind != null ? kind.getClass().getSimpleName() : null);
 
             // For blocking calls that were interrupted (returned on first event),
             // wait for agent execution and event processing BEFORE returning to client.
@@ -316,29 +328,31 @@ public EventKind onMessageSend(MessageSendParams params, ServerCallContext conte
                 // 2. Close the queue to signal consumption can complete
                 // 3. Wait for consumption to finish processing events
                 // 4. Fetch final task state from TaskStore
+                LOGGER.info("DefaultRequestHandler: Entering blocking fire-and-forget handling for task {}", taskId);
 
                 try {
                     // Step 1: Wait for agent to finish (with configurable timeout)
                     if (agentFuture != null) {
                         try {
                             agentFuture.get(agentCompletionTimeoutSeconds, SECONDS);
-                            LOGGER.debug("Agent completed for task {}", taskId);
+                            LOGGER.info("DefaultRequestHandler: Step 1 - Agent completed for task {}", taskId);
                         } catch (java.util.concurrent.TimeoutException e) {
                             // Agent still running after timeout - that's fine, events already being processed
-                            LOGGER.debug("Agent still running for task {} after {}s", taskId, agentCompletionTimeoutSeconds);
+                            LOGGER.info("DefaultRequestHandler: Step 1 - Agent still running for task {} after {}s timeout",
+                                taskId, agentCompletionTimeoutSeconds);
                         }
                     }
 
                     // Step 2: Close the queue to signal consumption can complete
                     // For fire-and-forget tasks, there's no final event, so we need to close the queue
                     // This allows EventConsumer.consumeAll() to exit
                     queue.close(false, false);  // graceful close, don't notify parent yet
-                    LOGGER.debug("Closed queue for task {} to allow consumption completion", taskId);
+                    LOGGER.info("DefaultRequestHandler: Step 2 - Closed queue for task {} to allow consumption completion", taskId);
 
                     // Step 3: Wait for consumption to complete (now that queue is closed)
                     if (etai.consumptionFuture() != null) {
                         etai.consumptionFuture().get(consumptionCompletionTimeoutSeconds, SECONDS);
-                        LOGGER.debug("Consumption completed for task {}", taskId);
+                        LOGGER.info("DefaultRequestHandler: Step 3 - Consumption completed for task {}", taskId);
                     }
                 } catch (InterruptedException e) {
                     Thread.currentThread().interrupt();
@@ -359,11 +373,11 @@ public EventKind onMessageSend(MessageSendParams params, ServerCallContext conte
                 Task updatedTask = taskStore.get(taskId);
                 if (updatedTask != null) {
                     kind = updatedTask;
-                    if (LOGGER.isDebugEnabled()) {
-                        LOGGER.debug("Fetched final task for {} with state {} and {} artifacts",
-                            taskId, updatedTask.getStatus().state(),
-                            updatedTask.getArtifacts().size());
-                    }
+                    LOGGER.info("DefaultRequestHandler: Step 4 - Fetched final task for {} with state {} and {} artifacts",
+                        taskId, updatedTask.getStatus().state(),
+                        updatedTask.getArtifacts().size());
+                } else {
+                    LOGGER.warn("DefaultRequestHandler: Step 4 - Task {} not found in TaskStore!", taskId);
                 }
             }
             if (kind instanceof Task taskResult && !taskId.equals(taskResult.getId())) {

server-common/src/main/java/io/a2a/server/tasks/ResultAggregator.java

@@ -145,6 +145,9 @@ public EventTypeAndInterrupt consumeAndBreakOnInterrupt(EventConsumer consumer,
                     boolean isAuthRequired = (event instanceof Task task && task.getStatus().state() == TaskState.AUTH_REQUIRED)
                             || (event instanceof TaskStatusUpdateEvent tsue && tsue.getStatus().state() == TaskState.AUTH_REQUIRED);
 
+                    LOGGER.info("ResultAggregator: Evaluating interrupt (blocking={}, isFinal={}, isAuth={}, eventType={})",
+                        blocking, isFinalEvent, isAuthRequired, event.getClass().getSimpleName());
+
                     // Always interrupt on auth_required, as it needs external action.
                     if (isAuthRequired) {
                         // auth-required is a special state: the message should be
@@ -154,23 +157,27 @@ public EventTypeAndInterrupt consumeAndBreakOnInterrupt(EventConsumer consumer,
                         // new request is expected in order for the agent to make progress,
                         // so the agent should exit.
                         shouldInterrupt = true;
+                        LOGGER.info("ResultAggregator: Setting shouldInterrupt=true (AUTH_REQUIRED)");
                     }
                     else if (!blocking) {
                         // For non-blocking calls, interrupt as soon as a task is available.
                         shouldInterrupt = true;
+                        LOGGER.info("ResultAggregator: Setting shouldInterrupt=true (non-blocking)");
                     }
                     else if (blocking) {
                         // For blocking calls: Interrupt to free Vert.x thread, but continue in background
                         // Python's async consumption doesn't block threads, but Java's does
                         // So we interrupt to return quickly, then rely on background consumption
                         shouldInterrupt = true;
+                        LOGGER.info("ResultAggregator: Setting shouldInterrupt=true (blocking, isFinal={})", isFinalEvent);
                         if (LOGGER.isDebugEnabled()) {
                             LOGGER.debug("Blocking call for task {}: {} event, returning with background consumption",
                                 taskIdForLogging(), isFinalEvent ? "final" : "non-final");
                         }
                     }
 
                     if (shouldInterrupt) {
+                        LOGGER.info("ResultAggregator: Interrupting consumption (setting interrupted=true)");
                         // Complete the future to unblock the main thread
                         interrupted.set(true);
                         completionFuture.complete(null);