Tracing UI displays resource name for outgoing resources

src/Aspire.Dashboard/Components/Pages/TraceDetail.razor.cs

@@ -16,6 +16,7 @@ public partial class TraceDetail
     private OtlpTrace? _trace;
     private OtlpSpan? _span;
     private Subscription? _tracesSubscription;
+    private IDisposable? _peerChangesSubscription;
     private List<SpanWaterfallViewModel>? _spanWaterfallViewModels;
     private int _maxDepth;
 
@@ -28,6 +29,18 @@ public partial class TraceDetail
     [Inject]
     public required TelemetryRepository TelemetryRepository { get; set; }
 
+    [Inject]
+    public required IOutgoingPeerResolver OutgoingPeerResolver { get; set; }
+
+    protected override void OnInitialized()
+    {
+        _peerChangesSubscription = OutgoingPeerResolver.OnPeerChanges(async () =>
+        {
+            UpdateDetailViewData();
+            await InvokeAsync(StateHasChanged);
+        });
+    }
+
     private ValueTask<GridItemsProviderResult<SpanWaterfallViewModel>> GetData(GridItemsProviderRequest<SpanWaterfallViewModel> request)
     {
         Debug.Assert(_spanWaterfallViewModels != null);
@@ -39,34 +52,34 @@ private ValueTask<GridItemsProviderResult<SpanWaterfallViewModel>> GetData(GridI
         });
     }
 
