Merge remote-tracking branch 'origin/master'

skywalking-api/.gitignore

@@ -12,3 +12,4 @@
 hs_err_pid*
 .idea
 *.iml
+/bin/

skywalking-sdk-plugin/jdbc-plugin/pom.xml

@@ -29,5 +29,11 @@
 			<version>${project.version}</version>
 			<scope>test</scope>
 		</dependency>
+		<dependency>
+			<groupId>mysql</groupId>
+			<artifactId>mysql-connector-java</artifactId>
+			<version>5.1.36</version>
+			<scope>test</scope>
+		</dependency>
 	</dependencies>
 </project>

skywalking-sdk-plugin/jdbc-plugin/src/main/java/com/ai/cloud/skywalking/plugin/jdbc/SWConnection.java

@@ -0,0 +1,319 @@
+package com.ai.cloud.skywalking.plugin.jdbc;
+
+import java.sql.Array;
+import java.sql.Blob;
+import java.sql.CallableStatement;
+import java.sql.Clob;
+import java.sql.DatabaseMetaData;
+import java.sql.NClob;
+import java.sql.PreparedStatement;
+import java.sql.SQLClientInfoException;
+import java.sql.SQLException;
+import java.sql.SQLWarning;
+import java.sql.SQLXML;
+import java.sql.Savepoint;
+import java.sql.Statement;
+import java.sql.Struct;
+import java.util.Map;
+import java.util.Properties;
+import java.util.concurrent.Executor;
+
+import com.ai.cloud.skywalking.plugin.jdbc.tracing.ConnectionTracing;
+import com.ai.cloud.skywalking.plugin.jdbc.tracing.ConnectionTracing.Executable;
+
+public class SWConnection implements java.sql.Connection {
+	private String connectInfo;
+
+	private final java.sql.Connection realConnection;
+
+	public SWConnection(String url, Properties info,
+			java.sql.Connection realConnection) {
+		super();
+		this.connectInfo = url + "(" + info.getProperty("user") + ")";
+		this.realConnection = realConnection;
+	}
+
+	public <T> T unwrap(Class<T> iface) throws SQLException {
+		return realConnection.unwrap(iface);
+	}
+
+	public boolean isWrapperFor(Class<?> iface) throws SQLException {
+		return realConnection.isWrapperFor(iface);
+	}
+
+	public Statement createStatement() throws SQLException {
+		return new SWStatement(this, realConnection.createStatement(),
+				this.connectInfo);
+	}
+
+	public PreparedStatement prepareStatement(String sql) throws SQLException {
+		return new SWPreparedStatement(this,
+				realConnection.prepareStatement(sql), this.connectInfo, sql);
+	}
+
+	public CallableStatement prepareCall(String sql) throws SQLException {
+		return new SWCallableStatement(this, realConnection.prepareCall(sql),
+				this.connectInfo, sql);
+	}
+
+	public String nativeSQL(String sql) throws SQLException {
+		return ConnectionTracing.execute(realConnection, connectInfo,
+				"nativeSQL", sql, new Executable<String>() {
+					public String exe(java.sql.Connection realConnection,
+							String sql) throws SQLException {
+						return realConnection.nativeSQL(sql);
+					}
+				});
+	}
+
+	public void setAutoCommit(boolean autoCommit) throws SQLException {
+		realConnection.setAutoCommit(autoCommit);
+	}
+
+	public boolean getAutoCommit() throws SQLException {
+		return realConnection.getAutoCommit();
+	}
+
+	public void commit() throws SQLException {
+		ConnectionTracing.execute(realConnection, connectInfo, "commit", "",
+				new Executable<String>() {
+					public String exe(java.sql.Connection realConnection,
+							String sql) throws SQLException {
+						realConnection.commit();
+						return null;
+					}
+				});
+	}
+
+	public void rollback() throws SQLException {
+		ConnectionTracing.execute(realConnection, connectInfo, "rollback", "",
+				new Executable<String>() {
+					public String exe(java.sql.Connection realConnection,
+							String sql) throws SQLException {
+						realConnection.rollback();
+						return null;
+					}
+				});
+	}
+
+	public void close() throws SQLException {
+		realConnection.close();
+	}
+
+	public boolean isClosed() throws SQLException {
+		return realConnection.isClosed();
+	}
+
+	public DatabaseMetaData getMetaData() throws SQLException {
+		return realConnection.getMetaData();
+	}
+
+	public void setReadOnly(boolean readOnly) throws SQLException {
+		realConnection.setReadOnly(readOnly);
+	}
+
+	public boolean isReadOnly() throws SQLException {
+		return realConnection.isReadOnly();
+	}
+
+	public void setCatalog(String catalog) throws SQLException {
+		realConnection.setCatalog(catalog);
+	}
+
+	public String getCatalog() throws SQLException {
+		return realConnection.getCatalog();
+	}
+
+	public void setTransactionIsolation(int level) throws SQLException {
+		realConnection.setTransactionIsolation(level);
+	}
+
+	public int getTransactionIsolation() throws SQLException {
+		return realConnection.getTransactionIsolation();
+	}
+
+	public SQLWarning getWarnings() throws SQLException {
+		return realConnection.getWarnings();
+	}
+
+	public void clearWarnings() throws SQLException {
+		realConnection.clearWarnings();
+	}
+
+	public Statement createStatement(int resultSetType, int resultSetConcurrency)
+			throws SQLException {
+		return new SWStatement(this, realConnection.createStatement(
+				resultSetType, resultSetConcurrency), this.connectInfo);
+	}
+
+	public PreparedStatement prepareStatement(String sql, int resultSetType,
+			int resultSetConcurrency) throws SQLException {
+		return new SWPreparedStatement(this, realConnection.prepareStatement(
+				sql, resultSetType, resultSetConcurrency), this.connectInfo,
+				sql);
+	}
+
+	public CallableStatement prepareCall(String sql, int resultSetType,
+			int resultSetConcurrency) throws SQLException {
+		return new SWCallableStatement(this, realConnection.prepareCall(sql,
+				resultSetType, resultSetConcurrency), this.connectInfo, sql);
+	}
+
+	public Map<String, Class<?>> getTypeMap() throws SQLException {
+		return realConnection.getTypeMap();
+	}
+
+	public void setTypeMap(Map<String, Class<?>> map) throws SQLException {
+		realConnection.setTypeMap(map);
+	}
+
+	public void setHoldability(int holdability) throws SQLException {
+		realConnection.setHoldability(holdability);
+	}
+
+	public int getHoldability() throws SQLException {
+		return realConnection.getHoldability();
+	}
+
+	public Savepoint setSavepoint() throws SQLException {
+		return realConnection.setSavepoint();
+	}
+
+	public Savepoint setSavepoint(String name) throws SQLException {
+		return realConnection.setSavepoint(name);
+	}
+
+	public void rollback(final Savepoint savepoint) throws SQLException {
+		ConnectionTracing.execute(realConnection, connectInfo,
+				"rollback to savepoint", "", new Executable<String>() {
+					public String exe(java.sql.Connection realConnection,
+							String sql) throws SQLException {
+						realConnection.rollback(savepoint);
+						return null;
+					}
+				});
+	}
+
+	public void releaseSavepoint(final Savepoint savepoint) throws SQLException {
+		ConnectionTracing.execute(realConnection, connectInfo,
+				"releaseSavepoint savepoint", "", new Executable<String>() {
+					public String exe(java.sql.Connection realConnection,
+							String sql) throws SQLException {
+						realConnection.releaseSavepoint(savepoint);
+						return null;
+					}
+				});
+	}
+
+	public Statement createStatement(int resultSetType,
+			int resultSetConcurrency, int resultSetHoldability)
+			throws SQLException {
+		return new SWStatement(this, realConnection.createStatement(
+				resultSetType, resultSetConcurrency, resultSetHoldability),
+				this.connectInfo);
+	}
+
+	public PreparedStatement prepareStatement(String sql, int resultSetType,
+			int resultSetConcurrency, int resultSetHoldability)
+			throws SQLException {
+		return new SWPreparedStatement(this,
+				realConnection.prepareStatement(sql, resultSetType,
+						resultSetConcurrency, resultSetHoldability),
+				this.connectInfo, sql);
+	}
+
+	public CallableStatement prepareCall(String sql, int resultSetType,
+			int resultSetConcurrency, int resultSetHoldability)
+			throws SQLException {
+		return new SWCallableStatement(this, realConnection.prepareCall(sql,
+				resultSetType, resultSetConcurrency, resultSetHoldability), this.connectInfo, sql);
+	}
+
+	public PreparedStatement prepareStatement(String sql, int autoGeneratedKeys)
+			throws SQLException {
+		return new SWPreparedStatement(this, realConnection.prepareStatement(
+				sql, autoGeneratedKeys), this.connectInfo, sql);
+	}
+
+	public PreparedStatement prepareStatement(String sql, int[] columnIndexes)
+			throws SQLException {
+		return new SWPreparedStatement(this, realConnection.prepareStatement(
+				sql, columnIndexes), this.connectInfo, sql);
+	}
+
+	public PreparedStatement prepareStatement(String sql, String[] columnNames)
+			throws SQLException {
+		return new SWPreparedStatement(this, realConnection.prepareStatement(
+				sql, columnNames), this.connectInfo, sql);
+	}
+
+	public Clob createClob() throws SQLException {
+		return realConnection.createClob();
+	}
+
+	public Blob createBlob() throws SQLException {
+		return realConnection.createBlob();
+	}
+
+	public NClob createNClob() throws SQLException {
+		return realConnection.createNClob();
+	}
+
+	public SQLXML createSQLXML() throws SQLException {
+		return realConnection.createSQLXML();
+	}
+
+	public boolean isValid(int timeout) throws SQLException {
+		return realConnection.isValid(timeout);
+	}
+
+	public void setClientInfo(String name, String value)
+			throws SQLClientInfoException {
+		realConnection.setClientInfo(name, value);
+	}
+
+	public void setClientInfo(Properties properties)
+			throws SQLClientInfoException {
+		realConnection.setClientInfo(properties);
+	}
+
+	public String getClientInfo(String name) throws SQLException {
+		return realConnection.getClientInfo(name);
+	}
+
+	public Properties getClientInfo() throws SQLException {
+		return realConnection.getClientInfo();
+	}
+
+	public Array createArrayOf(String typeName, Object[] elements)
+			throws SQLException {
+		return realConnection.createArrayOf(typeName, elements);
+	}
+
+	public Struct createStruct(String typeName, Object[] attributes)
+			throws SQLException {
+		return realConnection.createStruct(typeName, attributes);
+	}
+
+	public void setSchema(String schema) throws SQLException {
+		realConnection.setSchema(schema);
+	}
+
+	public String getSchema() throws SQLException {
+		return realConnection.getSchema();
+	}
+
+	public void abort(Executor executor) throws SQLException {
+		realConnection.abort(executor);
+	}
+
+	public void setNetworkTimeout(Executor executor, int milliseconds)
+			throws SQLException {
+		realConnection.setNetworkTimeout(executor, milliseconds);
+	}
+
+	public int getNetworkTimeout() throws SQLException {
+		return realConnection.getNetworkTimeout();
+	}
+
+}

