io.opentracing.contrib.redis.common.TracingConfiguration Java Examples

@Test
public void sync() {
  RedisClient client = RedisClient.create("redis://localhost");

  StatefulRedisConnection<String, String> connection =
      new TracingStatefulRedisConnection<>(client.connect(),
          new TracingConfiguration.Builder(mockTracer).build());
  RedisCommands<String, String> commands = connection.sync();

  assertEquals("OK", commands.set("key", "value"));
  assertEquals("value", commands.get("key"));

  connection.close();

  client.shutdown();

  List<MockSpan> spans = mockTracer.finishedSpans();
  assertEquals(2, spans.size());
}
 

public TracingJedisPool(final GenericObjectPoolConfig poolConfig, final String host,
    final int port,
    final int timeout, final String password, final boolean ssl,
    final SSLSocketFactory sslSocketFactory, final SSLParameters sslParameters,
    final HostnameVerifier hostnameVerifier, TracingConfiguration tracingConfiguration) {
  super(poolConfig, host, port, timeout, password, ssl, sslSocketFactory, sslParameters,
      hostnameVerifier);
  this.tracingConfiguration = tracingConfiguration;
}
 

@Test
public void testPoolReturnsTracedJedis() {
  JedisPool pool = new TracingJedisPool(new TracingConfiguration.Builder(mockTracer).build());

  Jedis jedis = pool.getResource();
  assertEquals("OK", jedis.set("key", "value"));
  assertEquals("value", jedis.get("key"));

  jedis.close();

  List<MockSpan> spans = mockTracer.finishedSpans();
  assertEquals(2, spans.size());
}
 

public TracingJedisPool(final GenericObjectPoolConfig poolConfig, final String host,
    final int port, final boolean ssl,
    final SSLSocketFactory sslSocketFactory, final SSLParameters sslParameters,
    final HostnameVerifier hostnameVerifier, TracingConfiguration tracingConfiguration) {
  super(poolConfig, host, port, ssl, sslSocketFactory, sslParameters, hostnameVerifier);
  this.tracingConfiguration = tracingConfiguration;
}
 

public TracingJedisPool(final GenericObjectPoolConfig poolConfig, final String host,
    final int port,
    final int timeout, final String password, final boolean ssl,
    TracingConfiguration tracingConfiguration) {
  super(poolConfig, host, port, timeout, password, ssl);
  this.tracingConfiguration = tracingConfiguration;
}
 

public TracingJedisSentinelPool(TracingConfiguration tracingConfiguration, String masterName,
    Set<String> sentinels,
    final GenericObjectPoolConfig poolConfig, final int connectionTimeout, final int soTimeout,
    final String password, final int database, final String clientName) {
  super(masterName, sentinels, poolConfig, connectionTimeout, soTimeout, password, database,
      clientName);
  this.tracingConfiguration = tracingConfiguration;
}
 

@Test
public void async_continue_span() throws Exception {
  final MockSpan parent = mockTracer.buildSpan("test").start();
  try (Scope ignored = mockTracer.activateSpan(parent)) {
    Span activeSpan = mockTracer.activeSpan();

    RedisClient client = RedisClient.create("redis://localhost");

    StatefulRedisConnection<String, String> connection =
        new TracingStatefulRedisConnection<>(client.connect(),
            new TracingConfiguration.Builder(mockTracer).build());

    RedisAsyncCommands<String, String> commands = connection.async();

    assertEquals("OK",
        commands.set("key2", "value2").toCompletableFuture().thenApply(s -> {
          assertSame(activeSpan, mockTracer.activeSpan());
          return s;
        }).get(15, TimeUnit.SECONDS));

    connection.close();

    client.shutdown();
  }
  parent.finish();
  List<MockSpan> spans = mockTracer.finishedSpans();
  assertEquals(2, spans.size());
}
 

/**
 * @param commands redis async commands
 * @param tracingConfiguration tracing configuration
 */
public TracingRedisAsyncCommands(RedisAsyncCommands<K, V> commands,
    TracingConfiguration tracingConfiguration) {
  this.commands = commands;
  this.tracingConfiguration = tracingConfiguration;
  this.helper = new TracingHelper(tracingConfiguration);
}
 

public TracingJedisPool(final GenericObjectPoolConfig poolConfig, final String host,
    final int port, final int timeout,
    final String password, final int database, final boolean ssl,
    final SSLSocketFactory sslSocketFactory, final SSLParameters sslParameters,
    final HostnameVerifier hostnameVerifier, TracingConfiguration tracingConfiguration) {
  super(poolConfig, host, port, timeout, password, database, ssl, sslSocketFactory, sslParameters,
      hostnameVerifier);
  this.tracingConfiguration = tracingConfiguration;
}
 

@Test
public void shouldReturnResourceToThePoolAndStayConnected() {
  //given
  TracingJedisPool pool = new TracingJedisPool(
      new TracingConfiguration.Builder(mockTracer).build());
  Jedis resource = pool.getResource();
  assertTrue(resource.isConnected());

  //when
  pool.returnResource(resource);

  //then
  assertTrue(resource.isConnected());
}
 

