Simplify thread safe logic by moving to memoized Supplier

Author: psx95

exporters/trace/src/main/java/com/google/cloud/opentelemetry/trace/NoopTraceExporter.java renamed to exporters/trace/src/main/java/com/google/cloud/opentelemetry/trace/NoopSpanExporter.java

@@ -25,15 +25,15 @@
  * A noop implementation of a {@link SpanExporter}. This class is implemented as a singleton and
  * return a successful result on all public methods without performing any action.
  */
-class NoopTraceExporter implements SpanExporter {
+class NoopSpanExporter implements SpanExporter {
 
-  NoopTraceExporter() {
+  NoopSpanExporter() {
     // prevent explicit public call to default constructor
   }
 
   @Override
   public CompletableResultCode export(@Nonnull Collection<SpanData> spans) {
-    return CompletableResultCode.ofSuccess();
+    return CompletableResultCode.ofFailure();
   }
 
   @Override

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

@@ -16,26 +16,35 @@
 package com.google.cloud.opentelemetry.trace;
 
 import com.google.cloud.ServiceOptions;
+import com.google.common.base.Suppliers;
 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.Collection;
-import java.util.concurrent.atomic.AtomicReference;
-import javax.annotation.Nonnull;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import javax.annotation.Nonnull;
+import java.io.IOException;
+import java.util.Collection;
+import java.util.function.Supplier;
+
 public class TraceExporter implements SpanExporter {
 
   private static final Logger logger = LoggerFactory.getLogger(TraceExporter.class);
 
-  private final TraceConfiguration customTraceConfiguration;
-  private final AtomicReference<SpanExporter> internalTraceExporter;
+  private final Supplier<SpanExporter> internalTraceExporterSupplier;
 
   private TraceExporter(TraceConfiguration configuration) {
-    this.customTraceConfiguration = configuration;
-    this.internalTraceExporter = new AtomicReference<>(null);
+    this.internalTraceExporterSupplier =
+        Suppliers.memoize(
+            () -> {
+              try {
+                return InternalTraceExporter.createWithConfiguration(configuration);
+              } catch (IOException e) {
+                logger.warn("Unable to initialize TraceExporter. Export operation failed.", e);
+                return new NoopSpanExporter();
+              }
+            });
   }
 
   /**
@@ -75,33 +84,16 @@ public static SpanExporter createWithConfiguration(TraceConfiguration configurat
 
   @Override
   public CompletableResultCode flush() {
-    // We do no exporter buffering of spans, so we're always flushed.
-    return CompletableResultCode.ofSuccess();
+    return internalTraceExporterSupplier.get().flush();
   }
 
   @Override
   public CompletableResultCode export(@Nonnull Collection<SpanData> spanDataList) {
-    SpanExporter currentExporter = internalTraceExporter.get();
-    if (currentExporter == null) {
-      try {
-        internalTraceExporter.compareAndSet(
-            null, InternalTraceExporter.createWithConfiguration(this.customTraceConfiguration));
-        currentExporter = internalTraceExporter.get();
-      } catch (IOException e) {
-        logger.warn("Unable to initialize TraceExporter. Export operation failed.", e);
-        return CompletableResultCode.ofFailure();
-      }
-    }
-    return currentExporter.export(spanDataList);
+    return internalTraceExporterSupplier.get().export(spanDataList);
   }
 
   @Override
   public CompletableResultCode shutdown() {
-    SpanExporter currentExporter = internalTraceExporter.get();
-    if (currentExporter != null) {
-      return currentExporter.shutdown();
-    } else {
-      return CompletableResultCode.ofFailure();
-    }
+    return internalTraceExporterSupplier.get().shutdown();
   }
 }