Skip to content

S
SkyWalking

阿信在这里 / SkyWalking
与 Fork 源项目一致

Fork自 山不在高_有仙则灵 / SkyWalking

通知 1
Star 0
Fork 0
S
SkyWalking

体验新版 GitCode，发现更多精彩内容 >>

提交 5a7c2870 编写于 作者: A ascrutae
浏览文件
操作

1.移除Mysql插件，改为JDBC插件

上级 d16588fa
展开全部 隐藏空白更改
内联 并排
Showing with 2431 addition and 4607 deletion
skywalking-sdk-plugin/jdbc-plugin/pom.xml
浏览文件 @ 5a7c2870
......@@ -27,14 +27,20 @@
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.36</version>
<scope>compile</scope>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>com.oracle</groupId>
<artifactId>ojdbc14</artifactId>
<version>10.2.0.3.0</version>
<version>10.2.0.4.0</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.apache.logging.log4j</groupId>
<artifactId>log4j-core</artifactId>
<version>2.6</version>
<scope>provided</scope>
</dependency>
</dependencies>
<build>
......
skywalking-sdk-plugin/jdbc-plugin/src/main/java/com/ai/cloud/skywalking/plugin/jdbc/JDBCPluginDefine.java 0 → 100644
浏览文件 @ 5a7c2870
package com.ai.cloud.skywalking.plugin.jdbc;
import com.ai.cloud.skywalking.plugin.boot.BootException;
import com.ai.cloud.skywalking.plugin.boot.BootPluginDefine;
import com.ai.cloud.skywalking.plugin.jdbc.driver.TracingDriver;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.sql.Driver;
import java.sql.DriverManager;
import java.util.concurrent.CopyOnWriteArrayList;
public class JDBCPluginDefine extends BootPluginDefine {
private Logger logger = LogManager.getLogger(JDBCPluginDefine.class);
@Override
protected void boot() throws BootException {
try {
Class classes = Class.forName("java.sql.DriverInfo");
Constructor constructor = classes.getDeclaredConstructor(Driver.class);
constructor.setAccessible(true);
Object traceDriverInfo = constructor.newInstance(new TracingDriver());
Field field = DriverManager.class.getDeclaredField("registeredDrivers");
field.setAccessible(true);
CopyOnWriteArrayList copyOnWriteArrayList = (CopyOnWriteArrayList) field.get(DriverManager.class);
copyOnWriteArrayList.add(0, traceDriverInfo);
} catch (Exception e) {
// 开启补偿机制
logger.error("Failed to change the byte code of DriverManger, Will open compensation mechanism.", e);
TracingDriver.registerDriver();
}
}
}
skywalking-sdk-plugin/jdbc-plugin/src/main/java/com/ai/cloud/skywalking/plugin/jdbc/SWConnection.java 已删除 100755 → 0
浏览文件 @ d16588fa
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 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 {
ConnectionTracing.execute(realConnection, connectInfo, "close", "",
new Executable<String>() {
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<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 已删除 100755 → 0
浏览文件 @ d16588fa
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<ResultSet>() {
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<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 PreparedStatementTracing.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 PreparedStatementTracing.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 PreparedStatementTracing.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 PreparedStatementTracing.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 PreparedStatementTracing.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 PreparedStatementTracing.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 PreparedStatementTracing.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 PreparedStatementTracing.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 PreparedStatementTracing.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 PreparedStatementTracing.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 PreparedStatementTracing.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 已删除 100755 → 0
浏览文件 @ d16588fa
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 已删除 100755 → 0
浏览文件 @ d16588fa
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;
}
}
skywalking-sdk-plugin/mysql-plugin/src/main/java/com/ai/cloud/skywalking/plugin/mysql/tracing/StatementTracing.java → skywalking-sdk-plugin/jdbc-plugin/src/main/java/com/ai/cloud/skywalking/plugin/jdbc/driver/CallableStatementTracing.java
浏览文件 @ 5a7c2870
package com.ai.cloud.skywalking.plugin.mysql.tracing;
package com.ai.cloud.skywalking.plugin.jdbc.driver;
import com.ai.cloud.skywalking.buriedpoint.RPCBuriedPointSender;
import com.ai.cloud.skywalking.plugin.mysql.JDBCBuriedPointType;
import com.ai.cloud.skywalking.model.Identification;
import java.sql.SQLException;
/**
* 连接级追踪，用于追踪用于Statement的操作追踪
* 连接级追踪，用于追踪用于Connection的操作追踪
*
* @author wusheng
*/
public class StatementTracing {
public class CallableStatementTracing {
private static RPCBuriedPointSender sender = new RPCBuriedPointSender();
public static <R> R execute(java.sql.Statement realStatement,
public static <R> R execute(java.sql.CallableStatement realStatement,
String connectInfo, String method, String sql, Executable<R> exec)
throws SQLException {
try {
......@@ -22,7 +21,7 @@ public class StatementTracing {
.newBuilder()
.viewPoint(connectInfo)
.businessKey(
"statement."
"callableStatement."
+ method
+ (sql == null || sql.length() == 0 ? ""
: ":" + sql)).spanType(JDBCBuriedPointType.instance()).build());
......@@ -36,7 +35,7 @@ public class StatementTracing {
}
public interface Executable<R> {
public R exe(java.sql.Statement realStatement, String sql)
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/driver/ConnectionTracing.java 0 → 100755
浏览文件 @ 5a7c2870
package com.ai.cloud.skywalking.plugin.jdbc.driver;
import com.ai.cloud.skywalking.buriedpoint.RPCBuriedPointSender;
import com.ai.cloud.skywalking.model.Identification;
import java.sql.SQLException;
/**
* 连接级追踪，用于追踪用于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(JDBCBuriedPointType.instance()).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/driver/DriverChooser.java 0 → 100644
浏览文件 @ 5a7c2870
package com.ai.cloud.skywalking.plugin.jdbc.driver;
import java.io.InputStream;
import java.sql.Driver;
import java.util.Map;
import java.util.Properties;
public class DriverChooser {
private static Properties urlDriverMapping = new Properties();
static {
InputStream inputStream = DriverChooser.class.getResourceAsStream("/conurl-driver-mapping.properties");
try {
urlDriverMapping.load(inputStream);
} catch (Exception e) {
System.err.println("Failed to load conurl-driver-mapping.properties");
}
}
public static Driver choose(String url) throws ClassNotFoundException,
IllegalAccessException,
InstantiationException {
Driver driver = null;
for (Map.Entry<Object, Object> entry : urlDriverMapping.entrySet()) {
if (url.startsWith(entry.getValue().toString())) {
Class driverClass = Class.forName(entry.getKey().toString());
driver = (Driver) driverClass.newInstance();
}
}
return driver;
}
}
skywalking-sdk-plugin/jdbc-plugin/src/main/java/com/ai/cloud/skywalking/plugin/jdbc/JDBCBuriedPointType.java → skywalking-sdk-plugin/jdbc-plugin/src/main/java/com/ai/cloud/skywalking/plugin/jdbc/driver/JDBCBuriedPointType.java 100755 → 100644
浏览文件 @ 5a7c2870
package com.ai.cloud.skywalking.plugin.jdbc;
package com.ai.cloud.skywalking.plugin.jdbc.driver;
import com.ai.cloud.skywalking.api.IBuriedPointType;
import com.ai.cloud.skywalking.protocol.CallType;
......@@ -26,7 +26,7 @@ public class JDBCBuriedPointType implements IBuriedPointType {
return CallType.LOCAL;
}
private JDBCBuriedPointType(){
private JDBCBuriedPointType() {
//Non
}
}
skywalking-sdk-plugin/jdbc-plugin/src/main/java/com/ai/cloud/skywalking/plugin/jdbc/tracing/PreparedStatementTracing.java → skywalking-sdk-plugin/jdbc-plugin/src/main/java/com/ai/cloud/skywalking/plugin/jdbc/driver/PreparedStatementTracing.java 100755 → 100644
浏览文件 @ 5a7c2870
package com.ai.cloud.skywalking.plugin.jdbc.tracing;
import java.sql.SQLException;
package com.ai.cloud.skywalking.plugin.jdbc.driver;
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;
/**
* 连接级追踪，用于追踪用于Connection的操作追踪
*
......
skywalking-sdk-plugin/jdbc-plugin/src/main/java/com/ai/cloud/skywalking/plugin/jdbc/driver/SWConnection.java 0 → 100755
浏览文件 @ 5a7c2870
package com.ai.cloud.skywalking.plugin.jdbc.driver;
import java.sql.*;
import java.util.Map;
import java.util.Properties;
import java.util.concurrent.Executor;
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 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 ConnectionTracing.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 ConnectionTracing.Executable<String>() {
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 ConnectionTracing.Executable<String>() {
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<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 ConnectionTracing.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 ConnectionTracing.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/driver/SWPreparedStatement.java 0 → 100644
浏览文件 @ 5a7c2870
package com.ai.cloud.skywalking.plugin.jdbc.driver;
import java.io.InputStream;
import java.io.Reader;
import java.math.BigDecimal;
import java.net.URL;
import java.sql.*;
import java.util.Calendar;
public class SWPreparedStatement implements PreparedStatement {
private Connection realConnection;
private PreparedStatement realStatement;
private String connectInfo;
private String sql;
SWPreparedStatement(Connection realConnection,
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 PreparedStatementTracing.Executable<ResultSet>() {
public ResultSet exe(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 PreparedStatementTracing.Executable<Integer>() {
public Integer exe(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 PreparedStatementTracing.Executable<Boolean>() {
public Boolean exe(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 PreparedStatementTracing.Executable<int[]>() {
public int[] exe(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 PreparedStatementTracing.Executable<Integer>() {
public Integer exe(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 PreparedStatementTracing.Executable<Integer>() {
public Integer exe(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 PreparedStatementTracing.Executable<Integer>() {
public Integer exe(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 PreparedStatementTracing.Executable<Boolean>() {
public Boolean exe(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 PreparedStatementTracing.Executable<Boolean>() {
public Boolean exe(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 PreparedStatementTracing.Executable<Boolean>() {
public Boolean exe(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 PreparedStatementTracing.execute(realStatement, connectInfo, "executeQuery", sql, new PreparedStatementTracing.Executable<ResultSet>() {
public ResultSet exe(PreparedStatement realStatement, String sql)
throws SQLException {
return realStatement.executeQuery();
}
});
}
public int executeUpdate() throws SQLException {
return PreparedStatementTracing.execute(realStatement, connectInfo, "executeUpdate", sql, new PreparedStatementTracing.Executable<Integer>() {
public Integer exe(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 PreparedStatementTracing.Executable<Boolean>() {
public Boolean exe(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/driver/SWStatement.java 0 → 100644
浏览文件 @ 5a7c2870
package com.ai.cloud.skywalking.plugin.jdbc.driver;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.SQLWarning;
public class SWStatement implements java.sql.Statement {
private Connection realConnection;
private java.sql.Statement realStatement;
private String connectInfo;
SWStatement(Connection 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 StatementTracing.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 StatementTracing.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 StatementTracing.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 StatementTracing.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 StatementTracing.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 StatementTracing.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 StatementTracing.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 StatementTracing.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 StatementTracing.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 StatementTracing.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/tracing/StatementTracing.java → skywalking-sdk-plugin/jdbc-plugin/src/main/java/com/ai/cloud/skywalking/plugin/jdbc/driver/StatementTracing.java 100755 → 100644
浏览文件 @ 5a7c2870
package com.ai.cloud.skywalking.plugin.jdbc.tracing;
package com.ai.cloud.skywalking.plugin.jdbc.driver;
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;
......
skywalking-sdk-plugin/jdbc-plugin/src/main/java/com/ai/cloud/skywalking/plugin/jdbc/driver/TracingDriver.java 0 → 100755
浏览文件 @ 5a7c2870
package com.ai.cloud.skywalking.plugin.jdbc.driver;
import com.ai.cloud.skywalking.conf.AuthDesc;
import java.sql.*;
import java.util.Properties;
import java.util.logging.Logger;
public class TracingDriver implements Driver {
private static final String TRACING_SIGN = "tracing:";
private static boolean isOpenCompensation = false;
public static final void registerDriver() {
try {
DriverManager.registerDriver(new TracingDriver());
isOpenCompensation = true;
} catch (SQLException e) {
throw new RuntimeException("register "
+ TracingDriver.class.getName() + " driver failure.");
}
}
private Driver realDriver;
private Driver chooseDriver(String url) throws IllegalAccessException,
InstantiationException, ClassNotFoundException, SQLException {
if (realDriver == null) {
this.realDriver = DriverChooser.choose(url);
}
return realDriver;
}
private String getRealUrl(String url) throws SQLException {
if (!isOpenCompensation) {
return url;
} else {
if (url.toLowerCase().startsWith(TRACING_SIGN)) {
return url.substring(TRACING_SIGN.length());
} else {
throw new SQLException("tracing jdbc url must start with 'tracing:'");
}
}
}
public java.sql.Connection connect(String url, Properties info) throws SQLException {
java.sql.Connection conn = null;
try {
conn = chooseDriver(getRealUrl(url)).connect(getRealUrl(url), info);
} catch (Exception e) {
throw new SQLException(e);
}
if (!AuthDesc.isAuth()) {
return conn;
} else {
return new SWConnection(getRealUrl(url), info, conn);
}
}
public boolean acceptsURL(String url) throws SQLException {
Driver driver = null;
try {
driver = chooseDriver(getRealUrl(url));
} catch (Exception e) {
throw new SQLException(e);
}
return driver.acceptsURL(getRealUrl(url));
}
public DriverPropertyInfo[] getPropertyInfo(String url, Properties info)
throws SQLException {
Driver driver = null;
try {
driver = chooseDriver(getRealUrl(url));
} catch (Exception e) {
throw new SQLException(e);
}
return driver.getPropertyInfo(getRealUrl(url), info);
}
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 已删除 100755 → 0
浏览文件 @ d16588fa
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 已删除 100755 → 0
浏览文件 @ d16588fa
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> 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(JDBCBuriedPointType.instance()).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 已删除 100755 → 0
浏览文件 @ d16588fa
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> 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(JDBCBuriedPointType.instance()).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/resources/conurl-driver-mapping.properties 0 → 100644
浏览文件 @ 5a7c2870
#mysql
com.mysql.jdbc.Driver=jdbc:mysql
#oracle
oracle.jdbc.driver.OracleDriver=jdbc:oracle
#sysbase
com.sybase.jdbc2.jdbc.SybDriver=jdbc:sybase
# SQLServer 2000
com.microsoft.jdbc.sqlserver.SQLServerDriver=jdbc:microsoft:sqlserver
#SQLServer 2005
com.microsoft.sqlserver.jdbc.SQLServerDriver=jdbc:sqlserver
#SQLServer 7.0
net.sourceforge.jtds.jdbc.Driver=jdbc:jtds:sqlserver
#DB2
com.ibm.db2.jcc.DB2Driver=jdbc:db2
#Informix
com.informix.jdbc.IfxDriver=jdbc:informix-sqli
\ No newline at end of file
skywalking-sdk-plugin/jdbc-plugin/src/test/java/test/ai/cloud/skywalking/plugin/oracle/TestMyDriver.java → skywalking-sdk-plugin/jdbc-plugin/src/test/java/test/ai/cloud/skywalking/plugin/drivermanger/TestMyDriver.java
浏览文件 @ 5a7c2870
package test.ai.cloud.skywalking.plugin.oracle;
package test.ai.cloud.skywalking.plugin.drivermanger;
import java.sql.Connection;
import java.sql.DriverManager;
......@@ -10,7 +10,7 @@ import java.sql.SQLException;
*/
public class TestMyDriver {
public static void main(String[] args) throws ClassNotFoundException, SQLException {
Class.forName("test.ai.cloud.skywalking.plugin.oracle.MyDriver");
Class.forName("test.ai.cloud.skywalking.plugin.drivermanger.MyDriver");
String url = "jdbc:oracle:thin:@10.1.130.239:1521:ora";
Connection con = DriverManager.getConnection(url, "edc_export", "edc_export");
con.setAutoCommit(false);
......
skywalking-sdk-plugin/mysql-plugin/src/test/java/test/ai/cloud/skywalking/plugin/mysql/TestMySQLDriver.java → skywalking-sdk-plugin/jdbc-plugin/src/test/java/test/ai/cloud/skywalking/plugin/mysql/MysqlJDBCTest.java
浏览文件 @ 5a7c2870
......@@ -10,18 +10,20 @@ import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
public class TestMySQLDriver {
public class MysqlJDBCTest {
@Test
public void testsql() throws IllegalAccessException,
IllegalArgumentException, InvocationTargetException,
NoSuchMethodException, SecurityException, ClassNotFoundException {
public void testMySqlJDBC() throws InvocationTargetException,
NoSuchMethodException, ClassNotFoundException,
IllegalAccessException {
TracingBootstrap
.main(new String[]{"test.ai.cloud.skywalking.plugin.mysql.TestMySQLDriver"});
.main(new String[]{"test.ai.cloud.skywalking.plugin.mysql.MysqlJDBCTest"});
}
public static void main(String[] args) throws ClassNotFoundException, SQLException, InterruptedException {
public static void main(String[] args) throws ClassNotFoundException,
SQLException, InterruptedException {
Class.forName("com.mysql.jdbc.Driver");
String url = "jdbc:mysql://127.0.0.1:3306/test?user=root&password=root";
String url = "jdbc:mysql://10.1.241.20:31306/sw_db?user=sw_dbusr01&password=sw_dbusr01";
Connection con = DriverManager.getConnection(url);
con.setAutoCommit(false);
......@@ -31,10 +33,11 @@ public class TestMySQLDriver {
con.commit();
con.close();
TraceTreeAssert.assertEquals(new String[][]{
{"0", "jdbc:mysql://127.0.0.1:3306/test?user=root&password=root(root)", "preaparedStatement.executeUpdate:select 1 from dual where 1=?"},
{"0", "jdbc:mysql://127.0.0.1:3306/test?user=root&password=root(root)", "connection.commit"},
{"0.0", "jdbc:mysql://127.0.0.1:3306/test?user=root&password=root(root)", "connection.rollback"},
{"0", "jdbc:mysql://127.0.0.1:3306/test?user=root&password=root(root)", "connection.close"},
{"0", "jdbc:mysql://10.1.241.20:31306/sw_db?user=sw_dbusr01&password=sw_dbusr01(null)", "preaparedStatement.executeUpdate:select 1 from dual where 1=?"},
{"0", "jdbc:mysql://10.1.241.20:31306/sw_db?user=sw_dbusr01&password=sw_dbusr01(null)", "connection.commit"},
{"0", "jdbc:mysql://10.1.241.20:31306/sw_db?user=sw_dbusr01&password=sw_dbusr01(null)", "connection.close"},
}, true);
}
}
skywalking-sdk-plugin/jdbc-plugin/src/test/java/test/ai/cloud/skywalking/plugin/oracle/OracleJDBCTest.java 0 → 100644
浏览文件 @ 5a7c2870
package test.ai.cloud.skywalking.plugin.oracle;
import com.ai.cloud.skywalking.plugin.TracingBootstrap;
import com.ai.skywalking.testframework.api.TraceTreeAssert;
import org.junit.Test;
import java.lang.reflect.InvocationTargetException;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
/**
* Created by xin on 16-6-15.
*/
public class OracleJDBCTest {
@Test
public void testOracleJDBC() throws InvocationTargetException,
NoSuchMethodException, ClassNotFoundException,
IllegalAccessException {
TracingBootstrap
.main(new String[]{"test.ai.cloud.skywalking.plugin.oracle.OracleJDBCTest"});
}
public static void main(String[] args) throws ClassNotFoundException,
SQLException, InterruptedException {
Class.forName("oracle.jdbc.driver.OracleDriver");
String url = "jdbc:oracle:thin:@10.1.130.239:1521:ora";
Connection con = DriverManager.getConnection(url, "edc_export", "edc_export");
con.setAutoCommit(false);
PreparedStatement p0 = con.prepareStatement("select 1 from dual where 1=?");
p0.setInt(1, 1);
p0.execute();
con.commit();
con.close();
TraceTreeAssert.assertEquals(new String[][]{
{"0", "jdbc:oracle:thin:@10.1.130.239:1521:ora(edc_export)", "preaparedStatement.executeUpdate:select 1 from dual where 1=?"},
{"0", "jdbc:oracle:thin:@10.1.130.239:1521:ora(edc_export)", "connection.commit"},
{"0", "jdbc:oracle:thin:@10.1.130.239:1521:ora(edc_export)", "connection.close"},
}, true);
}
}
skywalking-sdk-plugin/mysql-plugin/src/test/resources/sky-walking.auth → skywalking-sdk-plugin/jdbc-plugin/src/test/resources/sky-walking.auth
浏览文件 @ 5a7c2870
......@@ -6,6 +6,7 @@ skywalking.application_code=test
skywalking.auth_system_env_name=SKYWALKING_RUN
#skywalking数据编码
skywalking.charset=UTF-8
skywalking.auth_override=true
#是否打印数据
buriedpoint.printf=true
......@@ -31,7 +32,7 @@ sender.retry_get_sender_wait_interval=2000
#最大消费线程数
consumer.max_consumer=2
consumer.max_consumer=0
#消费者最大等待时间
consumer.max_wait_time=5
#发送失败等待时间
......
skywalking-sdk-plugin/mysql-plugin/README.md 已删除 100644 → 0
浏览文件 @ d16588fa
# 如何追踪MySQL访问？
- 引入所需插件
```xml
<dependency>
<groupId>com.ai.cloud</groupId>
<artifactId>skywalking-mysql-plugin</artifactId>
<version>{latest_version}</version>
</dependency>
```
skywalking-sdk-plugin/mysql-plugin/pom.xml 已删除 100644 → 0
浏览文件 @ d16588fa
此差异已折叠。
skywalking-sdk-plugin/mysql-plugin/src/main/java/com/ai/cloud/skywalking/plugin/mysql/ConnectionPluginDefine.java 已删除 100644 → 0
浏览文件 @ d16588fa
package com.ai.cloud.skywalking.plugin.mysql;
import com.ai.cloud.skywalking.plugin.interceptor.IAroundInterceptor;
import com.ai.cloud.skywalking.plugin.interceptor.InterceptorPluginDefine;
import com.ai.cloud.skywalking.plugin.interceptor.MethodMatcher;
import com.ai.cloud.skywalking.plugin.interceptor.matcher.SimpleMethodMatcher;
public class ConnectionPluginDefine extends InterceptorPluginDefine {
@Override
public String getBeInterceptedClassName() {
return "com.mysql.jdbc.JDBC4Connection";
}
@Override
public MethodMatcher[] getBeInterceptedMethodsMatchers() {
return new MethodMatcher[] { new SimpleMethodMatcher("createStatement", 2),
new SimpleMethodMatcher("prepareStatement", 3),
new SimpleMethodMatcher("prepareCall", 3),
new SimpleMethodMatcher("commit"), new SimpleMethodMatcher("rollback"),
new SimpleMethodMatcher("close") };
}
@Override
public IAroundInterceptor instance() {
return new ConnectionInterceptor();
}
}
skywalking-sdk-plugin/mysql-plugin/src/main/java/com/ai/cloud/skywalking/plugin/mysql/JDBCBuriedPointType.java 已删除 100644 → 0
浏览文件 @ d16588fa
package com.ai.cloud.skywalking.plugin.mysql;
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
}
}
skywalking-sdk-plugin/pom.xml
浏览文件 @ 5a7c2870
此差异已折叠。
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或