add test case and fix some issue

skywalking-sniffer/skywalking-sdk-plugin/jdbc-plugin/src/main/java/com/a/eye/skywalking/plugin/jdbc/CallableStatementTracing.java

@@ -26,6 +26,7 @@ public class CallableStatementTracing {
             Tags.DB_TYPE.set(span, "sql");
             Tags.DB_INSTANCE.set(span, connectInfo.getDatabaseName());
             Tags.DB_STATEMENT.set(span, sql);
+            Tags.SPAN_LAYER.asDB(span);
             Tags.COMPONENT.set(span, connectInfo.getDBType());
             if (!StringUtil.isEmpty(connectInfo.getHosts())) {
                 Tags.PEERS.set(span, connectInfo.getHosts());

skywalking-sniffer/skywalking-sdk-plugin/jdbc-plugin/src/main/java/com/a/eye/skywalking/plugin/jdbc/ConnectionTracing.java

@@ -27,6 +27,7 @@ public class ConnectionTracing {
             Tags.DB_INSTANCE.set(span, connectInfo.getDatabaseName());
             Tags.DB_STATEMENT.set(span, sql);
             Tags.COMPONENT.set(span, connectInfo.getDBType());
+            Tags.SPAN_LAYER.asDB(span);
             if (!StringUtil.isEmpty(connectInfo.getHosts())) {
                 Tags.PEERS.set(span, connectInfo.getHosts());
             } else {

skywalking-sniffer/skywalking-sdk-plugin/jdbc-plugin/src/main/java/com/a/eye/skywalking/plugin/jdbc/PreparedStatementTracing.java

@@ -32,6 +32,7 @@ public class PreparedStatementTracing {
                 Tags.PEER_PORT.set(span, connectInfo.getPort());
                 Tags.PEER_HOST.set(span, connectInfo.getHost());
             }
+            Tags.SPAN_LAYER.asDB(span);
             return exec.exe(realStatement, sql);
         } catch (SQLException e) {
             Span span = ContextManager.INSTANCE.activeSpan();

skywalking-sniffer/skywalking-sdk-plugin/jdbc-plugin/src/main/java/com/a/eye/skywalking/plugin/jdbc/SWConnection.java

@@ -315,4 +315,5 @@ public class SWConnection implements Connection {
         return realConnection.getNetworkTimeout();
     }
 
+
 }

skywalking-sniffer/skywalking-sdk-plugin/jdbc-plugin/src/main/java/com/a/eye/skywalking/plugin/jdbc/StatementTracing.java

@@ -26,6 +26,7 @@ public class StatementTracing {
             Tags.DB_INSTANCE.set(span, connectInfo.getDatabaseName());
             Tags.DB_STATEMENT.set(span, sql);
             Tags.COMPONENT.set(span, connectInfo.getDBType());
+            Tags.SPAN_LAYER.asDB(span);
             if (!StringUtil.isEmpty(connectInfo.getHosts())) {
                 Tags.PEERS.set(span, connectInfo.getHosts());
             } else {

skywalking-sniffer/skywalking-sdk-plugin/jdbc-plugin/src/test/java/com/a/eye/skywalking/plugin/jdbc/AbstractStatementTest.java

+package com.a.eye.skywalking.plugin.jdbc;
+
+import com.a.eye.skywalking.sniffer.mock.context.MockTracerContextListener;
+import com.a.eye.skywalking.trace.LogData;
+import com.a.eye.skywalking.trace.Span;
+import com.a.eye.skywalking.trace.tag.Tags;
+
+import org.hamcrest.CoreMatchers;
+
+import java.sql.SQLException;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+public abstract class AbstractStatementTest {
+
+    protected MockTracerContextListener mockTracerContextListener;
+
+
+    protected void assertDBSpanLog(LogData logData) {
+        assertThat(logData.getFields().size(), is(4));
+        assertThat(logData.getFields().get("event"), CoreMatchers.<Object>is("error"));
+        assertEquals(logData.getFields().get("error.kind"), SQLException.class.getName());
+        assertNull(logData.getFields().get("message"));
+    }
+
+
+    protected void assertDBSpan(Span span, String exceptOperationName, String exceptDBStatement) {
+        assertDBSpan(span, exceptOperationName);
+        assertThat(Tags.DB_STATEMENT.get(span), is(exceptDBStatement));
+    }
+
+
+    protected void assertDBSpan(Span span, String exceptOperationName) {
+        assertThat(span.getOperationName(), is(exceptOperationName));
+        assertThat(Tags.COMPONENT.get(span), is("Mysql"));
+        assertThat(Tags.DB_INSTANCE.get(span), is("test"));
+        assertTrue(Tags.SPAN_LAYER.isDB(span));
+    }
+}

skywalking-sniffer/skywalking-sdk-plugin/jdbc-plugin/src/test/java/com/a/eye/skywalking/plugin/jdbc/SWConnectionTest.java

+package com.a.eye.skywalking.plugin.jdbc;
+
+import com.a.eye.skywalking.api.context.TracerContext;
+import com.a.eye.skywalking.sniffer.mock.context.MockTracerContextListener;
+import com.a.eye.skywalking.sniffer.mock.context.SegmentAssert;
+import com.a.eye.skywalking.trace.TraceSegment;
+import com.mysql.cj.api.jdbc.JdbcConnection;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.runners.MockitoJUnitRunner;
+
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+import java.sql.Savepoint;
+import java.util.HashMap;
+import java.util.Properties;
+import java.util.concurrent.Executor;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.anyBoolean;
+import static org.mockito.Matchers.anyInt;
+import static org.mockito.Matchers.anyString;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+@RunWith(MockitoJUnitRunner.class)
+public class SWConnectionTest extends AbstractStatementTest {
+    @Mock
+    private com.mysql.cj.jdbc.PreparedStatement mysqlPreparedStatement;
+    @Mock
+    private JdbcConnection jdbcConnection;
+    @Mock
+    private Executor executor;
+    @Mock
+    private Savepoint savepoint;
+    private SWConnection swConnection;
+    private SWConnection multiHostConnection;
+
+    @Before
+    public void setUp() throws Exception {
+        mockTracerContextListener = new MockTracerContextListener();
+        swConnection = new SWConnection("jdbc:mysql://127.0.0.1:3306/test", new Properties(), jdbcConnection);
+        multiHostConnection = new SWConnection("jdbc:mysql://127.0.0.1:3306,127.0.0.1:3309/test", new Properties(), jdbcConnection);
+
+        TracerContext.ListenerManager.add(mockTracerContextListener);
+
+        when(jdbcConnection.prepareStatement(anyString())).thenReturn(mysqlPreparedStatement);
+    }
+
+    @Test
+    public void testCommit() throws SQLException {
+        PreparedStatement preparedStatement = swConnection.prepareStatement("SELECT * FROM test");
+
+        swConnection.commit();
+
+        mockTracerContextListener.assertSize(1);
+        mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
+            @Override
+            public void call(TraceSegment traceSegment) {
+                assertThat(traceSegment.getSpans().size(), is(1));
+                assertDBSpan(traceSegment.getSpans().get(0), "JDBC/Connection/commit");
+            }
+        });
+    }
+
+    @Test
+    public void testMultiHostCommit() throws SQLException {
+        PreparedStatement preparedStatement = swConnection.prepareStatement("SELECT * FROM test", new String[]{"1"});
+        multiHostConnection.commit();
+
+        mockTracerContextListener.assertSize(1);
+        mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
+            @Override
+            public void call(TraceSegment traceSegment) {
+                assertThat(traceSegment.getSpans().size(), is(1));
+                assertDBSpan(traceSegment.getSpans().get(0), "JDBC/Connection/commit");
+            }
+        });
+    }
+
+    @Test(expected = SQLException.class)
+    public void testCommitWithException() throws SQLException {
+        PreparedStatement preparedStatement = swConnection.prepareStatement("SELECT * FROM test", new int[]{1});
+        doThrow(new SQLException()).when(jdbcConnection).commit();
+        try {
+            swConnection.commit();
+        } finally {
+            mockTracerContextListener.assertSize(1);
+            mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
+                @Override
+                public void call(TraceSegment traceSegment) {
+                    assertThat(traceSegment.getSpans().size(), is(1));
+                    assertDBSpan(traceSegment.getSpans().get(0), "JDBC/Connection/commit");
+                    assertDBSpanLog(traceSegment.getSpans().get(0).getLogs().get(0));
+                }
+            });
+        }
+    }
+
+    @Test
+    public void testRollBack() throws SQLException {
+        PreparedStatement preparedStatement = swConnection.prepareStatement("SELECT * FROM test", 1, 1);
+        swConnection.rollback();
+
+        mockTracerContextListener.assertSize(1);
+        mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
+            @Override
+            public void call(TraceSegment traceSegment) {
+                assertThat(traceSegment.getSpans().size(), is(1));
+                assertDBSpan(traceSegment.getSpans().get(0), "JDBC/Connection/rollback");
+
+            }
+        });
+    }
+
+    @Test
+    public void testMultiHostRollBack() throws SQLException {
+        PreparedStatement preparedStatement = swConnection.prepareStatement("SELECT * FROM test", 1, 1, 1);
+        multiHostConnection.rollback();
+
+        mockTracerContextListener.assertSize(1);
+        mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
+            @Override
+            public void call(TraceSegment traceSegment) {
+                assertThat(traceSegment.getSpans().size(), is(1));
+                assertDBSpan(traceSegment.getSpans().get(0), "JDBC/Connection/rollback");
+            }
+        });
+    }
+
+    @Test(expected = SQLException.class)
+    public void testRollBackWithException() throws SQLException {
+        doThrow(new SQLException()).when(jdbcConnection).rollback();
+
+        swConnection.rollback();
+
+        mockTracerContextListener.assertSize(1);
+        mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
+            @Override
+            public void call(TraceSegment traceSegment) {
+                assertThat(traceSegment.getSpans().size(), is(1));
+                assertDBSpan(traceSegment.getSpans().get(0), "JDBC/Connection/rollback");
+            }
+        });
+    }
+
+
+    @Test
+    public void testRollBackWithSavePoint() throws SQLException {
+        swConnection.rollback(savepoint);
+
+        mockTracerContextListener.assertSize(1);
+        mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
+            @Override
+            public void call(TraceSegment traceSegment) {
+                assertThat(traceSegment.getSpans().size(), is(1));
+                assertDBSpan(traceSegment.getSpans().get(0), "JDBC/Connection/rollback to savepoint");
+            }
+        });
+    }
+
+    @Test
+    public void testMultiHostRollBackWithSavePoint() throws SQLException {
+        multiHostConnection.rollback(savepoint);
+
+        mockTracerContextListener.assertSize(1);
+        mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
+            @Override
+            public void call(TraceSegment traceSegment) {
+                assertThat(traceSegment.getSpans().size(), is(1));
+                assertDBSpan(traceSegment.getSpans().get(0), "JDBC/Connection/rollback to savepoint");
+            }
+        });
+    }
+
+    @Test(expected = SQLException.class)
+    public void testRollBackWithSavePointWithException() throws SQLException {
+        doThrow(new SQLException()).when(jdbcConnection).rollback(any(Savepoint.class));
+
+        swConnection.rollback(savepoint);
+
+        mockTracerContextListener.assertSize(1);
+        mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
+            @Override
+            public void call(TraceSegment traceSegment) {
+                assertThat(traceSegment.getSpans().size(), is(1));
+                assertDBSpan(traceSegment.getSpans().get(0), "JDBC/Connection/rollback to savepoint");
+                assertDBSpanLog(traceSegment.getSpans().get(0).getLogs().get(0));
+            }
+        });
+    }
+
+    @Test
+    public void testClose() throws SQLException {
+        swConnection.close();
+        swConnection.clearWarnings();
+
+        mockTracerContextListener.assertSize(1);
+        mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
+            @Override
+            public void call(TraceSegment traceSegment) {
+                assertThat(traceSegment.getSpans().size(), is(1));
+                assertDBSpan(traceSegment.getSpans().get(0), "JDBC/Connection/close");
+            }
+        });
+    }
+
+    @Test
+    public void testMultiHostClose() throws SQLException {
+        multiHostConnection.close();
+
+        mockTracerContextListener.assertSize(1);
+        mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
+            @Override
+            public void call(TraceSegment traceSegment) {
+                assertThat(traceSegment.getSpans().size(), is(1));
+                assertDBSpan(traceSegment.getSpans().get(0), "JDBC/Connection/close");
+            }
+        });
+    }
+
+    @Test(expected = SQLException.class)
+    public void testCloseWithException() throws SQLException {
+        doThrow(new SQLException()).when(jdbcConnection).close();
+
+        swConnection.close();
+
+        mockTracerContextListener.assertSize(1);
+        mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
+            @Override
+            public void call(TraceSegment traceSegment) {
+                assertThat(traceSegment.getSpans().size(), is(1));
+                assertDBSpan(traceSegment.getSpans().get(0), "JDBC/Connection/close");
+                assertDBSpanLog(traceSegment.getSpans().get(0).getLogs().get(0));
+            }
+        });
+    }
+
+
+    @Test
+    public void testReleaseSavePoint() throws SQLException {
+        swConnection.releaseSavepoint(savepoint);
+        swConnection.clearWarnings();
+
+        mockTracerContextListener.assertSize(1);
+        mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
+            @Override
+            public void call(TraceSegment traceSegment) {
+                assertThat(traceSegment.getSpans().size(), is(1));
+                assertDBSpan(traceSegment.getSpans().get(0), "JDBC/Connection/releaseSavepoint savepoint");
+            }
+        });
+    }
+
+    @Test
+    public void testMultiHostReleaseSavePoint() throws SQLException {
+        multiHostConnection.releaseSavepoint(savepoint);
+
+        mockTracerContextListener.assertSize(1);
+        mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
+            @Override
+            public void call(TraceSegment traceSegment) {
+                assertThat(traceSegment.getSpans().size(), is(1));
+                assertDBSpan(traceSegment.getSpans().get(0), "JDBC/Connection/releaseSavepoint savepoint");
+            }
+        });
+    }
+
+    @Test(expected = SQLException.class)
+    public void testReleaseSavePointWithException() throws SQLException {
+        doThrow(new SQLException()).when(jdbcConnection).releaseSavepoint(any(Savepoint.class));
+
+        swConnection.releaseSavepoint(savepoint);
+
+        mockTracerContextListener.assertSize(1);
+        mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
+            @Override
+            public void call(TraceSegment traceSegment) {
+                assertThat(traceSegment.getSpans().size(), is(1));
+                assertDBSpan(traceSegment.getSpans().get(0), "JDBC/Connection/releaseSavepoint savepoint");
+                assertDBSpanLog(traceSegment.getSpans().get(0).getLogs().get(0));
+            }
+        });
+    }
+
+    @Test
+    public void testSetConfig() throws SQLException {
+        swConnection.createArrayOf("1", new Object[0]);
+        swConnection.createBlob();
+        swConnection.createClob();
+        swConnection.createNClob();
+        swConnection.createSQLXML();
+        swConnection.nativeSQL("SELECT IT");
+        swConnection.setAutoCommit(true);
+        swConnection.getAutoCommit();
+        swConnection.setCatalog("test");
+        swConnection.getCatalog();
+        swConnection.setClientInfo(new Properties());
+        swConnection.getClientInfo();
+        swConnection.setHoldability(1);
+        swConnection.getHoldability();
+        swConnection.setReadOnly(false);
+        swConnection.setClientInfo("test-client", "test-client");
+        swConnection.getClientInfo("test");
+        swConnection.setSavepoint();
+        swConnection.getMetaData();
+        swConnection.getTransactionIsolation();
+        swConnection.getTypeMap();
+        swConnection.getWarnings();
+        swConnection.isClosed();
+        swConnection.isReadOnly();
+        swConnection.isValid(10);
+        swConnection.setSavepoint("test");
+        swConnection.setTransactionIsolation(1);
+        swConnection.setTypeMap(new HashMap<String, Class<?>>());
+
+        verify(jdbcConnection, times(1)).createBlob();
+        verify(jdbcConnection, times(1)).createClob();
+        verify(jdbcConnection, times(1)).createNClob();
+        verify(jdbcConnection, times(1)).createSQLXML();
+        verify(jdbcConnection, times(1)).nativeSQL(anyString());
+        verify(jdbcConnection, times(1)).setAutoCommit(anyBoolean());
+        verify(jdbcConnection, times(1)).getAutoCommit();
+        verify(jdbcConnection, times(1)).setCatalog(anyString());
+        verify(jdbcConnection, times(1)).getCatalog();
+        verify(jdbcConnection, times(1)).setClientInfo(anyString(), anyString());
+        verify(jdbcConnection, times(1)).setHoldability(anyInt());
+        verify(jdbcConnection, times(1)).getHoldability();
+        verify(jdbcConnection, times(1)).setReadOnly(anyBoolean());
+        verify(jdbcConnection, times(1)).getClientInfo();
+        verify(jdbcConnection, times(1)).getClientInfo(anyString());
+        verify(jdbcConnection, times(1)).setSavepoint(anyString());
+        verify(jdbcConnection, times(1)).setSavepoint();
+        verify(jdbcConnection, times(1)).getMetaData();
+        verify(jdbcConnection, times(1)).getTransactionIsolation();
+        verify(jdbcConnection, times(1)).getTypeMap();
+        verify(jdbcConnection, times(1)).getWarnings();
+        verify(jdbcConnection, times(1)).setTransactionIsolation(anyInt());
+        verify(jdbcConnection, times(1)).getTransactionIsolation();
+        verify(jdbcConnection, times(1)).isClosed();
+        verify(jdbcConnection, times(1)).isReadOnly();
+        verify(jdbcConnection, times(1)).isValid(anyInt());
+        verify(jdbcConnection, times(1)).setTypeMap(any(HashMap.class));
+
+
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        TracerContext.ListenerManager.remove(mockTracerContextListener);
+    }
+
+}
\ No newline at end of file