skywalking-sdk-plugin/jdbc-plugin/src/main/java/com/ai/cloud/skywalking/plugin/jdbc/SWPreparedStatement.java

@@ -0,0 +1,537 @@
+package com.ai.cloud.skywalking.plugin.jdbc;
+
+import java.io.InputStream;
+import java.io.Reader;
+import java.math.BigDecimal;
+import java.net.URL;
+import java.sql.Array;
+import java.sql.Blob;
+import java.sql.Clob;
+import java.sql.Connection;
+import java.sql.Date;
+import java.sql.NClob;
+import java.sql.ParameterMetaData;
+import java.sql.PreparedStatement;
+import java.sql.Ref;
+import java.sql.ResultSet;
+import java.sql.ResultSetMetaData;
+import java.sql.RowId;
+import java.sql.SQLException;
+import java.sql.SQLWarning;
+import java.sql.SQLXML;
+import java.sql.Time;
+import java.sql.Timestamp;
+import java.util.Calendar;
+
+import com.ai.cloud.skywalking.plugin.jdbc.tracing.PreaparedStatementTracing;
+import com.ai.cloud.skywalking.plugin.jdbc.tracing.PreaparedStatementTracing.Executable;
+
+public class SWPreparedStatement implements PreparedStatement {
+	private SWConnection realConnection;
+	private java.sql.PreparedStatement realStatement;
+	private String connectInfo;
+	private String sql;
+
+	SWPreparedStatement(SWConnection realConnection,
+			java.sql.PreparedStatement realStatement, String connectInfo,
+			String sql) {
+		this.realConnection = realConnection;
+		this.realStatement = realStatement;
+		this.connectInfo = connectInfo;
+		this.sql = sql;
+	}
+
+	public ResultSet executeQuery(String sql) throws SQLException {
+		return PreaparedStatementTracing.execute(realStatement, connectInfo, "executeQuery", sql, new Executable<ResultSet>() {
+			public ResultSet exe(java.sql.PreparedStatement realStatement, String sql)
+					throws SQLException {
+				return realStatement.executeQuery(sql);
+			}
+		});
+	}
+
+	public int executeUpdate(String sql) throws SQLException {
+		return PreaparedStatementTracing.execute(realStatement, connectInfo, "executeUpdate", sql, new Executable<Integer>() {
+			public Integer exe(java.sql.PreparedStatement realStatement, String sql)
+					throws SQLException {
+				return realStatement.executeUpdate(sql);
+			}
+		});
+	}
+
+	public void close() throws SQLException {
+		realStatement.close();
+	}
+
+	public int getMaxFieldSize() throws SQLException {
+		return realStatement.getMaxFieldSize();
+	}
+
+	public void setMaxFieldSize(int max) throws SQLException {
+		realStatement.setMaxFieldSize(max);
+	}
+
+	public int getMaxRows() throws SQLException {
+		return realStatement.getMaxRows();
+	}
+
+	public void setMaxRows(int max) throws SQLException {
+		realStatement.setMaxRows(max);
+	}
+
+	public void setEscapeProcessing(boolean enable) throws SQLException {
+		realStatement.setEscapeProcessing(enable);
+	}
+
+	public int getQueryTimeout() throws SQLException {
+		return realStatement.getQueryTimeout();
+	}
+
+	public void setQueryTimeout(int seconds) throws SQLException {
+		realStatement.setQueryTimeout(seconds);
+	}
+
+	public void cancel() throws SQLException {
+		realStatement.cancel();
+	}
+
+	public SQLWarning getWarnings() throws SQLException {
+		return realStatement.getWarnings();
+	}
+
+	public void clearWarnings() throws SQLException {
+		realStatement.clearWarnings();
+	}
+
+	public void setCursorName(String name) throws SQLException {
+		realStatement.setCursorName(name);
+	}
+
+	public boolean execute(String sql) throws SQLException {
+		return PreaparedStatementTracing.execute(realStatement, connectInfo, "execute", sql, new Executable<Boolean>() {
+			public Boolean exe(java.sql.PreparedStatement realStatement, String sql)
+					throws SQLException {
+				return realStatement.execute(sql);
+			}
+		});
+	}
+
+	public ResultSet getResultSet() throws SQLException {
+		return realStatement.getResultSet();
+	}
+
+	public int getUpdateCount() throws SQLException {
+		return realStatement.getUpdateCount();
+	}
+
+	public boolean getMoreResults() throws SQLException {
+		return realStatement.getMoreResults();
+	}
+
+	public void setFetchDirection(int direction) throws SQLException {
+		realStatement.setFetchDirection(direction);
+	}
+
+	public int getFetchDirection() throws SQLException {
+		return realStatement.getFetchDirection();
+	}
+
+	public void setFetchSize(int rows) throws SQLException {
+		realStatement.setFetchSize(rows);
+	}
+
+	public int getFetchSize() throws SQLException {
+		return realStatement.getFetchSize();
+	}
+
+	public int getResultSetConcurrency() throws SQLException {
+		return realStatement.getResultSetConcurrency();
+	}
+
+	public int getResultSetType() throws SQLException {
+		return realStatement.getResultSetType();
+	}
+
+	public void addBatch(String sql) throws SQLException {
+		realStatement.addBatch(sql);
+	}
+
+	public void clearBatch() throws SQLException {
+		realStatement.clearBatch();
+	}
+
+	public int[] executeBatch() throws SQLException {
+		return PreaparedStatementTracing.execute(realStatement, connectInfo, "executeBatch", "", new Executable<int[]>() {
+			public int[] exe(java.sql.PreparedStatement realStatement, String sql)
+					throws SQLException {
+				return realStatement.executeBatch();
+			}
+		});
+	}
+
+	public Connection getConnection() throws SQLException {
+		return realConnection;
+	}
+
+	public boolean getMoreResults(int current) throws SQLException {
+		return realStatement.getMoreResults(current);
+	}
+
+	public ResultSet getGeneratedKeys() throws SQLException {
+		return realStatement.getGeneratedKeys();
+	}
+
+	public int executeUpdate(String sql, final int autoGeneratedKeys)
+			throws SQLException {
+		return PreaparedStatementTracing.execute(realStatement, connectInfo, "executeUpdate", sql, new Executable<Integer>() {
+			public Integer exe(java.sql.PreparedStatement realStatement, String sql)
+					throws SQLException {
+				return realStatement.executeUpdate(sql, autoGeneratedKeys);
+			}
+		});
+	}
+
+	public int executeUpdate(String sql, final int[] columnIndexes)
+			throws SQLException {
+		return PreaparedStatementTracing.execute(realStatement, connectInfo, "executeUpdate", sql, new Executable<Integer>() {
+			public Integer exe(java.sql.PreparedStatement realStatement, String sql)
+					throws SQLException {
+				return realStatement.executeUpdate(sql, columnIndexes);
+			}
+		});
+	}
+
+	public int executeUpdate(String sql, final String[] columnNames)
+			throws SQLException {
+		return PreaparedStatementTracing.execute(realStatement, connectInfo, "executeUpdate", sql, new Executable<Integer>() {
+			public Integer exe(java.sql.PreparedStatement realStatement, String sql)
+					throws SQLException {
+				return realStatement.executeUpdate(sql, columnNames);
+			}
+		});
+	}
+
+	public boolean execute(String sql, final int autoGeneratedKeys)
+			throws SQLException {
+		return PreaparedStatementTracing.execute(realStatement, connectInfo, "execute", sql, new Executable<Boolean>() {
+			public Boolean exe(java.sql.PreparedStatement realStatement, String sql)
+					throws SQLException {
+				return realStatement.execute(sql, autoGeneratedKeys);
+			}
+		});
+	}
+
+	public boolean execute(String sql, final int[] columnIndexes) throws SQLException {
+		return PreaparedStatementTracing.execute(realStatement, connectInfo, "execute", sql, new Executable<Boolean>() {
+			public Boolean exe(java.sql.PreparedStatement realStatement, String sql)
+					throws SQLException {
+				return realStatement.execute(sql, columnIndexes);
+			}
+		});
+	}
+
+	public boolean execute(String sql, final String[] columnNames)
+			throws SQLException {
+		return PreaparedStatementTracing.execute(realStatement, connectInfo, "execute", sql, new Executable<Boolean>() {
+			public Boolean exe(java.sql.PreparedStatement realStatement, String sql)
+					throws SQLException {
+				return realStatement.execute(sql, columnNames);
+			}
+		});
+	}
+
+	public int getResultSetHoldability() throws SQLException {
+		return realStatement.getResultSetHoldability();
+	}
+
+	public boolean isClosed() throws SQLException {
+		return realStatement.isClosed();
+	}
+
+	public void setPoolable(boolean poolable) throws SQLException {
+		realStatement.setPoolable(poolable);
+	}
+
+	public boolean isPoolable() throws SQLException {
+		return realStatement.isPoolable();
+	}
+
+	public void closeOnCompletion() throws SQLException {
+		realStatement.closeOnCompletion();
+	}
+
+	public boolean isCloseOnCompletion() throws SQLException {
+		return realStatement.isCloseOnCompletion();
+	}
+
+	public <T> T unwrap(Class<T> iface) throws SQLException {
+		return realStatement.unwrap(iface);
+	}
+
+	public boolean isWrapperFor(Class<?> iface) throws SQLException {
+		return realStatement.isWrapperFor(iface);
+	}
+
+	public ResultSet executeQuery() throws SQLException {
+		return PreaparedStatementTracing.execute(realStatement, connectInfo, "executeQuery", sql, new Executable<ResultSet>() {
+			public ResultSet exe(java.sql.PreparedStatement realStatement, String sql)
+					throws SQLException {
+				return realStatement.executeQuery();
+			}
+		});
+	}
+
+	public int executeUpdate() throws SQLException {
+		return PreaparedStatementTracing.execute(realStatement, connectInfo, "executeUpdate", sql, new Executable<Integer>() {
+			public Integer exe(java.sql.PreparedStatement realStatement, String sql)
+					throws SQLException {
+				return realStatement.executeUpdate();
+			}
+		});
+	}
+
+	public void setNull(int parameterIndex, int sqlType) throws SQLException {
+		realStatement.setNull(parameterIndex, sqlType);
+	}
+
+	public void setBoolean(int parameterIndex, boolean x) throws SQLException {
+		realStatement.setBoolean(parameterIndex, x);
+	}
+
+	public void setByte(int parameterIndex, byte x) throws SQLException {
+		realStatement.setByte(parameterIndex, x);
+	}
+
+	public void setShort(int parameterIndex, short x) throws SQLException {
+		realStatement.setShort(parameterIndex, x);
+	}
+
+	public void setInt(int parameterIndex, int x) throws SQLException {
+		realStatement.setInt(parameterIndex, x);
+	}
+
+	public void setLong(int parameterIndex, long x) throws SQLException {
+		realStatement.setLong(parameterIndex, x);
+	}
+
+	public void setFloat(int parameterIndex, float x) throws SQLException {
+		realStatement.setFloat(parameterIndex, x);
+	}
+
+	public void setDouble(int parameterIndex, double x) throws SQLException {
+		realStatement.setDouble(parameterIndex, x);
+	}
+
+	public void setBigDecimal(int parameterIndex, BigDecimal x)
+			throws SQLException {
+		realStatement.setBigDecimal(parameterIndex, x);
+	}
+
+	public void setString(int parameterIndex, String x) throws SQLException {
+		realStatement.setString(parameterIndex, x);
+	}
+
+	public void setBytes(int parameterIndex, byte[] x) throws SQLException {
+		realStatement.setBytes(parameterIndex, x);
+	}
+
+	public void setDate(int parameterIndex, Date x) throws SQLException {
+		realStatement.setDate(parameterIndex, x);
+	}
+
+	public void setTime(int parameterIndex, Time x) throws SQLException {
+		realStatement.setTime(parameterIndex, x);
+	}
+
+	public void setTimestamp(int parameterIndex, Timestamp x)
+			throws SQLException {
+		realStatement.setTimestamp(parameterIndex, x);
+	}
+
+	public void setAsciiStream(int parameterIndex, InputStream x, int length)
+			throws SQLException {
+		realStatement.setAsciiStream(parameterIndex, x, length);
+	}
+
+	@Deprecated
+	public void setUnicodeStream(int parameterIndex, InputStream x, int length)
+			throws SQLException {
+		realStatement.setUnicodeStream(parameterIndex, x, length);
+	}
+
+	public void setBinaryStream(int parameterIndex, InputStream x, int length)
+			throws SQLException {
+		realStatement.setBinaryStream(parameterIndex, x, length);
+	}
+
+	public void clearParameters() throws SQLException {
+		realStatement.clearParameters();
+	}
+
+	public void setObject(int parameterIndex, Object x, int targetSqlType)
+			throws SQLException {
+		realStatement.setObject(parameterIndex, x, targetSqlType);
+	}
+
+	public void setObject(int parameterIndex, Object x) throws SQLException {
+		realStatement.setObject(parameterIndex, x);
+	}
+
+	public boolean execute() throws SQLException {
+		return PreaparedStatementTracing.execute(realStatement, connectInfo, "executeUpdate", sql, new Executable<Boolean>() {
+			public Boolean exe(java.sql.PreparedStatement realStatement, String sql)
+					throws SQLException {
+				return realStatement.execute();
+			}
+		});
+	}
+
+	public void addBatch() throws SQLException {
+		realStatement.addBatch();
+	}
+
+	public void setCharacterStream(int parameterIndex, Reader reader, int length)
+			throws SQLException {
+		realStatement.setCharacterStream(parameterIndex, reader, length);
+	}
+
+	public void setRef(int parameterIndex, Ref x) throws SQLException {
+		realStatement.setRef(parameterIndex, x);
+	}
+
+	public void setBlob(int parameterIndex, Blob x) throws SQLException {
+		realStatement.setBlob(parameterIndex, x);
+	}
+
+	public void setClob(int parameterIndex, Clob x) throws SQLException {
+		realStatement.setClob(parameterIndex, x);
+	}
+
+	public void setArray(int parameterIndex, Array x) throws SQLException {
+		realStatement.setArray(parameterIndex, x);
+	}
+
+	public ResultSetMetaData getMetaData() throws SQLException {
+		return realStatement.getMetaData();
+	}
+
+	public void setDate(int parameterIndex, Date x, Calendar cal)
+			throws SQLException {
+		realStatement.setDate(parameterIndex, x, cal);
+	}
+
+	public void setTime(int parameterIndex, Time x, Calendar cal)
+			throws SQLException {
+		realStatement.setTime(parameterIndex, x, cal);
+	}
+
+	public void setTimestamp(int parameterIndex, Timestamp x, Calendar cal)
+			throws SQLException {
+		realStatement.setTimestamp(parameterIndex, x, cal);
+	}
+
+	public void setNull(int parameterIndex, int sqlType, String typeName)
+			throws SQLException {
+		realStatement.setNull(parameterIndex, sqlType, typeName);
+	}
+
+	public void setURL(int parameterIndex, URL x) throws SQLException {
+		realStatement.setURL(parameterIndex, x);
+	}
+
+	public ParameterMetaData getParameterMetaData() throws SQLException {
+		return realStatement.getParameterMetaData();
+	}
+
+	public void setRowId(int parameterIndex, RowId x) throws SQLException {
+		realStatement.setRowId(parameterIndex, x);
+	}
+
+	public void setNString(int parameterIndex, String value)
+			throws SQLException {
+		realStatement.setNString(parameterIndex, value);
+	}
+
+	public void setNCharacterStream(int parameterIndex, Reader value,
+			long length) throws SQLException {
+		realStatement.setNCharacterStream(parameterIndex, value, length);
+	}
+
+	public void setNClob(int parameterIndex, NClob value) throws SQLException {
+		realStatement.setNClob(parameterIndex, value);
+	}
+
+	public void setClob(int parameterIndex, Reader reader, long length)
+			throws SQLException {
+		realStatement.setClob(parameterIndex, reader, length);
+	}
+
+	public void setBlob(int parameterIndex, InputStream inputStream, long length)
+			throws SQLException {
+		realStatement.setBlob(parameterIndex, inputStream, length);
+	}
+
+	public void setNClob(int parameterIndex, Reader reader, long length)
+			throws SQLException {
+		realStatement.setNClob(parameterIndex, reader, length);
+	}
+
+	public void setSQLXML(int parameterIndex, SQLXML xmlObject)
+			throws SQLException {
+		realStatement.setSQLXML(parameterIndex, xmlObject);
+	}
+
+	public void setObject(int parameterIndex, Object x, int targetSqlType,
+			int scaleOrLength) throws SQLException {
+		realStatement.setObject(parameterIndex, x, targetSqlType, scaleOrLength);
+	}
+
+	public void setAsciiStream(int parameterIndex, InputStream x, long length)
+			throws SQLException {
+		realStatement.setAsciiStream(parameterIndex, x, length);
+	}
+
+	public void setBinaryStream(int parameterIndex, InputStream x, long length)
+			throws SQLException {
+		realStatement.setBinaryStream(parameterIndex, x, length);
+	}
+
+	public void setCharacterStream(int parameterIndex, Reader reader,
+			long length) throws SQLException {
+		realStatement.setCharacterStream(parameterIndex, reader, length);
+	}
+
+	public void setAsciiStream(int parameterIndex, InputStream x)
+			throws SQLException {
+		realStatement.setAsciiStream(parameterIndex, x);
+	}
+
+	public void setBinaryStream(int parameterIndex, InputStream x)
+			throws SQLException {
+		realStatement.setBinaryStream(parameterIndex, x);
+	}
+
+	public void setCharacterStream(int parameterIndex, Reader reader)
+			throws SQLException {
+		realStatement.setCharacterStream(parameterIndex, reader);
+	}
+
+	public void setNCharacterStream(int parameterIndex, Reader value)
+			throws SQLException {
+		realStatement.setNCharacterStream(parameterIndex, value);
+	}
+
+	public void setClob(int parameterIndex, Reader reader) throws SQLException {
+		realStatement.setClob(parameterIndex, reader);
+	}
+
+	public void setBlob(int parameterIndex, InputStream inputStream)
+			throws SQLException {
+		realStatement.setBlob(parameterIndex, inputStream);
+	}
+
+	public void setNClob(int parameterIndex, Reader reader) throws SQLException {
+		realStatement.setNClob(parameterIndex, reader);
+	}
+
+}

