static Scope buildSendSpan(Tracer tracer, MessageProperties messageProperties) {
  Tracer.SpanBuilder spanBuilder =
      tracer
          .buildSpan(RabbitMqTracingTags.SPAN_KIND_PRODUCER)
          .ignoreActiveSpan()
          .withTag(Tags.SPAN_KIND.getKey(), RabbitMqTracingTags.SPAN_KIND_PRODUCER);

  ScopeManager scopeManager = tracer.scopeManager();
  Optional<SpanContext> existingSpanContext = Optional.ofNullable(scopeManager)
      .map(ScopeManager::activeSpan)
      .map(Span::context);

  existingSpanContext.ifPresent(spanBuilder::asChildOf);

  if (messageProperties.getHeaders() != null) {
    Optional<SpanContext> messageParentContext = findParent(messageProperties, tracer);
    messageParentContext.ifPresent(spanBuilder::asChildOf);
  }
  Span span = spanBuilder.start();
  return scopeManager.activate(span);
}
 

@Override
public MiniConProp.ContextSnapshot capture() {
    Tracer tracer = GlobalTracer.get();
    ScopeManager scopeManager = tracer.scopeManager();
    Scope activeScope = scopeManager.active();

    if (activeScope != null) {
        Span span = activeScope.span();
        return () -> {
            Scope propagated = scopeManager.activate(span, false);
            return propagated::close;
        };
    }

    return MiniConProp.ContextSnapshot.NOOP;
}
 

private void finishAndCloseActiveSpan() {
  ScopeManager scopeManager = GlobalTracer.get().scopeManager();
  if (scopeManager != null && scopeManager.activeSpan() != null) {
    scopeManager.activeSpan().finish();
    scopeManager.activate(null);
  }
}
 

@Override
public ThreadContextSnapshot currentContext(Map<String, String> props) {
    Tracer tracer = GlobalTracer.get();
    ScopeManager scopeManager = tracer.scopeManager();
    Scope activeScope = scopeManager.active();

    if (activeScope != null) {
        Span span = activeScope.span();
        return () -> {
            Scope propagated = scopeManager.activate(span, false);
            return propagated::close;
        };
    }
    return () -> DO_NOTHING;
}
 

@Override
public ThreadContextSnapshot clearedContext(Map<String, String> props) {
    return () -> {
        Tracer tracer = GlobalTracer.get();
        ScopeManager scopeManager = tracer.scopeManager();
        Scope activeScope = scopeManager.active();
        if (activeScope != null) {
            activeScope.close();
        }
        return () -> {
            // TODO: we should bring back the span here
        };
    };
}
 

@Override
public ProxyMockScopeManager scopeManager() {
  final ScopeManager mockScopeManager = super.scopeManager();
  final ScopeManager realScopeManager = realTracer.scopeManager();
  if (scopeManager == null || scopeManager.mockScopeManager != mockScopeManager || scopeManager.realScopeManager != realScopeManager)
    scopeManager = new ProxyMockScopeManager(this, mockScopeManager, realScopeManager);

  return scopeManager;
}
 

private ScopeManager getScopeManager() {
    ScopeManager scopeManager = new ThreadLocalScopeManager();
    if (logTraceContext) {
        scopeManager = new MDCScopeManager(scopeManager);
    }
    return scopeManager;
}
 

@Before
public void setup() {
    this.reporterMock = mock(Reporter.class);
    this.spanBuilderMock = mock(Tracer.SpanBuilder.class);
    this.scopeManagerMock = mock(ScopeManager.class);
    this.newSpanMock = mock(Span.class);
    this.parentSpanMock = mock(Span.class);
    this.parentSpanContextMock = mock(SpanContext.class);

    // default mock behaviors
    when(spanBuilderMock.start()).thenReturn(newSpanMock);
    when(parentSpanMock.context()).thenReturn(parentSpanContextMock);
}
 

private static Tracer provideTracerByConstructor() throws Exception {
    Tracer backend = new MockTracer();
    Reporter reporter = new Slf4jReporter(LoggerFactory.getLogger("tracer"), true);
    //ScopeManager scopeManager = new ThreadLocalScopeManager();
    ScopeManager scopeManager = new ThreadLocalScopeManager();
    return new TracerR(backend, reporter, scopeManager);
}
 

public OpenTracingHystrixCallable(Callable<S> delegate, ScopeManager scopeManager, Span span) {
    if (span == null || delegate == null || scopeManager == null) {
        throw new NullPointerException();
    }
    this.delegateCallable = delegate;
    this.scopeManager = scopeManager;
    this.span = span;
}
 

static boolean isV0_31() {
  // Find OpenTracing 0.31 method
  try {
    if (ScopeManager.class.getMethod("activate", Span.class, boolean.class)
        .getAnnotation(Deprecated.class) == null) {
      return true;
    }
  } catch (NoSuchMethodException e) {
    // EmptyCatch: ignored
  }
  return false;
}
 

static v0_32 buildIfSupported() {
  // Find OpenTracing 0.32 deprecated method
  try {
    if (ScopeManager.class.getMethod("activate", Span.class, boolean.class)
        .getAnnotation(Deprecated.class) != null) {
      return new v0_32();
    }
  } catch (NoSuchMethodException e) {
    // EmptyCatch: ignored
  }
  return null;
}
 

@Test
void shouldProxyScopeManager() {
    final ScopeManager manager = unit.scopeManager();

    final Span test = unit.buildSpan("test").start();
    try (final Scope ignored = manager.activate(test)) {
        manager.activeSpan().setOperationName("GET");
    } finally {
        test.finish();
    }

    final MockSpan span = getOnlyElement(tracer.finishedSpans());
    assertEquals("get", span.operationName());
}
 

@Override
public ScopeManager scopeManager() {
  return scopeManagerShim;
}
 

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

ProxyMockScopeManager(final ProxyMockTracer tracer, final ScopeManager mockScopeManager, final ScopeManager realScopeManager) {
  this.tracer = Objects.requireNonNull(tracer);
  this.mockScopeManager = Objects.requireNonNull(mockScopeManager);
  this.realScopeManager = Objects.requireNonNull(realScopeManager);
}
 

public ProxyMockTracer(final Tracer tracer, final ScopeManager scopeManager) {
  super(scopeManager, Propagator.TEXT_MAP);
  this.realTracer = tracer;
}
 

public ProxyMockTracer(final Tracer tracer, final ScopeManager scopeManager, final Propagator propagator) {
  super(scopeManager, propagator);
  this.realTracer = tracer;
}
 

public MockTracer(ScopeManager scopeManager) {
    this(scopeManager, Propagator.TEXT_MAP);
}
 

public MockTracer(ScopeManager scopeManager, Propagator propagator) {
    this.scopeManager = scopeManager;
    this.propagator = propagator;
}
 

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

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

public ProxyScopeManager(final ScopeManager scopeManager) {
  this.scopeManager = scopeManager;
}
 

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

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

ScopeManagerWrapper(ScopeManager delegate) {
	this.delegate = delegate;
}
 

public MDCScopeManager(ScopeManager scopeManager) {
    this.wrapped = scopeManager;
}
 

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

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

@Override
public ScopeManager scopeManager() {
    return null;
}