Changes to Span exporter with an asynchronous logic:

The write asynchronously send the spans, and recover the failed sent spans in case of error, it alwsys return success
flush sends whatever is left without being sent and waits for the payload to be sent before returning

Author: Nacho Bonafonte

Sources/Exporters/OpenTelemetryProtocol/trace/OtlpHTttpTraceExporter.swift renamed to Sources/Exporters/OpenTelemetryProtocol/trace/OtlpHttpTraceExporter.swift

@@ -3,44 +3,63 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-import OpenTelemetrySdk
 import Foundation
+import OpenTelemetrySdk
 
 public func defaultOltpHttpTracesEndpoint() -> URL {
     URL(string: "http://localhost:4318/v1/traces")!
 }
 
 public class OtlpHttpTraceExporter: OtlpHttpExporterBase, SpanExporter {
     var pendingSpans: [SpanData] = []
-    
+
     override
     public init(endpoint: URL = defaultOltpHttpTracesEndpoint(), useSession: URLSession? = nil) {
         super.init(endpoint: endpoint, useSession: useSession)
     }
-     
+
     public func export(spans: [SpanData]) -> SpanExporterResultCode {
         pendingSpans.append(contentsOf: spans)
-        return self.flush()
-    }
-
-    public func flush() -> SpanExporterResultCode {
-        var exporterResult: SpanExporterResultCode = .failure
-        let spans = pendingSpans
+        let sendingSpans = pendingSpans
         pendingSpans = []
+
         let body = Opentelemetry_Proto_Collector_Trace_V1_ExportTraceServiceRequest.with {
             $0.resourceSpans = SpanAdapter.toProtoResourceSpans(spanDataList: spans)
         }
-        
         let request = createRequest(body: body, endpoint: endpoint)
-        httpClient.send(request: request) { result in
+        httpClient.send(request: request) { [weak self] result in
             switch result {
-            case .success(_):
-                exporterResult = SpanExporterResultCode.success
+            case .success:
+                break
             case .failure(let error):
+                self?.pendingSpans.append(contentsOf: sendingSpans)
                 print(error)
-                exporterResult = SpanExporterResultCode.failure
             }
         }
-        return exporterResult
+        return .success
+    }
+
+    public func flush() -> SpanExporterResultCode {
+        var resultValue: SpanExporterResultCode = .success
+        if !pendingSpans.isEmpty {
+            let body = Opentelemetry_Proto_Collector_Trace_V1_ExportTraceServiceRequest.with {
+                $0.resourceSpans = SpanAdapter.toProtoResourceSpans(spanDataList: pendingSpans)
+            }
+            let semaphore = DispatchSemaphore(value: 0)
+            let request = createRequest(body: body, endpoint: endpoint)
+
+            httpClient.send(request: request) { result in
+                switch result {
+                case .success:
+                    break
+                case .failure(let error):
+                    print(error)
+                    resultValue = .failure
+                }
+                semaphore.signal()
+            }
+            semaphore.wait()
+        }
+        return resultValue
     }
 }

Sources/Exporters/OpenTelemetryProtocol/trace/utils/HTTPClient.swift

@@ -28,9 +28,7 @@ internal final class HTTPClient {
         let task = session.dataTask(with: request) { data, response, error in
             completion(httpClientResult(for: (data, response, error)))
         }
-        
         task.resume()
-        Thread.sleep(forTimeInterval: 1)  // FIXME is there a better way to handle this?
     }
 }