Merge 43e0556 into cf94fb0

opentracing-contrib · Oct 30, 2018 · c1163ef · c1163ef
2 parents cf94fb0 + 43e0556
commit c1163ef
Show file tree

Hide file tree

Showing 8 changed files with 189 additions and 66 deletions.
diff --git a/...racing-redis-common/src/main/java/io/opentracing/contrib/redis/common/ThrowingAction.java b/...racing-redis-common/src/main/java/io/opentracing/contrib/redis/common/ThrowingAction.java
@@ -0,0 +1,20 @@
+/*
+ * Copyright 2017-2018 The OpenTracing Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+ * or implied. See the License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package io.opentracing.contrib.redis.common;
+
+@FunctionalInterface
+public interface ThrowingAction<T extends Exception> {
+
+  void execute() throws T;
+}
diff --git a/...tracing-redis-common/src/main/java/io/opentracing/contrib/redis/common/TracingHelper.java b/...tracing-redis-common/src/main/java/io/opentracing/contrib/redis/common/TracingHelper.java
@@ -13,11 +13,13 @@
  */
 package io.opentracing.contrib.redis.common;
 
+import io.opentracing.Scope;
 import io.opentracing.Span;
 import io.opentracing.Tracer;
 import io.opentracing.Tracer.SpanBuilder;
 import io.opentracing.noop.NoopSpan;
 import io.opentracing.tag.Tags;