@Test
public void async_continue_span() throws Exception {
  final MockSpan parent = mockTracer.buildSpan("test").start();
  try (Scope ignored = mockTracer.activateSpan(parent)) {
    Span activeSpan = mockTracer.activeSpan();

    RedisClient client = RedisClient.create("redis://localhost");

    StatefulRedisConnection<String, String> connection =
        new TracingStatefulRedisConnection<>(client.connect(),
            new TracingConfiguration.Builder(mockTracer).build());

    RedisAsyncCommands<String, String> commands = connection.async();

    assertEquals("OK",
        commands.set("key2", "value2").toCompletableFuture().thenApply(s -> {
          assertSame(activeSpan, mockTracer.activeSpan());
          return s;
        }).get(15, TimeUnit.SECONDS));

    connection.close();

    client.shutdown();
  }
  parent.finish();
  List<MockSpan> spans = mockTracer.finishedSpans();
  assertEquals(2, spans.size());
}
 

@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
  if (bean instanceof RedisConnectionFactory) {
    bean = new TracingRedisConnectionFactory((RedisConnectionFactory) bean,
        new TracingConfiguration.Builder(tracer).traceWithActiveSpanOnly(false).build());
  }
  return bean;
}
 

public TracingRedisAdvancedClusterCommands(RedisAdvancedClusterCommands<K, V> commands,
    TracingConfiguration tracingConfiguration) {

  this.commands = commands;
  this.helper = new TracingHelper(tracingConfiguration);
  this.tracingConfiguration = tracingConfiguration;
}
 

public TracingJedisSentinelPool(TracingConfiguration tracingConfiguration, String masterName,
    Set<String> sentinels,
    final GenericObjectPoolConfig poolConfig, int timeout, final String password,
    final int database, final String clientName) {
  super(masterName, sentinels, poolConfig, timeout, timeout, password, database, clientName);
  this.tracingConfiguration = tracingConfiguration;
}
 

public TracingJedisPool(final GenericObjectPoolConfig poolConfig, final String host,
    final int port, final int timeout,
    final String password, final int database, final String clientName, final boolean ssl,
    TracingConfiguration tracingConfiguration) {
  super(poolConfig, host, port, timeout, password, database, clientName, ssl);
  this.tracingConfiguration = tracingConfiguration;
}
 

/**
 * @param commands redis async commands
 * @param tracingConfiguration tracing configuration
 */
public TracingRedisAsyncCommands(RedisAsyncCommands<K, V> commands,
    TracingConfiguration tracingConfiguration) {
  this.commands = commands;
  this.tracingConfiguration = tracingConfiguration;
  this.helper = new TracingHelper(tracingConfiguration);
}
 

public TracingJedisWrapper(final String host, final int port, final int connectionTimeout,
    final int soTimeout,
    final boolean ssl, final SSLSocketFactory sslSocketFactory, final SSLParameters sslParameters,
    final HostnameVerifier hostnameVerifier, TracingConfiguration tracingConfiguration) {
  this.wrapped = new TracingJedisWrapper(
      new Jedis(host, port, connectionTimeout, soTimeout, ssl, sslSocketFactory, sslParameters,
          hostnameVerifier), tracingConfiguration);
  this.helper = new TracingHelper(tracingConfiguration);
}
 

public TracingJedisPool(final GenericObjectPoolConfig poolConfig, final URI uri,
    final int timeout,
    final SSLSocketFactory sslSocketFactory, final SSLParameters sslParameters,
    final HostnameVerifier hostnameVerifier, TracingConfiguration tracingConfiguration) {
  super(poolConfig, uri, timeout, sslSocketFactory, sslParameters, hostnameVerifier);
  this.tracingConfiguration = tracingConfiguration;
}
 

public TracingJedisPool(final GenericObjectPoolConfig poolConfig, final String host,
    final int port, final int timeout,
    final boolean ssl, final SSLSocketFactory sslSocketFactory, final SSLParameters sslParameters,
    final HostnameVerifier hostnameVerifier, TracingConfiguration tracingConfiguration) {
  super(poolConfig, host, port, timeout, ssl, sslSocketFactory, sslParameters, hostnameVerifier);
  this.tracingConfiguration = tracingConfiguration;
}
 

@Bean
public RedisConnectionFactory redisConnectionFactory() {
  RedisConnectionFactory factory = mock(RedisConnectionFactory.class);
  when(factory.getConnection())
      .thenReturn(new TracingRedisConnection(mockRedisConnection(),
          new TracingConfiguration.Builder(mockTracer()).traceWithActiveSpanOnly(false).build()));
  when(factory.getClusterConnection()).thenReturn(
      new TracingRedisClusterConnection(mockRedisClusterConnection(),
          new TracingConfiguration.Builder(mockTracer()).traceWithActiveSpanOnly(false).build()));
  return factory;
}
 

