Fix OTLP endpoint resolution in isolated mode

src/Aspire.Hosting/Dcp/ContainerCreator.cs

@@ -538,7 +538,6 @@ private string GetTunnelProxyResourceName()
                 KeyPath = ReferenceExpression.Create($"{serverAuthCertificatesBasePath}/{cert.Thumbprint}.key"),
                 PfxPath = ReferenceExpression.Create($"{serverAuthCertificatesBasePath}/{cert.Thumbprint}.pfx"),
             })
-            .AddExecutionConfigurationGatherer(new OtlpEndpointReferenceGatherer())
             .BuildAsync(_executionContext, resourceLogger, cancellationToken)
             .ConfigureAwait(false);
 

src/Aspire.Hosting/OtlpConfigurationExtensions.cs

@@ -4,6 +4,7 @@
 using Aspire.Hosting.ApplicationModel;
 using Aspire.Hosting.Dcp.Model;
 using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
 
 namespace Aspire.Hosting;
@@ -68,9 +69,23 @@ private static void RegisterOtlpEnvironment(IResource resource, IConfiguration c
                 return;
             }
 
-            var (url, protocol) = OtlpEndpointResolver.ResolveOtlpEndpoint(configuration, otlpExporterAnnotation.RequiredProtocol);
-            context.EnvironmentVariables[KnownOtelConfigNames.ExporterOtlpEndpoint] = new HostUrl(url);
-            context.EnvironmentVariables[KnownOtelConfigNames.ExporterOtlpProtocol] = protocol;
+            var dashboardEndpoint = ResolveOtlpEndpointFromDashboard(context, otlpExporterAnnotation.RequiredProtocol);
+
+            if (dashboardEndpoint is not null)
+            {
+                // Use the dashboard endpoint reference directly. This resolves to the actual allocated URL,
+                // including when ports are randomized (e.g. isolated mode).
+                context.EnvironmentVariables[KnownOtelConfigNames.ExporterOtlpEndpoint] = dashboardEndpoint.Value.Endpoint;
+                context.EnvironmentVariables[KnownOtelConfigNames.ExporterOtlpProtocol] = dashboardEndpoint.Value.Protocol;
+            }
+            else
+            {
+                // Fall back to resolving from configuration. This is the case when the dashboard resource
+                // is not in the model (e.g. in tests or publish mode).
+                var (url, protocol) = OtlpEndpointResolver.ResolveOtlpEndpoint(configuration, otlpExporterAnnotation.RequiredProtocol);
+                context.EnvironmentVariables[KnownOtelConfigNames.ExporterOtlpEndpoint] = new HostUrl(url);
+                context.EnvironmentVariables[KnownOtelConfigNames.ExporterOtlpProtocol] = protocol;
+            }
 
             // Set the service name and instance id to the resource name and UID. Values are injected by DCP.
             context.EnvironmentVariables[KnownOtelConfigNames.ResourceAttributes] = "service.instance.id={{- index .Annotations \"" + CustomResource.OtelServiceInstanceIdAnnotation + "\" -}}";
@@ -148,4 +163,53 @@ public static IResourceBuilder<T> WithOtlpExporter<T>(this IResourceBuilder<T> b
 
         return builder;
     }
