From 9aa957c481e43945c10be2a5b523ec173c07003f Mon Sep 17 00:00:00 2001 From: wusheng Date: Wed, 16 Mar 2016 15:01:40 +0800 Subject: [PATCH] =?UTF-8?q?1.=E6=81=A2=E5=A4=8Djdbc-plugin=EF=BC=8C?= =?UTF-8?q?=E4=BD=BF=E7=94=A8=E4=BB=A3=E7=A0=81=E6=9B=BF=E6=8D=A2=E7=9A=84?= =?UTF-8?q?=E6=A8=A1=E5=BC=8F=E5=AE=9E=E7=8E=B0oracle-plugin=EF=BC=8C?= =?UTF-8?q?=E4=BB=A3=E7=A0=81=E8=BF=87=E4=BA=8E=E5=A4=8D=E6=9D=82=E5=92=8C?= =?UTF-8?q?=E7=AC=A8=E9=87=8D=E3=80=82=202.=E7=A7=BB=E9=99=A4jdbc-plugin?= =?UTF-8?q?=EF=BC=8C=E5=AF=B9=E4=BA=8Econnection.nativeSQL=E7=9A=84?= =?UTF-8?q?=E8=BF=BD=E8=B8=AA=E3=80=82?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- skywalking-sdk-plugin/jdbc-plugin/pom.xml | 64 + .../plugin/jdbc/JDBCBuriedPointType.java | 32 + .../plugin/jdbc/SWCallableStatement.java | 1058 +++++++++++++++++ .../skywalking/plugin/jdbc/SWConnection.java | 326 +++++ .../plugin/jdbc/SWPreparedStatement.java | 537 +++++++++ .../skywalking/plugin/jdbc/SWStatement.java | 254 ++++ .../skywalking/plugin/jdbc/TracingDriver.java | 72 ++ .../plugin/jdbc/mysql/MySQLTracingDriver.java | 31 + .../tracing/CallableStatementTracing.java | 43 + .../jdbc/tracing/ConnectionTracing.java | 43 + .../tracing/PreparedStatementTracing.java | 43 + .../plugin/jdbc/tracing/StatementTracing.java | 42 + skywalking-sdk-plugin/pom.xml | 6 +- 13 files changed, 2549 insertions(+), 2 deletions(-) create mode 100755 skywalking-sdk-plugin/jdbc-plugin/pom.xml create mode 100755 skywalking-sdk-plugin/jdbc-plugin/src/main/java/com/ai/cloud/skywalking/plugin/jdbc/JDBCBuriedPointType.java create mode 100755 skywalking-sdk-plugin/jdbc-plugin/src/main/java/com/ai/cloud/skywalking/plugin/jdbc/SWCallableStatement.java create mode 100755 skywalking-sdk-plugin/jdbc-plugin/src/main/java/com/ai/cloud/skywalking/plugin/jdbc/SWConnection.java create mode 100755 skywalking-sdk-plugin/jdbc-plugin/src/main/java/com/ai/cloud/skywalking/plugin/jdbc/SWPreparedStatement.java create mode 100755 skywalking-sdk-plugin/jdbc-plugin/src/main/java/com/ai/cloud/skywalking/plugin/jdbc/SWStatement.java create mode 100755 skywalking-sdk-plugin/jdbc-plugin/src/main/java/com/ai/cloud/skywalking/plugin/jdbc/TracingDriver.java create mode 100755 skywalking-sdk-plugin/jdbc-plugin/src/main/java/com/ai/cloud/skywalking/plugin/jdbc/mysql/MySQLTracingDriver.java create mode 100755 skywalking-sdk-plugin/jdbc-plugin/src/main/java/com/ai/cloud/skywalking/plugin/jdbc/tracing/CallableStatementTracing.java create mode 100755 skywalking-sdk-plugin/jdbc-plugin/src/main/java/com/ai/cloud/skywalking/plugin/jdbc/tracing/ConnectionTracing.java create mode 100755 skywalking-sdk-plugin/jdbc-plugin/src/main/java/com/ai/cloud/skywalking/plugin/jdbc/tracing/PreparedStatementTracing.java create mode 100755 skywalking-sdk-plugin/jdbc-plugin/src/main/java/com/ai/cloud/skywalking/plugin/jdbc/tracing/StatementTracing.java diff --git a/skywalking-sdk-plugin/jdbc-plugin/pom.xml b/skywalking-sdk-plugin/jdbc-plugin/pom.xml new file mode 100755 index 000000000..04ed251e3 --- /dev/null +++ b/skywalking-sdk-plugin/jdbc-plugin/pom.xml @@ -0,0 +1,64 @@ + + + skywalking-sdk-plugin + com.ai.cloud + 1.0-SNAPSHOT + + 4.0.0 + + skywalking-jdbc-plugin + jar + + jdbc-plugin + http://maven.apache.org + + + UTF-8 + + + + + com.ai.cloud + skywalking-api + ${project.version} + + + mysql + mysql-connector-java + 5.1.36 + compile + + + + + + + maven-compiler-plugin + + 1.7 + 1.7 + ${project.build.sourceEncoding} + + + + org.apache.maven.plugins + maven-deploy-plugin + + + + org.apache.maven.plugins + maven-source-plugin + + + + attach-sources + + jar + + + + + + + diff --git a/skywalking-sdk-plugin/jdbc-plugin/src/main/java/com/ai/cloud/skywalking/plugin/jdbc/JDBCBuriedPointType.java b/skywalking-sdk-plugin/jdbc-plugin/src/main/java/com/ai/cloud/skywalking/plugin/jdbc/JDBCBuriedPointType.java new file mode 100755 index 000000000..bacb6a948 --- /dev/null +++ b/skywalking-sdk-plugin/jdbc-plugin/src/main/java/com/ai/cloud/skywalking/plugin/jdbc/JDBCBuriedPointType.java @@ -0,0 +1,32 @@ +package com.ai.cloud.skywalking.plugin.jdbc; + +import com.ai.cloud.skywalking.api.IBuriedPointType; +import com.ai.cloud.skywalking.protocol.CallType; + +public class JDBCBuriedPointType implements IBuriedPointType { + + private static JDBCBuriedPointType jdbcBuriedPointType; + + public static IBuriedPointType instance() { + if (jdbcBuriedPointType == null) { + jdbcBuriedPointType = new JDBCBuriedPointType(); + } + + return jdbcBuriedPointType; + } + + + @Override + public String getTypeName() { + return "J"; + } + + @Override + public CallType getCallType() { + return CallType.LOCAL; + } + + private JDBCBuriedPointType(){ + //Non + } +} diff --git a/skywalking-sdk-plugin/jdbc-plugin/src/main/java/com/ai/cloud/skywalking/plugin/jdbc/SWCallableStatement.java b/skywalking-sdk-plugin/jdbc-plugin/src/main/java/com/ai/cloud/skywalking/plugin/jdbc/SWCallableStatement.java new file mode 100755 index 000000000..65b3d5045 --- /dev/null +++ b/skywalking-sdk-plugin/jdbc-plugin/src/main/java/com/ai/cloud/skywalking/plugin/jdbc/SWCallableStatement.java @@ -0,0 +1,1058 @@ +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.CallableStatement; +import java.sql.Clob; +import java.sql.Connection; +import java.sql.Date; +import java.sql.NClob; +import java.sql.ParameterMetaData; +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 java.util.Map; + +import com.ai.cloud.skywalking.plugin.jdbc.tracing.CallableStatementTracing; +import com.ai.cloud.skywalking.plugin.jdbc.tracing.CallableStatementTracing.Executable; + +public class SWCallableStatement implements CallableStatement { + private SWConnection realConnection; + private java.sql.CallableStatement realStatement; + private String connectInfo; + private String sql; + + SWCallableStatement(SWConnection realConnection, + java.sql.CallableStatement realStatement, String connectInfo, + String sql) { + this.realConnection = realConnection; + this.realStatement = realStatement; + this.connectInfo = connectInfo; + this.sql = sql; + } + + public ResultSet executeQuery() throws SQLException { + return CallableStatementTracing.execute(realStatement, connectInfo, + "executeQuery", sql, new Executable() { + public ResultSet exe( + java.sql.CallableStatement realStatement, String sql) + throws SQLException { + return realStatement.executeQuery(); + } + }); + } + + public int executeUpdate() throws SQLException { + return CallableStatementTracing.execute(realStatement, connectInfo, + "executeUpdate", sql, new Executable() { + public Integer exe( + java.sql.CallableStatement 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 CallableStatementTracing.execute(realStatement, connectInfo, + "execute", sql, new Executable() { + public Boolean exe( + java.sql.CallableStatement 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); + } + + public ResultSet executeQuery(String sql) throws SQLException { + return CallableStatementTracing.execute(realStatement, connectInfo, + "executeQuery", sql, new Executable() { + public ResultSet exe( + java.sql.CallableStatement realStatement, String sql) + throws SQLException { + return realStatement.executeQuery(sql); + } + }); + } + + public int executeUpdate(String sql) throws SQLException { + return CallableStatementTracing.execute(realStatement, connectInfo, + "executeUpdate", sql, new Executable() { + public Integer exe( + java.sql.CallableStatement 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 CallableStatementTracing.execute(realStatement, connectInfo, + "execute", sql, new Executable() { + public Boolean exe( + java.sql.CallableStatement 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(); + } + + public void clearBatch() throws SQLException { + realStatement.clearBatch(); + } + + public int[] executeBatch() throws SQLException { + return CallableStatementTracing.execute(realStatement, connectInfo, + "executeBatch", "", new Executable() { + public int[] exe( + java.sql.CallableStatement 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 CallableStatementTracing.execute(realStatement, connectInfo, + "executeUpdate", sql, new Executable() { + public Integer exe( + java.sql.CallableStatement realStatement, String sql) + throws SQLException { + return realStatement.executeUpdate(sql, autoGeneratedKeys); + } + }); + } + + public int executeUpdate(String sql, final int[] columnIndexes) + throws SQLException { + return CallableStatementTracing.execute(realStatement, connectInfo, + "executeUpdate", sql, new Executable() { + public Integer exe( + java.sql.CallableStatement realStatement, String sql) + throws SQLException { + return realStatement.executeUpdate(sql, columnIndexes); + } + }); + } + + public int executeUpdate(String sql, final String[] columnNames) + throws SQLException { + return CallableStatementTracing.execute(realStatement, connectInfo, + "executeUpdate", sql, new Executable() { + public Integer exe( + java.sql.CallableStatement realStatement, String sql) + throws SQLException { + return realStatement.executeUpdate(sql, columnNames); + } + }); + } + + public boolean execute(String sql, final int autoGeneratedKeys) + throws SQLException { + return CallableStatementTracing.execute(realStatement, connectInfo, + "execute", sql, new Executable() { + public Boolean exe( + java.sql.CallableStatement realStatement, String sql) + throws SQLException { + return realStatement.execute(sql, autoGeneratedKeys); + } + }); + } + + public boolean execute(String sql, final int[] columnIndexes) throws SQLException { + return CallableStatementTracing.execute(realStatement, connectInfo, + "execute", sql, new Executable() { + public Boolean exe( + java.sql.CallableStatement realStatement, String sql) + throws SQLException { + return realStatement.execute(sql, columnIndexes); + } + }); + } + + public boolean execute(String sql, final String[] columnNames) + throws SQLException { + return CallableStatementTracing.execute(realStatement, connectInfo, + "execute", sql, new Executable() { + public Boolean exe( + java.sql.CallableStatement 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 unwrap(Class iface) throws SQLException { + return realStatement.unwrap(iface); + } + + public boolean isWrapperFor(Class iface) throws SQLException { + return realStatement.isWrapperFor(iface); + } + + public void registerOutParameter(int parameterIndex, int sqlType) + throws SQLException { + realStatement.registerOutParameter(parameterIndex, sqlType); + } + + public void registerOutParameter(int parameterIndex, int sqlType, int scale) + throws SQLException { + realStatement.registerOutParameter(parameterIndex, sqlType, scale); + } + + public boolean wasNull() throws SQLException { + return realStatement.wasNull(); + } + + public String getString(int parameterIndex) throws SQLException { + return realStatement.getString(parameterIndex); + } + + public boolean getBoolean(int parameterIndex) throws SQLException { + return realStatement.getBoolean(parameterIndex); + } + + public byte getByte(int parameterIndex) throws SQLException { + return realStatement.getByte(parameterIndex); + } + + public short getShort(int parameterIndex) throws SQLException { + return realStatement.getShort(parameterIndex); + } + + public int getInt(int parameterIndex) throws SQLException { + return realStatement.getInt(parameterIndex); + } + + public long getLong(int parameterIndex) throws SQLException { + return realStatement.getLong(parameterIndex); + } + + public float getFloat(int parameterIndex) throws SQLException { + return realStatement.getFloat(parameterIndex); + } + + public double getDouble(int parameterIndex) throws SQLException { + return realStatement.getDouble(parameterIndex); + } + + @Deprecated + public BigDecimal getBigDecimal(int parameterIndex, int scale) + throws SQLException { + return realStatement.getBigDecimal(parameterIndex, scale); + } + + public byte[] getBytes(int parameterIndex) throws SQLException { + return realStatement.getBytes(parameterIndex); + } + + public Date getDate(int parameterIndex) throws SQLException { + return realStatement.getDate(parameterIndex); + } + + public Time getTime(int parameterIndex) throws SQLException { + return realStatement.getTime(parameterIndex); + } + + public Timestamp getTimestamp(int parameterIndex) throws SQLException { + return realStatement.getTimestamp(parameterIndex); + } + + public Object getObject(int parameterIndex) throws SQLException { + return realStatement.getObject(parameterIndex); + } + + public BigDecimal getBigDecimal(int parameterIndex) throws SQLException { + return realStatement.getBigDecimal(parameterIndex); + } + + public Object getObject(int parameterIndex, Map> map) + throws SQLException { + return realStatement.getObject(parameterIndex, map); + } + + public Ref getRef(int parameterIndex) throws SQLException { + return realStatement.getRef(parameterIndex); + } + + public Blob getBlob(int parameterIndex) throws SQLException { + return realStatement.getBlob(parameterIndex); + } + + public Clob getClob(int parameterIndex) throws SQLException { + return realStatement.getClob(parameterIndex); + } + + public Array getArray(int parameterIndex) throws SQLException { + return realStatement.getArray(parameterIndex); + } + + public Date getDate(int parameterIndex, Calendar cal) throws SQLException { + return realStatement.getDate(parameterIndex, cal); + } + + public Time getTime(int parameterIndex, Calendar cal) throws SQLException { + return realStatement.getTime(parameterIndex, cal); + } + + public Timestamp getTimestamp(int parameterIndex, Calendar cal) + throws SQLException { + return realStatement.getTimestamp(parameterIndex, cal); + } + + public void registerOutParameter(int parameterIndex, int sqlType, + String typeName) throws SQLException { + realStatement.registerOutParameter(parameterIndex, sqlType, typeName); + } + + public void registerOutParameter(String parameterName, int sqlType) + throws SQLException { + realStatement.registerOutParameter(parameterName, sqlType); + } + + public void registerOutParameter(String parameterName, int sqlType, + int scale) throws SQLException { + realStatement.registerOutParameter(parameterName, sqlType, scale); + } + + public void registerOutParameter(String parameterName, int sqlType, + String typeName) throws SQLException { + realStatement.registerOutParameter(parameterName, sqlType, typeName); + } + + public URL getURL(int parameterIndex) throws SQLException { + return realStatement.getURL(parameterIndex); + } + + public void setURL(String parameterName, URL val) throws SQLException { + realStatement.setURL(parameterName, val); + } + + public void setNull(String parameterName, int sqlType) throws SQLException { + realStatement.setNull(parameterName, sqlType); + } + + public void setBoolean(String parameterName, boolean x) throws SQLException { + realStatement.setBoolean(parameterName, x); + } + + public void setByte(String parameterName, byte x) throws SQLException { + realStatement.setByte(parameterName, x); + } + + public void setShort(String parameterName, short x) throws SQLException { + realStatement.setShort(parameterName, x); + } + + public void setInt(String parameterName, int x) throws SQLException { + realStatement.setInt(parameterName, x); + } + + public void setLong(String parameterName, long x) throws SQLException { + realStatement.setLong(parameterName, x); + } + + public void setFloat(String parameterName, float x) throws SQLException { + realStatement.setFloat(parameterName, x); + } + + public void setDouble(String parameterName, double x) throws SQLException { + realStatement.setDouble(parameterName, x); + } + + public void setBigDecimal(String parameterName, BigDecimal x) + throws SQLException { + realStatement.setBigDecimal(parameterName, x); + } + + public void setString(String parameterName, String x) throws SQLException { + realStatement.setString(parameterName, x); + } + + public void setBytes(String parameterName, byte[] x) throws SQLException { + realStatement.setBytes(parameterName, x); + } + + public void setDate(String parameterName, Date x) throws SQLException { + realStatement.setDate(parameterName, x); + } + + public void setTime(String parameterName, Time x) throws SQLException { + realStatement.setTime(parameterName, x); + } + + public void setTimestamp(String parameterName, Timestamp x) + throws SQLException { + realStatement.setTimestamp(parameterName, x); + } + + public void setAsciiStream(String parameterName, InputStream x, int length) + throws SQLException { + realStatement.setAsciiStream(parameterName, x, length); + } + + public void setBinaryStream(String parameterName, InputStream x, int length) + throws SQLException { + realStatement.setBinaryStream(parameterName, x, length); + } + + public void setObject(String parameterName, Object x, int targetSqlType, + int scale) throws SQLException { + realStatement.setObject(parameterName, x, targetSqlType, scale); + } + + public void setObject(String parameterName, Object x, int targetSqlType) + throws SQLException { + realStatement.setObject(parameterName, x, targetSqlType); + } + + public void setObject(String parameterName, Object x) throws SQLException { + realStatement.setObject(parameterName, x); + } + + public void setCharacterStream(String parameterName, Reader reader, + int length) throws SQLException { + realStatement.setCharacterStream(parameterName, reader, length); + } + + public void setDate(String parameterName, Date x, Calendar cal) + throws SQLException { + realStatement.setDate(parameterName, x, cal); + } + + public void setTime(String parameterName, Time x, Calendar cal) + throws SQLException { + realStatement.setTime(parameterName, x, cal); + } + + public void setTimestamp(String parameterName, Timestamp x, Calendar cal) + throws SQLException { + realStatement.setTimestamp(parameterName, x, cal); + } + + public void setNull(String parameterName, int sqlType, String typeName) + throws SQLException { + realStatement.setNull(parameterName, sqlType, typeName); + } + + public String getString(String parameterName) throws SQLException { + return realStatement.getString(parameterName); + } + + public boolean getBoolean(String parameterName) throws SQLException { + return realStatement.getBoolean(parameterName); + } + + public byte getByte(String parameterName) throws SQLException { + return realStatement.getByte(parameterName); + } + + public short getShort(String parameterName) throws SQLException { + return realStatement.getShort(parameterName); + } + + public int getInt(String parameterName) throws SQLException { + return realStatement.getInt(parameterName); + } + + public long getLong(String parameterName) throws SQLException { + return realStatement.getLong(parameterName); + } + + public float getFloat(String parameterName) throws SQLException { + return realStatement.getFloat(parameterName); + } + + public double getDouble(String parameterName) throws SQLException { + return realStatement.getDouble(parameterName); + } + + public byte[] getBytes(String parameterName) throws SQLException { + return realStatement.getBytes(parameterName); + } + + public Date getDate(String parameterName) throws SQLException { + return realStatement.getDate(parameterName); + } + + public Time getTime(String parameterName) throws SQLException { + return realStatement.getTime(parameterName); + } + + public Timestamp getTimestamp(String parameterName) throws SQLException { + return realStatement.getTimestamp(parameterName); + } + + public Object getObject(String parameterName) throws SQLException { + return realStatement.getObject(parameterName); + } + + public BigDecimal getBigDecimal(String parameterName) throws SQLException { + return realStatement.getBigDecimal(parameterName); + } + + public Object getObject(String parameterName, Map> map) + throws SQLException { + return realStatement.getObject(parameterName, map); + } + + public Ref getRef(String parameterName) throws SQLException { + return realStatement.getRef(parameterName); + } + + public Blob getBlob(String parameterName) throws SQLException { + return realStatement.getBlob(parameterName); + } + + public Clob getClob(String parameterName) throws SQLException { + return realStatement.getClob(parameterName); + } + + public Array getArray(String parameterName) throws SQLException { + return realStatement.getArray(parameterName); + } + + public Date getDate(String parameterName, Calendar cal) throws SQLException { + return realStatement.getDate(parameterName, cal); + } + + public Time getTime(String parameterName, Calendar cal) throws SQLException { + return realStatement.getTime(parameterName, cal); + } + + public Timestamp getTimestamp(String parameterName, Calendar cal) + throws SQLException { + return realStatement.getTimestamp(parameterName, cal); + } + + public URL getURL(String parameterName) throws SQLException { + return realStatement.getURL(parameterName); + } + + public RowId getRowId(int parameterIndex) throws SQLException { + return realStatement.getRowId(parameterIndex); + } + + public RowId getRowId(String parameterName) throws SQLException { + return realStatement.getRowId(parameterName); + } + + public void setRowId(String parameterName, RowId x) throws SQLException { + realStatement.setRowId(parameterName, x); + } + + public void setNString(String parameterName, String value) + throws SQLException { + realStatement.setNString(parameterName, value); + } + + public void setNCharacterStream(String parameterName, Reader value, + long length) throws SQLException { + realStatement.setNCharacterStream(parameterName, value, length); + } + + public void setNClob(String parameterName, NClob value) throws SQLException { + realStatement.setNClob(parameterName, value); + } + + public void setClob(String parameterName, Reader reader, long length) + throws SQLException { + realStatement.setClob(parameterName, reader, length); + } + + public void setBlob(String parameterName, InputStream inputStream, + long length) throws SQLException { + realStatement.setBlob(parameterName, inputStream, length); + } + + public void setNClob(String parameterName, Reader reader, long length) + throws SQLException { + realStatement.setNClob(parameterName, reader, length); + } + + public NClob getNClob(int parameterIndex) throws SQLException { + return realStatement.getNClob(parameterIndex); + } + + public NClob getNClob(String parameterName) throws SQLException { + return realStatement.getNClob(parameterName); + } + + public void setSQLXML(String parameterName, SQLXML xmlObject) + throws SQLException { + realStatement.setSQLXML(parameterName, xmlObject); + } + + public SQLXML getSQLXML(int parameterIndex) throws SQLException { + return realStatement.getSQLXML(parameterIndex); + } + + public SQLXML getSQLXML(String parameterName) throws SQLException { + return realStatement.getSQLXML(parameterName); + } + + public String getNString(int parameterIndex) throws SQLException { + return realStatement.getNString(parameterIndex); + } + + public String getNString(String parameterName) throws SQLException { + return realStatement.getNString(parameterName); + } + + public Reader getNCharacterStream(int parameterIndex) throws SQLException { + return realStatement.getNCharacterStream(parameterIndex); + } + + public Reader getNCharacterStream(String parameterName) throws SQLException { + return realStatement.getNCharacterStream(parameterName); + } + + public Reader getCharacterStream(int parameterIndex) throws SQLException { + return realStatement.getCharacterStream(parameterIndex); + } + + public Reader getCharacterStream(String parameterName) throws SQLException { + return realStatement.getCharacterStream(parameterName); + } + + public void setBlob(String parameterName, Blob x) throws SQLException { + realStatement.setBlob(parameterName, x); + } + + public void setClob(String parameterName, Clob x) throws SQLException { + realStatement.setClob(parameterName, x); + } + + public void setAsciiStream(String parameterName, InputStream x, long length) + throws SQLException { + realStatement.setAsciiStream(parameterName, x, length); + } + + public void setBinaryStream(String parameterName, InputStream x, long length) + throws SQLException { + realStatement.setBinaryStream(parameterName, x, length); + } + + public void setCharacterStream(String parameterName, Reader reader, + long length) throws SQLException { + realStatement.setCharacterStream(parameterName, reader, length); + } + + public void setAsciiStream(String parameterName, InputStream x) + throws SQLException { + realStatement.setAsciiStream(parameterName, x); + } + + public void setBinaryStream(String parameterName, InputStream x) + throws SQLException { + realStatement.setBinaryStream(parameterName, x); + } + + public void setCharacterStream(String parameterName, Reader reader) + throws SQLException { + realStatement.setCharacterStream(parameterName, reader); + } + + public void setNCharacterStream(String parameterName, Reader value) + throws SQLException { + realStatement.setNCharacterStream(parameterName, value); + } + + public void setClob(String parameterName, Reader reader) + throws SQLException { + realStatement.setClob(parameterName, reader); + } + + public void setBlob(String parameterName, InputStream inputStream) + throws SQLException { + realStatement.setBlob(parameterName, inputStream); + } + + public void setNClob(String parameterName, Reader reader) + throws SQLException { + realStatement.setNClob(parameterName, reader); + } + + public T getObject(int parameterIndex, Class type) + throws SQLException { + return realStatement.getObject(parameterIndex, type); + } + + public T getObject(String parameterName, Class type) + throws SQLException { + return realStatement.getObject(parameterName, type); + } + +} diff --git a/skywalking-sdk-plugin/jdbc-plugin/src/main/java/com/ai/cloud/skywalking/plugin/jdbc/SWConnection.java b/skywalking-sdk-plugin/jdbc-plugin/src/main/java/com/ai/cloud/skywalking/plugin/jdbc/SWConnection.java new file mode 100755 index 000000000..a52054466 --- /dev/null +++ b/skywalking-sdk-plugin/jdbc-plugin/src/main/java/com/ai/cloud/skywalking/plugin/jdbc/SWConnection.java @@ -0,0 +1,326 @@ +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 unwrap(Class 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() { + 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() { + 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() { + public String exe(java.sql.Connection realConnection, + String sql) throws SQLException { + realConnection.rollback(); + return null; + } + }); + } + + public void close() throws SQLException { + ConnectionTracing.execute(realConnection, connectInfo, "close", "", + new Executable() { + public String exe(java.sql.Connection realConnection, + String sql) throws SQLException { + realConnection.close(); + return null; + } + }); + } + + 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> getTypeMap() throws SQLException { + return realConnection.getTypeMap(); + } + + public void setTypeMap(Map> 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() { + 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() { + 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(); + } + +} diff --git a/skywalking-sdk-plugin/jdbc-plugin/src/main/java/com/ai/cloud/skywalking/plugin/jdbc/SWPreparedStatement.java b/skywalking-sdk-plugin/jdbc-plugin/src/main/java/com/ai/cloud/skywalking/plugin/jdbc/SWPreparedStatement.java new file mode 100755 index 000000000..7f9febd4e --- /dev/null +++ b/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.PreparedStatementTracing; +import com.ai.cloud.skywalking.plugin.jdbc.tracing.PreparedStatementTracing.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 PreparedStatementTracing.execute(realStatement, connectInfo, "executeQuery", sql, new Executable() { + public ResultSet exe(java.sql.PreparedStatement realStatement, String sql) + throws SQLException { + return realStatement.executeQuery(sql); + } + }); + } + + public int executeUpdate(String sql) throws SQLException { + return PreparedStatementTracing.execute(realStatement, connectInfo, "executeUpdate", sql, new Executable() { + 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 PreparedStatementTracing.execute(realStatement, connectInfo, "execute", sql, new Executable() { + 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 PreparedStatementTracing.execute(realStatement, connectInfo, "executeBatch", "", new Executable() { + 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 PreparedStatementTracing.execute(realStatement, connectInfo, "executeUpdate", sql, new Executable() { + 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 PreparedStatementTracing.execute(realStatement, connectInfo, "executeUpdate", sql, new Executable() { + 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 PreparedStatementTracing.execute(realStatement, connectInfo, "executeUpdate", sql, new Executable() { + 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 PreparedStatementTracing.execute(realStatement, connectInfo, "execute", sql, new Executable() { + 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 PreparedStatementTracing.execute(realStatement, connectInfo, "execute", sql, new Executable() { + 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 PreparedStatementTracing.execute(realStatement, connectInfo, "execute", sql, new Executable() { + 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 unwrap(Class iface) throws SQLException { + return realStatement.unwrap(iface); + } + + public boolean isWrapperFor(Class iface) throws SQLException { + return realStatement.isWrapperFor(iface); + } + + public ResultSet executeQuery() throws SQLException { + return PreparedStatementTracing.execute(realStatement, connectInfo, "executeQuery", sql, new Executable() { + public ResultSet exe(java.sql.PreparedStatement realStatement, String sql) + throws SQLException { + return realStatement.executeQuery(); + } + }); + } + + public int executeUpdate() throws SQLException { + return PreparedStatementTracing.execute(realStatement, connectInfo, "executeUpdate", sql, new Executable() { + 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 PreparedStatementTracing.execute(realStatement, connectInfo, "executeUpdate", sql, new Executable() { + 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); + } + +} diff --git a/skywalking-sdk-plugin/jdbc-plugin/src/main/java/com/ai/cloud/skywalking/plugin/jdbc/SWStatement.java b/skywalking-sdk-plugin/jdbc-plugin/src/main/java/com/ai/cloud/skywalking/plugin/jdbc/SWStatement.java new file mode 100755 index 000000000..e577c5cad --- /dev/null +++ b/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 unwrap(Class 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() { + 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() { + 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() { + 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() { + 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() { + 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() { + 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() { + 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() { + 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() { + 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() { + 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(); + } + +} diff --git a/skywalking-sdk-plugin/jdbc-plugin/src/main/java/com/ai/cloud/skywalking/plugin/jdbc/TracingDriver.java b/skywalking-sdk-plugin/jdbc-plugin/src/main/java/com/ai/cloud/skywalking/plugin/jdbc/TracingDriver.java new file mode 100755 index 000000000..3433e6e34 --- /dev/null +++ b/skywalking-sdk-plugin/jdbc-plugin/src/main/java/com/ai/cloud/skywalking/plugin/jdbc/TracingDriver.java @@ -0,0 +1,72 @@ +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; + +import com.ai.cloud.skywalking.conf.AuthDesc; + +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); + if(!AuthDesc.isAuth()){ + return conn; + }else{ + 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; + } +} diff --git a/skywalking-sdk-plugin/jdbc-plugin/src/main/java/com/ai/cloud/skywalking/plugin/jdbc/mysql/MySQLTracingDriver.java b/skywalking-sdk-plugin/jdbc-plugin/src/main/java/com/ai/cloud/skywalking/plugin/jdbc/mysql/MySQLTracingDriver.java new file mode 100755 index 000000000..6d0b94efa --- /dev/null +++ b/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."); + } + } + +} diff --git a/skywalking-sdk-plugin/jdbc-plugin/src/main/java/com/ai/cloud/skywalking/plugin/jdbc/tracing/CallableStatementTracing.java b/skywalking-sdk-plugin/jdbc-plugin/src/main/java/com/ai/cloud/skywalking/plugin/jdbc/tracing/CallableStatementTracing.java new file mode 100755 index 000000000..759c55dd1 --- /dev/null +++ b/skywalking-sdk-plugin/jdbc-plugin/src/main/java/com/ai/cloud/skywalking/plugin/jdbc/tracing/CallableStatementTracing.java @@ -0,0 +1,43 @@ +package com.ai.cloud.skywalking.plugin.jdbc.tracing; + +import java.sql.SQLException; + +import com.ai.cloud.skywalking.buriedpoint.RPCBuriedPointSender; +import com.ai.cloud.skywalking.plugin.jdbc.JDBCBuriedPointType; +import com.ai.cloud.skywalking.model.Identification; + +/** + * 连接级追踪，用于追踪用于Connection的操作追踪 + * + * @author wusheng + * + */ +public class CallableStatementTracing { + private static RPCBuriedPointSender sender = new RPCBuriedPointSender(); + + public static R execute(java.sql.CallableStatement realStatement, + String connectInfo, String method, String sql, Executable exec) + throws SQLException { + try { + sender.beforeSend(Identification + .newBuilder() + .viewPoint(connectInfo) + .businessKey( + "callableStatement." + + method + + (sql == null || sql.length() == 0 ? "" + : ":" + sql)).spanType(JDBCBuriedPointType.instance()).build()); + return exec.exe(realStatement, sql); + } catch (SQLException e) { + sender.handleException(e); + throw e; + } finally { + sender.afterSend(); + } + } + + public interface Executable { + public R exe(java.sql.CallableStatement realConnection, String sql) + throws SQLException; + } +} diff --git a/skywalking-sdk-plugin/jdbc-plugin/src/main/java/com/ai/cloud/skywalking/plugin/jdbc/tracing/ConnectionTracing.java b/skywalking-sdk-plugin/jdbc-plugin/src/main/java/com/ai/cloud/skywalking/plugin/jdbc/tracing/ConnectionTracing.java new file mode 100755 index 000000000..d2d76a589 --- /dev/null +++ b/skywalking-sdk-plugin/jdbc-plugin/src/main/java/com/ai/cloud/skywalking/plugin/jdbc/tracing/ConnectionTracing.java @@ -0,0 +1,43 @@ +package com.ai.cloud.skywalking.plugin.jdbc.tracing; + +import java.sql.SQLException; + +import com.ai.cloud.skywalking.buriedpoint.RPCBuriedPointSender; +import com.ai.cloud.skywalking.plugin.jdbc.JDBCBuriedPointType; +import com.ai.cloud.skywalking.model.Identification; + +/** + * 连接级追踪，用于追踪用于Connection的操作追踪 + * + * @author wusheng + * + */ +public class ConnectionTracing { + private static RPCBuriedPointSender sender = new RPCBuriedPointSender(); + + public static R execute(java.sql.Connection realConnection, + String connectInfo, String method, String sql, Executable exec) + throws SQLException { + try { + sender.beforeSend(Identification + .newBuilder() + .viewPoint(connectInfo) + .businessKey( + "connection." + + method + + (sql == null || sql.length() == 0 ? "" + : ":" + sql)).spanType(JDBCBuriedPointType.instance()).build()); + return exec.exe(realConnection, sql); + } catch (SQLException e) { + sender.handleException(e); + throw e; + } finally { + sender.afterSend(); + } + } + + public interface Executable { + public R exe(java.sql.Connection realConnection, String sql) + throws SQLException; + } +} diff --git a/skywalking-sdk-plugin/jdbc-plugin/src/main/java/com/ai/cloud/skywalking/plugin/jdbc/tracing/PreparedStatementTracing.java b/skywalking-sdk-plugin/jdbc-plugin/src/main/java/com/ai/cloud/skywalking/plugin/jdbc/tracing/PreparedStatementTracing.java new file mode 100755 index 000000000..d3535e386 --- /dev/null +++ b/skywalking-sdk-plugin/jdbc-plugin/src/main/java/com/ai/cloud/skywalking/plugin/jdbc/tracing/PreparedStatementTracing.java @@ -0,0 +1,43 @@ +package com.ai.cloud.skywalking.plugin.jdbc.tracing; + +import java.sql.SQLException; + +import com.ai.cloud.skywalking.buriedpoint.RPCBuriedPointSender; +import com.ai.cloud.skywalking.plugin.jdbc.JDBCBuriedPointType; +import com.ai.cloud.skywalking.model.Identification; + +/** + * 连接级追踪，用于追踪用于Connection的操作追踪 + * + * @author wusheng + * + */ +public class PreparedStatementTracing { + private static RPCBuriedPointSender sender = new RPCBuriedPointSender(); + + public static R execute(java.sql.PreparedStatement realStatement, + String connectInfo, String method, String sql, Executable exec) + throws SQLException { + try { + sender.beforeSend(Identification + .newBuilder() + .viewPoint(connectInfo) + .businessKey( + "preaparedStatement." + + method + + (sql == null || sql.length() == 0 ? "" + : ":" + sql)).spanType(JDBCBuriedPointType.instance()).build()); + return exec.exe(realStatement, sql); + } catch (SQLException e) { + sender.handleException(e); + throw e; + } finally { + sender.afterSend(); + } + } + + public interface Executable { + public R exe(java.sql.PreparedStatement realConnection, String sql) + throws SQLException; + } +} diff --git a/skywalking-sdk-plugin/jdbc-plugin/src/main/java/com/ai/cloud/skywalking/plugin/jdbc/tracing/StatementTracing.java b/skywalking-sdk-plugin/jdbc-plugin/src/main/java/com/ai/cloud/skywalking/plugin/jdbc/tracing/StatementTracing.java new file mode 100755 index 000000000..d1dd7d3e4 --- /dev/null +++ b/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 com.ai.cloud.skywalking.buriedpoint.RPCBuriedPointSender; +import com.ai.cloud.skywalking.plugin.jdbc.JDBCBuriedPointType; +import com.ai.cloud.skywalking.model.Identification; + +import java.sql.SQLException; + +/** + * 连接级追踪，用于追踪用于Statement的操作追踪 + * + * @author wusheng + */ +public class StatementTracing { + private static RPCBuriedPointSender sender = new RPCBuriedPointSender(); + + public static R execute(java.sql.Statement realStatement, + String connectInfo, String method, String sql, Executable exec) + throws SQLException { + try { + sender.beforeSend(Identification + .newBuilder() + .viewPoint(connectInfo) + .businessKey( + "statement." + + method + + (sql == null || sql.length() == 0 ? "" + : ":" + sql)).spanType(JDBCBuriedPointType.instance()).build()); + return exec.exe(realStatement, sql); + } catch (SQLException e) { + sender.handleException(e); + throw e; + } finally { + sender.afterSend(); + } + } + + public interface Executable { + public R exe(java.sql.Statement realStatement, String sql) + throws SQLException; + } +} diff --git a/skywalking-sdk-plugin/pom.xml b/skywalking-sdk-plugin/pom.xml index 05addc40a..c87e9eff2 100644 --- a/skywalking-sdk-plugin/pom.xml +++ b/skywalking-sdk-plugin/pom.xml @@ -1,3 +1,4 @@ + 4.0.0 @@ -9,6 +10,7 @@ dubbo-plugin spring-plugin mysql-plugin + jdbc-plugin web-plugin httpclient-4.2.x-plugin httpclient-4.3.x-plugin @@ -52,7 +54,7 @@ - + company-private-nexus-library-snapshots @@ -60,4 +62,4 @@ http://10.1.228.199:18081/nexus/content/repositories/snapshots/ - + \ No newline at end of file