skywalking-sdk-plugin/jdbc-plugin/src/main/java/com/ai/cloud/skywalking/plugin/jdbc/SWStatement.java

@@ -0,0 +1,254 @@
+package com.ai.cloud.skywalking.plugin.jdbc;
+
+import java.sql.Connection;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.SQLWarning;
+
+import com.ai.cloud.skywalking.plugin.jdbc.tracing.StatementTracing;
+import com.ai.cloud.skywalking.plugin.jdbc.tracing.StatementTracing.Executable;
+
+
+public class SWStatement implements java.sql.Statement {
+	private SWConnection realConnection;
+	private java.sql.Statement realStatement;
+	private String connectInfo;
+	
+	SWStatement(SWConnection realConnection, java.sql.Statement realStatement, String connectInfo){
+		this.realConnection = realConnection;
+		this.realStatement = realStatement;
+		this.connectInfo = connectInfo;
+	}
+
+	public <T> T unwrap(Class<T> iface) throws SQLException {
+		return realStatement.unwrap(iface);
+	}
+
+	public boolean isWrapperFor(Class<?> iface) throws SQLException {
+		return realStatement.isWrapperFor(iface);
+	}
+
+	public ResultSet executeQuery(String sql) throws SQLException {
+		return StatementTracing.execute(realStatement, connectInfo, "executeQuery", sql, new Executable<ResultSet>() {
+			public ResultSet exe(java.sql.Statement realStatement, String sql)
+					throws SQLException {
+				return realStatement.executeQuery(sql);
+			}
+		});
+	}
+
+	public int executeUpdate(String sql) throws SQLException {
+		return StatementTracing.execute(realStatement, connectInfo, "executeUpdate", sql, new Executable<Integer>() {
+			public Integer exe(java.sql.Statement realStatement, String sql)
+					throws SQLException {
+				return realStatement.executeUpdate(sql);
+			}
+		});
+	}
+
+	public void close() throws SQLException {
+		realStatement.close();		
+	}
+
+	public int getMaxFieldSize() throws SQLException {
+		return realStatement.getMaxFieldSize();
+	}
+
+	public void setMaxFieldSize(int max) throws SQLException {
+		realStatement.setMaxFieldSize(max);		
+	}
+
+	public int getMaxRows() throws SQLException {
+		return realStatement.getMaxRows();
+	}
+
+	public void setMaxRows(int max) throws SQLException {
+		realStatement.setMaxRows(max);		
+	}
+
+	public void setEscapeProcessing(boolean enable) throws SQLException {
+		realStatement.setEscapeProcessing(enable);		
+	}
+
+	public int getQueryTimeout() throws SQLException {
+		return realStatement.getQueryTimeout();
+	}
+
+	public void setQueryTimeout(int seconds) throws SQLException {
+		realStatement.setQueryTimeout(seconds);		
+	}
+
+	public void cancel() throws SQLException {
+		realStatement.cancel();		
+	}
+
+	public SQLWarning getWarnings() throws SQLException {
+		return realStatement.getWarnings();
+	}
+
+	public void clearWarnings() throws SQLException {
+		realStatement.clearWarnings();		
+	}
+
+	public void setCursorName(String name) throws SQLException {
+		realStatement.setCursorName(name);		
+	}
+
+	public boolean execute(String sql) throws SQLException {
+		return StatementTracing.execute(realStatement, connectInfo, "execute", sql, new Executable<Boolean>() {
+			public Boolean exe(java.sql.Statement realStatement, String sql)
+					throws SQLException {
+				return realStatement.execute(sql);
+			}
+		});
+	}
+
+	public ResultSet getResultSet() throws SQLException {
+		return realStatement.getResultSet();
+	}
+
+	public int getUpdateCount() throws SQLException {
+		return realStatement.getUpdateCount();
+	}
+
+	public boolean getMoreResults() throws SQLException {
+		return realStatement.getMoreResults();
+	}
+
+	public void setFetchDirection(int direction) throws SQLException {
+		realStatement.setFetchDirection(direction);		
+	}
+
+	public int getFetchDirection() throws SQLException {
+		return realStatement.getFetchDirection();
+	}
+
+	public void setFetchSize(int rows) throws SQLException {
+		realStatement.setFetchSize(rows);		
+	}
+
+	public int getFetchSize() throws SQLException {
+		return realStatement.getFetchSize();
+	}
+
+	public int getResultSetConcurrency() throws SQLException {
+		return realStatement.getResultSetConcurrency();
+	}
+
+	public int getResultSetType() throws SQLException {
+		return realStatement.getResultSetType();
+	}
+
+	public void addBatch(String sql) throws SQLException {
+		realStatement.addBatch(sql);		
+	}
+
+	public void clearBatch() throws SQLException {
+		realStatement.clearBatch();		
+	}
+
+	public int[] executeBatch() throws SQLException {
+		return StatementTracing.execute(realStatement, connectInfo, "executeBatch", "", new Executable<int[]>() {
+			public int[] exe(java.sql.Statement realStatement, String sql)
+					throws SQLException {
+				return realStatement.executeBatch();
+			}
+		});
+	}
+
+	public Connection getConnection() throws SQLException {
+		return this.realConnection;
+	}
+
+	public boolean getMoreResults(int current) throws SQLException {
+		return realStatement.getMoreResults(current);
+	}
+
+	public ResultSet getGeneratedKeys() throws SQLException {
+		return realStatement.getGeneratedKeys();
+	}
+
+	public int executeUpdate(String sql, final int autoGeneratedKeys)
+			throws SQLException {
+		return StatementTracing.execute(realStatement, connectInfo, "executeUpdate", sql, new Executable<Integer>() {
+			public Integer exe(java.sql.Statement realStatement, String sql)
+					throws SQLException {
+				return realStatement.executeUpdate(sql, autoGeneratedKeys);
+			}
+		});
+	}
+
+	public int executeUpdate(String sql, final int[] columnIndexes)
+			throws SQLException {
+		return StatementTracing.execute(realStatement, connectInfo, "executeUpdate", sql, new Executable<Integer>() {
+			public Integer exe(java.sql.Statement realStatement, String sql)
+					throws SQLException {
+				return realStatement.executeUpdate(sql, columnIndexes);
+			}
+		});
+	}
+
+	public int executeUpdate(String sql, final String[] columnNames)
+			throws SQLException {
+		return StatementTracing.execute(realStatement, connectInfo, "executeUpdate", sql, new Executable<Integer>() {
+			public Integer exe(java.sql.Statement realStatement, String sql)
+					throws SQLException {
+				return realStatement.executeUpdate(sql, columnNames);
+			}
+		});
+	}
+
+	public boolean execute(String sql, final int autoGeneratedKeys)
+			throws SQLException {
+		return StatementTracing.execute(realStatement, connectInfo, "execute", sql, new Executable<Boolean>() {
+			public Boolean exe(java.sql.Statement realStatement, String sql)
+					throws SQLException {
+				return realStatement.execute(sql, autoGeneratedKeys);
+			}
+		});
+	}
+
+	public boolean execute(String sql, final int[] columnIndexes) throws SQLException {
+		return StatementTracing.execute(realStatement, connectInfo, "execute", sql, new Executable<Boolean>() {
+			public Boolean exe(java.sql.Statement realStatement, String sql)
+					throws SQLException {
+				return realStatement.execute(sql, columnIndexes);
+			}
+		});
+	}
+
+	public boolean execute(String sql, final String[] columnNames)
+			throws SQLException {
+		return StatementTracing.execute(realStatement, connectInfo, "execute", sql, new Executable<Boolean>() {
+			public Boolean exe(java.sql.Statement realStatement, String sql)
+					throws SQLException {
+				return realStatement.execute(sql, columnNames);
+			}
+		});
+	}
+
+	public int getResultSetHoldability() throws SQLException {
+		return realStatement.getResultSetHoldability();
+	}
+
+	public boolean isClosed() throws SQLException {
+		return realStatement.isClosed();
+	}
+
+	public void setPoolable(boolean poolable) throws SQLException {
+		realStatement.setPoolable(poolable);		
+	}
+
+	public boolean isPoolable() throws SQLException {
+		return realStatement.isPoolable();
+	}
+
+	public void closeOnCompletion() throws SQLException {
+		realStatement.closeOnCompletion();		
+	}
+
+	public boolean isCloseOnCompletion() throws SQLException {
+		return realStatement.isCloseOnCompletion();
+	}
+
+}

