com.undefinedlabs.scope.ScopeGlobalTracer Maven / Gradle / Ivy

Go to download
package com.undefinedlabs.scope;

import io.opentracing.Scope;
import io.opentracing.ScopeManager;
import io.opentracing.Span;
import io.opentracing.SpanContext;
import io.opentracing.Tracer;
import io.opentracing.noop.NoopTracerFactory;
import io.opentracing.propagation.Format;
import java.util.concurrent.Callable;

public class ScopeGlobalTracer implements Tracer {
  private static final ScopeGlobalTracer INSTANCE = new ScopeGlobalTracer();
  private static volatile Tracer tracer = NoopTracerFactory.create();
  private static volatile boolean isRegistered = false;

  private ScopeGlobalTracer() {}

  public static Tracer get() {
    return INSTANCE;
  }

  public static boolean isRegistered() {
    return isRegistered;
  }

  public static synchronized boolean registerIfAbsent(final Callable provider) {
    requireNonNull(provider, "Cannot register ScopeGlobalTracer from provider .");
    if (!isRegistered()) {
      try {
        final Tracer suppliedTracer =
            requireNonNull(provider.call(), "Cannot register ScopeGlobalTracer .");
        if (!(suppliedTracer instanceof ScopeGlobalTracer)) {
          tracer = suppliedTracer;
          isRegistered = true;
          return true;
        }
      } catch (final RuntimeException var2) {
        throw var2;
      } catch (final Exception var3) {
        throw new IllegalStateException(
            "Exception obtaining tracer from provider: " + var3.getMessage(), var3);
      }
    }

    return false;
  }

  public static synchronized boolean registerIfAbsent(final Tracer tracer) {
    requireNonNull(tracer, "Cannot register ScopeGlobalTracer. Tracer is null");
    return registerIfAbsent(
        new Callable() {
          @Override
          public Tracer call() {
            return tracer;
          }
        });
  }

  @Deprecated
  public static void register(final Tracer tracer) {
    if (!registerIfAbsent(provide(tracer))
        && !tracer.equals(ScopeGlobalTracer.tracer)
        && !(tracer instanceof ScopeGlobalTracer)) {
      throw new IllegalStateException("There is already a current global Tracer registered.");
    }
  }

  @Override
  public ScopeManager scopeManager() {
    return tracer.scopeManager();
  }

  @Override
  public SpanBuilder buildSpan(final String operationName) {
    return tracer.buildSpan(operationName);
  }

  @Override
  public  void inject(final SpanContext spanContext, final Format format, final C carrier) {
    tracer.inject(spanContext, format, carrier);
  }

  @Override
  public  SpanContext extract(final Format format, final C carrier) {
    return tracer.extract(format, carrier);
  }

  @Override
  public Span activeSpan() {
    return tracer.activeSpan();
  }

  @Override
  public Scope activateSpan(final Span span) {
    return tracer.activateSpan(span);
  }

  @Override
  public void close() {
    tracer.close();
  }

  @Override
  public String toString() {
    return ScopeGlobalTracer.class.getSimpleName() + '{' + tracer + '}';
  }

  private static Callable provide(final Tracer tracer) {
    return new Callable() {
      @Override
      public Tracer call() {
        return tracer;
      }
    };
  }

  private static  T requireNonNull(final T value, final String message) {
    if (value == null) {
      throw new NullPointerException(message);
    } else {
      return value;
    }
  }
}