+import io.opentracing.util.GlobalTracer;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
@@ -26,6 +28,7 @@
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.function.Function;
+import java.util.function.Supplier;
 
 
 public class TracingHelper {
@@ -48,43 +51,54 @@ public TracingHelper(Tracer tracer, boolean traceWithActiveSpanOnly,
     this.spanNameProvider = spanNameProvider;
   }
 
-
-  private SpanBuilder builder(String operationName) {
-    return tracer.buildSpan(this.spanNameProvider.apply(operationName))
+  private static SpanBuilder builder(String operationName, Tracer tracer,
+      Function<String, String> spanNameProvider) {
+    return getNullSafeTracer(tracer).buildSpan(spanNameProvider.apply(operationName))
         .withTag(Tags.COMPONENT.getKey(), COMPONENT_NAME)
         .withTag(Tags.SPAN_KIND.getKey(), Tags.SPAN_KIND_CLIENT)
         .withTag(Tags.DB_TYPE.getKey(), "redis");
   }
 
+  public static Span buildSpan(String operationName, boolean traceWithActiveSpanOnly,
+      Tracer tracer) {
+    if (traceWithActiveSpanOnly && getNullSafeTracer(tracer).activeSpan() == null) {
+      return NoopSpan.INSTANCE;
+    } else {
+      return builder(operationName, tracer, RedisSpanNameProvider.OPERATION_NAME).start();
+    }
+  }
+
   public Span buildSpan(String operationName) {
-    if (traceWithActiveSpanOnly && tracer.activeSpan() == null) {
+    if (traceWithActiveSpanOnly && getNullSafeTracer(tracer).activeSpan() == null) {
       return NoopSpan.INSTANCE;
     } else {
-      return builder(operationName).start();
+      return builder(operationName, tracer, spanNameProvider).start();
     }
   }
 
   public Span buildSpan(String operationName, Object key) {
-    if (traceWithActiveSpanOnly && tracer.activeSpan() == null) {
+    if (traceWithActiveSpanOnly && getNullSafeTracer(tracer).activeSpan() == null) {
       return NoopSpan.INSTANCE;
     } else {
-      return builder(operationName).withTag("key", nullable(key)).start();
+      return builder(operationName, tracer, spanNameProvider).withTag("key", nullable(key)).start();
     }
   }
 
   public Span buildSpan(String operationName, byte[] key) {
-    if (traceWithActiveSpanOnly && tracer.activeSpan() == null) {
+    if (traceWithActiveSpanOnly && getNullSafeTracer(tracer).activeSpan() == null) {
       return NoopSpan.INSTANCE;
     } else {
-      return builder(operationName).withTag("key", Arrays.toString(key)).start();
+      return builder(operationName, tracer, spanNameProvider).withTag("key", Arrays.toString(key))
+          .start();
     }
   }
 
   public Span buildSpan(String operationName, Object[] keys) {
-    if (traceWithActiveSpanOnly && tracer.activeSpan() == null) {
+    if (traceWithActiveSpanOnly && getNullSafeTracer(tracer).activeSpan() == null) {
       return NoopSpan.INSTANCE;
     } else {
-      return builder(operationName).withTag("keys", Arrays.toString(keys)).start();
+      return builder(operationName, tracer, spanNameProvider).withTag("keys", Arrays.toString(keys))
+          .start();
     }
   }
 
@@ -176,4 +190,56 @@ public static <V> String toStringMap2(Map<byte[], V> map) {
 
     return "{" + String.join(", ", list) + "}";
   }
+
+  public static Tracer getNullSafeTracer(final Tracer tracer) {
+    if (tracer == null) {
+      return GlobalTracer.get();
+    }
+    return tracer;
+  }
+
+  public static <T extends Exception> void doInScopeExceptionally(String operationName,
+      ThrowingAction<T> action,
+      boolean traceWithActiveSpanOnly, Tracer tracer)
+      throws T {
+    Span span = buildSpan(operationName, traceWithActiveSpanOnly, tracer);
+    try (Scope ignore = GlobalTracer.get().scopeManager().activate(span, false)) {
+      action.execute();
+    } catch (Exception e) {
+      onError(e, span);
+      throw e;
+    } finally {
+      span.finish();
+    }
+  }
+
+  public static void doInScope(String operationName, Runnable action,
+      boolean traceWithActiveSpanOnly, Tracer tracer) {
+    Span span = buildSpan(operationName, traceWithActiveSpanOnly, tracer);
+    try (Scope ignore = GlobalTracer.get().scopeManager().activate(span, false)) {
+      action.run();
+    } catch (Exception e) {
+      onError(e, span);
+      throw e;
+    } finally {
+      span.finish();
+    }
+  }
+
+  public static <T> T doInScope(String operationName, Supplier<T> action,
+      boolean traceWithActiveSpanOnly, Tracer tracer) {
+    Span span = buildSpan(operationName, traceWithActiveSpanOnly, tracer);
+    return doInScope(span, action);
+  }
+
+  public static <T> T doInScope(Span span, Supplier<T> action) {
+    try (Scope ignore = GlobalTracer.get().scopeManager().activate(span, false)) {
+      return action.get();
+    } catch (Exception e) {
+      onError(e, span);
+      throw e;
+    } finally {
+      span.finish();
+    }
+  }
 }
diff --git a/opentracing-redis-jedis/src/main/java/io/opentracing/contrib/redis/jedis/TracingJedis.java b/opentracing-redis-jedis/src/main/java/io/opentracing/contrib/redis/jedis/TracingJedis.java
@@ -207,14 +207,7 @@ public TracingJedis(final URI uri, final int connectionTimeout, final int soTime
   public String set(String key, String value) {
     Span span = helper.buildSpan("set", key);
     span.setTag("value", value);
-    try {
-      return super.set(key, value);
-    } catch (Exception e) {
-      onError(e, span);
-      throw e;
-    } finally {
-      span.finish();
-    }
+    return TracingHelper.doInScope(span, () -> super.set(key, value));
   }
 
   @Override
@@ -237,14 +230,7 @@ public String set(String key, String value, String nxxx, String expx, long time)
   @Override
   public String get(String key) {
     Span span = helper.buildSpan("get", key);
-    try {
-      return super.get(key);
-    } catch (Exception e) {
-      onError(e, span);
-      throw e;
-    } finally {
-      span.finish();
-    }
+    return TracingHelper.doInScope(span, () -> super.get(key));
   }
 
   @Override
@@ -6139,41 +6125,20 @@ public String slowlogReset() {
   @Override
   public Long slowlogLen() {
     Span span = helper.buildSpan("slowlogLen");
-    try {
-      return super.slowlogLen();
-    } catch (Exception e) {
-      onError(e, span);
-      throw e;
-    } finally {
-      span.finish();
-    }
+    return TracingHelper.doInScope(span, super::slowlogLen);
   }
 
   @Override
   public List<byte[]> slowlogGetBinary() {
     Span span = helper.buildSpan("slowlogGetBinary");
-    try {
-      return super.slowlogGetBinary();
-    } catch (Exception e) {
-      onError(e, span);
-      throw e;
-    } finally {
-      span.finish();
-    }
+    return TracingHelper.doInScope(span, super::slowlogGetBinary);
   }
 
   @Override
   public List<byte[]> slowlogGetBinary(long entries) {
     Span span = helper.buildSpan("slowlogGetBinary");
     span.setTag("entries", entries);
-    try {
-      return super.slowlogGetBinary(entries);
-    } catch (Exception e) {
-      onError(e, span);
-      throw e;
-    } finally {
-      span.finish();
-    }
+    return TracingHelper.doInScope(span, () -> super.slowlogGetBinary(entries));
   }
 
   @Override

diff --git a/...pring/src/main/java/io/opentracing/contrib/redis/spring/connection/RedisTracingUtils.java b/...pring/src/main/java/io/opentracing/contrib/redis/spring/connection/RedisTracingUtils.java
@@ -13,14 +13,15 @@
  */
 package io.opentracing.contrib.redis.spring.connection;
 
+import static io.opentracing.contrib.redis.common.TracingHelper.getNullSafeTracer;
+
 import io.opentracing.Scope;
 import io.opentracing.Span;
 import io.opentracing.Tracer;
 import io.opentracing.contrib.redis.common.TracingHelper;
 import io.opentracing.noop.NoopScopeManager.NoopScope;
 import io.opentracing.tag.StringTag;
 import io.opentracing.tag.Tags;
-import io.opentracing.util.GlobalTracer;
 import java.util.function.Supplier;
 
 
@@ -67,13 +68,6 @@ private static Scope buildScope(String command, boolean withActiveSpanOnly,
     return scope;
   }
 
-  private static Tracer getNullSafeTracer(final Tracer tracer) {
-    if (tracer == null) {
-      return GlobalTracer.get();
-    }
-    return tracer;
-  }
-
   private static void decorate(Span span, String command) {
     Tags.COMPONENT.set(span, TracingHelper.COMPONENT_NAME);
     COMMAND_TAG.set(span, command);

diff --git a/.../src/main/java/io/opentracing/contrib/redis/spring/connection/TracingRedisConnection.java b/.../src/main/java/io/opentracing/contrib/redis/spring/connection/TracingRedisConnection.java
@@ -178,7 +178,8 @@ public Subscription getSubscription() {
 
   @Override
   public RedisSentinelConnection getSentinelConnection() {
-    return connection.getSentinelConnection();
+    return new TracingRedisSentinelConnection(connection.getSentinelConnection(),
+        withActiveSpanOnly, tracer);
   }
 
   @Override

diff --git a/...in/java/io/opentracing/contrib/redis/spring/connection/TracingRedisConnectionFactory.java b/...in/java/io/opentracing/contrib/redis/spring/connection/TracingRedisConnectionFactory.java
@@ -63,7 +63,8 @@ public boolean getConvertPipelineAndTxResults() {
 
   @Override
   public RedisSentinelConnection getSentinelConnection() {
-    return delegate.getSentinelConnection();
+    return new TracingRedisSentinelConnection(delegate.getSentinelConnection(), withActiveSpanOnly,
+        tracer);
   }
 
   @Override

diff --git a/...n/java/io/opentracing/contrib/redis/spring/connection/TracingRedisSentinelConnection.java b/...n/java/io/opentracing/contrib/redis/spring/connection/TracingRedisSentinelConnection.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright 2017-2018 The OpenTracing Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+ * or implied. See the License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package io.opentracing.contrib.redis.spring.connection;
+
+import static io.opentracing.contrib.redis.spring.connection.RedisTracingUtils.doInScope;
+
+import io.opentracing.Tracer;
+import io.opentracing.contrib.redis.common.TracingHelper;
+import java.io.IOException;
+import java.util.Collection;
+import org.springframework.data.redis.connection.NamedNode;
+import org.springframework.data.redis.connection.RedisSentinelConnection;
+import org.springframework.data.redis.connection.RedisServer;
+
+public class TracingRedisSentinelConnection implements RedisSentinelConnection {
+  private final RedisSentinelConnection redisSentinelConnection;
+  private final boolean withActiveSpanOnly;
+  private final Tracer tracer;
+
+  public TracingRedisSentinelConnection(
+      RedisSentinelConnection redisSentinelConnection, boolean withActiveSpanOnly,
+      Tracer tracer) {
+    this.redisSentinelConnection = redisSentinelConnection;
+    this.withActiveSpanOnly = withActiveSpanOnly;
+    this.tracer = tracer;
+  }
+
+  @Override
+  public boolean isOpen() {
+    return doInScope("isOpen", redisSentinelConnection::isOpen, withActiveSpanOnly, tracer);
+  }
+
+  @Override
+  public void failover(NamedNode master) {
+    TracingHelper.doInScope("failover", () -> redisSentinelConnection.failover(master),
+        withActiveSpanOnly, tracer);
+  }
+
+  @Override
+  public Collection<RedisServer> masters() {
+    return TracingHelper.doInScope("masters", redisSentinelConnection::masters,
+        withActiveSpanOnly, tracer);
+  }
+
+  @Override
+  public Collection<RedisServer> slaves(
+      NamedNode master) {
+    return TracingHelper.doInScope("slaves", () -> redisSentinelConnection.slaves(master),
+        withActiveSpanOnly, tracer);
+  }
+
+  @Override
+  public void remove(NamedNode master) {
+    TracingHelper.doInScope("remove", () -> redisSentinelConnection.remove(master),
+        withActiveSpanOnly, tracer);
+  }
+
+  @Override
+  public void monitor(RedisServer master) {
+    TracingHelper.doInScope("monitor", () -> redisSentinelConnection.monitor(master),
+        withActiveSpanOnly, tracer);
+  }
+
+  @Override
+  public void close() throws IOException {
+    TracingHelper.doInScopeExceptionally("close", redisSentinelConnection::close,
+        withActiveSpanOnly, tracer);
+  }
+}
diff --git a/...ava/io/opentracing/contrib/redis/spring/connection/TracingRedisConnectionFactoryTest.java b/...ava/io/opentracing/contrib/redis/spring/connection/TracingRedisConnectionFactoryTest.java
@@ -13,11 +13,9 @@
  */
 package io.opentracing.contrib.redis.spring.connection;
 
-import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
 
 import io.opentracing.Tracer;
 import org.junit.Before;
@@ -70,11 +68,9 @@ public void delegatesCallToGetConvertPipelineAndTxResults() {
 
   @Test
   public void delegatesCallToGetSentinelConnection() {
-    RedisSentinelConnection sentinelConnection = mock(RedisSentinelConnection.class);
-    when(connectionFactory.getSentinelConnection()).thenReturn(sentinelConnection);
     RedisSentinelConnection connection = connectionFactory.getSentinelConnection();
     verify(delegate).getSentinelConnection();
-    assertEquals(sentinelConnection, connection);
+    assertTrue(connection instanceof TracingRedisSentinelConnection);
   }
 
   @Test