skywalking-sdk-plugin/jdbc-plugin/src/main/java/com/ai/cloud/skywalking/plugin/jdbc/TracingDriver.java

@@ -0,0 +1,66 @@
+package com.ai.cloud.skywalking.plugin.jdbc;
+
+import java.sql.Driver;
+import java.sql.DriverPropertyInfo;
+import java.sql.SQLException;
+import java.sql.SQLFeatureNotSupportedException;
+import java.util.Properties;
+import java.util.logging.Logger;
+
+public abstract class TracingDriver implements Driver {
+	private static final String TRACING_SIGN = "tracing:";
+
+	private Driver realDriver;
+
+	protected TracingDriver() {
+		this.realDriver = this.registerTracingDriver();
+	}
+
+	protected abstract Driver registerTracingDriver();
+
+	public java.sql.Connection connect(String url, Properties info) throws SQLException {
+		java.sql.Connection conn = this.realDriver.connect(this.getRealUrl(url), info);
+		return new SWConnection(url, info, conn);
+	}
+
+	public boolean acceptsURL(String url) throws SQLException {
+		return this.realDriver.acceptsURL(this.getRealUrl(url));
+	}
+
+	public DriverPropertyInfo[] getPropertyInfo(String url, Properties info)
+			throws SQLException {
+		return this.realDriver.getPropertyInfo(this.getRealUrl(url), info);
+	}
+
+	private String getRealUrl(String url) throws SQLException {
+		if(url.toLowerCase().startsWith(TRACING_SIGN)){
+			return url.substring(TRACING_SIGN.length());
+		}else{
+			throw new SQLException("tracing jdbc url must start with 'tracing:'");
+		}
+	}
+
+	public int getMajorVersion() {
+		return safeIntParse("1");
+	}
+
+	public int getMinorVersion() {
+		return safeIntParse("0");
+	}
+
+	public boolean jdbcCompliant() {
+		return false;
+	}
+
+	public Logger getParentLogger() throws SQLFeatureNotSupportedException {
+		return null;
+	}
+
+	private static int safeIntParse(String intAsString) {
+		try {
+			return Integer.parseInt(intAsString);
+		} catch (NumberFormatException nfe) {
+		}
+		return 0;
+	}
+}