skywalking-sniffer/skywalking-sdk-plugin/jdbc-plugin/src/test/java/com/a/eye/skywalking/plugin/jdbc/SWStatementTest.java

+package com.a.eye.skywalking.plugin.jdbc;
+
+import com.a.eye.skywalking.api.context.TracerContext;
+import com.a.eye.skywalking.sniffer.mock.context.MockTracerContextListener;
+import com.a.eye.skywalking.sniffer.mock.context.SegmentAssert;
+import com.a.eye.skywalking.trace.LogData;
+import com.a.eye.skywalking.trace.Span;
+import com.a.eye.skywalking.trace.TraceSegment;
+import com.a.eye.skywalking.trace.tag.Tags;
+import com.mysql.cj.api.jdbc.JdbcConnection;
+
+import org.hamcrest.CoreMatchers;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.runners.MockitoJUnitRunner;
+
+import java.net.MalformedURLException;
+import java.sql.Connection;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.Properties;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Matchers.anyBoolean;
+import static org.mockito.Matchers.anyInt;
+import static org.mockito.Matchers.anyString;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+@RunWith(MockitoJUnitRunner.class)
+public class SWStatementTest extends AbstractStatementTest {
+    @Mock
+    private com.mysql.cj.jdbc.StatementImpl mysqlStatement;
+    @Mock
+    private JdbcConnection jdbcConnection;
+    private SWConnection swConnection;
+    private SWConnection multiHostConnection;
+
+
+    @Before
+    public void setUp() throws Exception {
+        mockTracerContextListener = new MockTracerContextListener();
+        swConnection = new SWConnection("jdbc:mysql://127.0.0.1:3306/test", new Properties(), jdbcConnection);
+        multiHostConnection = new SWConnection("jdbc:mysql://127.0.0.1:3306,127.0.0.1:3309/test", new Properties(), jdbcConnection);
+
+        TracerContext.ListenerManager.add(mockTracerContextListener);
+
+        when(jdbcConnection.createStatement()).thenReturn(mysqlStatement);
+        when(jdbcConnection.createStatement(anyInt(), anyInt())).thenReturn(mysqlStatement);
+        when(jdbcConnection.createStatement(anyInt(), anyInt(), anyInt())).thenReturn(mysqlStatement);
+    }
+
+    @Test
+    public void testPreparedStatementConfig() throws SQLException {
+        Statement statement = swConnection.createStatement();
+        statement.cancel();
+        statement.getUpdateCount();
+        statement.setFetchDirection(1);
+        statement.getFetchDirection();
+        statement.getResultSetConcurrency();
+        statement.getResultSetType();
+        statement.isClosed();
+        statement.setPoolable(false);
+        statement.isPoolable();
+        statement.getWarnings();
+        statement.clearWarnings();
+        statement.setCursorName("test");
+        statement.setMaxFieldSize(11);
+        statement.getMaxFieldSize();
+        statement.setMaxRows(10);
+        statement.getMaxRows();
+        statement.setEscapeProcessing(true);
+        statement.setFetchSize(1);
+        statement.getFetchSize();
+        statement.setQueryTimeout(1);
+        statement.getQueryTimeout();
+        Connection connection = statement.getConnection();
+
+        statement.execute("SELECT * FROM test");
+        statement.getMoreResults();
+        statement.getMoreResults(1);
+        statement.getResultSetHoldability();
+        statement.getResultSet();
+
+        statement.close();
+        verify(mysqlStatement, times(1)).getUpdateCount();
+        verify(mysqlStatement, times(1)).getMoreResults();
+        verify(mysqlStatement, times(1)).setFetchDirection(anyInt());
+        verify(mysqlStatement, times(1)).getFetchDirection();
+        verify(mysqlStatement, times(1)).getResultSetType();
+        verify(mysqlStatement, times(1)).isClosed();
+        verify(mysqlStatement, times(1)).setPoolable(anyBoolean());
+        verify(mysqlStatement, times(1)).getWarnings();
+        verify(mysqlStatement, times(1)).clearWarnings();
+        verify(mysqlStatement, times(1)).setCursorName(anyString());
+        verify(mysqlStatement, times(1)).setMaxFieldSize(anyInt());
+        verify(mysqlStatement, times(1)).getMaxFieldSize();
+        verify(mysqlStatement, times(1)).setMaxRows(anyInt());
+        verify(mysqlStatement, times(1)).getMaxRows();
+        verify(mysqlStatement, times(1)).setEscapeProcessing(anyBoolean());
+        verify(mysqlStatement, times(1)).getResultSetConcurrency();
+        verify(mysqlStatement, times(1)).getResultSetConcurrency();
+        verify(mysqlStatement, times(1)).getResultSetType();
+        verify(mysqlStatement, times(1)).getMoreResults(anyInt());
+        verify(mysqlStatement, times(1)).setFetchSize(anyInt());
+        verify(mysqlStatement, times(1)).getFetchSize();
+        verify(mysqlStatement, times(1)).getQueryTimeout();
+        verify(mysqlStatement, times(1)).setQueryTimeout(anyInt());
+        verify(mysqlStatement, times(1)).getResultSet();
+        assertThat(connection, CoreMatchers.<Connection>is(swConnection));
+
+        mockTracerContextListener.assertSize(1);
+        mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
+            @Override
+            public void call(TraceSegment traceSegment) {
+                assertThat(traceSegment.getSpans().size(), is(1));
+                Span span = traceSegment.getSpans().get(0);
+                assertDBSpan(span, "JDBC/Statement/execute", "SELECT * FROM test");
+            }
+        });
+    }
+
+    @Test
+    public void testExecuteWithAutoGeneratedKey() throws SQLException {
+        Statement statement = swConnection.createStatement(1, 1);
+        boolean executeSuccess = statement.execute("SELECT * FROM test", 1);
+
+        mockTracerContextListener.assertSize(1);
+        mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
+            @Override
+            public void call(TraceSegment traceSegment) {
+                assertThat(traceSegment.getSpans().size(), is(1));
+                Span span = traceSegment.getSpans().get(0);
+                assertDBSpan(span, "JDBC/Statement/execute", "SELECT * FROM test");
+            }
+        });
+    }
+
+    @Test
+    public void testExecuteQuery() throws SQLException {
+        Statement statement = swConnection.createStatement(1, 1, 1);
+        ResultSet executeSuccess = statement.executeQuery("SELECT * FROM test");
+
+        mockTracerContextListener.assertSize(1);
+        mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
+            @Override
+            public void call(TraceSegment traceSegment) {
+                assertThat(traceSegment.getSpans().size(), is(1));
+                Span span = traceSegment.getSpans().get(0);
+                assertDBSpan(span, "JDBC/Statement/executeQuery", "SELECT * FROM test");
+            }
+        });
+    }
+
+    @Test
+    public void testExecuteUpdate() throws SQLException {
+        Statement statement = swConnection.createStatement(1, 1, 1);
+        int executeSuccess = statement.executeUpdate("UPDATE test SET a = 1");
+
+        mockTracerContextListener.assertSize(1);
+        mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
+            @Override
+            public void call(TraceSegment traceSegment) {
+                assertThat(traceSegment.getSpans().size(), is(1));
+                Span span = traceSegment.getSpans().get(0);
+                assertDBSpan(span, "JDBC/Statement/executeUpdate", "UPDATE test SET a = 1");
+            }
+        });
+    }
+
+    @Test
+    public void testExecuteUpdateWithAutoGeneratedKey() throws SQLException {
+        Statement statement = swConnection.createStatement(1, 1, 1);
+        int executeSuccess = statement.executeUpdate("UPDATE test SET a = 1", 1);
+        statement.getGeneratedKeys();
+
+        verify(mysqlStatement, times(1)).getGeneratedKeys();
+        mockTracerContextListener.assertSize(1);
+        mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
+            @Override
+            public void call(TraceSegment traceSegment) {
+                assertThat(traceSegment.getSpans().size(), is(1));
+                Span span = traceSegment.getSpans().get(0);
+                assertDBSpan(span, "JDBC/Statement/executeUpdate", "UPDATE test SET a = 1");
+            }
+        });
+    }
+
+    @Test
+    public void testExecuteUpdateWithColumnIndexes() throws SQLException {
+        Statement statement = swConnection.createStatement(1, 1, 1);
+        int executeSuccess = statement.executeUpdate("UPDATE test SET a = 1", new int[]{1});
+
+        mockTracerContextListener.assertSize(1);
+        mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
+            @Override
+            public void call(TraceSegment traceSegment) {
+                assertThat(traceSegment.getSpans().size(), is(1));
+                Span span = traceSegment.getSpans().get(0);
+                assertDBSpan(span, "JDBC/Statement/executeUpdate", "UPDATE test SET a = 1");
+            }
+        });
+    }
+
+    @Test
+    public void testExecuteUpdateWithColumnStringIndexes() throws SQLException {
+        Statement statement = swConnection.createStatement(1, 1, 1);
+        int executeSuccess = statement.executeUpdate("UPDATE test SET a = 1", new String[]{"1"});
+
+        mockTracerContextListener.assertSize(1);
+        mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
+            @Override
+            public void call(TraceSegment traceSegment) {
+                assertThat(traceSegment.getSpans().size(), is(1));
+                Span span = traceSegment.getSpans().get(0);
+                assertDBSpan(span, "JDBC/Statement/executeUpdate", "UPDATE test SET a = 1");
+            }
+        });
+    }
+
+    @Test
+    public void testExecuteWithColumnIndexes() throws SQLException {
+        Statement statement = swConnection.createStatement(1, 1, 1);
+        boolean executeSuccess = statement.execute("UPDATE test SET a = 1", new int[]{1});
+
+        mockTracerContextListener.assertSize(1);
+        mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
+            @Override
+            public void call(TraceSegment traceSegment) {
+                assertThat(traceSegment.getSpans().size(), is(1));
+                Span span = traceSegment.getSpans().get(0);
+                assertDBSpan(span, "JDBC/Statement/execute", "UPDATE test SET a = 1");
+            }
+        });
+    }
+
+    @Test
+    public void testExecuteWithColumnStringIndexes() throws SQLException {
+        Statement statement = swConnection.createStatement(1, 1, 1);
+        boolean executeSuccess = statement.execute("UPDATE test SET a = 1", new String[]{"1"});
+
+        mockTracerContextListener.assertSize(1);
+        mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
+            @Override
+            public void call(TraceSegment traceSegment) {
+                assertThat(traceSegment.getSpans().size(), is(1));
+                Span span = traceSegment.getSpans().get(0);
+                assertDBSpan(span, "JDBC/Statement/execute", "UPDATE test SET a = 1");
+            }
+        });
+    }
+
+    @Test
+    public void testBatch() throws SQLException, MalformedURLException {
+        Statement statement = multiHostConnection.createStatement();
+        statement.addBatch("UPDATE test SET a = 1 WHERE b = 2");
+        int[] resultSet = statement.executeBatch();
+        statement.clearBatch();
+
+        verify(mysqlStatement, times(1)).executeBatch();
+        verify(mysqlStatement, times(1)).addBatch(anyString());
+        verify(mysqlStatement, times(1)).clearBatch();
+
+        mockTracerContextListener.assertSize(1);
+        mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
+            @Override
+            public void call(TraceSegment traceSegment) {
+                assertThat(traceSegment.getSpans().size(), is(1));
+                Span span = traceSegment.getSpans().get(0);
+                assertDBSpan(span, "JDBC/Statement/executeBatch", "");
+            }
+        });
+    }
+
+    @Test(expected = SQLException.class)
+    public void testMultiHostWithException() throws SQLException {
+        when(mysqlStatement.execute(anyString())).thenThrow(new SQLException());
+        try {
+            Statement statement = multiHostConnection.createStatement();
+            statement.execute("UPDATE test SET a = 1 WHERE b = 2");
+        } finally {
+            verify(mysqlStatement, times(1)).execute(anyString());
+            mockTracerContextListener.assertSize(1);
+            mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
+                @Override
+                public void call(TraceSegment traceSegment) {
+                    assertThat(traceSegment.getSpans().size(), is(1));
+                    Span span = traceSegment.getSpans().get(0);
+                    assertDBSpan(span, "JDBC/Statement/execute", "UPDATE test SET a = 1 WHERE b = 2");
+                    assertThat(span.getLogs().size(), is(1));
+                    assertDBSpanLog(span.getLogs().get(0));
+                }
+            });
+        }
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        TracerContext.ListenerManager.remove(mockTracerContextListener);
+    }
+}
\ No newline at end of file