Update project OpenTelemetry.Exporter.OpenTelemetryProtocol to use fi… (#4685)

Author: jarosal

src/OpenTelemetry.Exporter.OpenTelemetryProtocol/Implementation/ActivityExtensions.cs

@@ -20,56 +20,55 @@
 using Grpc.Net.Client;
 #endif
 
-namespace OpenTelemetry.Exporter.OpenTelemetryProtocol.Implementation.ExportClient
+namespace OpenTelemetry.Exporter.OpenTelemetryProtocol.Implementation.ExportClient;
+
+/// <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>
 {
-    /// <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>
+    protected BaseOtlpGrpcExportClient(OtlpExporterOptions options)
     {
-        protected BaseOtlpGrpcExportClient(OtlpExporterOptions options)
-        {
-            Guard.ThrowIfNull(options);
-            Guard.ThrowIfInvalidTimeout(options.TimeoutMilliseconds);
+        Guard.ThrowIfNull(options);
+        Guard.ThrowIfInvalidTimeout(options.TimeoutMilliseconds);
 
-            ExporterClientValidation.EnsureUnencryptedSupportIsEnabled(options);
+        ExporterClientValidation.EnsureUnencryptedSupportIsEnabled(options);
 
-            this.Endpoint = new UriBuilder(options.Endpoint).Uri;
-            this.Headers = options.GetMetadataFromHeaders();
-            this.TimeoutMilliseconds = options.TimeoutMilliseconds;
-        }
+        this.Endpoint = new UriBuilder(options.Endpoint).Uri;
+        this.Headers = options.GetMetadataFromHeaders();
+        this.TimeoutMilliseconds = options.TimeoutMilliseconds;
+    }
 
 #if NETSTANDARD2_1 || NET6_0_OR_GREATER
-        internal GrpcChannel Channel { get; set; }
+    internal GrpcChannel Channel { get; set; }
 #else
-        internal Channel Channel { get; set; }
+    internal Channel Channel { get; set; }
 #endif
 
-        internal Uri Endpoint { get; }
+    internal Uri Endpoint { get; }
 
-        internal Metadata Headers { get; }
+    internal Metadata Headers { get; }
 
-        internal int TimeoutMilliseconds { get; }
+    internal int TimeoutMilliseconds { get; }
 
-        /// <inheritdoc/>
-        public abstract bool SendExportRequest(TRequest request, CancellationToken cancellationToken = default);
+    /// <inheritdoc/>
+    public abstract bool SendExportRequest(TRequest request, CancellationToken cancellationToken = default);
 
-        /// <inheritdoc/>
-        public virtual bool Shutdown(int timeoutMilliseconds)
+    /// <inheritdoc/>
+    public virtual bool Shutdown(int timeoutMilliseconds)
+    {
+        if (this.Channel == null)
         {
-            if (this.Channel == null)
-            {
-                return true;
-            }
+            return true;
+        }
 
-            if (timeoutMilliseconds == -1)
-            {
-                this.Channel.ShutdownAsync().Wait();
-                return true;
-            }
-            else
-            {
-                return Task.WaitAny(new Task[] { this.Channel.ShutdownAsync(), Task.Delay(timeoutMilliseconds) }) == 0;
-            }
+        if (timeoutMilliseconds == -1)
+        {
+            this.Channel.ShutdownAsync().Wait();
+            return true;
+        }
+        else
+        {
+            return Task.WaitAny(new Task[] { this.Channel.ShutdownAsync(), Task.Delay(timeoutMilliseconds) }) == 0;
         }
     }
 }

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

@@ -19,83 +19,82 @@
 #endif
 using OpenTelemetry.Internal;
 
-namespace OpenTelemetry.Exporter.OpenTelemetryProtocol.Implementation.ExportClient
+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>
 {
-    /// <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>
+    protected BaseOtlpHttpExportClient(OtlpExporterOptions options, HttpClient httpClient, string signalPath)
     {
-        protected BaseOtlpHttpExportClient(OtlpExporterOptions options, HttpClient httpClient, string signalPath)
-        {
-            Guard.ThrowIfNull(options);
-            Guard.ThrowIfNull(httpClient);
-            Guard.ThrowIfNull(signalPath);
-            Guard.ThrowIfInvalidTimeout(options.TimeoutMilliseconds);
-
-            Uri exporterEndpoint = !options.ProgrammaticallyModifiedEndpoint
-                ? options.Endpoint.AppendPathIfNotPresent(signalPath)
-                : options.Endpoint;
-            this.Endpoint = new UriBuilder(exporterEndpoint).Uri;
-            this.Headers = options.GetHeaders<Dictionary<string, string>>((d, k, v) => d.Add(k, v));
-            this.HttpClient = httpClient;
-        }
+        Guard.ThrowIfNull(options);
+        Guard.ThrowIfNull(httpClient);
+        Guard.ThrowIfNull(signalPath);
+        Guard.ThrowIfInvalidTimeout(options.TimeoutMilliseconds);
+
+        Uri exporterEndpoint = !options.ProgrammaticallyModifiedEndpoint
+            ? options.Endpoint.AppendPathIfNotPresent(signalPath)
+            : options.Endpoint;
+        this.Endpoint = new UriBuilder(exporterEndpoint).Uri;
+        this.Headers = options.GetHeaders<Dictionary<string, string>>((d, k, v) => d.Add(k, v));
+        this.HttpClient = httpClient;
+    }
 
-        internal HttpClient HttpClient { get; }
+    internal HttpClient HttpClient { get; }
 
-        internal Uri Endpoint { get; set; }
+    internal Uri Endpoint { get; set; }
 
-        internal IReadOnlyDictionary<string, string> Headers { get; }
+    internal IReadOnlyDictionary<string, string> Headers { get; }
 
-        /// <inheritdoc/>
-        public bool SendExportRequest(TRequest request, CancellationToken cancellationToken = default)
+    /// <inheritdoc/>
+    public bool SendExportRequest(TRequest request, CancellationToken cancellationToken = default)
+    {
+        try
         {
-            try
-            {
-                using var httpRequest = this.CreateHttpRequest(request);
-
-                using var httpResponse = this.SendHttpRequest(httpRequest, cancellationToken);
+            using var httpRequest = this.CreateHttpRequest(request);
 
-                httpResponse?.EnsureSuccessStatusCode();
-            }
-            catch (HttpRequestException ex)
-            {
-                OpenTelemetryProtocolExporterEventSource.Log.FailedToReachCollector(this.Endpoint, ex);
+            using var httpResponse = this.SendHttpRequest(httpRequest, cancellationToken);
 
-                return false;
-            }
-
-            return true;
+            httpResponse?.EnsureSuccessStatusCode();
         }
-
-        /// <inheritdoc/>
-        public bool Shutdown(int timeoutMilliseconds)
+        catch (HttpRequestException ex)
         {
-            this.HttpClient.CancelPendingRequests();
-            return true;
+            OpenTelemetryProtocolExporterEventSource.Log.FailedToReachCollector(this.Endpoint, ex);
+
+            return false;
         }
 
-        protected abstract HttpContent CreateHttpContent(TRequest exportRequest);
+        return true;
+    }
 
-        protected HttpRequestMessage CreateHttpRequest(TRequest exportRequest)
-        {
-            var request = new HttpRequestMessage(HttpMethod.Post, this.Endpoint);
-            foreach (var header in this.Headers)
-            {
-                request.Headers.Add(header.Key, header.Value);
-            }
+    /// <inheritdoc/>
+    public bool Shutdown(int timeoutMilliseconds)
+    {
+        this.HttpClient.CancelPendingRequests();
+        return true;
+    }
 
-            request.Content = this.CreateHttpContent(exportRequest);
+    protected abstract HttpContent CreateHttpContent(TRequest exportRequest);
 
-            return request;
+    protected HttpRequestMessage CreateHttpRequest(TRequest exportRequest)
+    {
+        var request = new HttpRequestMessage(HttpMethod.Post, this.Endpoint);
+        foreach (var header in this.Headers)
+        {
+            request.Headers.Add(header.Key, header.Value);
         }
 
-        protected HttpResponseMessage SendHttpRequest(HttpRequestMessage request, CancellationToken cancellationToken)
-        {
+        request.Content = this.CreateHttpContent(exportRequest);
+
+        return request;
+    }
+
+    protected HttpResponseMessage SendHttpRequest(HttpRequestMessage request, CancellationToken cancellationToken)
+    {
 #if NET6_0_OR_GREATER
-            return this.HttpClient.Send(request, cancellationToken);
+        return this.HttpClient.Send(request, cancellationToken);
 #else
-            return this.HttpClient.SendAsync(request, cancellationToken).GetAwaiter().GetResult();
+        return this.HttpClient.SendAsync(request, cancellationToken).GetAwaiter().GetResult();
 #endif
-        }
     }
 }

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

@@ -14,29 +14,28 @@
 // limitations under the License.
 // </copyright>
 
-namespace OpenTelemetry.Exporter.OpenTelemetryProtocol.Implementation.ExportClient
+namespace OpenTelemetry.Exporter.OpenTelemetryProtocol.Implementation.ExportClient;
+
+internal static class ExporterClientValidation
 {
-    internal static class ExporterClientValidation
+    internal static void EnsureUnencryptedSupportIsEnabled(OtlpExporterOptions options)
     {
-        internal static void EnsureUnencryptedSupportIsEnabled(OtlpExporterOptions options)
-        {
-            var version = Environment.Version;
+        var version = Environment.Version;
 
-            // This verification is only required for .NET Core 3.x
-            if (version.Major != 3)
-            {
-                return;
-            }
+        // This verification is only required for .NET Core 3.x
+        if (version.Major != 3)
+        {
+            return;
+        }
 
-            if (options.Endpoint.Scheme.Equals("http", StringComparison.OrdinalIgnoreCase))
+        if (options.Endpoint.Scheme.Equals("http", StringComparison.OrdinalIgnoreCase))
+        {
+            if (AppContext.TryGetSwitch(
+                    "System.Net.Http.SocketsHttpHandler.Http2UnencryptedSupport", out var unencryptedIsSupported) == false
+                || unencryptedIsSupported == false)
             {
-                if (AppContext.TryGetSwitch(
-                        "System.Net.Http.SocketsHttpHandler.Http2UnencryptedSupport", out var unencryptedIsSupported) == false
-                    || unencryptedIsSupported == false)
-                {
-                    throw new InvalidOperationException(
-                        "Calling insecure gRPC services on .NET Core 3.x requires enabling the 'System.Net.Http.SocketsHttpHandler.Http2UnencryptedSupport' switch. See: https://docs.microsoft.com/aspnet/core/grpc/troubleshoot#call-insecure-grpc-services-with-net-core-client");
-                }
+                throw new InvalidOperationException(
+                    "Calling insecure gRPC services on .NET Core 3.x requires enabling the 'System.Net.Http.SocketsHttpHandler.Http2UnencryptedSupport' switch. See: https://docs.microsoft.com/aspnet/core/grpc/troubleshoot#call-insecure-grpc-services-with-net-core-client");
             }
         }
     }

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

@@ -14,30 +14,29 @@
 // limitations under the License.
 // </copyright>
 
-namespace OpenTelemetry.Exporter.OpenTelemetryProtocol.Implementation.ExportClient
+namespace OpenTelemetry.Exporter.OpenTelemetryProtocol.Implementation.ExportClient;
+
+/// <summary>Export client interface.</summary>
+/// <typeparam name="TRequest">Type of export request.</typeparam>
+internal interface IExportClient<in TRequest>
 {
-    /// <summary>Export client interface.</summary>
-    /// <typeparam name="TRequest">Type of export request.</typeparam>
-    internal interface IExportClient<in TRequest>
-    {
-        /// <summary>
-        /// Method for sending export request to the server.
-        /// </summary>
-        /// <param name="request">The request to send to the server.</param>
-        /// <param name="cancellationToken">An optional token for canceling the call.</param>
-        /// <returns>True if the request has been sent successfully, otherwise false.</returns>
-        bool SendExportRequest(TRequest request, CancellationToken cancellationToken = default);
+    /// <summary>
+    /// Method for sending export request to the server.
+    /// </summary>
+    /// <param name="request">The request to send to the server.</param>
+    /// <param name="cancellationToken">An optional token for canceling the call.</param>
+    /// <returns>True if the request has been sent successfully, otherwise false.</returns>
+    bool SendExportRequest(TRequest request, CancellationToken cancellationToken = default);
 
-        /// <summary>
-        /// Method for shutting down the export client.
-        /// </summary>
-        /// <param name="timeoutMilliseconds">
-        /// The number of milliseconds to wait, or <c>Timeout.Infinite</c> to
-        /// wait indefinitely.
-        /// </param>
-        /// <returns>
-        /// Returns <c>true</c> if shutdown succeeded; otherwise, <c>false</c>.
-        /// </returns>
-        bool Shutdown(int timeoutMilliseconds);
-    }
+    /// <summary>
+    /// Method for shutting down the export client.
+    /// </summary>
+    /// <param name="timeoutMilliseconds">
+    /// The number of milliseconds to wait, or <c>Timeout.Infinite</c> to
+    /// wait indefinitely.
+    /// </param>
+    /// <returns>
+    /// Returns <c>true</c> if shutdown succeeded; otherwise, <c>false</c>.
+    /// </returns>
+    bool Shutdown(int timeoutMilliseconds);
 }