Make the TraceExporter thread-safe

Author: psx95

exporters/trace/src/main/java/com/google/cloud/opentelemetry/trace/InternalTraceExporter.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2023 Google
+ * Copyright 2022 Google
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -15,6 +15,8 @@
  */
 package com.google.cloud.opentelemetry.trace;
 
+import static com.google.api.client.util.Preconditions.checkNotNull;
+
 import com.google.api.gax.core.FixedCredentialsProvider;
 import com.google.api.gax.core.NoCredentialsProvider;
 import com.google.api.gax.grpc.GrpcTransportChannel;
@@ -33,14 +35,12 @@
 import io.opentelemetry.sdk.common.CompletableResultCode;
 import io.opentelemetry.sdk.trace.data.SpanData;
 import io.opentelemetry.sdk.trace.export.SpanExporter;
-
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
 import java.util.Map;
-
-import static com.google.api.client.util.Preconditions.checkNotNull;
+import javax.annotation.Nonnull;
 
 class InternalTraceExporter implements SpanExporter {
 
@@ -53,6 +53,15 @@ class InternalTraceExporter implements SpanExporter {
       Map.of("User-Agent", "opentelemetry-operations-java/" + TraceVersions.EXPORTER_VERSION);
   private static final HeaderProvider HEADER_PROVIDER = () -> HEADERS;
 
+  private static InternalTraceExporter createWithClient(
+      String projectId,
+      CloudTraceClient cloudTraceClient,
+      ImmutableMap<String, String> attributeMappings,
+      Map<String, AttributeValue> fixedAttributes) {
+    return new InternalTraceExporter(
+        projectId, cloudTraceClient, attributeMappings, fixedAttributes);
+  }
+
   static SpanExporter createWithConfiguration(TraceConfiguration configuration) throws IOException {
     String projectId = configuration.getProjectId();
     TraceServiceStub stub = configuration.getTraceServiceStub();
@@ -99,13 +108,34 @@ static SpanExporter createWithConfiguration(TraceConfiguration configuration) th
         configuration.getFixedAttributes());
   }
 
-  private static InternalTraceExporter createWithClient(
-      String projectId,
-      CloudTraceClient cloudTraceClient,
-      ImmutableMap<String, String> attributeMappings,
-      Map<String, AttributeValue> fixedAttributes) {
-    return new InternalTraceExporter(
-        projectId, cloudTraceClient, attributeMappings, fixedAttributes);
+  /**
+   * A noop implementation of {@link TraceExporter}. Should be used when {@link TraceExporter}
+   * cannot be initialized due to some error/exception.
+   *
+   * @return noop implementation of {@link TraceExporter} as a {@link SpanExporter}.
+   */
+  static SpanExporter noop() {
+    return new SpanExporter() {
+      @Override
+      public CompletableResultCode export(@Nonnull Collection<SpanData> spans) {
+        return CompletableResultCode.ofSuccess();
+      }
+
+      @Override
+      public CompletableResultCode flush() {
+        return CompletableResultCode.ofSuccess();
+      }
+
+      @Override
+      public CompletableResultCode shutdown() {
+        return CompletableResultCode.ofSuccess();
+      }
+
+      @Override
+      public String toString() {
+        return "NoopTraceExporter{}";
+      }
+    };
   }
 
   InternalTraceExporter(

exporters/trace/src/main/java/com/google/cloud/opentelemetry/trace/TraceExporter.java

@@ -17,21 +17,29 @@
 
 import com.google.cloud.ServiceOptions;
 import io.opentelemetry.sdk.common.CompletableResultCode;
+import io.opentelemetry.sdk.internal.ThrottlingLogger;
 import io.opentelemetry.sdk.trace.data.SpanData;
 import io.opentelemetry.sdk.trace.export.SpanExporter;
 import java.io.IOException;
 import java.util.Collection;
+import java.util.Objects;
 import java.util.concurrent.atomic.AtomicReference;
+import java.util.logging.Level;
+import java.util.logging.Logger;
 import javax.annotation.Nonnull;
 
 public class TraceExporter implements SpanExporter {
 
+  private static final Logger logger = Logger.getLogger(TraceExporter.class.getName());
+
   private final TraceConfiguration.Builder customTraceConfigurationBuilder;
   private final AtomicReference<SpanExporter> internalTraceExporter;
+  private final ThrottlingLogger throttlingLogger;
 
   private TraceExporter(TraceConfiguration.Builder configurationBuilder) {
     this.customTraceConfigurationBuilder = configurationBuilder;
     this.internalTraceExporter = new AtomicReference<>(null);
+    this.throttlingLogger = new ThrottlingLogger(logger);
   }
 
   private static SpanExporter generateStubTraceExporter(TraceConfiguration.Builder configBuilder) {
@@ -93,13 +101,21 @@ public CompletableResultCode flush() {
 
   @Override
   public CompletableResultCode export(@Nonnull Collection<SpanData> spanDataList) {
-    try {
-      internalTraceExporter.compareAndSet(null, createActualTraceExporter());
-      return internalTraceExporter.get().export(spanDataList);
-    } catch (IOException e) {
-      e.printStackTrace();
-      return CompletableResultCode.ofFailure();
+    if (Objects.isNull(internalTraceExporter.get())) {
+      synchronized (this) {
+        try {
+          internalTraceExporter.compareAndSet(null, createActualTraceExporter());
+        } catch (IOException e) {
+          // unable to create actual trace exporter
+          throttlingLogger.log(
+              Level.WARNING,
+              String.format("Unable to initialize trace exporter. Error %s", e.getMessage()));
+          throttlingLogger.log(Level.INFO, "Setting TraceExporter to noop.");
+          internalTraceExporter.set(InternalTraceExporter.noop());
+        }
+      }
     }
+    return internalTraceExporter.get().export(spanDataList);
   }
 
   @Override