-    private static List<SpanWaterfallViewModel> CreateSpanWaterfallViewModels(OtlpTrace trace)
+    private static List<SpanWaterfallViewModel> CreateSpanWaterfallViewModels(OtlpTrace trace, IOutgoingPeerResolver outgoingPeerResolver)
     {
         var orderedSpans = new List<SpanWaterfallViewModel>();
         // There should be one root span but just in case, we'll add them all.
         foreach (var rootSpan in trace.Spans.Where(s => string.IsNullOrEmpty(s.ParentSpanId)).OrderBy(s => s.StartTime))
         {
-            AddSelfAndChildren(orderedSpans, rootSpan, depth: 1, CreateViewModel);
+            AddSelfAndChildren(orderedSpans, rootSpan, depth: 1, outgoingPeerResolver, CreateViewModel);
         }
         // Unparented spans.
         foreach (var unparentedSpan in trace.Spans.Where(s => !string.IsNullOrEmpty(s.ParentSpanId) && s.GetParentSpan() == null).OrderBy(s => s.StartTime))
         {
-            AddSelfAndChildren(orderedSpans, unparentedSpan, depth: 1, CreateViewModel);
+            AddSelfAndChildren(orderedSpans, unparentedSpan, depth: 1, outgoingPeerResolver, CreateViewModel);
         }
 
         return orderedSpans;
 
-        static void AddSelfAndChildren(List<SpanWaterfallViewModel> orderedSpans, OtlpSpan span, int depth, Func<OtlpSpan, int, SpanWaterfallViewModel> createViewModel)
+        static void AddSelfAndChildren(List<SpanWaterfallViewModel> orderedSpans, OtlpSpan span, int depth, IOutgoingPeerResolver outgoingPeerResolver, Func<OtlpSpan, int, IOutgoingPeerResolver, SpanWaterfallViewModel> createViewModel)
         {
-            orderedSpans.Add(createViewModel(span, depth));
+            orderedSpans.Add(createViewModel(span, depth, outgoingPeerResolver));
             depth++;
 
             foreach (var child in span.GetChildSpans().OrderBy(s => s.StartTime))
             {
-                AddSelfAndChildren(orderedSpans, child, depth, createViewModel);
+                AddSelfAndChildren(orderedSpans, child, depth, outgoingPeerResolver, createViewModel);
             }
         }
 
-        static SpanWaterfallViewModel CreateViewModel(OtlpSpan span, int depth)
+        static SpanWaterfallViewModel CreateViewModel(OtlpSpan span, int depth, IOutgoingPeerResolver outgoingPeerResolver)
         {
             var traceStart = span.Trace.FirstSpan.StartTime;
             var relativeStart = span.StartTime - traceStart;
@@ -82,6 +95,13 @@ static SpanWaterfallViewModel CreateViewModel(OtlpSpan span, int depth)
             // A span may indicate a call to another service but the service isn't instrumented.
             var hasPeerService = span.Attributes.Any(a => a.Key == OtlpSpan.PeerServiceAttributeKey);
             var isUninstrumentedPeer = hasPeerService && span.Kind is OtlpSpanKind.Client or OtlpSpanKind.Producer && !span.GetChildSpans().Any();
+            var uninstrumentedPeer = isUninstrumentedPeer
+                ? OtlpHelpers.GetValue(span.Attributes, OtlpSpan.PeerServiceAttributeKey)
+                : null;
+            if (uninstrumentedPeer != null)
+            {
+                uninstrumentedPeer = outgoingPeerResolver.ResolvePeerName(uninstrumentedPeer);
+            }
 
             var viewModel = new SpanWaterfallViewModel
             {
@@ -90,7 +110,7 @@ static SpanWaterfallViewModel CreateViewModel(OtlpSpan span, int depth)
                 Width = width,
                 Depth = depth,
                 LabelIsRight = labelIsRight,
-                UninstrumentedPeer = isUninstrumentedPeer ? OtlpHelpers.GetValue(span.Attributes, OtlpSpan.PeerServiceAttributeKey) : null
+                UninstrumentedPeer = uninstrumentedPeer
             };
             return viewModel;
         }
@@ -111,7 +131,7 @@ private void UpdateDetailViewData()
             _trace = TelemetryRepository.GetTrace(TraceId);
             if (_trace != null)
             {
-                _spanWaterfallViewModels = CreateSpanWaterfallViewModels(_trace);
+                _spanWaterfallViewModels = CreateSpanWaterfallViewModels(_trace, OutgoingPeerResolver);
                 _maxDepth = _spanWaterfallViewModels.Max(s => s.Depth);
 
                 if (_tracesSubscription is null || _tracesSubscription.ApplicationId != _trace.FirstSpan.Source.InstanceId)
@@ -169,6 +189,7 @@ private void ClearSelectedSpan()
 
     public void Dispose()
     {
+        _peerChangesSubscription?.Dispose();
         _tracesSubscription?.Dispose();
     }
 }

src/Aspire.Dashboard/DashboardWebApplication.cs

@@ -86,6 +86,7 @@ public DashboardWebApplication(ILogger<DashboardWebApplication> logger, Action<I
         // OTLP services.
         builder.Services.AddGrpc();
         builder.Services.AddSingleton<TelemetryRepository>();
+        builder.Services.AddScoped<IOutgoingPeerResolver, ResourceOutgoingPeerResolver>();
         builder.Services.AddTransient<StructuredLogsViewModel>();
         builder.Services.AddTransient<TracesViewModel>();
 

src/Aspire.Dashboard/Model/IOutgoingPeerResolver.cs

@@ -0,0 +1,10 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Aspire.Dashboard.Model;
+
+public interface IOutgoingPeerResolver
+{
+    string ResolvePeerName(string networkAddress);
+    IDisposable OnPeerChanges(Func<Task> callback);
+}

src/Aspire.Dashboard/Model/Otlp/SpanWaterfallViewModel.cs

@@ -28,7 +28,7 @@ public string GetTooltip()
         }
         if (HasUninstrumentedPeer)
         {
-            tooltip += Environment.NewLine + $"Outgoing call to peer {UninstrumentedPeer}";
+            tooltip += Environment.NewLine + $"Outgoing call to {UninstrumentedPeer}";
         }
 
         return tooltip;

src/Aspire.Dashboard/Model/ResourceOutgoingPeerResolver.cs

@@ -0,0 +1,133 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Collections.Concurrent;
+
+namespace Aspire.Dashboard.Model;
+
+public sealed class ResourceOutgoingPeerResolver : IOutgoingPeerResolver, IAsyncDisposable
+{
+    private readonly IDashboardViewModelService _dashboardViewModelService;
+    private readonly ConcurrentDictionary<string, ResourceViewModel> _resourceNameMapping = new();
+    private readonly CancellationTokenSource _watchContainersTokenSource = new();
+    private readonly Task _watchTask;
+    private readonly List<Subscription> _subscriptions;
+    private readonly object _lock = new object();
+
+    public ResourceOutgoingPeerResolver(IDashboardViewModelService dashboardViewModelService)
+    {
+        _dashboardViewModelService = dashboardViewModelService;
+        _subscriptions = new List<Subscription>();
+
+        var viewModelMonitor = _dashboardViewModelService.GetResources();
+        var initialList = viewModelMonitor.Snapshot;
+        var watch = viewModelMonitor.Watch;
+
+        foreach (var result in initialList)
+        {
+            _resourceNameMapping[result.Name] = result;
+        }
+
+        _watchTask = Task.Run(async () =>
+        {
+            await foreach (var resourceChanged in watch.WithCancellation(_watchContainersTokenSource.Token))
+            {
+                await OnResourceListChanged(resourceChanged.ObjectChangeType, resourceChanged.Resource).ConfigureAwait(false);
+            }
+        });
+    }
+
+    private async Task OnResourceListChanged(ObjectChangeType changeType, ResourceViewModel resourceViewModel)
+    {
+        if (changeType == ObjectChangeType.Added)
+        {
+            _resourceNameMapping[resourceViewModel.Name] = resourceViewModel;
+        }
+        else if (changeType == ObjectChangeType.Modified)
+        {
+            _resourceNameMapping[resourceViewModel.Name] = resourceViewModel;
+        }
+        else if (changeType == ObjectChangeType.Deleted)
+        {
+            _resourceNameMapping.TryRemove(resourceViewModel.Name, out _);
+        }
+
+        await RaisePeerChangesAsync().ConfigureAwait(false);
+    }
+
+    public string ResolvePeerName(string networkAddress)
+    {
+        foreach (var (resourceName, resource) in _resourceNameMapping)
+        {
+            foreach (var service in resource.Services)
+            {
+                if (string.Equals(service.AddressAndPort, networkAddress, StringComparison.OrdinalIgnoreCase))
+                {
+                    return resource.Name;
+                }
+            }
+        }
+
+        return networkAddress;
+    }
+
+    public IDisposable OnPeerChanges(Func<Task> callback)
+    {
+        lock (_lock)
+        {
+            var subscription = new Subscription(callback, RemoveSubscription);
+            _subscriptions.Add(subscription);
+            return subscription;
+        }
+    }
+
+    private void RemoveSubscription(Subscription subscription)
+    {
+        lock (_lock)
+        {
+            _subscriptions.Remove(subscription);
+        }
+    }
+
+    private async Task RaisePeerChangesAsync()
+    {
+        if (_subscriptions.Count == 0)
+        {
+            return;
+        }
+
+        Subscription[] subscriptions;
+        lock (_lock)
+        {
+            subscriptions = _subscriptions.ToArray();
+        }
+
+        foreach (var subscription in subscriptions)
+        {
+            await subscription.ExecuteAsync().ConfigureAwait(false);
+        }
+    }
+
+    public async ValueTask DisposeAsync()
+    {
+        _watchContainersTokenSource.Cancel();
+        _watchContainersTokenSource.Dispose();
+
+        try
+        {
+            await _watchTask.ConfigureAwait(false);
+        }
+        catch (OperationCanceledException)
+        {
+        }
+    }
+
+    private sealed class Subscription(Func<Task> callback, Action<Subscription> onDispose) : IDisposable
+    {
+        private readonly Func<Task> _callback = callback;
+        private readonly Action<Subscription> _onDispose = onDispose;
+
+        public void Dispose() => _onDispose(this);
+        public Task ExecuteAsync() => _callback();
+    }
+}

src/Aspire.Dashboard/Model/ResourceViewModel.cs

@@ -13,8 +13,17 @@ public abstract class ResourceViewModel
     public List<EnvironmentVariableViewModel> Environment { get; } = new();
     public required ILogSource LogSource { get; init; }
     public List<string> Endpoints { get; } = new();
+    public List<ResourceService> Services { get; } = new();
     public int? ExpectedEndpointsCount { get; init; }
     public abstract string ResourceType { get; }
 }
 
+public sealed class ResourceService(string name, string? allocatedAddress, int? allocatedPort)
+{
+    public string Name { get; } = name;
+    public string? AllocatedAddress { get; } = allocatedAddress;
+    public int? AllocatedPort { get; } = allocatedPort;
+    public string AddressAndPort { get; } = $"{allocatedAddress}:{allocatedPort}";
+}
+
 public sealed record NamespacedName(string Name, string? Namespace);