import io.opentracing.Tracer.SpanBuilder; //导入依赖的package包/类
private Span createSpan(
    Instant start, String service, String procedure, String caller, HttpHeaders httpHeaders) {
  SpanBuilder spanBuilder =
      tracer
          .buildSpan(procedure)
          .withStartTimestamp(Instant.EPOCH.until(start, ChronoUnit.MICROS))
          .withTag(SpanTags.CALLER, caller)
          .withTag(SpanTags.SERVICE, service)
          .withTag(SpanTags.ENCODING, httpHeaders.get(HeaderMapper.ENCODING))
          .withTag(SpanTags.TRANSPORT, "http");
  SpanContext parent =
      tracer.extract(Builtin.HTTP_HEADERS, new TextMapExtractAdapter(httpHeaders));
  if (parent != null) {
    spanBuilder.asChildOf(parent);
  }
  return spanBuilder.start();
}
 

import io.opentracing.Tracer.SpanBuilder; //导入依赖的package包/类
protected void doStartSpan(SpanBuilder spanBuilder, String id) {
    TraceState ts = traceState.get();

    if (ts == null) {
        ts = new TraceState();
        traceState.set(ts);

        if (log.isLoggable(Level.FINEST)) {
            log.finest("Create trace state = " + ts);
        }
    }

    Span span = spanBuilder.start();

    if (log.isLoggable(Level.FINEST)) {
        log.finest("Start span = " + span + " id = " + id + " trace state = " + ts);
    }

    ts.pushSpan(span, id);
}
 

import io.opentracing.Tracer.SpanBuilder; //导入依赖的package包/类
@Override
public SpanBuilder addReference(String type, SpanContext ctx) {
    if (ctx != null) {
        spanBuilder.addReference(type, ctx);
    }
    return this;
}
 

import io.opentracing.Tracer.SpanBuilder; //导入依赖的package包/类
@Override
public SpanBuilder asChildOf(SpanContext ctx) {
    if (ctx != null) {
        spanBuilder.asChildOf(ctx);
    }
    return this;
}
 

import io.opentracing.Tracer.SpanBuilder; //导入依赖的package包/类
/**
 * process trace in client end
 * 
 * @param caller
 * @param request
 * @return
 */
protected Response processRefererTrace(Tracer tracer, Caller<?> caller, Request request) {
    String operationName = buildOperationName(request);
    SpanBuilder spanBuilder = tracer.buildSpan(operationName);
    Span activeSpan = OpenTracingContext.getActiveSpan();
    if (activeSpan != null) {
        spanBuilder.asChildOf(activeSpan);
    }
    Span span = spanBuilder.start();
    span.setTag("requestId", request.getRequestId());

    attachTraceInfo(tracer, span, request);
    return process(caller, request, span);

}
 

import io.opentracing.Tracer.SpanBuilder; //导入依赖的package包/类
protected Span extractTraceInfo(Request request, Tracer tracer) {
    String operationName = buildOperationName(request);
    SpanBuilder span = tracer.buildSpan(operationName);
    try {
        SpanContext spanContext = tracer.extract(Format.Builtin.TEXT_MAP, new TextMapExtractAdapter(request.getAttachments()));
        if (spanContext != null) {
            span.asChildOf(spanContext);
        }
    } catch (Exception e) {
        span.withTag("Error", "extract from request fail, error msg:" + e.getMessage());
    }
    return span.start();
}
 

import io.opentracing.Tracer.SpanBuilder; //导入依赖的package包/类
/**
 * Replaces the {@link #delegate} SpanBuilder by a delegated-method result.
 *
 * @param spanBuilder The builder returned from the delegate (normally '== delegate').
 * @return This re-wrapped ManagedSpanBuilder.
 */
SpanBuilder rewrap(SpanBuilder spanBuilder) {
    if (spanBuilder != null) {
        this.delegate = spanBuilder;
    }
    return this;
}
 

