Merge pull request #868 from HailongWen/app-engine-compatible-threadfactory

Use AppEngine compatible way to create threads. (fixes #707 and #777)

Author: HailongWen

impl_core/src/main/java/io/opencensus/implcore/internal/DaemonThreadFactory.java

@@ -16,12 +16,19 @@
 
 package io.opencensus.implcore.internal;
 
+import com.google.common.util.concurrent.MoreExecutors;
 import java.util.concurrent.ThreadFactory;
 import java.util.concurrent.atomic.AtomicInteger;
 
 /** A {@link ThreadFactory} implementation that starts all {@link Thread} as daemons. */
 public final class DaemonThreadFactory implements ThreadFactory {
+  // AppEngine runtimes have constraints on threading and socket handling
+  // that need to be accommodated.
+  public static final boolean IS_RESTRICTED_APPENGINE =
+      System.getProperty("com.google.appengine.runtime.environment") != null
+          && "1.7".equals(System.getProperty("java.specification.version"));
   private static final String DELIMITER = "-";
+  private static final ThreadFactory threadFactory = MoreExecutors.platformThreadFactory();
   private final AtomicInteger threadIdGen = new AtomicInteger();
   private final String threadPrefix;
 
@@ -36,8 +43,11 @@ public DaemonThreadFactory(String threadPrefix) {
 
   @Override
   public Thread newThread(Runnable r) {
-    Thread thread = new Thread(r, threadPrefix + threadIdGen.getAndIncrement());
-    thread.setDaemon(true);
+    Thread thread = threadFactory.newThread(r);
+    if (!IS_RESTRICTED_APPENGINE) {
+      thread.setName(threadPrefix + threadIdGen.getAndIncrement());
+      thread.setDaemon(true);
+    }
     return thread;
   }
 }

impl_core/src/main/java/io/opencensus/implcore/trace/export/SpanExporterImpl.java

@@ -17,6 +17,7 @@
 package io.opencensus.implcore.trace.export;
 
 import com.google.common.annotations.VisibleForTesting;
+import io.opencensus.implcore.internal.DaemonThreadFactory;
 import io.opencensus.implcore.trace.SpanImpl;
 import io.opencensus.trace.export.ExportComponent;
 import io.opencensus.trace.export.SpanData;
@@ -35,7 +36,8 @@
 public final class SpanExporterImpl extends SpanExporter {
   private static final Logger logger = Logger.getLogger(ExportComponent.class.getName());
 
-  private final WorkerThread workerThread;
+  private final Worker worker;
+  private final Thread workerThread;
 
   /**
    * Constructs a {@code SpanExporterImpl} that exports the {@link SpanData} asynchronously.
@@ -49,9 +51,8 @@ public final class SpanExporterImpl extends SpanExporter {
    */
   static SpanExporterImpl create(int bufferSize, long scheduleDelayMillis) {
     // TODO(bdrutu): Consider to add a shutdown hook to not avoid dropping data.
-    WorkerThread workerThread = new WorkerThread(bufferSize, scheduleDelayMillis);
-    workerThread.start();
-    return new SpanExporterImpl(workerThread);
+    Worker worker = new Worker(bufferSize, scheduleDelayMillis);
+    return new SpanExporterImpl(worker);
   }
 
   /**
@@ -60,29 +61,32 @@ static SpanExporterImpl create(int bufferSize, long scheduleDelayMillis) {
    * @param span the {@code Span} to be added.
    */
   public void addSpan(SpanImpl span) {
-    workerThread.addSpan(span);
+    worker.addSpan(span);
   }
 
   @Override
   public void registerHandler(String name, Handler handler) {
-    workerThread.registerHandler(name, handler);
+    worker.registerHandler(name, handler);
   }
 
   @Override
   public void unregisterHandler(String name) {
-    workerThread.unregisterHandler(name);
+    worker.unregisterHandler(name);
   }
 
-  private SpanExporterImpl(WorkerThread workerThread) {
-    this.workerThread = workerThread;
+  private SpanExporterImpl(Worker worker) {
+    this.workerThread =
+        new DaemonThreadFactory("ExportComponent.ServiceExporterThread").newThread(worker);
+    this.workerThread.start();
+    this.worker = worker;
   }
 
   @VisibleForTesting
   Thread getServiceExporterThread() {
     return workerThread;
   }
 
-  // Worker thread that batches multiple span data and calls the registered services to export
+  // Worker in a thread that batches multiple span data and calls the registered services to export
   // that data.
   //
   // The map of registered handlers is implemented using ConcurrentHashMap ensuring full
@@ -91,7 +95,7 @@ Thread getServiceExporterThread() {
   //
   // The list of batched data is protected by an explicit monitor object which ensures full
   // concurrency.
-  private static final class WorkerThread extends Thread {
+  private static final class Worker implements Runnable {
     private final Object monitor = new Object();
 
     @GuardedBy("monitor")
@@ -140,12 +144,10 @@ private void onBatchExport(List<SpanData> spanDataList) {
 
     // TODO: Decide whether to use a different class instead of LinkedList.
     @SuppressWarnings("JdkObsolete")
-    private WorkerThread(int bufferSize, long scheduleDelayMillis) {
+    private Worker(int bufferSize, long scheduleDelayMillis) {
       spans = new LinkedList<SpanImpl>();
       this.bufferSize = bufferSize;
       this.scheduleDelayMillis = scheduleDelayMillis;
-      setDaemon(true);
-      setName("ExportComponent.ServiceExporterThread");
     }
 
     // Returns an unmodifiable list of all buffered spans data to ensure that any registered