public TracingJedisPool(final GenericObjectPoolConfig poolConfig, final String host,
    final int port,
    final int timeout, final String password,
    TracingConfiguration tracingConfiguration) {
  super(poolConfig, host, port, timeout, password);
  this.tracingConfiguration = tracingConfiguration;
}
 

public TracingJedisPool(final GenericObjectPoolConfig poolConfig, final String host,
    final int port,
    final int connectionTimeout, final int soTimeout, final String password, final int database,
    final String clientName, final boolean ssl, final SSLSocketFactory sslSocketFactory,
    final SSLParameters sslParameters, final HostnameVerifier hostnameVerifier,
    TracingConfiguration tracingConfiguration) {

  super(poolConfig, host, port, connectionTimeout, soTimeout, password, database, clientName, ssl,
      sslSocketFactory, sslParameters, hostnameVerifier);
  this.tracingConfiguration = tracingConfiguration;
}
 

@Bean
public RedisConnectionFactory redisConnectionFactory() {
  LettuceConnectionFactory lettuceConnectionFactory = new LettuceConnectionFactory();
  lettuceConnectionFactory.afterPropertiesSet();
  return new TracingRedisConnectionFactory(lettuceConnectionFactory,
      new TracingConfiguration.Builder(tracer()).build());
}
 

public TracingJedisCluster(Set<HostAndPort> jedisClusterNode, int connectionTimeout,
    int soTimeout,
    int maxAttempts, String password, GenericObjectPoolConfig poolConfig,
    TracingConfiguration tracingConfiguration) {
  super(jedisClusterNode, connectionTimeout, soTimeout, maxAttempts, password, poolConfig);
  this.helper = new TracingHelper(tracingConfiguration);
}
 

@Test
public void test_config_span_name() throws Exception {
  Config config = new Config();
  config.useSingleServer().setAddress("redis://127.0.0.1:6379");

  RedissonClient customClient = new TracingRedissonClient(Redisson.create(config),
      new TracingConfiguration.Builder(tracer)
          .traceWithActiveSpanOnly(true)
          .withSpanNameProvider(operation -> "Redis." + operation)
          .build());

  final MockSpan parent = tracer.buildSpan("test").start();
  try (Scope ignore = tracer.activateSpan(parent)) {
    RMap<String, String> map = customClient.getMap("map_config_span_name");
    map.getAsync("key").get(15, TimeUnit.SECONDS);
  }
  parent.finish();

  await().atMost(15, TimeUnit.SECONDS).until(reportedSpansSize(), equalTo(2));

  List<MockSpan> spans = tracer.finishedSpans();
  assertEquals(2, spans.size());
  MockSpan redisSpan = spans.get(0);
  assertEquals("Redis.getAsync", redisSpan.operationName());

  assertNull(tracer.activeSpan());
  customClient.shutdown();
}
 

public TracingJedisSentinelPool(TracingConfiguration tracingConfiguration, String masterName,
    Set<String> sentinels,
    final GenericObjectPoolConfig poolConfig, int timeout, final String password,
    final int database, Function<String, String> customSpanName) {
  super(masterName, sentinels, poolConfig, timeout, timeout, password, database);
  this.tracingConfiguration = tracingConfiguration;
}
 

@Test
public void shouldReturnResourceToThePoolOnCloseAndStayConnected() {
  //given
  JedisPool pool = new TracingJedisPool(new TracingConfiguration.Builder(mockTracer).build());
  Jedis resource = pool.getResource();
  assertTrue(resource.isConnected());

  //when
  resource.close();

  //then - valid resource should not be destroyed but returned to pool & stay connected for at least {@link BaseGenericObjectPool#getMinEvictableIdleTimeMillis()}
  assertTrue(resource.isConnected());
}
 

public TracingJedisPool(final GenericObjectPoolConfig poolConfig, final String host,
    final int port, final int timeout,
    final String password, final int database, final String clientName, final boolean ssl,
    TracingConfiguration tracingConfiguration) {
  super(poolConfig, host, port, timeout, password, database, clientName, ssl);
  this.tracingConfiguration = tracingConfiguration;
}
 

public TracingJedisCluster(Set<HostAndPort> jedisClusterNode, int connectionTimeout,
    int soTimeout, int maxAttempts,
    GenericObjectPoolConfig poolConfig, TracingConfiguration tracingConfiguration,
    Function<String, String> customSpanNameProvider) {
  super(jedisClusterNode, connectionTimeout, soTimeout, maxAttempts, poolConfig);
  this.helper = new TracingHelper(tracingConfiguration);
}
 

public TracingJedisCluster(Set<HostAndPort> jedisClusterNode, int connectionTimeout,
    int soTimeout,
    int maxAttempts, GenericObjectPoolConfig poolConfig,
    TracingConfiguration tracingConfiguration) {
  super(jedisClusterNode, connectionTimeout, soTimeout, maxAttempts, poolConfig);
  this.helper = new TracingHelper(tracingConfiguration);
}