Otlp Retry Part1 - Refactor ExportClients

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

@@ -13,6 +13,8 @@ namespace OpenTelemetry.Exporter.OpenTelemetryProtocol.Implementation.ExportClie
 /// <typeparam name="TRequest">Type of export request.</typeparam>
 internal abstract class BaseOtlpGrpcExportClient<TRequest> : IExportClient<TRequest>
 {
+    protected static readonly ExportClientGrpcResponse SuccessExportResponse = new ExportClientGrpcResponse(success: true, deadlineUtc: null, exception: null);
+
     protected BaseOtlpGrpcExportClient(OtlpExporterOptions options)
     {
         Guard.ThrowIfNull(options);
@@ -38,7 +40,7 @@ protected BaseOtlpGrpcExportClient(OtlpExporterOptions options)
     internal int TimeoutMilliseconds { get; }
 
     /// <inheritdoc/>
-    public abstract bool SendExportRequest(TRequest request, CancellationToken cancellationToken = default);
+    public abstract ExportClientResponse SendExportRequest(TRequest request, CancellationToken cancellationToken = default);
 
     /// <inheritdoc/>
     public virtual bool Shutdown(int timeoutMilliseconds)

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

@@ -12,6 +12,8 @@ namespace OpenTelemetry.Exporter.OpenTelemetryProtocol.Implementation.ExportClie
 /// <typeparam name="TRequest">Type of export request.</typeparam>
 internal abstract class BaseOtlpHttpExportClient<TRequest> : IExportClient<TRequest>
 {
+    private static readonly ExportClientHttpResponse SuccessExportResponse = new ExportClientHttpResponse(success: true, deadlineUtc: null, response: null, exception: null);
+
     protected BaseOtlpHttpExportClient(OtlpExporterOptions options, HttpClient httpClient, string signalPath)
     {
         Guard.ThrowIfNull(options);
@@ -34,24 +36,33 @@ protected BaseOtlpHttpExportClient(OtlpExporterOptions options, HttpClient httpC
     internal IReadOnlyDictionary<string, string> Headers { get; }
 
     /// <inheritdoc/>
-    public bool SendExportRequest(TRequest request, CancellationToken cancellationToken = default)
+    public ExportClientResponse SendExportRequest(TRequest request, CancellationToken cancellationToken = default)
     {
+        DateTime deadline = DateTime.UtcNow.AddMilliseconds(this.HttpClient.Timeout.TotalMilliseconds);
         try
         {
             using var httpRequest = this.CreateHttpRequest(request);
 
             using var httpResponse = this.SendHttpRequest(httpRequest, cancellationToken);
 
-            httpResponse?.EnsureSuccessStatusCode();
+            try
+            {
+                httpResponse.EnsureSuccessStatusCode();
+            }
+            catch (HttpRequestException ex)
+            {
+                return new ExportClientHttpResponse(success: false, deadlineUtc: deadline, response: httpResponse, ex);
+            }
+
+            // We do not need to return back response and deadline for successful response so using cached value.
+            return SuccessExportResponse;
         }
         catch (HttpRequestException ex)
         {
             OpenTelemetryProtocolExporterEventSource.Log.FailedToReachCollector(this.Endpoint, ex);
 
-            return false;
+            return new ExportClientHttpResponse(success: false, deadlineUtc: deadline, response: null, exception: ex);
         }
-
-        return true;
     }
 
     /// <inheritdoc/>

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

@@ -0,0 +1,17 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#nullable enable
+
+namespace OpenTelemetry.Exporter.OpenTelemetryProtocol.Implementation.ExportClient;
+
+internal sealed class ExportClientGrpcResponse : ExportClientResponse
+{
+    public ExportClientGrpcResponse(
+        bool success,
+        DateTime? deadlineUtc,
+        Exception? exception)
+        : base(success, deadlineUtc, exception)
+    {
+    }
+}

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

@@ -0,0 +1,30 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#nullable enable
+
+using System.Net;
+#if NETFRAMEWORK
+using System.Net.Http;
+#endif
+using System.Net.Http.Headers;
+
+namespace OpenTelemetry.Exporter.OpenTelemetryProtocol.Implementation.ExportClient;
+
+internal sealed class ExportClientHttpResponse : ExportClientResponse
+{
+    public ExportClientHttpResponse(
+        bool success,
+        DateTime? deadlineUtc,
+        HttpResponseMessage? response,
+        Exception? exception)
+        : base(success, deadlineUtc, exception)
+    {
+        this.Headers = response?.Headers;
+        this.StatusCode = response?.StatusCode;
+    }
+
+    public HttpResponseHeaders? Headers { get; }
+
+    public HttpStatusCode? StatusCode { get; }
+}

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

@@ -0,0 +1,22 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#nullable enable
+
+namespace OpenTelemetry.Exporter.OpenTelemetryProtocol.Implementation.ExportClient;
+
+internal abstract class ExportClientResponse
+{
+    protected ExportClientResponse(bool success, DateTime? deadlineUtc, Exception? exception)
+    {
+        this.Success = success;
+        this.Exception = exception;
+        this.DeadlineUtc = deadlineUtc;
+    }
+
+    public bool Success { get; }
+
+    public Exception? Exception { get; }
+
+    public DateTime? DeadlineUtc { get; }
+}

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

@@ -1,6 +1,8 @@
 // Copyright The OpenTelemetry Authors
 // SPDX-License-Identifier: Apache-2.0
 
+#nullable enable
+
 namespace OpenTelemetry.Exporter.OpenTelemetryProtocol.Implementation.ExportClient;
 
 /// <summary>Export client interface.</summary>
@@ -12,8 +14,8 @@ internal interface IExportClient<in TRequest>
     /// </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);
+    /// <returns><see cref="ExportClientResponse"/>.</returns>
+    ExportClientResponse SendExportRequest(TRequest request, CancellationToken cancellationToken = default);
 
     /// <summary>
     /// Method for shutting down the export client.

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

@@ -26,21 +26,22 @@ public OtlpGrpcLogExportClient(OtlpExporterOptions options, OtlpCollector.LogsSe
     }
 
     /// <inheritdoc/>
-    public override bool SendExportRequest(OtlpCollector.ExportLogsServiceRequest request, CancellationToken cancellationToken = default)
+    public override ExportClientResponse SendExportRequest(OtlpCollector.ExportLogsServiceRequest request, CancellationToken cancellationToken = default)
     {
         var deadline = DateTime.UtcNow.AddMilliseconds(this.TimeoutMilliseconds);
 
         try
         {
             this.logsClient.Export(request, headers: this.Headers, deadline: deadline, cancellationToken: cancellationToken);
+
+            // We do not need to return back response and deadline for successful response so using cached value.
+            return SuccessExportResponse;
         }
         catch (RpcException ex)
         {
             OpenTelemetryProtocolExporterEventSource.Log.FailedToReachCollector(this.Endpoint, ex);
 
-            return false;
+            return new ExportClientGrpcResponse(success: false, deadlineUtc: deadline, exception: ex);
         }
-
-        return true;
     }
 }

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

@@ -26,21 +26,22 @@ public OtlpGrpcMetricsExportClient(OtlpExporterOptions options, OtlpCollector.Me
     }
 
     /// <inheritdoc/>
-    public override bool SendExportRequest(OtlpCollector.ExportMetricsServiceRequest request, CancellationToken cancellationToken = default)
+    public override ExportClientResponse SendExportRequest(OtlpCollector.ExportMetricsServiceRequest request, CancellationToken cancellationToken = default)
     {
         var deadline = DateTime.UtcNow.AddMilliseconds(this.TimeoutMilliseconds);
 
         try
         {
             this.metricsClient.Export(request, headers: this.Headers, deadline: deadline, cancellationToken: cancellationToken);
+
+            // We do not need to return back response and deadline for successful response so using cached value.
+            return SuccessExportResponse;
         }
         catch (RpcException ex)
         {
             OpenTelemetryProtocolExporterEventSource.Log.FailedToReachCollector(this.Endpoint, ex);
 
-            return false;
+            return new ExportClientGrpcResponse(success: false, deadlineUtc: deadline, exception: ex);
         }
-
-        return true;
     }
 }

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

@@ -26,21 +26,22 @@ public OtlpGrpcTraceExportClient(OtlpExporterOptions options, OtlpCollector.Trac
     }
 
     /// <inheritdoc/>
-    public override bool SendExportRequest(OtlpCollector.ExportTraceServiceRequest request, CancellationToken cancellationToken = default)
+    public override ExportClientResponse SendExportRequest(OtlpCollector.ExportTraceServiceRequest request, CancellationToken cancellationToken = default)
     {
         var deadline = DateTime.UtcNow.AddMilliseconds(this.TimeoutMilliseconds);
 
         try
         {
             this.traceClient.Export(request, headers: this.Headers, deadline: deadline, cancellationToken: cancellationToken);
+
+            // We do not need to return back response and deadline for successful response so using cached value.
+            return SuccessExportResponse;
         }
         catch (RpcException ex)
         {
             OpenTelemetryProtocolExporterEventSource.Log.FailedToReachCollector(this.Endpoint, ex);
 
-            return false;
+            return new ExportClientGrpcResponse(success: false, deadlineUtc: deadline, exception: ex);
         }
-
-        return true;
     }
 }

src/OpenTelemetry.Exporter.OpenTelemetryProtocol/OtlpLogExporter.cs

@@ -89,7 +89,7 @@ public override ExportResult Export(in Batch<LogRecord> logRecordBatch)
         {
             request = this.otlpLogRecordTransformer.BuildExportRequest(this.ProcessResource, logRecordBatch);
 
-            if (!this.exportClient.SendExportRequest(request))
+            if (!this.exportClient.SendExportRequest(request).Success)
             {
                 return ExportResult.Failure;
             }

src/OpenTelemetry.Exporter.OpenTelemetryProtocol/OtlpMetricExporter.cs

@@ -72,7 +72,7 @@ public override ExportResult Export(in Batch<Metric> metrics)
         {
             request.AddMetrics(this.ProcessResource, metrics);
 
-            if (!this.exportClient.SendExportRequest(request))
+            if (!this.exportClient.SendExportRequest(request).Success)
             {
                 return ExportResult.Failure;
             }

src/OpenTelemetry.Exporter.OpenTelemetryProtocol/OtlpTraceExporter.cs

@@ -80,7 +80,7 @@ public override ExportResult Export(in Batch<Activity> activityBatch)
         {
             request.AddBatch(this.sdkLimitOptions, this.ProcessResource, activityBatch);
 
-            if (!this.exportClient.SendExportRequest(request))
+            if (!this.exportClient.SendExportRequest(request).Success)
             {
                 return ExportResult.Failure;
             }

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

@@ -135,7 +135,7 @@ void RunTest(Batch<Activity> batch)
             var httpRequest = testHttpHandler.HttpRequestMessage;
 
             // Assert
-            Assert.True(result);
+            Assert.True(result.Success);
             Assert.NotNull(httpRequest);
             Assert.Equal(HttpMethod.Post, httpRequest.Method);
             Assert.Equal("http://localhost:4317/", httpRequest.RequestUri.AbsoluteUri);

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

@@ -13,20 +13,28 @@ internal class TestExportClient<T>(bool throwException = false) : IExportClient<
 
     public bool ThrowException { get; set; } = throwException;
 
-    public bool SendExportRequest(T request, CancellationToken cancellationToken = default)
+    public ExportClientResponse SendExportRequest(T request, CancellationToken cancellationToken = default)
     {
         if (this.ThrowException)
         {
             throw new Exception("Exception thrown from SendExportRequest");
         }
 
         this.SendExportRequestCalled = true;
-        return true;
+        return new TestExportClientResponse(true, null, null);
     }
 
     public bool Shutdown(int timeoutMilliseconds)
     {
         this.ShutdownCalled = true;
         return true;
     }
+
+    private class TestExportClientResponse : ExportClientResponse
+    {
+        public TestExportClientResponse(bool success, DateTime? deadline, Exception exception)
+            : base(success, deadline, exception)
+        {
+        }
+    }
 }