+
+    /// <summary>
+    /// Tries to resolve the OTLP endpoint from the dashboard resource in the distributed application model.
+    /// This ensures that when ports are randomized (e.g. isolated mode), resources use the actual
+    /// allocated endpoint rather than the statically configured port.
+    /// </summary>
+    /// <remarks>
+    /// The returned <see cref="EndpointReference"/> has no network context baked in, so it resolves
+    /// using the calling resource's network at evaluation time. This means containers automatically
+    /// get container-network URLs and non-containers get localhost URLs.
+    /// </remarks>
+    private static (EndpointReference Endpoint, string Protocol)? ResolveOtlpEndpointFromDashboard(EnvironmentCallbackContext context, OtlpProtocol? requiredProtocol)
+    {
+        DistributedApplicationModel? model;
+        try
+        {
+            model = context.ExecutionContext.ServiceProvider.GetService<DistributedApplicationModel>();
+        }
+        catch (InvalidOperationException)
+        {
+            // ServiceProvider may not be available if the container hasn't been built yet
+            // (e.g. env var evaluation during testing without a fully built host).
+            return null;
+        }
+
+        if (model is null)
+        {
+            return null;
+        }
+
+        var dashboardResource = model.Resources.SingleOrDefault(r => string.Equals(r.Name, KnownResourceNames.AspireDashboard, StringComparisons.ResourceName)) as IResourceWithEndpoints;
+        if (dashboardResource is null)
+        {
+            return null;
+        }
+
+        var grpcEndpoint = dashboardResource.GetEndpoint(KnownEndpointNames.OtlpGrpcEndpointName);
+        var httpEndpoint = dashboardResource.GetEndpoint(KnownEndpointNames.OtlpHttpEndpointName);
+
+        return (requiredProtocol, grpcEndpoint.Exists, httpEndpoint.Exists) switch
+        {
+            (OtlpProtocol.Grpc, true, _) => (grpcEndpoint, "grpc"),
+            (OtlpProtocol.HttpProtobuf, _, true) => (httpEndpoint, "http/protobuf"),
+            (OtlpProtocol.HttpJson, _, true) => (httpEndpoint, "http/json"),
+            (_, true, _) => (grpcEndpoint, "grpc"),
+            (_, _, true) => (httpEndpoint, "http/protobuf"),
+            _ => null
+        };
+    }
 }

tests/Aspire.Cli.EndToEnd.Tests/Helpers/CliE2EAutomatorHelpers.cs

@@ -326,7 +326,8 @@ internal static async Task InstallAspireCliVersionAsync(
     internal static async Task AspireStartAsync(
         this Hex1bTerminalAutomator auto,
         SequenceCounter counter,
-        TimeSpan? startTimeout = null)
+        TimeSpan? startTimeout = null,
+        bool isolated = false)
     {
         var effectiveTimeout = startTimeout ?? TimeSpan.FromMinutes(3);
         var expectedCounter = counter.Value;
@@ -336,9 +337,11 @@ internal static async Task AspireStartAsync(
             ? AspireStartJsonFile
             : "$ASPIRE_E2E_WORKSPACE/_aspire-start.json";
 
+        var isolatedFlag = isolated ? " --isolated" : "";
+
         // Keep aspire start as a single shell pipeline so tee captures the exact JSON emitted to the terminal while
         // pipefail preserves the real CLI exit code instead of letting tee mask build/startup failures.
-        await auto.TypeAsync($"(set -o pipefail; aspire start --format json | tee \"{jsonFile}\")");
+        await auto.TypeAsync($"(set -o pipefail; aspire start{isolatedFlag} --format json | tee \"{jsonFile}\")");
         await auto.EnterAsync();
 
         // Wait for the command to finish — check for success or error exit.

tests/Aspire.Cli.EndToEnd.Tests/OtelLogsTests.cs

@@ -16,7 +16,15 @@ public sealed class OtelLogsTests(ITestOutputHelper output)
 {
     [Fact]
     [CaptureWorkspaceOnFailure]
-    public async Task OtelLogsReturnsStructuredLogsFromStarterApp()
+    public Task OtelLogsReturnsStructuredLogsFromStarterApp()
+        => OtelLogsReturnsStructuredLogsFromStarterAppCore(isolated: false);
+
+    [Fact]
+    [CaptureWorkspaceOnFailure]
+    public Task OtelLogsReturnsStructuredLogsFromStarterAppIsolated()
+        => OtelLogsReturnsStructuredLogsFromStarterAppCore(isolated: true);
+
+    private async Task OtelLogsReturnsStructuredLogsFromStarterAppCore(bool isolated)
     {
         var repoRoot = CliE2ETestHelpers.GetRepoRoot();
         var strategy = CliInstallStrategy.Detect();
@@ -42,7 +50,7 @@ public async Task OtelLogsReturnsStructuredLogsFromStarterApp()
         await auto.WaitForSuccessPromptAsync(counter);
 
         // Start the AppHost in the background
-        await auto.AspireStartAsync(counter);
+        await auto.AspireStartAsync(counter, isolated: isolated);
 
         // Wait for the apiservice resource to be running before querying logs
         await auto.TypeAsync("aspire wait apiservice --status up --timeout 300");