Java Code Examples for io.opentracing.util.GlobalTracer#registerIfAbsent()

public static void main(String[] args) throws InterruptedException {
    KafkaProducerConfig config = KafkaProducerConfig.fromEnv();
    Properties props = KafkaProducerConfig.createProperties(config);

    if (System.getenv("JAEGER_SERVICE_NAME") != null)   {
        Tracer tracer = Configuration.fromEnv().getTracer();
        GlobalTracer.registerIfAbsent(tracer);

        props.put(ProducerConfig.INTERCEPTOR_CLASSES_CONFIG, TracingProducerInterceptor.class.getName());
    }

    KafkaProducer producer = new KafkaProducer(props);
    log.info("Sending {} messages ...", config.getMessageCount());
    for (long i = 0; i < config.getMessageCount(); i++) {
        log.info("Sending messages \"" + config.getMessage() + " - {}\"", i);
        producer.send(new ProducerRecord(config.getTopic(),  "\"" + config.getMessage()  + " - " + i + "\""));
        Thread.sleep(config.getDelay());
    }
    log.info("{} messages sent ...", config.getMessageCount());
    producer.close();
}
 

public static void main(String[] args) {
    KafkaConsumerConfig config = KafkaConsumerConfig.fromEnv();
    Properties props = KafkaConsumerConfig.createProperties(config);
    int receivedMsgs = 0;

    if (System.getenv("JAEGER_SERVICE_NAME") != null)   {
        Tracer tracer = Configuration.fromEnv().getTracer();
        GlobalTracer.registerIfAbsent(tracer);

        props.put(ConsumerConfig.INTERCEPTOR_CLASSES_CONFIG, TracingConsumerInterceptor.class.getName());
    }

    boolean commit = !Boolean.parseBoolean(config.getEnableAutoCommit());
    KafkaConsumer consumer = new KafkaConsumer(props);
    consumer.subscribe(Collections.singletonList(config.getTopic()));

    while (receivedMsgs < config.getMessageCount()) {
        ConsumerRecords<String, String> records = consumer.poll(Long.MAX_VALUE);
        for (ConsumerRecord<String, String> record : records) {
            log.info("Received message:");
            log.info("\tpartition: {}", record.partition());
            log.info("\toffset: {}", record.offset());
            log.info("\tvalue: {}", record.value());
            receivedMsgs++;
        }
        if (commit) {
            consumer.commitSync();
        }
    }
}
 

@Before
public void setUp() {
  GlobalTracerTestUtil.resetGlobalTracer();
  clientTracer.reset();
  serverTracer.reset();
  // register server tracer to verify active span on server side
  GlobalTracer.registerIfAbsent(serverTracer);
}
 

@Test
public void testExplicitTracer() {
  Tracer tracer = new MockTracer();
  GlobalTracer.registerIfAbsent(tracer);
  Tracer tracer2 = new MockTracer();
  TracingDriver tracingDriver = new TracingDriver();
  tracingDriver.setTracer(tracer2);
  assertEquals(tracer2, tracingDriver.getTracer());
}
 

@Override
protected void run() {
    final Tracer tracer = new JaegerTracer.Builder("tracer-jaxws")
        .withSampler(new ConstSampler(true))
        .withReporter(REPORTER)
        .build();
    GlobalTracer.registerIfAbsent(tracer);

    final JaxWsServerFactoryBean sf = new JaxWsServerFactoryBean();
    sf.setServiceClass(BookStore.class);
    sf.setAddress("http://localhost:" + PORT);
    sf.getFeatures().add(new OpenTracingFeature(tracer));
    server = sf.create();
}
 

@Test
public void testDefaultConfiguration() {
    MockTracer mockTracer = new MockTracer(new ThreadLocalScopeManager(), Propagator.TEXT_MAP);
    GlobalTracer.registerIfAbsent(mockTracer);

    Client client = ClientBuilder.newClient()
            .register(ClientTracingFeature.class);

    Response response = client.target(url("/hello"))
            .request()
            .get();
    response.close();
    assertNoActiveSpan();
    Assert.assertEquals(1, mockTracer.finishedSpans().size());
}
 

/**
 * Agent entry point
 *
 * @param agentArgs The type of tracing which should be initialized
 */
