Merge 9c0fdf2 into 1cd8a4a

opentracing-contrib · Aug 29, 2018 · b0b6e66 · b0b6e66
2 parents 1cd8a4a + 9c0fdf2
commit b0b6e66
Show file tree

Hide file tree

Showing 5 changed files with 113 additions and 48 deletions.
diff --git a/src/main/java/io/opentracing/contrib/jdbc/JdbcTracingUtils.java b/src/main/java/io/opentracing/contrib/jdbc/JdbcTracingUtils.java
@@ -19,36 +19,62 @@
 import io.opentracing.noop.NoopScopeManager.NoopScope;
 import io.opentracing.tag.Tags;
 import io.opentracing.util.GlobalTracer;
+
 import java.util.Set;
 
 
 class JdbcTracingUtils {
 
-  static final String COMPONENT_NAME = "java-jdbc";
+    static final String COMPONENT_NAME = "java-jdbc";
 
-  static Scope buildScope(String operationName, String sql, String dbType, String dbUser,
-      boolean withActiveSpanOnly, Set<String> ignoredStatements) {
-    if (withActiveSpanOnly && GlobalTracer.get().activeSpan() == null) {
-      return NoopScope.INSTANCE;
-    } else if (ignoredStatements != null && ignoredStatements.contains(sql)) {
-      return NoopScope.INSTANCE;
+    static Scope buildScope(String operationName,
+                            String sql,
+                            String dbType,
+                            String dbUser,
+                            boolean withActiveSpanOnly,
+                            Set<String> ignoredStatements) {
+        return buildScope(operationName, sql, dbType, dbUser, withActiveSpanOnly, ignoredStatements, null);
     }
 
-    Tracer.SpanBuilder spanBuilder = GlobalTracer.get().buildSpan(operationName)
-        .withTag(Tags.SPAN_KIND.getKey(), Tags.SPAN_KIND_CLIENT);
+    static Scope buildScope(String operationName,
+                            String sql,
+                            String dbType,
+                            String dbUser,
+                            boolean withActiveSpanOnly,
+                            Set<String> ignoredStatements,
+                            Tracer tracer) {
+        Tracer currentTracer = getNullsafeTracer(tracer);
+        if (withActiveSpanOnly && currentTracer.activeSpan() == null) {
+            return NoopScope.INSTANCE;
+        } else if (ignoredStatements != null && ignoredStatements.contains(sql)) {
+            return NoopScope.INSTANCE;
+        }
+
+        Tracer.SpanBuilder spanBuilder = currentTracer.buildSpan(operationName)
+                                                      .withTag(Tags.SPAN_KIND.getKey(), Tags.SPAN_KIND_CLIENT);
 
-    Scope scope = spanBuilder.startActive(true);
-    decorate(scope.span(), sql, dbType, dbUser);
+        Scope scope = spanBuilder.startActive(true);
+        decorate(scope.span(), sql, dbType, dbUser);
 
-    return scope;
-  }
+        return scope;
+    }
+
+    private static Tracer getNullsafeTracer(final Tracer tracer) {
+        if (tracer == null) {
+            return GlobalTracer.get();
+        }
+        return tracer;
+    }
 
-  private static void decorate(Span span, String sql, String dbType, String dbUser) {
-    Tags.COMPONENT.set(span, COMPONENT_NAME);
-    Tags.DB_STATEMENT.set(span, sql);
-    Tags.DB_TYPE.set(span, dbType);
-    if (dbUser != null) {
-      Tags.DB_USER.set(span, dbUser);
+    private static void decorate(Span span,
+                                 String sql,
+                                 String dbType,
+                                 String dbUser) {
+        Tags.COMPONENT.set(span, COMPONENT_NAME);
+        Tags.DB_STATEMENT.set(span, sql);
+        Tags.DB_TYPE.set(span, dbType);
+        if (dbUser != null) {
+            Tags.DB_USER.set(span, dbUser);
+        }
     }
-  }
 }
diff --git a/src/main/java/io/opentracing/contrib/jdbc/TracingCallableStatement.java b/src/main/java/io/opentracing/contrib/jdbc/TracingCallableStatement.java
@@ -13,6 +13,8 @@
  */
 package io.opentracing.contrib.jdbc;
 
+import io.opentracing.Tracer;
+
 import java.io.InputStream;
 import java.io.Reader;
 import java.math.BigDecimal;
@@ -40,8 +42,13 @@ public class TracingCallableStatement extends TracingPreparedStatement implement
   private final CallableStatement statement;
 
   public TracingCallableStatement(CallableStatement statement, String query, String dbType,
-      String dbUser, boolean withActiveSpanOnly, Set<String> ignoredStatements) {
-    super(statement, query, dbType, dbUser, withActiveSpanOnly, ignoredStatements);
+                                  String dbUser, boolean withActiveSpanOnly, Set<String> ignoredStatements) {
+    this(statement, query, dbType, dbUser, withActiveSpanOnly, ignoredStatements, null);
+  }
+
+  public TracingCallableStatement(CallableStatement statement, String query, String dbType,
+                                  String dbUser, boolean withActiveSpanOnly, Set<String> ignoredStatements, Tracer tracer) {
+    super(statement, query, dbType, dbUser, withActiveSpanOnly, ignoredStatements, tracer);
     this.statement = statement;
   }
 

diff --git a/src/main/java/io/opentracing/contrib/jdbc/TracingConnection.java b/src/main/java/io/opentracing/contrib/jdbc/TracingConnection.java
@@ -14,6 +14,8 @@
 package io.opentracing.contrib.jdbc;
 
 
+import io.opentracing.Tracer;
+
 import java.sql.Array;
 import java.sql.Blob;
 import java.sql.CallableStatement;
@@ -41,25 +43,32 @@ public class TracingConnection implements Connection {
   private final String dbUser;
   private final boolean withActiveSpanOnly;
   private final Set<String> ignoredStatements;
+  private final Tracer tracer;
 
   public TracingConnection(Connection connection, String dbType, String dbUser,
-      boolean withActiveSpanOnly, Set<String> ignoredStatements) {
+                           boolean withActiveSpanOnly, Set<String> ignoredStatements) {
+    this(connection, dbType, dbUser, withActiveSpanOnly, ignoredStatements, null);
+  }
+
+  public TracingConnection(Connection connection, String dbType, String dbUser,
+                           boolean withActiveSpanOnly, Set<String> ignoredStatements, Tracer tracer) {
     this.connection = connection;
     this.dbType = dbType;
     this.dbUser = dbUser;
     this.withActiveSpanOnly = withActiveSpanOnly;
     this.ignoredStatements = ignoredStatements;
+    this.tracer = tracer;
   }
 
   @Override
   public Statement createStatement() throws SQLException {
-    return new TracingStatement(connection.createStatement(), dbType, dbUser, withActiveSpanOnly, ignoredStatements);
+    return new TracingStatement(connection.createStatement(), dbType, dbUser, withActiveSpanOnly, ignoredStatements, tracer);
   }
 
   @Override
   public PreparedStatement prepareStatement(String sql) throws SQLException {
     return new TracingPreparedStatement(connection.prepareStatement(sql), sql, dbType, dbUser,
-        withActiveSpanOnly, ignoredStatements);
+        withActiveSpanOnly, ignoredStatements, tracer);
   }
 
   @Override
@@ -160,7 +169,7 @@ public PreparedStatement prepareStatement(String sql, int resultSetType, int res
       throws SQLException {
     return new TracingPreparedStatement(
         connection.prepareStatement(sql, resultSetType, resultSetConcurrency), sql, dbType, dbUser,
-        withActiveSpanOnly, ignoredStatements);
+        withActiveSpanOnly, ignoredStatements, tracer);
   }
 
   @Override
@@ -224,33 +233,33 @@ public PreparedStatement prepareStatement(String sql, int resultSetType, int res
       int resultSetHoldability) throws SQLException {
     return new TracingPreparedStatement(
         connection.prepareStatement(sql, resultSetType, resultSetConcurrency, resultSetHoldability),
-        sql, dbType, dbUser, withActiveSpanOnly, ignoredStatements);
+        sql, dbType, dbUser, withActiveSpanOnly, ignoredStatements, tracer);
   }
 
   @Override
   public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency,
       int resultSetHoldability) throws SQLException {
     return new TracingCallableStatement(
         connection.prepareCall(sql, resultSetType, resultSetConcurrency, resultSetHoldability), sql,
-        dbType, dbUser, withActiveSpanOnly, ignoredStatements);
+        dbType, dbUser, withActiveSpanOnly, ignoredStatements, tracer);
   }
 
   @Override
   public PreparedStatement prepareStatement(String sql, int autoGeneratedKeys) throws SQLException {
     return new TracingPreparedStatement(connection.prepareStatement(sql, autoGeneratedKeys), sql,
-        dbType, dbUser, withActiveSpanOnly, ignoredStatements);
+        dbType, dbUser, withActiveSpanOnly, ignoredStatements, tracer);
   }
 
   @Override
   public PreparedStatement prepareStatement(String sql, int[] columnIndexes) throws SQLException {
     return new TracingPreparedStatement(connection.prepareStatement(sql, columnIndexes), sql,
-        dbType, dbUser, withActiveSpanOnly, ignoredStatements);
+        dbType, dbUser, withActiveSpanOnly, ignoredStatements, tracer);
   }
 
   @Override
   public PreparedStatement prepareStatement(String sql, String[] columnNames) throws SQLException {
     return new TracingPreparedStatement(connection.prepareStatement(sql, columnNames), sql, dbType,
-        dbUser, withActiveSpanOnly, ignoredStatements);
+        dbUser, withActiveSpanOnly, ignoredStatements, tracer);
   }
 
   @Override

