feat: Fail fast when insecure channel is not configured for .NET Core 3.1 with gRPC

src/OpenTelemetry.Exporter.OpenTelemetryProtocol/CHANGELOG.md

@@ -5,6 +5,9 @@
 * Added configuration options for `MetricReaderType` to allow for configuring
   the `OtlpMetricExporter` to export either manually or periodically.
   ([#2674](https://github.com/open-telemetry/opentelemetry-dotnet/pull/2674))
+* Added validation that unsecure channel is configured correctly when using
+  .NET Core 3.1 for gRPC & HTTP exporting.
+  ([#2691](https://github.com/open-telemetry/opentelemetry-dotnet/pull/2691))
 
 ## 1.2.0-beta2
 

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

@@ -0,0 +1,53 @@
+// <copyright file="BaseOtlpExportClient.cs" company="OpenTelemetry Authors">
+// Copyright The OpenTelemetry Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// </copyright>
+
+using System;
+using OpenTelemetry.Internal;
+
+namespace OpenTelemetry.Exporter.OpenTelemetryProtocol.Implementation.ExportClient
+{
+    /// <summary>Base class for sending OTLP export requests.</summary>
+    internal abstract class BaseOtlpExportClient
+    {
+        protected BaseOtlpExportClient(OtlpExporterOptions options)
+        {
+            Guard.Null(options, nameof(options));
+            Guard.InvalidTimeout(options.TimeoutMilliseconds, nameof(options.TimeoutMilliseconds));
+
+            this.Options = options;
+
+#if NETCOREAPP3_1
+            EnsureUnencryptedSupportIsEnabled(options);
+#endif
+        }
+
+        internal OtlpExporterOptions Options { get; }
+
+        private static void EnsureUnencryptedSupportIsEnabled(OtlpExporterOptions options)
+        {
+            if (options.Endpoint.Scheme.Equals("http", StringComparison.InvariantCultureIgnoreCase))
+            {
+                if (AppContext.TryGetSwitch(
+                        "System.Net.Http.SocketsHttpHandler.Http2UnencryptedSupport", out var unencryptedIsSupported) == false
+                    || unencryptedIsSupported == false)
+                {
+                    throw new NotSupportedException(
+                        "'System.Net.Http.SocketsHttpHandler.Http2UnencryptedSupport' must be enabled for using HTTP with .NET 3.1");
+                }
+            }
+        }
+    }
+}

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

@@ -26,19 +26,14 @@ namespace OpenTelemetry.Exporter.OpenTelemetryProtocol.Implementation.ExportClie
 {
     /// <summary>Base class for sending OTLP export request over gRPC.</summary>
     /// <typeparam name="TRequest">Type of export request.</typeparam>
-    internal abstract class BaseOtlpGrpcExportClient<TRequest> : IExportClient<TRequest>
+    internal abstract class BaseOtlpGrpcExportClient<TRequest> : BaseOtlpExportClient, IExportClient<TRequest>
     {
         protected BaseOtlpGrpcExportClient(OtlpExporterOptions options)
+            : base(options)
         {
-            Guard.Null(options, nameof(options));
-            Guard.InvalidTimeout(options.TimeoutMilliseconds, nameof(options.TimeoutMilliseconds));
-
-            this.Options = options;
             this.Headers = options.GetMetadataFromHeaders();
         }
 
-        internal OtlpExporterOptions Options { get; }
-
 #if NETSTANDARD2_1 || NET5_0_OR_GREATER
         internal GrpcChannel Channel { get; set; }
 #else

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

@@ -18,26 +18,20 @@
 using System.Collections.Generic;
 using System.Net.Http;
 using System.Threading;
-using OpenTelemetry.Internal;
 
 namespace OpenTelemetry.Exporter.OpenTelemetryProtocol.Implementation.ExportClient
 {
     /// <summary>Base class for sending OTLP export request over HTTP.</summary>
     /// <typeparam name="TRequest">Type of export request.</typeparam>
-    internal abstract class BaseOtlpHttpExportClient<TRequest> : IExportClient<TRequest>
+    internal abstract class BaseOtlpHttpExportClient<TRequest> : BaseOtlpExportClient, IExportClient<TRequest>
     {
         protected BaseOtlpHttpExportClient(OtlpExporterOptions options, HttpClient httpClient = null)
+            : base(options)
         {
-            Guard.Null(options, nameof(options));
-            Guard.InvalidTimeout(options.TimeoutMilliseconds, $"{nameof(options)}.{nameof(options.TimeoutMilliseconds)}");
-
-            this.Options = options;
             this.Headers = options.GetHeaders<Dictionary<string, string>>((d, k, v) => d.Add(k, v));
-            this.HttpClient = httpClient ?? new HttpClient { Timeout = TimeSpan.FromMilliseconds(this.Options.TimeoutMilliseconds) };
+            this.HttpClient = httpClient ?? new HttpClient { Timeout = TimeSpan.FromMilliseconds(base.Options.TimeoutMilliseconds) };
         }
 
-        internal OtlpExporterOptions Options { get; }
-
         internal HttpClient HttpClient { get; }
 
         internal IReadOnlyDictionary<string, string> Headers { get; }

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

@@ -62,5 +62,40 @@ public void ExportResultIsSuccess()
             Assert.Single(delegatingExporter.ExportResults);
             Assert.Equal(ExportResult.Success, delegatingExporter.ExportResults[0]);
         }
+
+#if NETCOREAPP3_1
+        [Trait("CategoryName", "CollectorIntegrationTests")]
+        [SkipUnlessEnvVarFoundFact(CollectorEndpointEnvVarName)]
+        public void ExportResultIsFailedBecauseEncryptedHttpSupportIsDisabled()
+        {
+            // Adding the OtlpExporter creates a GrpcChannel.
+            // This switch must be set before creating a GrpcChannel/HttpClient when calling an insecure gRPC service.
+            // We want to fail fast so we are disabling it
+            // See: https://docs.microsoft.com/aspnet/core/grpc/troubleshoot#call-insecure-grpc-services-with-net-core-client
+            AppContext.SetSwitch("System.Net.Http.SocketsHttpHandler.Http2UnencryptedSupport", false);
+
+            var exporterOptions = new OtlpExporterOptions
+            {
+                Endpoint = new Uri($"http://{CollectorEndpoint}"),
+            };
+
+            Assert.Throws<NotSupportedException>(() => new OtlpTraceExporter(exporterOptions));
+        }
+
+        [Trait("CategoryName", "CollectorIntegrationTests")]
+        [SkipUnlessEnvVarFoundFact(CollectorEndpointEnvVarName)]
+        public void ExportResultIsFailedBecauseEncryptedHttpSupportIsNotConfigured()
+        {
+            // Adding the OtlpExporter creates a GrpcChannel.
+            // This switch must be set before creating a GrpcChannel/HttpClient when calling an insecure gRPC service.
+            // We want to fail fast so not setting it to ensure it fails
+            var exporterOptions = new OtlpExporterOptions
+            {
+                Endpoint = new Uri($"http://{CollectorEndpoint}"),
+            };
+
+            Assert.Throws<NotSupportedException>(() => new OtlpTraceExporter(exporterOptions));
+        }
+#endif
     }
 }