skywalking-sdk-plugin/jdbc-plugin/src/main/java/com/ai/cloud/skywalking/plugin/jdbc/mysql/MySQLTracingDriver.java

@@ -0,0 +1,31 @@
+package com.ai.cloud.skywalking.plugin.jdbc.mysql;
+
+import java.sql.Driver;
+import java.sql.DriverManager;
+import java.sql.SQLException;
+
+import com.ai.cloud.skywalking.plugin.jdbc.TracingDriver;
+
+public class MySQLTracingDriver extends TracingDriver {
+	static {
+		try {
+			DriverManager.registerDriver(new MySQLTracingDriver());
+		} catch (SQLException e) {
+			throw new RuntimeException("register "
+					+ MySQLTracingDriver.class.getName() + " driver failure.");
+		}
+	}
+
+	/**
+	 * 继承自TracingDriver，返回真实的Driver
+	 */
+	@Override
+	protected Driver registerTracingDriver() {
+		try {
+			return new com.mysql.jdbc.Driver();
+		} catch (SQLException e) {
+			throw new RuntimeException("create com.mysql.jdbc.Driver failure.");
+		}
+	}
+
+}

skywalking-sdk-plugin/jdbc-plugin/src/main/java/com/ai/cloud/skywalking/plugin/jdbc/tracing/CallableStatementTracing.java

