import zipkin.reporter.Reporter; //导入依赖的package包/类
@SuppressWarnings("unchecked")
public Tracing httpTracer(Config config, Map<String, String> properties, Reporter reporter) {

    Sampler sampler = Sampler.ALWAYS_SAMPLE;

    try {
        ServiceReference<Sampler>[] samplers =
                (ServiceReference<Sampler>[]) context.getAllServiceReferences(
                        Sampler.class.getName(), config.samplerFilter());
        if (samplers != null && samplers.length > 0) {
            sampler = context.getService(samplers[0]);
        }

    } catch (InvalidSyntaxException e) {

    }

    Tracing.Builder tracingBuilder = Tracing.newBuilder();
    tracingBuilder.localServiceName(config.localServiceName());
    tracingBuilder.sampler(sampler);
    tracingBuilder.reporter(reporter);
    tracingBuilder.currentTraceContext(MDCCurrentTraceContext.create());

    return tracingBuilder.build();
}
 

import zipkin.reporter.Reporter; //导入依赖的package包/类
/**
 * Creates and returns a tracer that is uses 
 * a serviceName and the location of a zipkin host/port
 * to provide tracing capability.
 *
 * @param serviceName
 * @param config
 */
public OpentracingZipkinTracer(String serviceName, Config config) {
	String traceServiceUrl = "http://"+config.host()+":"+config.port()+"/api/v1/spans";
	OkHttpSender.Builder senderBuilder = OkHttpSender.builder().endpoint(traceServiceUrl).compressionEnabled(config.compress());
	if (config.maxRequests() != Integer.MIN_VALUE) {
		senderBuilder.maxRequests(config.maxRequests());
	}
	if (config.encoding() != null) {
		senderBuilder.encoding(config.encoding());
	}
	if (config.maxMessageSize() != Integer.MIN_VALUE) {
		senderBuilder.messageMaxBytes(config.maxMessageSize());
	}
	Sender sender = senderBuilder.build();
	AsyncReporter.Builder reporterBuilder = AsyncReporter.builder(sender);
	if (config.closeTimeout() != Integer.MIN_VALUE) {
		reporterBuilder.closeTimeout(config.closeTimeout(), TimeUnit.SECONDS);
	}
	if (config.messageTimeout() != Integer.MIN_VALUE) {
		reporterBuilder.messageTimeout(config.messageTimeout(), TimeUnit.SECONDS);
	}
	if (config.queuedMaxBytes() != Integer.MIN_VALUE) {
		reporterBuilder.queuedMaxBytes(config.queuedMaxBytes());
	}
	if (config.queuedMaxSpans() != Integer.MIN_VALUE) {
		reporterBuilder.queuedMaxSpans(config.queuedMaxSpans());
	}
	Reporter<zipkin.Span> reporter = reporterBuilder.build();
	Tracing braveTracing = Tracing.newBuilder()
			.localServiceName(serviceName)
			.reporter(reporter)
			.build();
	tracer = BraveTracer.create(braveTracing);
}
 

import zipkin.reporter.Reporter; //导入依赖的package包/类
@Test
public void inlineBraveSetup() {
    Reporter<Span> local = new Reporter<Span>() {

        @Override
        public void report(Span span) {
            spans.add(span);
        }
    };
    Brave brave = new Brave.Builder().reporter(local).build();
    brave.localTracer().startNewSpan("test", "testop");
    brave.localTracer().finishSpan();
    Assert.assertThat(1, equalTo(spans.size()));
}
 

import zipkin.reporter.Reporter; //导入依赖的package包/类
@Activate
public void activate(Config config, BundleContext context, Map<String,String> properties) {
    URLConnectionSender sender = URLConnectionSender.builder()
        .endpoint(config.endpoint()) //
        .compressionEnabled(config.compressionEnabled()) //
        .connectTimeout(config.connectTimeout())
        .messageMaxBytes(config.messageMaxBytes())
        .build();
    reporter = AsyncReporter.builder(sender).build();
    reg = context.registerService(Reporter.class, reporter, new Hashtable<String, String>(properties));
}
 

import zipkin.reporter.Reporter; //导入依赖的package包/类
@Activate
public void activate(Config config, BundleContext context, Map<String, String> properties) {
    this.context = context;
    OkHttpSender sender = createSender(config, properties);
    reporter = AsyncReporter.create(sender);

    reporterServiceRegistration = context.registerService(Reporter.class, reporter,
            new Hashtable<String, String>(properties));

    tracing = httpTracer(config, properties, reporter);
    tracingServiceRegistration = context.registerService(Tracing.class, tracing,
            new Hashtable<String, String>(properties));
}
 

import zipkin.reporter.Reporter; //导入依赖的package包/类
SpanRecorder(Reporter<Span> reporter, StatsReceiver stats, Timer timer) {
  this.reporter = reporter;
  this.unhandledReceiver = stats.scope("record").scope("unhandled");
  this.flusher = timer.schedule(ttl.$div(2L), () -> {
    flush(ttl.ago());
    return null;
  });
}
 

import zipkin.reporter.Reporter; //导入依赖的package包/类
@Bean
    Reporter<Span> reporter() {
//        return new LoggingReporter(); // logs spans to console
        return AsyncReporter.builder(sender()).build(); // sends spans to zipkin
    }
 

import zipkin.reporter.Reporter; //导入依赖的package包/类
/** Configuration for how to buffer spans into messages for Zipkin */
    @Bean Reporter<Span> reporter() {
//        return new LoggingReporter();
        return AsyncReporter.builder(sender()).build(); // Sends to Zipkin
    }
 

import zipkin.reporter.Reporter; //导入依赖的package包/类
@SuppressWarnings("rawtypes")
@Test
public void checkReporterUrlConnect() throws InvalidSyntaxException {
    ServiceReference<Reporter> ref = getSingleService(FILTER_URLCONNECT);
    Assert.assertEquals(10000, ref.getProperty("connectTimeout"));
}
 

import zipkin.reporter.Reporter; //导入依赖的package包/类
@SuppressWarnings("rawtypes")
@Test
public void checkReporterKafka() throws InvalidSyntaxException {
    ServiceReference<Reporter> ref = getSingleService(FILTER_KAFKA08);
    Assert.assertEquals("zipkin", ref.getProperty("topic"));
}
 

import zipkin.reporter.Reporter; //导入依赖的package包/类
@SuppressWarnings("rawtypes")
private ServiceReference<Reporter> getSingleService(String filter) throws InvalidSyntaxException {
    Collection<ServiceReference<Reporter>> refs = context.getServiceReferences(Reporter.class, filter);
    Assert.assertEquals(1, refs.size());
    return refs.iterator().next();
}
 

import zipkin.reporter.Reporter; //导入依赖的package包/类
@Activate
public void activate(Config config, BundleContext context, Map<String,String> properties) {
    KafkaSender sender = createSender(config, properties);
    reporter = AsyncReporter.builder(sender).build();
    reg = context.registerService(Reporter.class, reporter, new Hashtable<String, String>(properties));
}
 

import zipkin.reporter.Reporter; //导入依赖的package包/类
private Reporter<Span> buildReporter(ApplicationConfig config) {
  return AsyncReporter.builder(OkHttpSender.create(config.getZipkinUrl())).build();
}
 

import zipkin.reporter.Reporter; //导入依赖的package包/类
@Produces
@Singleton
public Brave createBrave(Reporter<Span> reporter) {
    return new Brave.Builder().reporter(reporter).build();
}