Remove usages of beta Guava APIs. (#2095)

build.gradle

@@ -418,6 +418,8 @@ configure(opentelemetryProjects) {
         // build if error prone releases a new version with a new check
         errorprone libraries.errorprone_core
 
+        annotationProcessor "com.google.guava:guava-beta-checker:1.0"
+
         // Workaround for @javax.annotation.Generated
         // see: https://github.com/grpc/grpc-java/issues/3633
         compileOnly libraries.javax_annotations

exporters/jaeger/src/main/java/io/opentelemetry/exporter/jaeger/JaegerGrpcSpanExporter.java

@@ -30,10 +30,11 @@ import java.util.Collection;
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 import java.util.stream.Collectors;
-import javax.annotation.Nullable;
 import javax.annotation.concurrent.ThreadSafe;
 
 /** Exports spans to Jaeger via gRPC, using Jaeger's protobuf model. */
@@ -126,21 +127,37 @@ public final class JaegerGrpcSpanExporter implements SpanExporter {
     }
 
     final CompletableResultCode result = new CompletableResultCode();
-    Futures.addCallback(
+    AtomicInteger pending = new AtomicInteger(listenableFutures.size());
-        Futures.allAsList(listenableFutures),
+    AtomicReference<Throwable> error = new AtomicReference<>();
-        new FutureCallback<List<PostSpansResponse>>() {
+    for (ListenableFuture<Collector.PostSpansResponse> future : listenableFutures) {
-          @Override
+      Futures.addCallback(
-          public void onSuccess(@Nullable List<Collector.PostSpansResponse> response) {
+          future,
-            result.succeed();
+          new FutureCallback<PostSpansResponse>() {
-          }
+            @Override
+            public void onSuccess(Collector.PostSpansResponse result) {
+              fulfill();
+            }
 
-          @Override
+            @Override
-          public void onFailure(Throwable t) {
+            public void onFailure(Throwable t) {
-            logger.log(Level.WARNING, "Failed to export spans", t);
+              error.set(t);
-            result.fail();
+              fulfill();
-          }
+            }
-        },
+
-        MoreExecutors.directExecutor());
+            private void fulfill() {
+              if (pending.decrementAndGet() == 0) {
+                Throwable t = error.get();
+                if (t != null) {
+                  logger.log(Level.WARNING, "Failed to export spans", t);
+                  result.fail();
+                } else {
+                  result.succeed();
+                }
+              }
+            }
+          },
+          MoreExecutors.directExecutor());
+    }
     return result;
   }
 

sdk-extensions/zpages/src/main/java/io/opentelemetry/sdk/extension/zpages/SpanBucket.java

@@ -5,7 +5,6 @@
 
 package io.opentelemetry.sdk.extension.zpages;
 
-import com.google.common.primitives.UnsignedInts;
 import io.opentelemetry.sdk.trace.ReadableSpan;
 import java.util.List;
 import java.util.concurrent.atomic.AtomicInteger;
@@ -28,7 +27,7 @@ final class SpanBucket {
   }
 
   void add(ReadableSpan span) {
-    spans.set(UnsignedInts.remainder(index.getAndIncrement(), bucketSize), span);
+    spans.set(remainder(index.getAndIncrement(), bucketSize), span);
   }
 
   int size() {
@@ -50,4 +49,8 @@ final class SpanBucket {
       }
     }
   }
+
+  private static int remainder(int dividend, int divisor) {
+    return (int) (Integer.toUnsignedLong(dividend) % Integer.toUnsignedLong(divisor));
+  }
 }

sdk/common/src/main/java/io/opentelemetry/sdk/common/DaemonThreadFactory.java

@@ -5,7 +5,7 @@
 
 package io.opentelemetry.sdk.common;
 
-import com.google.common.util.concurrent.MoreExecutors;
+import java.util.concurrent.Executors;
 import java.util.concurrent.ThreadFactory;
 import java.util.concurrent.atomic.AtomicInteger;
 