@@ -0,0 +1,42 @@
+package com.ai.cloud.skywalking.plugin.jdbc.tracing;
+
+import java.sql.SQLException;
+
+import com.ai.cloud.skywalking.buriedpoint.RPCBuriedPointSender;
+import com.ai.cloud.skywalking.model.Identification;
+
+/**
+ * 连接级追踪，用于追踪用于Connection的操作追踪
+ * 
+ * @author wusheng
+ *
+ */
+public class CallableStatementTracing {
+	private static RPCBuriedPointSender sender = new RPCBuriedPointSender();
+
+	public static <R> R execute(java.sql.CallableStatement realStatement,
+			String connectInfo, String method, String sql, Executable<R> exec)
+			throws SQLException {
+		try {
+			sender.beforeSend(Identification
+					.newBuilder()
+					.viewPoint(connectInfo)
+					.businessKey(
+							"callableStatement."
+									+ method
+									+ (sql == null || sql.length() == 0 ? ""
+											: ":" + sql)).spanType('J').build());
+			return exec.exe(realStatement, sql);
+		} catch (SQLException e) {
+			sender.handleException(e);
+			throw e;
+		} finally {
+			sender.afterSend();
+		}
+	}
+
+	public interface Executable<R> {
+		public R exe(java.sql.CallableStatement realConnection, String sql)
+				throws SQLException;
+	}
+}