diff --git a/src/main/java/io/opentracing/contrib/jdbc/TracingPreparedStatement.java b/src/main/java/io/opentracing/contrib/jdbc/TracingPreparedStatement.java
@@ -17,6 +17,8 @@
 import static io.opentracing.contrib.jdbc.JdbcTracingUtils.buildScope;
 
 import io.opentracing.Scope;
+import io.opentracing.Tracer;
+
 import java.io.InputStream;
 import java.io.Reader;
 import java.math.BigDecimal;
@@ -47,28 +49,35 @@ public class TracingPreparedStatement extends TracingStatement implements Prepar
   private final String dbUser;
   private final boolean withActiveSpanOnly;
   private final Set<String> ignoredQueries;
+  private final Tracer tracer;
+
+  public TracingPreparedStatement(PreparedStatement preparedStatement, String query, String dbType,
+                                  String dbUser, boolean withActiveSpanOnly, Set<String> ignoredStatements) {
+    this(preparedStatement, query, dbType, dbUser, withActiveSpanOnly, ignoredStatements, null);
+  }
 
   public TracingPreparedStatement(PreparedStatement preparedStatement, String query, String dbType,
-     String dbUser, boolean withActiveSpanOnly, Set<String> ignoredStatements) {
+                                  String dbUser, boolean withActiveSpanOnly, Set<String> ignoredStatements, Tracer tracer) {
     super(preparedStatement, query, dbType, dbUser, withActiveSpanOnly, ignoredStatements);
     this.preparedStatement = preparedStatement;
     this.query = query;
     this.dbType = dbType;
     this.dbUser = dbUser;
     this.withActiveSpanOnly = withActiveSpanOnly;
     this.ignoredQueries = ignoredStatements;
+    this.tracer = tracer;
   }
 
   @Override
   public ResultSet executeQuery() throws SQLException {
-    try (Scope ignored = buildScope("Query", query, dbType, dbUser, withActiveSpanOnly, ignoredQueries)) {
+    try (Scope ignored = buildScope("Query", query, dbType, dbUser, withActiveSpanOnly, ignoredQueries, tracer)) {
       return preparedStatement.executeQuery();
     }
   }
 
   @Override
   public int executeUpdate() throws SQLException {
-    try (Scope ignored = buildScope("Update", query, dbType, dbUser, withActiveSpanOnly, ignoredQueries)) {
+    try (Scope ignored = buildScope("Update", query, dbType, dbUser, withActiveSpanOnly, ignoredQueries, tracer)) {
       return preparedStatement.executeUpdate();
     }
   }
@@ -176,7 +185,7 @@ public void setObject(int parameterIndex, Object x) throws SQLException {
 
   @Override
   public boolean execute() throws SQLException {
-    try (Scope ignored = buildScope("Execute", query, dbType, dbUser, withActiveSpanOnly, ignoredQueries)) {
+    try (Scope ignored = buildScope("Execute", query, dbType, dbUser, withActiveSpanOnly, ignoredQueries, tracer)) {
       return preparedStatement.execute();
     }
   }

diff --git a/src/main/java/io/opentracing/contrib/jdbc/TracingStatement.java b/src/main/java/io/opentracing/contrib/jdbc/TracingStatement.java
@@ -17,6 +17,8 @@
 import static io.opentracing.contrib.jdbc.JdbcTracingUtils.buildScope;
 
 import io.opentracing.Scope;
+import io.opentracing.Tracer;
+
 import java.sql.Connection;
 import java.sql.ResultSet;
 import java.sql.SQLException;
@@ -34,32 +36,44 @@ public class TracingStatement implements Statement {
   private final String dbUser;
   private final boolean withActiveSpanOnly;
   private final Set<String> ignoredStatements;
+  private Tracer tracer;
+
+  TracingStatement(Statement statement, String dbType, String dbUser, boolean withActiveSpanOnly,
+                   Set<String> ignoredStatements) {
+    this(statement, dbType, dbUser, withActiveSpanOnly, ignoredStatements, null);
+  }
 
   TracingStatement(Statement statement, String dbType, String dbUser, boolean withActiveSpanOnly,
-      Set<String> ignoredStatements) {
-    this(statement, null, dbType, dbUser, withActiveSpanOnly, ignoredStatements);
+                   Set<String> ignoredStatements, Tracer tracer) {
+    this(statement, null, dbType, dbUser, withActiveSpanOnly, ignoredStatements, tracer);
+  }
+
+  TracingStatement(Statement statement, String query, String dbType, String dbUser,
+                   boolean withActiveSpanOnly, Set<String> ignoredStatements) {
+    this(statement, query, dbType, dbUser,withActiveSpanOnly, ignoredStatements, null);
   }
 
   TracingStatement(Statement statement, String query, String dbType, String dbUser,
-      boolean withActiveSpanOnly, Set<String> ignoredStatements) {
+                   boolean withActiveSpanOnly, Set<String> ignoredStatements, Tracer tracer) {
     this.statement = statement;
     this.query = query;
     this.dbType = dbType;
     this.dbUser = dbUser;
     this.withActiveSpanOnly = withActiveSpanOnly;
     this.ignoredStatements = ignoredStatements;
+    this.tracer = tracer;
   }
 
   @Override
   public ResultSet executeQuery(String sql) throws SQLException {
-    try (Scope ignored = buildScope("Query", sql, dbType, dbUser, withActiveSpanOnly, ignoredStatements)) {
+    try (Scope ignored = buildScope("Query", sql, dbType, dbUser, withActiveSpanOnly, ignoredStatements, tracer)) {
       return statement.executeQuery(sql);
     }
   }
 
   @Override
   public int executeUpdate(String sql) throws SQLException {
-    try (Scope ignored = buildScope("Update", sql, dbType, dbUser, withActiveSpanOnly, ignoredStatements)) {
+    try (Scope ignored = buildScope("Update", sql, dbType, dbUser, withActiveSpanOnly, ignoredStatements, tracer)) {
       return statement.executeUpdate(sql);
     }
   }
@@ -126,7 +140,7 @@ public void setCursorName(String name) throws SQLException {
 
   @Override
   public boolean execute(String sql) throws SQLException {
-    try (Scope ignored = buildScope("Execute", sql, dbType, dbUser, withActiveSpanOnly, ignoredStatements)) {
+    try (Scope ignored = buildScope("Execute", sql, dbType, dbUser, withActiveSpanOnly, ignoredStatements, tracer)) {
       return statement.execute(sql);
     }
   }
@@ -212,42 +226,42 @@ public ResultSet getGeneratedKeys() throws SQLException {
 
   @Override
   public int executeUpdate(String sql, int autoGeneratedKeys) throws SQLException {
-    try (Scope ignored = buildScope("Update", sql, dbType, dbUser, withActiveSpanOnly, ignoredStatements)) {
+    try (Scope ignored = buildScope("Update", sql, dbType, dbUser, withActiveSpanOnly, ignoredStatements, tracer)) {
       return statement.executeUpdate(sql, autoGeneratedKeys);
     }
   }
 
   @Override
   public int executeUpdate(String sql, int[] columnIndexes) throws SQLException {
-    try (Scope ignored = buildScope("Update", sql, dbType, dbUser, withActiveSpanOnly, ignoredStatements)) {
+    try (Scope ignored = buildScope("Update", sql, dbType, dbUser, withActiveSpanOnly, ignoredStatements, tracer)) {
       return statement.executeUpdate(sql, columnIndexes);
     }
   }
 
   @Override
   public int executeUpdate(String sql, String[] columnNames) throws SQLException {
-    try (Scope ignored = buildScope("Update", sql, dbType, dbUser, withActiveSpanOnly, ignoredStatements)) {
+    try (Scope ignored = buildScope("Update", sql, dbType, dbUser, withActiveSpanOnly, ignoredStatements, tracer)) {
       return statement.executeUpdate(sql, columnNames);
     }
   }
 
   @Override
   public boolean execute(String sql, int autoGeneratedKeys) throws SQLException {
-    try (Scope ignored = buildScope("Execute", sql, dbType, dbUser, withActiveSpanOnly, ignoredStatements)) {
+    try (Scope ignored = buildScope("Execute", sql, dbType, dbUser, withActiveSpanOnly, ignoredStatements, tracer)) {
       return statement.execute(sql, autoGeneratedKeys);
     }
   }
 
   @Override
   public boolean execute(String sql, int[] columnIndexes) throws SQLException {
-    try (Scope ignored = buildScope("Execute", sql, dbType, dbUser, withActiveSpanOnly, ignoredStatements)) {
+    try (Scope ignored = buildScope("Execute", sql, dbType, dbUser, withActiveSpanOnly, ignoredStatements, tracer)) {
       return statement.execute(sql, columnIndexes);
     }
   }
 
   @Override
   public boolean execute(String sql, String[] columnNames) throws SQLException {
-    try (Scope ignored = buildScope("Execute", sql, dbType, dbUser, withActiveSpanOnly, ignoredStatements)) {
+    try (Scope ignored = buildScope("Execute", sql, dbType, dbUser, withActiveSpanOnly, ignoredStatements, tracer)) {
       return statement.execute(sql, columnNames);
     }
   }
@@ -302,6 +316,6 @@ private Scope buildScopeForBatch() {
       sqlBuilder.append(batchCommand);
     }
 
-    return buildScope("Batch", sqlBuilder.toString(), dbType, dbUser, withActiveSpanOnly, ignoredStatements);
+    return buildScope("Batch", sqlBuilder.toString(), dbType, dbUser, withActiveSpanOnly, ignoredStatements, tracer);
   }
 }