Otlp http exporter: allow endpoint override

src/OpenTelemetry.Exporter.OpenTelemetryProtocol/Implementation/ExportClient/OtlpHttpTraceExportClient.cs

@@ -38,7 +38,7 @@ internal sealed class OtlpHttpTraceExportClient : BaseOtlpHttpExportClient<OtlpC
         public OtlpHttpTraceExportClient(OtlpExporterOptions options, HttpClient httpClient = null)
             : base(options, httpClient)
         {
-            this.exportTracesUri = this.Options.Endpoint.AppendPathIfNotPresent(OtlpExporterOptions.TracesExportPath);
+            this.exportTracesUri = this.Options.Endpoint;
         }
 
         protected override HttpRequestMessage CreateHttpRequest(OtlpCollector.ExportTraceServiceRequest exportRequest)

src/OpenTelemetry.Exporter.OpenTelemetryProtocol/OtlpExporterOptionsExtensions.cs

@@ -17,6 +17,7 @@
 using System;
 using Grpc.Core;
 using OpenTelemetry.Exporter.OpenTelemetryProtocol.Implementation.ExportClient;
+using OpenTelemetry.Internal;
 #if NETSTANDARD2_1 || NET5_0_OR_GREATER
 using Grpc.Net.Client;
 #endif
@@ -103,7 +104,26 @@ public static THeaders GetHeaders<THeaders>(this OtlpExporterOptions options, Ac
                 _ => null,
             };
 