skywalking-sdk-plugin/jdbc-plugin/src/main/java/com/ai/cloud/skywalking/plugin/jdbc/tracing/ConnectionTracing.java

@@ -0,0 +1,42 @@
+package com.ai.cloud.skywalking.plugin.jdbc.tracing;
+
+import java.sql.SQLException;
+
+import com.ai.cloud.skywalking.buriedpoint.RPCBuriedPointSender;
+import com.ai.cloud.skywalking.model.Identification;
+
+/**
+ * 连接级追踪，用于追踪用于Connection的操作追踪
+ * 
+ * @author wusheng
+ *
+ */
+public class ConnectionTracing {
+	private static RPCBuriedPointSender sender = new RPCBuriedPointSender();
+
+	public static <R> R execute(java.sql.Connection realConnection,
+			String connectInfo, String method, String sql, Executable<R> exec)
+			throws SQLException {
+		try {
+			sender.beforeSend(Identification
+					.newBuilder()
+					.viewPoint(connectInfo)
+					.businessKey(
+							"connection."
+									+ method
+									+ (sql == null || sql.length() == 0 ? ""
+											: ":" + sql)).spanType('J').build());
+			return exec.exe(realConnection, sql);
+		} catch (SQLException e) {
+			sender.handleException(e);
+			throw e;
+		} finally {
+			sender.afterSend();
+		}
+	}
+
+	public interface Executable<R> {
+		public R exe(java.sql.Connection realConnection, String sql)
+				throws SQLException;
+	}
+}

