diff --git a/dotnet/Directory.Packages.props b/dotnet/Directory.Packages.props
index 2e6e1bd413c..7718dc69fe9 100644
--- a/dotnet/Directory.Packages.props
+++ b/dotnet/Directory.Packages.props
@@ -17,6 +17,7 @@
+
diff --git a/dotnet/samples/05-end-to-end/DevUIAspireIntegration/DevUIIntegration.AppHost/DevUIIntegration.AppHost.csproj b/dotnet/samples/05-end-to-end/DevUIAspireIntegration/DevUIIntegration.AppHost/DevUIIntegration.AppHost.csproj
index 35c8eb709db..a7d06802a77 100644
--- a/dotnet/samples/05-end-to-end/DevUIAspireIntegration/DevUIIntegration.AppHost/DevUIIntegration.AppHost.csproj
+++ b/dotnet/samples/05-end-to-end/DevUIAspireIntegration/DevUIIntegration.AppHost/DevUIIntegration.AppHost.csproj
@@ -4,7 +4,8 @@
Exe
- net10.0
+ net10.0
+
enable
enable
@@ -18,6 +19,7 @@
+
diff --git a/dotnet/samples/05-end-to-end/DevUIAspireIntegration/DevUIIntegration.AppHost/Properties/launchSettings.json b/dotnet/samples/05-end-to-end/DevUIAspireIntegration/DevUIIntegration.AppHost/Properties/launchSettings.json
index 1012f97aa1e..6d5f6ddd5f5 100644
--- a/dotnet/samples/05-end-to-end/DevUIAspireIntegration/DevUIIntegration.AppHost/Properties/launchSettings.json
+++ b/dotnet/samples/05-end-to-end/DevUIAspireIntegration/DevUIIntegration.AppHost/Properties/launchSettings.json
@@ -11,7 +11,7 @@
"DOTNET_ENVIRONMENT": "Development",
"ASPIRE_DASHBOARD_OTLP_ENDPOINT_URL": "https://localhost:17250",
"ASPIRE_DASHBOARD_MCP_ENDPOINT_URL": "https://localhost:18100",
- "ASPIRE_RESOURCE_SERVICE_ENDPOINT_URL": "https://localhost:17250",
+ "ASPIRE_RESOURCE_SERVICE_ENDPOINT_URL": "https://localhost:17252",
"ASPIRE_SHOW_DASHBOARD_RESOURCES": "true"
}
},
@@ -25,7 +25,7 @@
"DOTNET_ENVIRONMENT": "Development",
"ASPIRE_DASHBOARD_OTLP_ENDPOINT_URL": "http://localhost:17251",
"ASPIRE_DASHBOARD_MCP_ENDPOINT_URL": "http://localhost:18101",
- "ASPIRE_RESOURCE_SERVICE_ENDPOINT_URL": "http://localhost:17251",
+ "ASPIRE_RESOURCE_SERVICE_ENDPOINT_URL": "http://localhost:17253",
"ASPIRE_SHOW_DASHBOARD_RESOURCES": "true",
"ASPIRE_ALLOW_UNSECURED_TRANSPORT": "true"
}
diff --git a/dotnet/src/Aspire.Hosting.AgentFramework.DevUI/AgentFrameworkBuilderExtensions.cs b/dotnet/src/Aspire.Hosting.AgentFramework.DevUI/AgentFrameworkBuilderExtensions.cs
index 7e7d5b16c08..618e71596f3 100644
--- a/dotnet/src/Aspire.Hosting.AgentFramework.DevUI/AgentFrameworkBuilderExtensions.cs
+++ b/dotnet/src/Aspire.Hosting.AgentFramework.DevUI/AgentFrameworkBuilderExtensions.cs
@@ -6,6 +6,7 @@
using System.Threading;
using Aspire.Hosting.AgentFramework;
using Aspire.Hosting.ApplicationModel;
+using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
@@ -63,7 +64,10 @@ public static IResourceBuilder AddDevUI(
builder.Eventing.Subscribe(resource, async (e, ct) =>
{
var logger = e.Logger;
- var aggregator = new DevUIAggregatorHostedService(resource, e.Services.GetRequiredService().CreateLogger());
+ var aggregator = new DevUIAggregatorHostedService(
+ resource,
+ e.Services.GetRequiredService().CreateLogger(),
+ e.Services.GetService());
try
{
diff --git a/dotnet/src/Aspire.Hosting.AgentFramework.DevUI/AspireDashboardTraceClient.cs b/dotnet/src/Aspire.Hosting.AgentFramework.DevUI/AspireDashboardTraceClient.cs
new file mode 100644
index 00000000000..b3771cfc59a
--- /dev/null
+++ b/dotnet/src/Aspire.Hosting.AgentFramework.DevUI/AspireDashboardTraceClient.cs
@@ -0,0 +1,318 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Net;
+using System.Net.Http;
+using System.Text.Json;
+using System.Text.Json.Nodes;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Aspire.Hosting.AgentFramework;
+
+///
+/// Connection details for the Aspire Dashboard telemetry API.
+///
+internal sealed record AspireDashboardConnection(Uri BaseUri, string? ApiKey);
+
+///
+/// Converts OTLP JSON returned by the Aspire Dashboard telemetry API into DevUI trace events.
+///
+internal static class AspireDashboardTraceClient
+{
+ private const string ApiKeyHeaderName = "x-api-key";
+
+ ///
+ /// Checks whether the configured Aspire Dashboard exposes its authenticated telemetry API.
+ ///
+ internal static async Task IsAvailableAsync(
+ HttpClient client,
+ Uri dashboardBaseUri,
+ string? dashboardApiKey,
+ CancellationToken cancellationToken)
+ {
+ using var request = new HttpRequestMessage(HttpMethod.Get, new Uri(dashboardBaseUri, "/api/telemetry/resources"));
+ AddApiKey(request, dashboardApiKey);
+
+ using var response = await client.SendAsync(request, cancellationToken).ConfigureAwait(false);
+ return response.IsSuccessStatusCode;
+ }
+
+ ///
+ /// Reads the spans for one response trace from the Aspire Dashboard telemetry API.
+ ///
+ internal static async Task?> GetTraceEventsAsync(
+ HttpClient client,
+ Uri dashboardBaseUri,
+ string? dashboardApiKey,
+ string traceId,
+ string responseId,
+ string entityId,
+ CancellationToken cancellationToken)
+ {
+ var path = $"/api/telemetry/traces/{Uri.EscapeDataString(traceId)}";
+ using var request = new HttpRequestMessage(HttpMethod.Get, new Uri(dashboardBaseUri, path));
+ AddApiKey(request, dashboardApiKey);
+
+ using var response = await client.SendAsync(request, cancellationToken).ConfigureAwait(false);
+ if (response.StatusCode == HttpStatusCode.NotFound)
+ {
+ return [];
+ }
+
+ if (!response.IsSuccessStatusCode)
+ {
+ return null;
+ }
+
+ using var document = await JsonDocument.ParseAsync(
+ await response.Content.ReadAsStreamAsync(cancellationToken).ConfigureAwait(false),
+ cancellationToken: cancellationToken).ConfigureAwait(false);
+
+ if (document.RootElement.TryGetProperty("totalCount", out var totalCount) &&
+ totalCount.TryGetInt64(out var total) &&
+ document.RootElement.TryGetProperty("returnedCount", out var returnedCount) &&
+ returnedCount.TryGetInt64(out var returned) &&
+ total != returned)
+ {
+ return null;
+ }
+
+ if (!document.RootElement.TryGetProperty("data", out var data) || data.ValueKind != JsonValueKind.Object)
+ {
+ return [];
+ }
+
+ return ConvertToTraceEvents(data, responseId, entityId);
+ }
+
+ private static void AddApiKey(HttpRequestMessage request, string? dashboardApiKey)
+ {
+ if (!string.IsNullOrEmpty(dashboardApiKey))
+ {
+ request.Headers.TryAddWithoutValidation(ApiKeyHeaderName, dashboardApiKey);
+ }
+ }
+
+ ///
+ /// Converts an OTLP trace response to the trace-event contract consumed by DevUI.
+ ///
+ internal static IReadOnlyList ConvertToTraceEvents(
+ JsonElement response,
+ string responseId,
+ string entityId)
+ {
+ var results = new List();
+
+ if (!response.TryGetProperty("resourceSpans", out var resourceSpans) ||
+ resourceSpans.ValueKind != JsonValueKind.Array)
+ {
+ return results;
+ }
+
+ foreach (var resourceSpan in resourceSpans.EnumerateArray())
+ {
+ if (!resourceSpan.TryGetProperty("scopeSpans", out var scopeSpans) ||
+ scopeSpans.ValueKind != JsonValueKind.Array)
+ {
+ continue;
+ }
+
+ foreach (var scopeSpan in scopeSpans.EnumerateArray())
+ {
+ if (!scopeSpan.TryGetProperty("spans", out var spans) || spans.ValueKind != JsonValueKind.Array)
+ {
+ continue;
+ }
+
+ foreach (var span in spans.EnumerateArray())
+ {
+ var data = ConvertSpan(span, responseId, entityId);
+ if (data is not null)
+ {
+ results.Add(new JsonObject
+ {
+ ["type"] = "response.trace.completed",
+ ["data"] = data,
+ ["sequence_number"] = 0
+ });
+ }
+ }
+ }
+ }
+
+ return results;
+ }
+
+ private static JsonObject? ConvertSpan(JsonElement span, string responseId, string entityId)
+ {
+ if (!TryGetString(span, "traceId", out var traceId) ||
+ !TryGetString(span, "spanId", out var spanId) ||
+ !TryGetString(span, "name", out var name))
+ {
+ return null;
+ }
+
+ var startTime = ReadUnixNanoseconds(span, "startTimeUnixNano");
+ var endTime = ReadUnixNanoseconds(span, "endTimeUnixNano");
+ var status = ReadStatus(span, out var error);
+
+ var data = new JsonObject
+ {
+ ["type"] = "trace_span",
+ ["span_id"] = spanId,
+ ["trace_id"] = traceId,
+ ["parent_span_id"] = ReadOptionalString(span, "parentSpanId"),
+ ["operation_name"] = name,
+ ["start_time"] = startTime,
+ ["end_time"] = endTime,
+ ["duration_ms"] = startTime is not null && endTime is not null
+ ? (endTime.Value - startTime.Value) * 1000
+ : null,
+ ["attributes"] = ReadAttributes(span),
+ ["status"] = status,
+ ["response_id"] = responseId,
+ ["entity_id"] = entityId
+ };
+
+ if (error is not null)
+ {
+ data["error"] = error;
+ }
+
+ if (span.TryGetProperty("events", out var events) && events.ValueKind == JsonValueKind.Array)
+ {
+ var convertedEvents = new JsonArray();
+ foreach (var spanEvent in events.EnumerateArray())
+ {
+ convertedEvents.Add(new JsonObject
+ {
+ ["name"] = ReadOptionalString(spanEvent, "name"),
+ ["timestamp"] = ReadUnixNanoseconds(spanEvent, "timeUnixNano"),
+ ["attributes"] = ReadAttributes(spanEvent)
+ });
+ }
+
+ data["events"] = convertedEvents;
+ }
+
+ return data;
+ }
+
+ private static string ReadStatus(JsonElement span, out string? error)
+ {
+ error = null;
+ if (!span.TryGetProperty("status", out var status) || status.ValueKind != JsonValueKind.Object)
+ {
+ return "StatusCode.UNSET";
+ }
+
+ var code = status.TryGetProperty("code", out var codeElement) && codeElement.TryGetInt32(out var value)
+ ? value
+ : 0;
+
+ if (code == 2)
+ {
+ error = ReadOptionalString(status, "message") ?? "Unknown error";
+ return "ERROR";
+ }
+
+ return code == 1 ? "OK" : "StatusCode.UNSET";
+ }
+
+ private static JsonObject ReadAttributes(JsonElement container)
+ {
+ var result = new JsonObject();
+ if (!container.TryGetProperty("attributes", out var attributes) || attributes.ValueKind != JsonValueKind.Array)
+ {
+ return result;
+ }
+
+ foreach (var attribute in attributes.EnumerateArray())
+ {
+ if (!TryGetString(attribute, "key", out var key) ||
+ !attribute.TryGetProperty("value", out var value) ||
+ value.ValueKind != JsonValueKind.Object)
+ {
+ continue;
+ }
+
+ result[key] = ReadAnyValue(value);
+ }
+
+ return result;
+ }
+
+ private static JsonNode? ReadAnyValue(JsonElement value)
+ {
+ if (value.TryGetProperty("stringValue", out var stringValue))
+ {
+ return JsonValue.Create(stringValue.GetString());
+ }
+
+ if (value.TryGetProperty("boolValue", out var boolValue) &&
+ boolValue.ValueKind is JsonValueKind.True or JsonValueKind.False)
+ {
+ return JsonValue.Create(boolValue.GetBoolean());
+ }
+
+ if (value.TryGetProperty("intValue", out var intValue))
+ {
+ if (intValue.ValueKind == JsonValueKind.Number && intValue.TryGetInt64(out var number))
+ {
+ return JsonValue.Create(number);
+ }
+
+ if (intValue.ValueKind == JsonValueKind.String &&
+ long.TryParse(intValue.GetString(), NumberStyles.Integer, CultureInfo.InvariantCulture, out number))
+ {
+ return JsonValue.Create(number);
+ }
+ }
+
+ if (value.TryGetProperty("doubleValue", out var doubleValue) && doubleValue.TryGetDouble(out var floatingPoint))
+ {
+ return JsonValue.Create(floatingPoint);
+ }
+
+ return JsonNode.Parse(value.GetRawText());
+ }
+
+ private static double? ReadUnixNanoseconds(JsonElement container, string propertyName)
+ {
+ if (!container.TryGetProperty(propertyName, out var value))
+ {
+ return null;
+ }
+
+ if (value.ValueKind == JsonValueKind.String &&
+ decimal.TryParse(value.GetString(), NumberStyles.Integer, CultureInfo.InvariantCulture, out var nanoseconds))
+ {
+ return (double)(nanoseconds / 1_000_000_000m);
+ }
+
+ if (value.ValueKind == JsonValueKind.Number && value.TryGetDecimal(out nanoseconds))
+ {
+ return (double)(nanoseconds / 1_000_000_000m);
+ }
+
+ return null;
+ }
+
+ private static bool TryGetString(JsonElement container, string propertyName, out string value)
+ {
+ value = string.Empty;
+ if (!container.TryGetProperty(propertyName, out var property) || property.ValueKind != JsonValueKind.String)
+ {
+ return false;
+ }
+
+ value = property.GetString()!;
+ return true;
+ }
+
+ private static string? ReadOptionalString(JsonElement container, string propertyName)
+ => TryGetString(container, propertyName, out var value) && !string.IsNullOrEmpty(value) ? value : null;
+}
diff --git a/dotnet/src/Aspire.Hosting.AgentFramework.DevUI/DevUIAggregatorHostedService.cs b/dotnet/src/Aspire.Hosting.AgentFramework.DevUI/DevUIAggregatorHostedService.cs
index d87e6ea28d1..c659f7b5474 100644
--- a/dotnet/src/Aspire.Hosting.AgentFramework.DevUI/DevUIAggregatorHostedService.cs
+++ b/dotnet/src/Aspire.Hosting.AgentFramework.DevUI/DevUIAggregatorHostedService.cs
@@ -3,6 +3,7 @@
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
+using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Net.Http;
@@ -17,6 +18,7 @@
using Microsoft.AspNetCore.Hosting.Server.Features;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.StaticFiles;
+using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
@@ -35,6 +37,13 @@ internal sealed class DevUIAggregatorHostedService : IAsyncDisposable
private WebApplication? _app;
private readonly DevUIResource _resource;
private readonly ILogger _logger;
+ private readonly IConfiguration? _configuration;
+ private readonly AspireDashboardConnection? _dashboardConnectionOverride;
+ private readonly SemaphoreSlim _tracingProbeLock = new(1, 1);
+ private bool _tracingAvailable;
+ private int _tracingUnavailableLogged;
+ private int _tracingEnabledLogged;
+ private int _disposed;
// Frontend resources loaded from the Microsoft.Agents.AI.DevUI assembly (null if unavailable)
private readonly Dictionary? _frontendResources;
@@ -43,12 +52,19 @@ internal sealed class DevUIAggregatorHostedService : IAsyncDisposable
// Populated when the aggregator routes conversation requests to a positively-resolved backend.
private readonly ConcurrentDictionary _conversationBackendMap = new(StringComparer.OrdinalIgnoreCase);
+ // Maps OpenAI response IDs to the Aspire resource and W3C trace ID propagated to that backend request.
+ private readonly ConcurrentDictionary _responseTraceMap = new(StringComparer.Ordinal);
+
public DevUIAggregatorHostedService(
DevUIResource resource,
- ILogger logger)
+ ILogger logger,
+ IConfiguration? configuration = null,
+ AspireDashboardConnection? dashboardConnectionOverride = null)
{
this._resource = resource;
this._logger = logger;
+ this._configuration = configuration;
+ this._dashboardConnectionOverride = dashboardConnectionOverride;
this._frontendResources = LoadFrontendResources(logger);
}
@@ -99,11 +115,18 @@ public async Task StopAsync(CancellationToken cancellationToken)
public async ValueTask DisposeAsync()
{
+ if (Interlocked.Exchange(ref this._disposed, 1) != 0)
+ {
+ return;
+ }
+
if (this._app is not null)
{
await this._app.DisposeAsync().ConfigureAwait(false);
this._app = null;
}
+
+ this._tracingProbeLock.Dispose();
}
///
@@ -248,8 +271,10 @@ private async Task TryServeResourceAsync(HttpContext context, string resou
return true;
}
- private static IResult GetMeta()
+ private async Task GetMetaAsync(HttpContext context)
{
+ var tracingAvailable = await this.IsTracingAvailableAsync(context).ConfigureAwait(false);
+
return Results.Json(new
{
ui_mode = "developer",
@@ -258,7 +283,9 @@ private static IResult GetMeta()
runtime = "dotnet",
capabilities = new Dictionary
{
- ["tracing"] = false,
+ ["instrumentation"] = tracingAvailable,
+ ["tracing"] = tracingAvailable,
+ ["trace_retrieval"] = tracingAvailable,
["openai_proxy"] = false,
["deployment"] = false
},
@@ -266,6 +293,86 @@ private static IResult GetMeta()
});
}
+ private async Task IsTracingAvailableAsync(HttpContext context)
+ {
+ if (this._tracingAvailable)
+ {
+ return true;
+ }
+
+ await this._tracingProbeLock.WaitAsync(context.RequestAborted).ConfigureAwait(false);
+ try
+ {
+ // Once the dashboard API has responded successfully, keep tracing armed. A later
+ // browser cancellation or transient dashboard failure must not disable other clients.
+ if (this._tracingAvailable)
+ {
+ return true;
+ }
+
+ if (!this.TryResolveDashboardConnection(out var dashboardBaseUri, out var dashboardApiKey))
+ {
+ this.LogTracingUnavailable("no loopback Aspire Dashboard endpoint was found in ASPNETCORE_URLS");
+ return false;
+ }
+
+ var httpClientFactory = context.RequestServices.GetRequiredService();
+ using var client = httpClientFactory.CreateClient("devui-proxy");
+ using var timeout = CancellationTokenSource.CreateLinkedTokenSource(context.RequestAborted);
+ timeout.CancelAfter(TimeSpan.FromSeconds(2));
+
+ try
+ {
+ this._tracingAvailable = await AspireDashboardTraceClient.IsAvailableAsync(
+ client,
+ dashboardBaseUri,
+ dashboardApiKey,
+ timeout.Token).ConfigureAwait(false);
+ }
+ catch (OperationCanceledException) when (context.RequestAborted.IsCancellationRequested)
+ {
+ throw;
+ }
+ catch (OperationCanceledException ex)
+ {
+ this.LogTracingUnavailable("the Aspire Dashboard telemetry API probe timed out", ex);
+ return false;
+ }
+ catch (HttpRequestException ex)
+ {
+ this.LogTracingUnavailable("the Aspire Dashboard telemetry API could not be reached", ex);
+ return false;
+ }
+
+ if (!this._tracingAvailable)
+ {
+ this.LogTracingUnavailable("the Aspire Dashboard telemetry API rejected the availability probe");
+ return false;
+ }
+
+ if (Interlocked.Exchange(ref this._tracingEnabledLogged, 1) == 0)
+ {
+ this._logger.LogInformation(
+ "Aspire Dashboard trace retrieval is enabled at {DashboardBaseUri}",
+ dashboardBaseUri);
+ }
+
+ return true;
+ }
+ finally
+ {
+ this._tracingProbeLock.Release();
+ }
+ }
+
+ private void LogTracingUnavailable(string reason, Exception? exception = null)
+ {
+ if (Interlocked.Exchange(ref this._tracingUnavailableLogged, 1) == 0)
+ {
+ this._logger.LogInformation(exception, "Aspire Dashboard trace retrieval is disabled because {Reason}.", reason);
+ }
+ }
+
private void MapRoutes(WebApplication app)
{
app.MapGet("/health", () => Results.Ok(new { status = "healthy" }));
@@ -274,8 +381,9 @@ private void MapRoutes(WebApplication app)
app.MapGet("/v1/entities", (Delegate)this.AggregateEntitiesAsync);
app.MapGet("/v1/entities/{**entityPath}", this.RouteEntityInfoAsync);
app.MapPost("/v1/responses", this.RouteResponsesAsync);
+ app.MapGet("/v1/responses/{responseId}/traces", this.GetResponseTracesAsync);
app.Map("/v1/conversations/{**path}", this.ProxyConversationsAsync);
- app.MapGet("/meta", GetMeta);
+ app.MapGet("/meta", (Delegate)this.GetMetaAsync);
// Serve the DevUI frontend from embedded assembly resources
app.Map("/devui/{**path}", this.ServeDevUIFrontendAsync);
@@ -474,7 +582,77 @@ await context.Response.WriteAsJsonAsync(
json!["metadata"]!["entity_id"] = actualEntityId;
var rewrittenBody = JsonSerializer.SerializeToUtf8Bytes(json);
- await ProxyRequestAsync(context, backendUrl, "/v1/responses", rewrittenBody, streaming: true).ConfigureAwait(false);
+ var resourceName = this.ResolveResourceName(entityId);
+ var traceId = resourceName is not null && this.TryResolveDashboardConnection(out _, out _)
+ ? ActivityTraceId.CreateRandom().ToHexString()
+ : null;
+ var traceParent = traceId is not null
+ ? $"00-{traceId}-{ActivitySpanId.CreateRandom().ToHexString()}-01"
+ : null;
+
+ string? responseId = null;
+ await ProxyRequestAsync(
+ context,
+ backendUrl,
+ "/v1/responses",
+ rewrittenBody,
+ streaming: true,
+ traceParent,
+ capturedResponseId => responseId = capturedResponseId).ConfigureAwait(false);
+
+ if (traceId is not null && responseId is not null && resourceName is not null)
+ {
+ this._responseTraceMap[responseId] = new TraceRequestInfo(traceId, entityId, DateTimeOffset.UtcNow);
+ this.RemoveExpiredTraceMappings();
+ }
+ }
+
+ private async Task GetResponseTracesAsync(string responseId, HttpContext context)
+ {
+ if (!this._responseTraceMap.TryGetValue(responseId, out var traceRequest))
+ {
+ return Results.NotFound();
+ }
+
+ if (!this.TryResolveDashboardConnection(out var dashboardBaseUri, out var dashboardApiKey))
+ {
+ return Results.StatusCode(StatusCodes.Status503ServiceUnavailable);
+ }
+
+ try
+ {
+ var httpClientFactory = context.RequestServices.GetRequiredService();
+ using var client = httpClientFactory.CreateClient("devui-proxy");
+ using var timeout = CancellationTokenSource.CreateLinkedTokenSource(context.RequestAborted);
+ timeout.CancelAfter(TimeSpan.FromSeconds(2));
+ var events = await AspireDashboardTraceClient.GetTraceEventsAsync(
+ client,
+ dashboardBaseUri,
+ dashboardApiKey,
+ traceRequest.TraceId,
+ responseId,
+ traceRequest.EntityId,
+ timeout.Token).ConfigureAwait(false);
+
+ if (events is null)
+ {
+ return Results.StatusCode(StatusCodes.Status503ServiceUnavailable);
+ }
+
+ return events.Count == 0
+ ? Results.Accepted(value: new { data = events })
+ : Results.Ok(new { data = events });
+ }
+ catch (OperationCanceledException ex) when (!context.RequestAborted.IsCancellationRequested)
+ {
+ this._logger.LogDebug(ex, "Timed out reading trace {TraceId} from the Aspire Dashboard", traceRequest.TraceId);
+ return Results.StatusCode(StatusCodes.Status503ServiceUnavailable);
+ }
+ catch (Exception ex) when (ex is HttpRequestException or JsonException)
+ {
+ this._logger.LogDebug(ex, "Unable to read trace {TraceId} from the Aspire Dashboard", traceRequest.TraceId);
+ return Results.StatusCode(StatusCodes.Status503ServiceUnavailable);
+ }
}
private async Task ProxyConversationsAsync(HttpContext context, string? path)
@@ -687,7 +865,9 @@ private static async Task ProxyRequestAsync(
string backendUrl,
string path,
byte[]? bodyBytes,
- bool streaming = false)
+ bool streaming = false,
+ string? traceParent = null,
+ Action? onResponseId = null)
{
var httpClientFactory = context.RequestServices.GetRequiredService();
using var client = httpClientFactory.CreateClient("devui-proxy");
@@ -712,6 +892,20 @@ private static async Task ProxyRequestAsync(
request.Headers.TryAddWithoutValidation(header.Key, header.Value.ToArray());
}
+ if (onResponseId is not null)
+ {
+ // Response ID capture parses SSE or JSON, so keep the upstream body uncompressed.
+ request.Headers.Remove("Accept-Encoding");
+ request.Headers.TryAddWithoutValidation("Accept-Encoding", "identity");
+ }
+
+ if (traceParent is not null)
+ {
+ request.Headers.Remove("traceparent");
+ request.Headers.Remove("tracestate");
+ request.Headers.TryAddWithoutValidation("traceparent", traceParent);
+ }
+
if (bodyBytes is not null)
{
request.Content = new ByteArrayContent(bodyBytes);
@@ -736,11 +930,28 @@ private static async Task ProxyRequestAsync(
context.Response.Headers.CacheControl = "no-cache";
using var stream = await response.Content.ReadAsStreamAsync(context.RequestAborted).ConfigureAwait(false);
- await stream.CopyToAsync(context.Response.Body, context.RequestAborted).ConfigureAwait(false);
+ var responseIdCapture = new SseResponseIdCapture();
+ var buffer = new byte[16 * 1024];
+ int bytesRead;
+ while ((bytesRead = await stream.ReadAsync(buffer, context.RequestAborted).ConfigureAwait(false)) > 0)
+ {
+ var bytes = buffer.AsMemory(0, bytesRead);
+ responseIdCapture.Append(bytes.Span);
+ await context.Response.Body.WriteAsync(bytes, context.RequestAborted).ConfigureAwait(false);
+ await context.Response.Body.FlushAsync(context.RequestAborted).ConfigureAwait(false);
+ }
+
+ if (responseIdCapture.ResponseId is not null)
+ {
+ onResponseId?.Invoke(responseIdCapture.ResponseId);
+ }
}
else
{
- await CopyResponseAsync(response, context).ConfigureAwait(false);
+ await CopyResponseAsync(
+ response,
+ context,
+ response.IsSuccessStatusCode ? onResponseId : null).ConfigureAwait(false);
}
}
@@ -772,6 +983,87 @@ private static async Task ProxyRequestAsync(
return (null, prefixedId);
}
+ private string? ResolveResourceName(string prefixedId)
+ {
+ var slashIndex = prefixedId.IndexOf('/');
+ var prefix = slashIndex >= 0 ? prefixedId[..slashIndex] : prefixedId;
+
+ return this._resource.Annotations
+ .OfType()
+ .FirstOrDefault(annotation => string.Equals(
+ annotation.EntityIdPrefix ?? annotation.AgentService.Name,
+ prefix,
+ StringComparison.Ordinal))?
+ .AgentService.Name;
+ }
+
+ internal bool TryResolveDashboardConnection(out Uri dashboardBaseUri, out string? dashboardApiKey)
+ {
+ dashboardBaseUri = null!;
+ dashboardApiKey = null;
+
+ if (this._dashboardConnectionOverride is not null)
+ {
+ dashboardBaseUri = this._dashboardConnectionOverride.BaseUri;
+ dashboardApiKey = this._dashboardConnectionOverride.ApiKey;
+ return true;
+ }
+
+ var dashboardUrls = this._configuration?["ASPNETCORE_URLS"];
+ if (string.IsNullOrWhiteSpace(dashboardUrls))
+ {
+ return false;
+ }
+
+ // In an AppHost, ASPNETCORE_URLS contains the built-in Dashboard frontend endpoints.
+ // Only loopback endpoints are accepted so the Dashboard API key can never be sent to
+ // an unrelated host through configuration.
+ foreach (var value in dashboardUrls.Split(';', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries))
+ {
+ if (Uri.TryCreate(value, UriKind.Absolute, out var candidate) && candidate.IsLoopback)
+ {
+ dashboardBaseUri = candidate;
+ break;
+ }
+ }
+
+ if (dashboardBaseUri is null)
+ {
+ return false;
+ }
+
+ dashboardApiKey = this._configuration?["AppHost:DashboardApiKey"];
+ return true;
+ }
+
+ private void RemoveExpiredTraceMappings()
+ {
+ if (this._responseTraceMap.Count <= 512)
+ {
+ return;
+ }
+
+ var cutoff = DateTimeOffset.UtcNow.AddMinutes(-30);
+ foreach (var item in this._responseTraceMap)
+ {
+ if (item.Value.CreatedAt < cutoff)
+ {
+ this._responseTraceMap.TryRemove(item.Key, out _);
+ }
+ }
+
+ var overflow = this._responseTraceMap.Count - 512;
+ if (overflow > 0)
+ {
+ foreach (var item in this._responseTraceMap.OrderBy(item => item.Value.CreatedAt).Take(overflow))
+ {
+ this._responseTraceMap.TryRemove(item.Key, out _);
+ }
+ }
+ }
+
+ private sealed record TraceRequestInfo(string TraceId, string EntityId, DateTimeOffset CreatedAt);
+
private static async Task ReadRequestBodyAsync(HttpRequest request)
{
using var ms = new MemoryStream();
@@ -779,7 +1071,10 @@ private static async Task ReadRequestBodyAsync(HttpRequest request)
return ms.ToArray();
}
- private static async Task CopyResponseAsync(HttpResponseMessage response, HttpContext context)
+ private static async Task CopyResponseAsync(
+ HttpResponseMessage response,
+ HttpContext context,
+ Action? onResponseId = null)
{
context.Response.StatusCode = (int)response.StatusCode;
@@ -793,7 +1088,29 @@ private static async Task CopyResponseAsync(HttpResponseMessage response, HttpCo
context.Response.Headers[header.Key] = header.Value.ToArray();
}
- await response.Content.CopyToAsync(context.Response.Body).ConfigureAwait(false);
+ if (onResponseId is null)
+ {
+ await response.Content.CopyToAsync(context.Response.Body, context.RequestAborted).ConfigureAwait(false);
+ return;
+ }
+
+ var responseBody = await response.Content.ReadAsByteArrayAsync(context.RequestAborted).ConfigureAwait(false);
+ try
+ {
+ using var document = JsonDocument.Parse(responseBody);
+ if (document.RootElement.TryGetProperty("id", out var responseId) &&
+ responseId.ValueKind == JsonValueKind.String &&
+ responseId.GetString() is { Length: > 0 } value)
+ {
+ onResponseId(value);
+ }
+ }
+ catch (JsonException)
+ {
+ // Best-effort capture only. The proxied response must remain unchanged.
+ }
+
+ await context.Response.Body.WriteAsync(responseBody, context.RequestAborted).ConfigureAwait(false);
}
private static bool IsHopByHopHeader(string headerName)
diff --git a/dotnet/src/Aspire.Hosting.AgentFramework.DevUI/README.md b/dotnet/src/Aspire.Hosting.AgentFramework.DevUI/README.md
index 8dbace2514e..a29b2ba3b7c 100644
--- a/dotnet/src/Aspire.Hosting.AgentFramework.DevUI/README.md
+++ b/dotnet/src/Aspire.Hosting.AgentFramework.DevUI/README.md
@@ -56,9 +56,20 @@ app.MapOpenAIConversations();
2. **Aggregates entities** from all configured agent service backends into a single `/v1/entities` listing. Each entity ID is prefixed with the backend name to ensure uniqueness across services (e.g., `writer-agent/writer`, `editor-agent/editor`).
3. **Routes requests** to the correct backend based on the entity ID prefix. When DevUI sends a `POST /v1/responses` or `/v1/conversations` request, the aggregator strips the prefix and forwards it to the appropriate service.
4. **Streams SSE responses** for the `/v1/responses` endpoint, so agent responses stream back to the DevUI frontend in real time.
+5. **Correlates OpenTelemetry traces** with each response when the Aspire Dashboard telemetry API is available. The aggregator propagates a unique W3C trace context to the selected agent service, retrieves matching spans from the dashboard after the response completes, and displays them in DevUI's Traces tab.
The aggregator publishes its URL to the Aspire dashboard, where it appears as a clickable link.
+## Tracing
+
+Tracing is enabled automatically when the running Aspire Dashboard exposes its telemetry API, available in Aspire 13.2 and later. DevUI checks this capability at startup, so older or unavailable dashboards do not delay agent responses or produce trace errors in the UI. The current Agent Framework dependency is Aspire 13.5.2.
+
+Agent services must still be configured to emit and export OpenTelemetry spans to Aspire. This normally means using Aspire service defaults and registering the Agent Framework activity sources used by the service. The aggregator keeps the dashboard API key server-side; it is never returned to the browser.
+
+Aspire commonly exports spans in batches, so trace events may appear shortly after an answer completes. Trace retrieval works for streaming and non-streaming responses, happens in the background, and does not keep the chat response in a streaming state.
+
+OpenTelemetry attributes can contain sensitive prompts, responses, tool arguments, or results when sensitive-data capture is enabled. Only enable sensitive telemetry in an appropriately secured development environment.
+
## Agent discovery
By default, `WithAgentService` declares a single agent named after the Aspire resource. You can provide explicit agent metadata when the agent name differs from the resource name, or when a service hosts multiple agents:
diff --git a/dotnet/src/Aspire.Hosting.AgentFramework.DevUI/SseResponseIdCapture.cs b/dotnet/src/Aspire.Hosting.AgentFramework.DevUI/SseResponseIdCapture.cs
new file mode 100644
index 00000000000..c33daf20fdc
--- /dev/null
+++ b/dotnet/src/Aspire.Hosting.AgentFramework.DevUI/SseResponseIdCapture.cs
@@ -0,0 +1,150 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System;
+using System.Buffers;
+using System.Text.Json;
+
+namespace Aspire.Hosting.AgentFramework;
+
+///
+/// Incrementally extracts an OpenAI response ID from an SSE response without delaying proxy writes.
+///
+internal sealed class SseResponseIdCapture
+{
+ private const int MaxLineLength = 64 * 1024;
+ private readonly ArrayBufferWriter _lineBuffer = new();
+ private bool _discardingOversizedLine;
+
+ ///
+ /// Gets the first response ID observed in the stream.
+ ///
+ internal string? ResponseId { get; private set; }
+
+ ///
+ /// Adds another raw SSE response fragment to the parser.
+ ///
+ /// The next bytes read from the proxied response.
+ internal void Append(ReadOnlySpan bytes)
+ {
+ if (this.ResponseId is not null)
+ {
+ return;
+ }
+
+ foreach (var value in bytes)
+ {
+ if (value == (byte)'\n')
+ {
+ if (!this._discardingOversizedLine)
+ {
+ this.ProcessLine(this._lineBuffer.WrittenSpan);
+ }
+
+ this._lineBuffer.Clear();
+ this._discardingOversizedLine = false;
+
+ if (this.ResponseId is not null)
+ {
+ return;
+ }
+
+ continue;
+ }
+
+ if (this._discardingOversizedLine)
+ {
+ continue;
+ }
+
+ if (this._lineBuffer.WrittenCount >= MaxLineLength)
+ {
+ this.ProcessLine(this._lineBuffer.WrittenSpan, isFinalBlock: false);
+ if (this.ResponseId is not null)
+ {
+ return;
+ }
+
+ this._lineBuffer.Clear();
+ this._discardingOversizedLine = true;
+ continue;
+ }
+
+ this._lineBuffer.GetSpan(1)[0] = value;
+ this._lineBuffer.Advance(1);
+ }
+ }
+
+ private void ProcessLine(ReadOnlySpan line, bool isFinalBlock = true)
+ {
+ if (!line.IsEmpty && line[^1] == (byte)'\r')
+ {
+ line = line[..^1];
+ }
+
+ ReadOnlySpan dataPrefix = "data:"u8;
+ if (!line.StartsWith(dataPrefix))
+ {
+ return;
+ }
+
+ line = line[dataPrefix.Length..].TrimStart((byte)' ');
+ if (line.SequenceEqual("[DONE]"u8))
+ {
+ return;
+ }
+
+ try
+ {
+ var reader = new Utf8JsonReader(line, isFinalBlock, state: default);
+ var responseObjectDepth = -1;
+ var pendingResponseObject = false;
+ var pendingResponseId = false;
+ var pendingDirectId = false;
+ string? nestedResponseId = null;
+ string? directResponseId = null;
+
+ while (reader.Read())
+ {
+ if (reader.TokenType == JsonTokenType.PropertyName)
+ {
+ pendingResponseObject = reader.CurrentDepth == 1 && reader.ValueTextEquals("response"u8);
+ pendingResponseId = reader.CurrentDepth == responseObjectDepth && reader.ValueTextEquals("id"u8);
+ pendingDirectId = reader.CurrentDepth == 1 && reader.ValueTextEquals("id"u8);
+ continue;
+ }
+
+ if (reader.TokenType == JsonTokenType.StartObject && pendingResponseObject)
+ {
+ responseObjectDepth = reader.CurrentDepth + 1;
+ }
+ else if (reader.TokenType == JsonTokenType.EndObject &&
+ responseObjectDepth == reader.CurrentDepth + 1)
+ {
+ responseObjectDepth = -1;
+ }
+ else if (reader.TokenType == JsonTokenType.String && (pendingResponseId || pendingDirectId))
+ {
+ var responseId = reader.GetString();
+ if (pendingResponseId)
+ {
+ nestedResponseId = responseId;
+ }
+ else if (responseId?.StartsWith("resp_", StringComparison.Ordinal) == true)
+ {
+ directResponseId = responseId;
+ }
+ }
+
+ pendingResponseObject = false;
+ pendingResponseId = false;
+ pendingDirectId = false;
+ }
+
+ this.ResponseId = nestedResponseId ?? directResponseId;
+ }
+ catch (JsonException)
+ {
+ // A malformed SSE event must not prevent a later valid response event from being captured.
+ }
+ }
+}
diff --git a/dotnet/tests/Aspire.Hosting.AgentFramework.DevUI.UnitTests/AspireDashboardTracingTests.cs b/dotnet/tests/Aspire.Hosting.AgentFramework.DevUI.UnitTests/AspireDashboardTracingTests.cs
new file mode 100644
index 00000000000..d0cf4706fba
--- /dev/null
+++ b/dotnet/tests/Aspire.Hosting.AgentFramework.DevUI.UnitTests/AspireDashboardTracingTests.cs
@@ -0,0 +1,886 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.IO;
+using System.IO.Compression;
+using System.Linq;
+using System.Net;
+using System.Net.Http;
+using System.Net.Sockets;
+using System.Text;
+using System.Text.Json;
+using System.Threading;
+using System.Threading.Tasks;
+using Aspire.Hosting.ApplicationModel;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Hosting.Server;
+using Microsoft.AspNetCore.Hosting.Server.Features;
+using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging.Abstractions;
+
+namespace Aspire.Hosting.AgentFramework.DevUI.UnitTests;
+
+///
+/// Regression tests for forwarding Aspire Dashboard traces to DevUI.
+///
+public class AspireDashboardTracingTests
+{
+ [Fact]
+ public void SseResponseIdCapture_FragmentedResponseCreatedEvent_CapturesResponseId()
+ {
+ // Arrange
+ var capture = new SseResponseIdCapture();
+
+ // Act
+ capture.Append(Encoding.UTF8.GetBytes("data: {\"type\":\"response.cre"));
+ capture.Append(Encoding.UTF8.GetBytes("ated\",\"response\":{\"id\":\"resp_123\"}}\r"));
+ capture.Append(Encoding.UTF8.GetBytes("\n\r\ndata: [DONE]\n\n"));
+
+ // Assert
+ Assert.Equal("resp_123", capture.ResponseId);
+ }
+
+ [Fact]
+ public void SseResponseIdCapture_MalformedEvent_DoesNotDiscardLaterValidEvent()
+ {
+ // Arrange
+ var capture = new SseResponseIdCapture();
+
+ // Act
+ capture.Append(Encoding.UTF8.GetBytes("data: {not-json}\n\n"));
+ capture.Append(Encoding.UTF8.GetBytes("data: {\"type\":\"response.completed\",\"response\":{\"id\":\"resp_valid\"}}\n\n"));
+
+ // Assert
+ Assert.Equal("resp_valid", capture.ResponseId);
+ }
+
+ [Fact]
+ public void SseResponseIdCapture_MalformedEventAfterResponseId_DoesNotCaptureInvalidId()
+ {
+ // Arrange
+ var capture = new SseResponseIdCapture();
+
+ // Act
+ capture.Append(Encoding.UTF8.GetBytes("data: {\"response\":{\"id\":\"resp_invalid\"},not-json}\n\n"));
+ capture.Append(Encoding.UTF8.GetBytes("data: {\"response\":{\"id\":\"resp_valid\"}}\n\n"));
+
+ // Assert
+ Assert.Equal("resp_valid", capture.ResponseId);
+ }
+
+ [Fact]
+ public void SseResponseIdCapture_NestedResponseIdTakesPriorityOverDirectFallback()
+ {
+ // Arrange
+ var capture = new SseResponseIdCapture();
+
+ // Act
+ capture.Append(Encoding.UTF8.GetBytes(
+ "data: {\"response\":{\"id\":\"resp_nested\"},\"id\":\"resp_direct\"}\n\n"));
+
+ // Assert
+ Assert.Equal("resp_nested", capture.ResponseId);
+ }
+
+ [Fact]
+ public void SseResponseIdCapture_OversizedFragmentedResponseCreatedEvent_CapturesResponseId()
+ {
+ // Arrange
+ var capture = new SseResponseIdCapture();
+ var oversizedEvent = Encoding.UTF8.GetBytes(
+ $"data: {{\"type\":\"response.created\",\"response\":{{\"id\":\"resp_oversized\",\"instructions\":\"{new string('x', 80 * 1024)}\"}}}}\n\n");
+
+ // Act
+ for (var offset = 0; offset < oversizedEvent.Length; offset += 1024)
+ {
+ capture.Append(oversizedEvent.AsSpan(offset, Math.Min(1024, oversizedEvent.Length - offset)));
+ }
+
+ // Assert
+ Assert.Equal("resp_oversized", capture.ResponseId);
+ }
+
+ [Fact]
+ public void ConvertToTraceEvents_OtlpSpan_PreservesHierarchyTimingAttributesAndError()
+ {
+ // Arrange
+ using var document = JsonDocument.Parse("""
+ {
+ "resourceSpans": [{
+ "scopeSpans": [{
+ "spans": [{
+ "traceId": "00112233445566778899aabbccddeeff",
+ "spanId": "0011223344556677",
+ "parentSpanId": "8899aabbccddeeff",
+ "name": "invoke_agent",
+ "startTimeUnixNano": "1000000000",
+ "endTimeUnixNano": "2500000000",
+ "attributes": [
+ {"key": "gen_ai.usage.input_tokens", "value": {"intValue": "12"}},
+ {"key": "agent.name", "value": {"stringValue": "writer"}},
+ {"key": "cached", "value": {"boolValue": true}}
+ ],
+ "status": {"code": 2, "message": "model failed"},
+ "events": [{
+ "name": "exception",
+ "timeUnixNano": "2000000000",
+ "attributes": [{"key": "exception.type", "value": {"stringValue": "System.Exception"}}]
+ }]
+ }]
+ }]
+ }]
+ }
+ """);
+
+ // Act
+ var events = AspireDashboardTraceClient.ConvertToTraceEvents(
+ document.RootElement,
+ responseId: "resp_123",
+ entityId: "writer-service/writer");
+
+ // Assert
+ var traceEvent = Assert.Single(events);
+ Assert.Equal("response.trace.completed", traceEvent["type"]?.GetValue());
+
+ var data = traceEvent["data"]!.AsObject();
+ Assert.Equal("trace_span", data["type"]?.GetValue());
+ Assert.Equal("00112233445566778899aabbccddeeff", data["trace_id"]?.GetValue());
+ Assert.Equal("0011223344556677", data["span_id"]?.GetValue());
+ Assert.Equal("8899aabbccddeeff", data["parent_span_id"]?.GetValue());
+ Assert.Equal("invoke_agent", data["operation_name"]?.GetValue());
+ Assert.Equal(1.0, data["start_time"]?.GetValue());
+ Assert.Equal(2.5, data["end_time"]?.GetValue());
+ Assert.Equal(1500.0, data["duration_ms"]?.GetValue());
+ Assert.Equal("ERROR", data["status"]?.GetValue());
+ Assert.Equal("model failed", data["error"]?.GetValue());
+ Assert.Equal("resp_123", data["response_id"]?.GetValue());
+ Assert.Equal("writer-service/writer", data["entity_id"]?.GetValue());
+
+ var attributes = data["attributes"]!.AsObject();
+ Assert.Equal(12, attributes["gen_ai.usage.input_tokens"]?.GetValue());
+ Assert.Equal("writer", attributes["agent.name"]?.GetValue());
+ Assert.True(attributes["cached"]?.GetValue());
+
+ var spanEvent = Assert.Single(data["events"]!.AsArray())!.AsObject();
+ Assert.Equal("exception", spanEvent["name"]?.GetValue());
+ Assert.Equal(2.0, spanEvent["timestamp"]?.GetValue());
+ Assert.Equal(
+ "System.Exception",
+ spanEvent["attributes"]?["exception.type"]?.GetValue());
+ }
+
+ [Fact]
+ public void ConvertToTraceEvents_UnsetStatuses_UseFrontendContractValue()
+ {
+ // Arrange
+ using var document = JsonDocument.Parse("""
+ {
+ "resourceSpans": [{
+ "scopeSpans": [{
+ "spans": [{
+ "traceId": "00112233445566778899aabbccddeeff",
+ "spanId": "0011223344556677",
+ "name": "invoke_agent"
+ }, {
+ "traceId": "00112233445566778899aabbccddeeff",
+ "spanId": "8899aabbccddeeff",
+ "name": "invoke_tool",
+ "status": {"code": 0}
+ }]
+ }]
+ }]
+ }
+ """);
+
+ // Act
+ var events = AspireDashboardTraceClient.ConvertToTraceEvents(
+ document.RootElement,
+ responseId: "resp_123",
+ entityId: "writer-service/writer");
+
+ // Assert
+ Assert.Equal(2, events.Count);
+ Assert.All(events, traceEvent =>
+ Assert.Equal("StatusCode.UNSET", traceEvent["data"]?["status"]?.GetValue()));
+ }
+
+ [Fact]
+ public async Task GetTraceEventsAsync_UsesTraceByIdEndpointAndKeepsDashboardKeyServerSide()
+ {
+ // Arrange
+ HttpRequestMessage? observedRequest = null;
+ using var client = new HttpClient(new StubHttpMessageHandler(request =>
+ {
+ observedRequest = request;
+ return new HttpResponseMessage(HttpStatusCode.OK)
+ {
+ Content = new StringContent("""
+ {
+ "data": {
+ "resourceSpans": [{
+ "scopeSpans": [{
+ "spans": [{
+ "traceId": "00112233445566778899aabbccddeeff",
+ "spanId": "0011223344556677",
+ "name": "invoke_agent"
+ }]
+ }]
+ }]
+ },
+ "totalCount": 1,
+ "returnedCount": 1
+ }
+ """, Encoding.UTF8, "application/json")
+ };
+ }));
+
+ // Act
+ var events = await AspireDashboardTraceClient.GetTraceEventsAsync(
+ client,
+ new Uri("https://localhost:18888"),
+ "dashboard-secret",
+ "00112233445566778899aabbccddeeff",
+ "resp_123",
+ "writer-service/writer",
+ CancellationToken.None);
+
+ // Assert
+ Assert.NotNull(events);
+ Assert.Single(events);
+ Assert.NotNull(observedRequest);
+ Assert.Equal(
+ "/api/telemetry/traces/00112233445566778899aabbccddeeff",
+ observedRequest.RequestUri?.PathAndQuery);
+ Assert.Equal("dashboard-secret", Assert.Single(observedRequest.Headers.GetValues("x-api-key")));
+ Assert.DoesNotContain("dashboard-secret", observedRequest.RequestUri?.ToString(), StringComparison.Ordinal);
+ }
+
+ [Fact]
+ public async Task GetTraceEventsAsync_TruncatedTraceResponse_ReturnsUnavailable()
+ {
+ // Arrange
+ using var client = new HttpClient(new StubHttpMessageHandler(_ =>
+ new HttpResponseMessage(HttpStatusCode.OK)
+ {
+ Content = new StringContent("""
+ {
+ "data": {"resourceSpans": []},
+ "totalCount": 2,
+ "returnedCount": 1
+ }
+ """, Encoding.UTF8, "application/json")
+ }));
+
+ // Act
+ var events = await AspireDashboardTraceClient.GetTraceEventsAsync(
+ client,
+ new Uri("https://localhost:18888"),
+ "dashboard-secret",
+ "00112233445566778899aabbccddeeff",
+ "resp_123",
+ "writer-service/writer",
+ CancellationToken.None);
+
+ // Assert
+ Assert.Null(events);
+ }
+
+ [Fact]
+ public async Task GetTraceEventsAsync_DashboardFailure_ReturnsUnavailableWithoutThrowing()
+ {
+ // Arrange
+ using var client = new HttpClient(new StubHttpMessageHandler(_ =>
+ new HttpResponseMessage(HttpStatusCode.ServiceUnavailable)));
+
+ // Act
+ var events = await AspireDashboardTraceClient.GetTraceEventsAsync(
+ client,
+ new Uri("https://localhost:18888"),
+ "dashboard-secret",
+ "00112233445566778899aabbccddeeff",
+ "resp_123",
+ "writer-service/writer",
+ CancellationToken.None);
+
+ // Assert
+ Assert.Null(events);
+ }
+
+ [Fact]
+ public void SseResponseIdCapture_ConcurrentStreams_RemainIsolated()
+ {
+ // Arrange
+ var capturedIds = new ConcurrentBag();
+
+ // Act
+ Parallel.For(0, 100, index =>
+ {
+ var capture = new SseResponseIdCapture();
+ capture.Append(Encoding.UTF8.GetBytes($"data: {{\"response\":{{\"id\":\"resp_{index}\"}}}}\n\n"));
+ capturedIds.Add(capture.ResponseId!);
+ });
+
+ // Assert
+ Assert.Equal(100, capturedIds.Distinct().Count());
+ }
+
+ [Fact]
+ public void TryResolveDashboardConnection_AppHostUrls_UsesLoopbackEndpointAndApiKey()
+ {
+ // Arrange
+ var configuration = new ConfigurationBuilder()
+ .AddInMemoryCollection(new Dictionary
+ {
+ ["ASPNETCORE_URLS"] = "https://localhost:16500;http://localhost:16501",
+ ["AppHost:DashboardApiKey"] = "dashboard-secret"
+ })
+ .Build();
+ var aggregator = new DevUIAggregatorHostedService(
+ new DevUIResource("test-devui"),
+ NullLogger.Instance,
+ configuration);
+
+ // Act
+ var resolved = aggregator.TryResolveDashboardConnection(out var dashboardBaseUri, out var dashboardApiKey);
+
+ // Assert
+ Assert.True(resolved);
+ Assert.Equal(new Uri("https://localhost:16500"), dashboardBaseUri);
+ Assert.Equal("dashboard-secret", dashboardApiKey);
+ }
+
+ [Fact]
+ public void TryResolveDashboardConnection_NonLoopbackUrl_DoesNotExposeApiKey()
+ {
+ // Arrange
+ var configuration = new ConfigurationBuilder()
+ .AddInMemoryCollection(new Dictionary
+ {
+ ["ASPNETCORE_URLS"] = "https://example.com:16500",
+ ["AppHost:DashboardApiKey"] = "dashboard-secret"
+ })
+ .Build();
+ var aggregator = new DevUIAggregatorHostedService(
+ new DevUIResource("test-devui"),
+ NullLogger.Instance,
+ configuration);
+
+ // Act
+ var resolved = aggregator.TryResolveDashboardConnection(out _, out var dashboardApiKey);
+
+ // Assert
+ Assert.False(resolved);
+ Assert.Null(dashboardApiKey);
+ }
+
+ [Fact]
+ public async Task Aggregator_ResponseTraceFlow_PropagatesTraceAndReturnsDashboardSpansAsync()
+ {
+ // Arrange
+ await using var context = await TracingProxyTestContext.StartAsync();
+ using var metaResponse = await context.Client.GetAsync(new Uri("/meta", UriKind.Relative));
+ metaResponse.EnsureSuccessStatusCode();
+ using var request = new HttpRequestMessage(HttpMethod.Post, "/v1/responses")
+ {
+ Content = new StringContent(
+ """{"metadata":{"entity_id":"writer-service/writer"},"input":"hello","stream":true}""",
+ Encoding.UTF8,
+ "application/json")
+ };
+
+ // Act
+ using var response = await context.Client.SendAsync(request);
+ var responseBody = await response.Content.ReadAsStringAsync();
+ using var tracesResponse = await context.Client.GetAsync(new Uri("/v1/responses/resp_integration/traces", UriKind.Relative));
+ using var tracesDocument = JsonDocument.Parse(await tracesResponse.Content.ReadAsStreamAsync());
+
+ // Assert
+ Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+ Assert.Contains("resp_integration", responseBody, StringComparison.Ordinal);
+ Assert.NotNull(context.AgentTraceParent);
+ Assert.Matches("^00-[0-9a-f]{32}-[0-9a-f]{16}-01$", context.AgentTraceParent);
+ Assert.Equal("dashboard-secret", context.DashboardApiKey);
+ Assert.Equal(context.AgentTraceParent![3..35], context.DashboardTraceId);
+ Assert.Equal(HttpStatusCode.OK, tracesResponse.StatusCode);
+ Assert.Equal(
+ "response.trace.completed",
+ tracesDocument.RootElement.GetProperty("data")[0].GetProperty("type").GetString());
+ }
+
+ [Fact]
+ public async Task Aggregator_ResponseBeforeMeta_StillPropagatesTraceAsync()
+ {
+ // Arrange
+ await using var context = await TracingProxyTestContext.StartAsync();
+ using var request = CreateAgentRequest("resp_before_meta");
+
+ // Act
+ using var response = await context.Client.SendAsync(request);
+ await response.Content.LoadIntoBufferAsync();
+ using var tracesResponse = await context.Client.GetAsync(
+ new Uri("/v1/responses/resp_before_meta/traces", UriKind.Relative));
+
+ // Assert
+ Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+ Assert.Equal(HttpStatusCode.OK, tracesResponse.StatusCode);
+ Assert.Equal(0, context.DashboardResourceProbeCount);
+ Assert.Equal(context.AgentTraceParents["resp_before_meta"][3..35], context.DashboardTraceId);
+ }
+
+ [Fact]
+ public async Task Aggregator_MetaProbeSuccess_IsLatchedAsync()
+ {
+ // Arrange
+ await using var context = await TracingProxyTestContext.StartAsync();
+
+ // Act
+ using var firstResponse = await context.Client.GetAsync(new Uri("/meta", UriKind.Relative));
+ using var firstDocument = JsonDocument.Parse(await firstResponse.Content.ReadAsStreamAsync());
+ context.FailDashboardResourceProbe();
+ using var secondResponse = await context.Client.GetAsync(new Uri("/meta", UriKind.Relative));
+ using var secondDocument = JsonDocument.Parse(await secondResponse.Content.ReadAsStreamAsync());
+
+ // Assert
+ Assert.True(firstDocument.RootElement.GetProperty("capabilities").GetProperty("trace_retrieval").GetBoolean());
+ Assert.True(secondDocument.RootElement.GetProperty("capabilities").GetProperty("trace_retrieval").GetBoolean());
+ Assert.Equal(1, context.DashboardResourceProbeCount);
+ }
+
+ [Fact]
+ public async Task Aggregator_NonStreamingResponse_CapturesResponseIdAndReturnsTracesAsync()
+ {
+ // Arrange
+ await using var context = await TracingProxyTestContext.StartAsync();
+ using var metaResponse = await context.Client.GetAsync(new Uri("/meta", UriKind.Relative));
+ metaResponse.EnsureSuccessStatusCode();
+ using var request = CreateAgentRequest("resp_non_streaming", streaming: false);
+
+ // Act
+ using var response = await context.Client.SendAsync(request);
+ using var responseDocument = JsonDocument.Parse(await response.Content.ReadAsStreamAsync());
+ using var tracesResponse = await context.Client.GetAsync(
+ new Uri("/v1/responses/resp_non_streaming/traces", UriKind.Relative));
+
+ // Assert
+ Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+ Assert.Equal("resp_non_streaming", responseDocument.RootElement.GetProperty("id").GetString());
+ Assert.Equal(HttpStatusCode.OK, tracesResponse.StatusCode);
+ Assert.Equal(context.AgentTraceParents["resp_non_streaming"][3..35], context.DashboardTraceId);
+ }
+
+ [Theory]
+ [InlineData(true, "gzip")]
+ [InlineData(true, "br")]
+ [InlineData(false, "gzip")]
+ [InlineData(false, "br")]
+ public async Task Aggregator_ResponseCapture_RequestsIdentityEncodingAsync(
+ bool streaming,
+ string acceptedEncoding)
+ {
+ // Arrange
+ await using var context = await TracingProxyTestContext.StartAsync(
+ responseCompressionEncoding: acceptedEncoding);
+ var responseId = $"resp_{(streaming ? "streaming" : "non_streaming")}_{acceptedEncoding}";
+ using var request = CreateAgentRequest(responseId, streaming);
+ request.Headers.AcceptEncoding.ParseAdd(acceptedEncoding);
+
+ // Act
+ using var response = await context.Client.SendAsync(request);
+ var responseBody = await response.Content.ReadAsStringAsync();
+ using var tracesResponse = await context.Client.GetAsync(
+ new Uri($"/v1/responses/{responseId}/traces", UriKind.Relative));
+
+ // Assert
+ Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+ Assert.Contains(responseId, responseBody, StringComparison.Ordinal);
+ Assert.Empty(response.Content.Headers.ContentEncoding);
+ Assert.Equal("identity", context.AgentAcceptEncoding);
+ Assert.Equal(HttpStatusCode.OK, tracesResponse.StatusCode);
+ }
+
+ [Fact]
+ public async Task Aggregator_DashboardTraceTimeout_ReturnsServiceUnavailableAsync()
+ {
+ // Arrange
+ await using var context = await TracingProxyTestContext.StartAsync(dashboardTraceTimeout: true);
+ using var metaResponse = await context.Client.GetAsync(new Uri("/meta", UriKind.Relative));
+ metaResponse.EnsureSuccessStatusCode();
+ using var request = CreateAgentRequest("resp_dashboard_timeout");
+ using var response = await context.Client.SendAsync(request);
+ await response.Content.LoadIntoBufferAsync();
+
+ // Act
+ using var tracesResponse = await context.Client.GetAsync(
+ new Uri("/v1/responses/resp_dashboard_timeout/traces", UriKind.Relative));
+
+ // Assert
+ Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+ Assert.Equal(HttpStatusCode.ServiceUnavailable, tracesResponse.StatusCode);
+ }
+
+ [Fact]
+ public async Task Aggregator_DashboardUnavailable_DoesNotBreakAgentResponseAsync()
+ {
+ // Arrange
+ await using var context = await TracingProxyTestContext.StartAsync(dashboardUnavailable: true);
+ using var metaResponse = await context.Client.GetAsync(new Uri("/meta", UriKind.Relative));
+ metaResponse.EnsureSuccessStatusCode();
+ using var request = CreateAgentRequest("resp_dashboard_down");
+
+ // Act
+ using var response = await context.Client.SendAsync(request);
+ var responseBody = await response.Content.ReadAsStringAsync();
+ using var tracesResponse = await context.Client.GetAsync(
+ new Uri("/v1/responses/resp_dashboard_down/traces", UriKind.Relative));
+
+ // Assert
+ Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+ Assert.Contains("resp_dashboard_down", responseBody, StringComparison.Ordinal);
+ Assert.Equal(HttpStatusCode.ServiceUnavailable, tracesResponse.StatusCode);
+ }
+
+ [Fact]
+ public async Task Aggregator_CancelledStreamingResponse_DoesNotRegisterTraceMappingAsync()
+ {
+ // Arrange
+ await using var context = await TracingProxyTestContext.StartAsync(pauseStreamingResponseAfterCreated: true);
+ using var cancellation = new CancellationTokenSource(TimeSpan.FromSeconds(10));
+ using var request = CreateAgentRequest("resp_cancelled");
+ using var response = await context.Client.SendAsync(
+ request,
+ HttpCompletionOption.ResponseHeadersRead,
+ cancellation.Token);
+ using var responseStream = await response.Content.ReadAsStreamAsync(cancellation.Token);
+ using var reader = new StreamReader(responseStream);
+ var createdEvent = await reader.ReadLineAsync(cancellation.Token);
+ Assert.Contains("resp_cancelled", createdEvent, StringComparison.Ordinal);
+
+ // Act
+ cancellation.Cancel();
+ response.Dispose();
+ await context.WaitForStreamingRequestCancellationAsync();
+ using var tracesResponse = await context.Client.GetAsync(
+ new Uri("/v1/responses/resp_cancelled/traces", UriKind.Relative));
+
+ // Assert
+ Assert.Equal(HttpStatusCode.NotFound, tracesResponse.StatusCode);
+ Assert.Null(context.DashboardTraceId);
+ }
+
+ [Fact]
+ public async Task Aggregator_ConcurrentResponses_DoNotCrossWireTraceIdsAsync()
+ {
+ // Arrange
+ await using var context = await TracingProxyTestContext.StartAsync();
+ using var metaResponse = await context.Client.GetAsync(new Uri("/meta", UriKind.Relative));
+ metaResponse.EnsureSuccessStatusCode();
+ var responseIds = Enumerable.Range(0, 12).Select(index => $"resp_concurrent_{index}").ToArray();
+
+ // Act
+ await Task.WhenAll(responseIds.Select(async responseId =>
+ {
+ using var request = CreateAgentRequest(responseId);
+ using var response = await context.Client.SendAsync(request);
+ response.EnsureSuccessStatusCode();
+ await response.Content.LoadIntoBufferAsync();
+ }));
+
+ var traceIds = new ConcurrentDictionary();
+ await Task.WhenAll(responseIds.Select(async responseId =>
+ {
+ using var response = await context.Client.GetAsync(
+ new Uri($"/v1/responses/{responseId}/traces", UriKind.Relative));
+ response.EnsureSuccessStatusCode();
+ using var document = JsonDocument.Parse(await response.Content.ReadAsStreamAsync());
+ var data = document.RootElement.GetProperty("data")[0].GetProperty("data");
+ Assert.Equal(responseId, data.GetProperty("response_id").GetString());
+ traceIds[responseId] = data.GetProperty("trace_id").GetString()!;
+ }));
+
+ // Assert
+ Assert.Equal(responseIds.Length, traceIds.Values.Distinct().Count());
+ foreach (var responseId in responseIds)
+ {
+ Assert.Equal(context.AgentTraceParents[responseId][3..35], traceIds[responseId]);
+ }
+ }
+
+ private static HttpRequestMessage CreateAgentRequest(string responseId, bool streaming = true)
+ => new(HttpMethod.Post, "/v1/responses")
+ {
+ Content = new StringContent(
+ $$"""{"metadata":{"entity_id":"writer-service/writer","test_response_id":"{{responseId}}"},"input":"hello","stream":{{(streaming ? "true" : "false")}}}""",
+ Encoding.UTF8,
+ "application/json")
+ };
+
+ private sealed class StubHttpMessageHandler(Func handler) : HttpMessageHandler
+ {
+ protected override Task SendAsync(
+ HttpRequestMessage request,
+ CancellationToken cancellationToken)
+ => Task.FromResult(handler(request));
+ }
+
+ private sealed class TracingProxyTestContext : IAsyncDisposable
+ {
+ private readonly WebApplication _agentBackend;
+ private readonly WebApplication _dashboard;
+ private readonly DevUIAggregatorHostedService _aggregator;
+ private readonly TaskCompletionSource _streamingRequestCancelled =
+ new(TaskCreationOptions.RunContinuationsAsynchronously);
+ private int _dashboardResourceProbeCount;
+ private volatile bool _failDashboardResourceProbe;
+
+ private TracingProxyTestContext(
+ WebApplication agentBackend,
+ WebApplication dashboard,
+ DevUIAggregatorHostedService aggregator,
+ HttpClient client)
+ {
+ this._agentBackend = agentBackend;
+ this._dashboard = dashboard;
+ this._aggregator = aggregator;
+ this.Client = client;
+ }
+
+ public HttpClient Client { get; }
+
+ public string? AgentTraceParent { get; private set; }
+
+ public string? AgentAcceptEncoding { get; private set; }
+
+ public ConcurrentDictionary AgentTraceParents { get; } = new(StringComparer.Ordinal);
+
+ public string? DashboardApiKey { get; private set; }
+
+ public string? DashboardTraceId { get; private set; }
+
+ public int DashboardResourceProbeCount => Volatile.Read(ref this._dashboardResourceProbeCount);
+
+ public void FailDashboardResourceProbe() => this._failDashboardResourceProbe = true;
+
+ public Task WaitForStreamingRequestCancellationAsync()
+ => this._streamingRequestCancelled.Task.WaitAsync(TimeSpan.FromSeconds(5));
+
+ public static async Task StartAsync(
+ bool dashboardUnavailable = false,
+ bool dashboardTraceTimeout = false,
+ bool pauseStreamingResponseAfterCreated = false,
+ string? responseCompressionEncoding = null)
+ {
+ var agentBackend = CreateWebApplication();
+ var dashboard = CreateWebApplication();
+ TracingProxyTestContext? testContext = null;
+
+ agentBackend.MapPost("/v1/responses", async context =>
+ {
+ using var requestDocument = await JsonDocument.ParseAsync(context.Request.Body, cancellationToken: context.RequestAborted);
+ var responseId = requestDocument.RootElement
+ .GetProperty("metadata")
+ .TryGetProperty("test_response_id", out var configuredResponseId)
+ ? configuredResponseId.GetString()!
+ : "resp_integration";
+ var traceParent = context.Request.Headers.TraceParent.FirstOrDefault();
+ testContext!.AgentTraceParent = traceParent;
+ testContext.AgentAcceptEncoding = context.Request.Headers.AcceptEncoding.ToString();
+ testContext.AgentTraceParents[responseId] = traceParent!;
+
+ if (requestDocument.RootElement.TryGetProperty("stream", out var stream) && !stream.GetBoolean())
+ {
+ context.Response.ContentType = "application/json";
+ await WriteAgentResponseAsync(
+ context,
+ JsonSerializer.SerializeToUtf8Bytes(new { id = responseId, output = Array.Empty