public static void premain(String agentArgs) {
    if ("jaeger".equals(agentArgs)) {
        String jaegerServiceName = System.getenv("JAEGER_SERVICE_NAME");

        if (jaegerServiceName != null) {
            LOGGER.info("Initializing Jaeger tracing with service name {}", jaegerServiceName);
            Tracer tracer = Configuration.fromEnv().getTracer();
            GlobalTracer.registerIfAbsent(tracer);
        } else {
            LOGGER.error("Jaeger tracing cannot be initialized because JAEGER_SERVICE_NAME environment variable is not defined");
        }
    }
}
 

protected Server() throws Exception {
    org.eclipse.jetty.server.Server server = new org.eclipse.jetty.server.Server(9000);

    // Register and map the dispatcher servlet
    final ServletHolder servletHolder = new ServletHolder(new CXFNonSpringJaxrsServlet());
    final ServletContextHandler context = new ServletContextHandler();
    context.setContextPath("/");
    context.addServlet(servletHolder, "/*");

    servletHolder.setInitParameter("javax.ws.rs.Application",
        CatalogApplication.class.getName());

    final Tracer tracer = new Configuration("tracer-server")
        .withSampler(new SamplerConfiguration().withType(ConstSampler.TYPE).withParam(1))
        .withReporter(new ReporterConfiguration().withSender(
            new SenderConfiguration() {
                @Override
                public Sender getSender() {
                    return new Slf4jLogSender();
                }
            }
        ))
        .getTracer();
    GlobalTracer.registerIfAbsent(tracer);
    
    server.setHandler(context);
    server.start();
    server.join();
}
 

private void initTracer() {
  Configuration config =
      new Configuration(_settings.getServiceName())
          .withSampler(new SamplerConfiguration().withType("const").withParam(1))
          .withReporter(
              new ReporterConfiguration()
                  .withSender(
                      SenderConfiguration.fromEnv()
                          .withAgentHost(_settings.getTracingAgentHost())
                          .withAgentPort(_settings.getTracingAgentPort()))
                  .withLogSpans(false));
  GlobalTracer.registerIfAbsent(config.getTracer());
}
 

private void initTracer() {
  Configuration config =
      new Configuration(_settings.getServiceName())
          .withSampler(new SamplerConfiguration().withType("const").withParam(1))
          .withReporter(
              new ReporterConfiguration()
                  .withSender(
                      SenderConfiguration.fromEnv()
                          .withAgentHost(_settings.getTracingAgentHost())
                          .withAgentPort(_settings.getTracingAgentPort()))
                  .withLogSpans(false));
  GlobalTracer.registerIfAbsent(config.getTracer());
}
 

private static void initTracer() {
  Configuration config =
      new Configuration(_settings.getServiceName())
          .withSampler(new SamplerConfiguration().withType("const").withParam(1))
          .withReporter(
              new ReporterConfiguration()
                  .withSender(
                      SenderConfiguration.fromEnv()
                          .withAgentHost(_settings.getTracingAgentHost())
                          .withAgentPort(_settings.getTracingAgentPort()))
                  .withLogSpans(false));
  GlobalTracer.registerIfAbsent(config.getTracer());
}
 

private static void initTracer() {
  io.jaegertracing.Configuration config =
      new io.jaegertracing.Configuration(_mainSettings.getServiceName())
          .withSampler(new SamplerConfiguration().withType("const").withParam(1))
          .withReporter(
              new ReporterConfiguration()
                  .withSender(
                      SenderConfiguration.fromEnv()
                          .withAgentHost(_mainSettings.getTracingAgentHost())
                          .withAgentPort(_mainSettings.getTracingAgentPort()))
                  .withLogSpans(false));
  GlobalTracer.registerIfAbsent(config.getTracer());
}
 

public TracingConfiguration(Tracer tracer) {
    this.tracer = tracer;
    GlobalTracer.registerIfAbsent(tracer);
}
 

@Override
public void tearDown() throws Exception {
    server.destroy();
    GlobalTracer.registerIfAbsent(NoopTracerFactory.create());
}
 

public TracerProvider(Tracer tracer) {
  this.tracer = tracer;
  GlobalTracer.registerIfAbsent(tracer);
}
 

public JaxrsApplication() {
    GlobalTracer.registerIfAbsent(mockTracer);
}
 

@BeforeClass
public static void init() {
  GlobalTracer.registerIfAbsent(mockTracer);
}
 

@BeforeClass
public static void beforeClass() {
  GlobalTracer.registerIfAbsent(tracer = new MockTracer(Propagator.TEXT_MAP));
}