-        public static Uri AppendPathIfNotPresent(this Uri uri, string path)
+        internal static void AppendExportPath(this OtlpExporterOptions options, Uri initialEndpoint, string exportRelativePath)
+        {
+            // The exportRelativePath is only appended when the options.Endpoint property wasn't set by the user,
+            // the protocol is HttpProtobuf and the OTEL_EXPORTER_OTLP_ENDPOINT environment variable
+            // is present. If the user provides a custom value for options.Endpoint that value is taken as is.
+            if (ReferenceEquals(initialEndpoint, options.Endpoint))
+            {
+                if (options.Protocol == OtlpExportProtocol.HttpProtobuf)
+                {
+                    if (EnvironmentVariableHelper.LoadUri(OtlpExporterOptions.EndpointEnvVarName, out Uri endpoint))
+                    {
+                        // At this point we can conclude that endpoint was initialized from OTEL_EXPORTER_OTLP_ENDPOINT
+                        // and has to be appended by export relative path (traces/metrics).
+                        options.Endpoint = endpoint.AppendPathIfNotPresent(exportRelativePath);
+                    }
+                }
+            }
+        }
+
+        internal static Uri AppendPathIfNotPresent(this Uri uri, string path)
         {
             var absoluteUri = uri.AbsoluteUri;
             var separator = string.Empty;

src/OpenTelemetry.Exporter.OpenTelemetryProtocol/OtlpMetricExporterExtensions.cs

@@ -48,8 +48,12 @@ public static MeterProviderBuilder AddOtlpExporter(this MeterProviderBuilder bui
 
         private static MeterProviderBuilder AddOtlpExporter(MeterProviderBuilder builder, OtlpExporterOptions options, Action<OtlpExporterOptions> configure = null)
         {
+            var initialEndpoint = options.Endpoint;
+
             configure?.Invoke(options);
 
+            options.AppendExportPath(initialEndpoint, OtlpExporterOptions.MetricsExportPath);
+
             var metricExporter = new OtlpMetricExporter(options);
             var metricReader = new PeriodicExportingMetricReader(metricExporter, options.MetricExportIntervalMilliseconds);
             metricReader.PreferredAggregationTemporality = options.AggregationTemporality;

src/OpenTelemetry.Exporter.OpenTelemetryProtocol/OtlpTraceExporterHelperExtensions.cs

@@ -48,7 +48,12 @@ public static TracerProviderBuilder AddOtlpExporter(this TracerProviderBuilder b
 
         private static TracerProviderBuilder AddOtlpExporter(TracerProviderBuilder builder, OtlpExporterOptions exporterOptions, Action<OtlpExporterOptions> configure = null)
         {
+            var originalEndpoint = exporterOptions.Endpoint;
+
             configure?.Invoke(exporterOptions);
+
+            exporterOptions.AppendExportPath(originalEndpoint, OtlpExporterOptions.TracesExportPath);
+
             var otlpExporter = new OtlpTraceExporter(exporterOptions);
 
             if (exporterOptions.ExportProcessorType == ExportProcessorType.Simple)

test/OpenTelemetry.Exporter.OpenTelemetryProtocol.Tests/Implementation/ExportClient/OtlpHttpTraceExportClientTests.cs

@@ -175,7 +175,7 @@ void RunTest(Batch<Activity> batch)
                 Assert.True(result);
                 Assert.NotNull(httpRequest);
                 Assert.Equal(HttpMethod.Post, httpRequest.Method);
-                Assert.Equal("http://localhost:4317/v1/traces", httpRequest.RequestUri.AbsoluteUri);
+                Assert.Equal("http://localhost:4317/", httpRequest.RequestUri.AbsoluteUri);
                 Assert.Equal(2, httpRequest.Headers.Count());
                 Assert.Contains(httpRequest.Headers, h => h.Key == header1.Name && h.Value.First() == header1.Value);
                 Assert.Contains(httpRequest.Headers, h => h.Key == header2.Name && h.Value.First() == header2.Value);

test/OpenTelemetry.Exporter.OpenTelemetryProtocol.Tests/OtlpExporterOptionsExtensionsTests.cs

@@ -131,5 +131,68 @@ public void AppendPathIfNotPresent_TracesPath_AppendsCorrectly(string inputUri,
 
             Assert.Equal(expectedUri, resultUri.AbsoluteUri);
         }
+
+        [Fact]
+        public void AppendExportPath_EndpointNotSet_EnvironmentVariableNotDefined_NotAppended()
+        {
+            ClearEndpointEnvVar();
+
+            var options = new OtlpExporterOptions { Protocol = OtlpExportProtocol.HttpProtobuf };
+
+            options.AppendExportPath(options.Endpoint, "test/path");
+
+            Assert.Equal("http://localhost:4317/", options.Endpoint.AbsoluteUri);
+        }
+
+        [Fact]
+        public void AppendExportPath_EndpointNotSet_EnvironmentVariableDefined_Appended()
+        {
+            Environment.SetEnvironmentVariable(OtlpExporterOptions.EndpointEnvVarName, "http://test:8888");
+
+            var options = new OtlpExporterOptions { Protocol = OtlpExportProtocol.HttpProtobuf };
+
+            options.AppendExportPath(options.Endpoint, "test/path");
+
+            Assert.Equal("http://test:8888/test/path", options.Endpoint.AbsoluteUri);
+
+            ClearEndpointEnvVar();
+        }
+
+        [Fact]
+        public void AppendExportPath_EndpointSetEqualToEnvironmentVariable_EnvironmentVariableDefined_NotAppended()
+        {
+            Environment.SetEnvironmentVariable(OtlpExporterOptions.EndpointEnvVarName, "http://test:8888");
+
+            var options = new OtlpExporterOptions { Protocol = OtlpExportProtocol.HttpProtobuf };
+            var originalEndpoint = options.Endpoint;
+            options.Endpoint = new Uri("http://test:8888");
+
+            options.AppendExportPath(originalEndpoint, "test/path");
+
+            Assert.Equal("http://test:8888/", options.Endpoint.AbsoluteUri);
+
+            ClearEndpointEnvVar();
+        }
+
+        [Theory]
+        [InlineData("http://localhost:4317/")]
+        [InlineData("http://test:8888/")]
+        public void AppendExportPath_EndpointSet_EnvironmentVariableNotDefined_NotAppended(string endpoint)
+        {
+            ClearEndpointEnvVar();
+
+            var options = new OtlpExporterOptions { Protocol = OtlpExportProtocol.HttpProtobuf };
+            var originalEndpoint = options.Endpoint;
+            options.Endpoint = new Uri(endpoint);
+
+            options.AppendExportPath(originalEndpoint, "test/path");
+
+            Assert.Equal(endpoint, options.Endpoint.AbsoluteUri);
+        }
+
+        private static void ClearEndpointEnvVar()
+        {
+            Environment.SetEnvironmentVariable(OtlpExporterOptions.EndpointEnvVarName, null);
+        }
     }
 }