@@ -23,7 +23,7 @@ public class DaemonThreadFactory implements ThreadFactory {
 
   @Override
   public Thread newThread(Runnable runnable) {
-    Thread t = MoreExecutors.platformThreadFactory().newThread(runnable);
+    Thread t = Executors.defaultThreadFactory().newThread(runnable);
     try {
       t.setDaemon(true);
       t.setName(namePrefix + "_" + counter.incrementAndGet());

sdk/tracing/src/main/java/io/opentelemetry/sdk/trace/RecordEventsReadableSpan.java

@@ -10,7 +10,6 @@ import static io.opentelemetry.api.common.AttributeKey.doubleKey;
 import static io.opentelemetry.api.common.AttributeKey.longKey;
 import static io.opentelemetry.api.common.AttributeKey.stringKey;
 
-import com.google.common.collect.EvictingQueue;
 import io.opentelemetry.api.common.AttributeConsumer;
 import io.opentelemetry.api.common.AttributeKey;
 import io.opentelemetry.api.common.Attributes;
@@ -82,7 +81,7 @@ final class RecordEventsReadableSpan implements ReadWriteSpan {
   private AttributesMap attributes;
   // List of recorded events.
   @GuardedBy("lock")
-  private final EvictingQueue<Event> events;
+  private final List<Event> events;
   // Number of events recorded.
   @GuardedBy("lock")
   private int totalRecordedEvents = 0;
@@ -126,7 +125,7 @@ final class RecordEventsReadableSpan implements ReadWriteSpan {
     this.clock = clock;
     this.startEpochNanos = startEpochNanos;
     this.attributes = attributes;
-    this.events = EvictingQueue.create(traceConfig.getMaxNumberOfEvents());
+    this.events = new ArrayList<>();
     this.traceConfig = traceConfig;
   }
 
@@ -373,7 +372,9 @@ final class RecordEventsReadableSpan implements ReadWriteSpan {
         logger.log(Level.FINE, "Calling addEvent() on an ended Span.");
         return;
       }
-      events.add(timedEvent);
+      if (events.size() < traceConfig.getMaxNumberOfEvents()) {
+        events.add(timedEvent);
+      }
       totalRecordedEvents++;
     }
   }

sdk/tracing/src/test/java/io/opentelemetry/sdk/trace/RecordEventsReadableSpanTest.java

@@ -631,11 +631,7 @@ class RecordEventsReadableSpanTest {
       assertThat(spanData.getEvents().size()).isEqualTo(maxNumberOfEvents);
       for (int i = 0; i < maxNumberOfEvents; i++) {
         Event expectedEvent =
-            Event.create(
+            Event.create(START_EPOCH_NANOS + i * NANOS_PER_SECOND, "event2", Attributes.empty(), 0);
-                START_EPOCH_NANOS + (maxNumberOfEvents + i) * NANOS_PER_SECOND,
-                "event2",
-                Attributes.empty(),
-                0);
         assertThat(spanData.getEvents().get(i)).isEqualTo(expectedEvent);
         assertThat(spanData.getTotalRecordedEvents()).isEqualTo(2 * maxNumberOfEvents);
       }
@@ -646,11 +642,7 @@ class RecordEventsReadableSpanTest {
     assertThat(spanData.getEvents().size()).isEqualTo(maxNumberOfEvents);
     for (int i = 0; i < maxNumberOfEvents; i++) {
       Event expectedEvent =
-          Event.create(
+          Event.create(START_EPOCH_NANOS + i * NANOS_PER_SECOND, "event2", Attributes.empty(), 0);
-              START_EPOCH_NANOS + (maxNumberOfEvents + i) * NANOS_PER_SECOND,
-              "event2",
-              Attributes.empty(),
-              0);
       assertThat(spanData.getEvents().get(i)).isEqualTo(expectedEvent);
     }
   }