skywalking-sdk-plugin/jdbc-plugin/src/main/java/com/ai/cloud/skywalking/plugin/jdbc/tracing/PreaparedStatementTracing.java

@@ -0,0 +1,42 @@
+package com.ai.cloud.skywalking.plugin.jdbc.tracing;
+
+import java.sql.SQLException;
+
+import com.ai.cloud.skywalking.buriedpoint.RPCBuriedPointSender;
+import com.ai.cloud.skywalking.model.Identification;
+
+/**
+ * 连接级追踪，用于追踪用于Connection的操作追踪
+ * 
+ * @author wusheng
+ *
+ */
+public class PreaparedStatementTracing {
+	private static RPCBuriedPointSender sender = new RPCBuriedPointSender();
+
+	public static <R> R execute(java.sql.PreparedStatement realStatement,
+			String connectInfo, String method, String sql, Executable<R> exec)
+			throws SQLException {
+		try {
+			sender.beforeSend(Identification
+					.newBuilder()
+					.viewPoint(connectInfo)
+					.businessKey(
+							"preaparedStatement."
+									+ method
+									+ (sql == null || sql.length() == 0 ? ""
+											: ":" + sql)).spanType('J').build());
+			return exec.exe(realStatement, sql);
+		} catch (SQLException e) {
+			sender.handleException(e);
+			throw e;
+		} finally {
+			sender.afterSend();
+		}
+	}
+
+	public interface Executable<R> {
+		public R exe(java.sql.PreparedStatement realConnection, String sql)
+				throws SQLException;
+	}
+}

skywalking-sdk-plugin/jdbc-plugin/src/main/java/com/ai/cloud/skywalking/plugin/jdbc/tracing/StatementTracing.java

@@ -0,0 +1,42 @@
+package com.ai.cloud.skywalking.plugin.jdbc.tracing;
+
+import java.sql.SQLException;
+
+import com.ai.cloud.skywalking.buriedpoint.RPCBuriedPointSender;
+import com.ai.cloud.skywalking.model.Identification;
+
+/**
+ * 连接级追踪，用于追踪用于Statement的操作追踪
+ * 
+ * @author wusheng
+ *
+ */
+public class StatementTracing {
+	private static RPCBuriedPointSender sender = new RPCBuriedPointSender();
+
+	public static <R> R execute(java.sql.Statement realStatement,
+			String connectInfo, String method, String sql, Executable<R> exec)
+			throws SQLException {
+		try {
+			sender.beforeSend(Identification
+					.newBuilder()
+					.viewPoint(connectInfo)
+					.businessKey(
+							"statement."
+									+ method
+									+ (sql == null || sql.length() == 0 ? ""
+											: ":" + sql)).spanType('J').build());
+			return exec.exe(realStatement, sql);
+		} catch (SQLException e) {
+			sender.handleException(e);
+			throw e;
+		} finally {
+			sender.afterSend();
+		}
+	}
+
+	public interface Executable<R> {
+		public R exe(java.sql.Statement realStatement, String sql)
+				throws SQLException;
+	}
+}