import io.opentracing.Tracer.SpanBuilder; //导入依赖的package包/类
protected void doStartSpanWithParent(SpanBuilder spanBuilder, String id) {
    Span parentSpan = getSpan();

    if (parentSpan != null) {
        spanBuilder.asChildOf(parentSpan);
    }

    doStartSpan(spanBuilder, id);
}
 

import io.opentracing.Tracer.SpanBuilder; //导入依赖的package包/类
public void beforeRequest(Object request, Context context) {
    logger.info("before send {}", request);

    // we cannot use active span because we don't know in which thread it is executed
    // and we cannot therefore activate span. thread can come from common thread pool.
    SpanBuilder spanBuilder = tracer.buildSpan(OPERATION_NAME)
            .ignoreActiveSpan()
            .withTag(Tags.SPAN_KIND.getKey(), Tags.SPAN_KIND_CLIENT);

    if (parentContext != null) {
        spanBuilder.asChildOf(parentContext);
    }

    context.put("span", spanBuilder.startManual());
}
 

import io.opentracing.Tracer.SpanBuilder; //导入依赖的package包/类
@Override
public SpanBuilder buildSpan(String operation) {
    return new AgentSpanBuilder(tracer.buildSpan(operation));
}
 

import io.opentracing.Tracer.SpanBuilder; //导入依赖的package包/类
public AgentSpanBuilder(SpanBuilder spanBuilder) {
    this.spanBuilder = spanBuilder;
}
 

import io.opentracing.Tracer.SpanBuilder; //导入依赖的package包/类
@Override
public SpanBuilder withStartTimestamp(long ts) {
    spanBuilder.withStartTimestamp(ts);
    return this;
}
 

import io.opentracing.Tracer.SpanBuilder; //导入依赖的package包/类
@Override
public SpanBuilder withTag(String name, String value) {
    spanBuilder.withTag(name, value);
    return this;
}
 

import io.opentracing.Tracer.SpanBuilder; //导入依赖的package包/类
@Override
public SpanBuilder ignoreActiveSpan() {
    spanBuilder.ignoreActiveSpan();
    return this;
}
 

import io.opentracing.Tracer.SpanBuilder; //导入依赖的package包/类
private SpanBuilder builder(String operationName) {
  return tracer.buildSpan(operationName)
      .withTag(Tags.COMPONENT.getKey(), COMPONENT_NAME)
      .withTag(Tags.SPAN_KIND.getKey(), Tags.SPAN_KIND_CLIENT)
      .withTag(Tags.DB_TYPE.getKey(), "redis");
}
 

import io.opentracing.Tracer.SpanBuilder; //导入依赖的package包/类
ManagedSpanBuilder(SpanBuilder delegate, SpanManager spanManager) {
    if (delegate == null) throw new NullPointerException("Delegate SpanBuilder was <null>.");
    if (spanManager == null) throw new NullPointerException("Span manager was <null>.");
    this.delegate = delegate;
    this.spanManager = spanManager;
}
 

import io.opentracing.Tracer.SpanBuilder; //导入依赖的package包/类
@Override
public SpanBuilder asChildOf(SpanContext parent) {
    return addReference(References.CHILD_OF, parent);
}
 

import io.opentracing.Tracer.SpanBuilder; //导入依赖的package包/类
@Override
public SpanBuilder addReference(String referenceType, SpanContext context) {
    return rewrap(delegate.addReference(referenceType, context));
}
 

import io.opentracing.Tracer.SpanBuilder; //导入依赖的package包/类
@Override
public SpanBuilder withTag(String key, String value) {
    return rewrap(delegate.withTag(key, value));
}
 

import io.opentracing.Tracer.SpanBuilder; //导入依赖的package包/类
@Override
public SpanBuilder withStartTimestamp(long microseconds) {
    return rewrap(delegate.withStartTimestamp(microseconds));
}