From 9144a06ca1c290c11df8709ee4de88e7495515ca Mon Sep 17 00:00:00 2001 From: xu1009 <2933250475@qq.com> Date: Tue, 25 Apr 2023 18:12:19 +0800 Subject: [PATCH] clickhouse-jdbc-plugin support trace sql parameters when enable plugin.jdbc.trace_sql_parameters (#515) Co-authored-by: litexu --- CHANGES.md | 1 + .../v32/SWClickHousePreparedStatement.java | 243 +++++++++++------- .../jdbc/trace/PreparedStatementTracing.java | 29 ++- .../jdbc/trace/SWPreparedStatement.java | 226 ++++++++++------ .../config/expectedData.yaml | 68 +++++ .../configuration.yml | 1 + .../neo4j/controller/CaseController.java | 8 + .../config/expectedData.yaml | 33 +++ .../configuration.yml | 1 + .../neo4j/controller/CaseController.java | 19 +- 10 files changed, 453 insertions(+), 176 deletions(-) diff --git a/CHANGES.md b/CHANGES.md index e80083e71..1fee03223 100644 --- a/CHANGES.md +++ b/CHANGES.md @@ -7,6 +7,7 @@ Release Notes. * Exclude `synthetic` methods for the WitnessMethod mechanism * Support ForkJoinPool trace +* Support clickhouse-jdbc-plugin trace sql parameters #### Documentation diff --git a/apm-sniffer/apm-sdk-plugin/clickhouse-0.3.2.x-plugin/src/main/java/org/apache/skywalking/apm/plugin/jdbc/clickhouse/v32/SWClickHousePreparedStatement.java b/apm-sniffer/apm-sdk-plugin/clickhouse-0.3.2.x-plugin/src/main/java/org/apache/skywalking/apm/plugin/jdbc/clickhouse/v32/SWClickHousePreparedStatement.java index b09e4d89b..77519603b 100644 --- a/apm-sniffer/apm-sdk-plugin/clickhouse-0.3.2.x-plugin/src/main/java/org/apache/skywalking/apm/plugin/jdbc/clickhouse/v32/SWClickHousePreparedStatement.java +++ b/apm-sniffer/apm-sdk-plugin/clickhouse-0.3.2.x-plugin/src/main/java/org/apache/skywalking/apm/plugin/jdbc/clickhouse/v32/SWClickHousePreparedStatement.java @@ -18,8 +18,7 @@ package org.apache.skywalking.apm.plugin.jdbc.clickhouse.v32; -import org.apache.skywalking.apm.plugin.jdbc.trace.ConnectionInfo; -import org.apache.skywalking.apm.plugin.jdbc.trace.PreparedStatementTracing; +import static org.apache.skywalking.apm.plugin.jdbc.define.Constants.SQL_PARAMETER_PLACEHOLDER; import java.io.InputStream; import java.io.Reader; @@ -38,16 +37,20 @@ import java.sql.ResultSet; import java.sql.ResultSetMetaData; import java.sql.RowId; import java.sql.SQLException; +import java.sql.SQLType; import java.sql.SQLWarning; import java.sql.SQLXML; -import java.sql.SQLType; import java.sql.Time; import java.sql.Timestamp; import java.util.Calendar; +import org.apache.skywalking.apm.plugin.jdbc.define.StatementEnhanceInfos; +import org.apache.skywalking.apm.plugin.jdbc.trace.ConnectionInfo; +import org.apache.skywalking.apm.plugin.jdbc.trace.PreparedStatementTracing; /** * Enhance based {@link org.apache.skywalking.apm.plugin.jdbc.trace.SWPreparedStatement} - * {@link SWClickHousePreparedStatement} wrapper the {@link PreparedStatement} created by client. and it will interceptor the + * {@link SWClickHousePreparedStatement} wrapper the {@link PreparedStatement} created by client. and it will + * interceptor the * following methods for trace. 1. {@link #execute()} 2. {@link #execute(String)} 3. {@link #execute(String, int[])} 4. * {@link #execute(String, String[])} 5. {@link #execute(String, int)} 6. {@link #executeQuery()} 7. {@link * #executeQuery(String)} 8. {@link #executeUpdate()} 9. {@link #executeUpdate(String)} 10. {@link @@ -58,32 +61,39 @@ import java.util.Calendar; * 15. {@link #executeLargeUpdate()} 16. {@link #executeLargeBatch()} ()} */ public class SWClickHousePreparedStatement implements PreparedStatement { + private Connection realConnection; private PreparedStatement realStatement; private ConnectionInfo connectInfo; private String sql; + private StatementEnhanceInfos statementEnhanceInfos; - public SWClickHousePreparedStatement(Connection realConnection, PreparedStatement realStatement, ConnectionInfo connectInfo, - String sql) { + public SWClickHousePreparedStatement(Connection realConnection, PreparedStatement realStatement, + ConnectionInfo connectInfo, + String sql) { this.realConnection = realConnection; this.realStatement = realStatement; this.connectInfo = connectInfo; this.sql = sql; + this.statementEnhanceInfos = new StatementEnhanceInfos(connectInfo, sql, "PreparedStatement"); } @Override public void setObject(int parameterIndex, Object x, SQLType targetSqlType, int scaleOrLength) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, x); realStatement.setObject(parameterIndex, x, targetSqlType, scaleOrLength); } @Override public void setObject(int parameterIndex, Object x, SQLType targetSqlType) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, x); realStatement.setObject(parameterIndex, x, targetSqlType); } @Override public long executeLargeUpdate() throws SQLException { - return ClickHousePrepareStatementTracing.of(connectInfo, "executeLargeUpdate", "", realStatement::executeLargeUpdate); + return ClickHousePrepareStatementTracing.of(connectInfo, "executeLargeUpdate", "", + realStatement::executeLargeUpdate); } @Override @@ -103,7 +113,8 @@ public class SWClickHousePreparedStatement implements PreparedStatement { @Override public long[] executeLargeBatch() throws SQLException { - return ClickHousePrepareStatementTracing.of(connectInfo, "executeLargeBatch", "", realStatement::executeLargeBatch); + return ClickHousePrepareStatementTracing.of(connectInfo, "executeLargeBatch", "", + realStatement::executeLargeBatch); } @Override @@ -128,22 +139,24 @@ public class SWClickHousePreparedStatement implements PreparedStatement { @Override public ResultSet executeQuery(String sql) throws SQLException { - return PreparedStatementTracing.execute(realStatement, connectInfo, "executeQuery", sql, new PreparedStatementTracing.Executable() { - @Override - public ResultSet exe(PreparedStatement realStatement, String sql) throws SQLException { - return realStatement.executeQuery(sql); - } - }); + return PreparedStatementTracing.execute(realStatement, connectInfo, "executeQuery", sql, + new PreparedStatementTracing.Executable() { + @Override + public ResultSet exe(PreparedStatement realStatement, String sql) throws SQLException { + return realStatement.executeQuery(sql); + } + }, statementEnhanceInfos); } @Override public int executeUpdate(String sql) throws SQLException { - return PreparedStatementTracing.execute(realStatement, connectInfo, "executeUpdate", sql, new PreparedStatementTracing.Executable() { - @Override - public Integer exe(PreparedStatement realStatement, String sql) throws SQLException { - return realStatement.executeUpdate(sql); - } - }); + return PreparedStatementTracing.execute(realStatement, connectInfo, "executeUpdate", sql, + new PreparedStatementTracing.Executable() { + @Override + public Integer exe(PreparedStatement realStatement, String sql) throws SQLException { + return realStatement.executeUpdate(sql); + } + }, statementEnhanceInfos); } @Override @@ -208,12 +221,13 @@ public class SWClickHousePreparedStatement implements PreparedStatement { @Override public boolean execute(String sql) throws SQLException { - return PreparedStatementTracing.execute(realStatement, connectInfo, "execute", sql, new PreparedStatementTracing.Executable() { - @Override - public Boolean exe(PreparedStatement realStatement, String sql) throws SQLException { - return realStatement.execute(sql); - } - }); + return PreparedStatementTracing.execute(realStatement, connectInfo, "execute", sql, + new PreparedStatementTracing.Executable() { + @Override + public Boolean exe(PreparedStatement realStatement, String sql) throws SQLException { + return realStatement.execute(sql); + } + }, statementEnhanceInfos); } @Override @@ -273,12 +287,13 @@ public class SWClickHousePreparedStatement implements PreparedStatement { @Override public int[] executeBatch() throws SQLException { - return PreparedStatementTracing.execute(realStatement, connectInfo, "executeBatch", "", new PreparedStatementTracing.Executable() { - @Override - public int[] exe(PreparedStatement realStatement, String sql) throws SQLException { - return realStatement.executeBatch(); - } - }); + return PreparedStatementTracing.execute(realStatement, connectInfo, "executeBatch", "", + new PreparedStatementTracing.Executable() { + @Override + public int[] exe(PreparedStatement realStatement, String sql) throws SQLException { + return realStatement.executeBatch(); + } + }, statementEnhanceInfos); } @Override @@ -298,62 +313,68 @@ public class SWClickHousePreparedStatement implements PreparedStatement { @Override public int executeUpdate(String sql, final int autoGeneratedKeys) throws SQLException { - return PreparedStatementTracing.execute(realStatement, connectInfo, "executeUpdate", sql, new PreparedStatementTracing.Executable() { - @Override - public Integer exe(PreparedStatement realStatement, String sql) throws SQLException { - return realStatement.executeUpdate(sql, autoGeneratedKeys); - } - }); + return PreparedStatementTracing.execute(realStatement, connectInfo, "executeUpdate", sql, + new PreparedStatementTracing.Executable() { + @Override + public Integer exe(PreparedStatement realStatement, String sql) throws SQLException { + return realStatement.executeUpdate(sql, autoGeneratedKeys); + } + }, statementEnhanceInfos); } @Override public int executeUpdate(String sql, final int[] columnIndexes) throws SQLException { - return PreparedStatementTracing.execute(realStatement, connectInfo, "executeUpdate", sql, new PreparedStatementTracing.Executable() { - @Override - public Integer exe(PreparedStatement realStatement, String sql) throws SQLException { - return realStatement.executeUpdate(sql, columnIndexes); - } - }); + return PreparedStatementTracing.execute(realStatement, connectInfo, "executeUpdate", sql, + new PreparedStatementTracing.Executable() { + @Override + public Integer exe(PreparedStatement realStatement, String sql) throws SQLException { + return realStatement.executeUpdate(sql, columnIndexes); + } + }, statementEnhanceInfos); } @Override public int executeUpdate(String sql, final String[] columnNames) throws SQLException { - return PreparedStatementTracing.execute(realStatement, connectInfo, "executeUpdate", sql, new PreparedStatementTracing.Executable() { - @Override - public Integer exe(PreparedStatement realStatement, String sql) throws SQLException { - return realStatement.executeUpdate(sql, columnNames); - } - }); + return PreparedStatementTracing.execute(realStatement, connectInfo, "executeUpdate", sql, + new PreparedStatementTracing.Executable() { + @Override + public Integer exe(PreparedStatement realStatement, String sql) throws SQLException { + return realStatement.executeUpdate(sql, columnNames); + } + }, statementEnhanceInfos); } @Override public boolean execute(String sql, final int autoGeneratedKeys) throws SQLException { - return PreparedStatementTracing.execute(realStatement, connectInfo, "execute", sql, new PreparedStatementTracing.Executable() { - @Override - public Boolean exe(PreparedStatement realStatement, String sql) throws SQLException { - return realStatement.execute(sql, autoGeneratedKeys); - } - }); + return PreparedStatementTracing.execute(realStatement, connectInfo, "execute", sql, + new PreparedStatementTracing.Executable() { + @Override + public Boolean exe(PreparedStatement realStatement, String sql) throws SQLException { + return realStatement.execute(sql, autoGeneratedKeys); + } + }, statementEnhanceInfos); } @Override public boolean execute(String sql, final int[] columnIndexes) throws SQLException { - return PreparedStatementTracing.execute(realStatement, connectInfo, "execute", sql, new PreparedStatementTracing.Executable() { - @Override - public Boolean exe(PreparedStatement realStatement, String sql) throws SQLException { - return realStatement.execute(sql, columnIndexes); - } - }); + return PreparedStatementTracing.execute(realStatement, connectInfo, "execute", sql, + new PreparedStatementTracing.Executable() { + @Override + public Boolean exe(PreparedStatement realStatement, String sql) throws SQLException { + return realStatement.execute(sql, columnIndexes); + } + }, statementEnhanceInfos); } @Override public boolean execute(String sql, final String[] columnNames) throws SQLException { - return PreparedStatementTracing.execute(realStatement, connectInfo, "execute", sql, new PreparedStatementTracing.Executable() { - @Override - public Boolean exe(PreparedStatement realStatement, String sql) throws SQLException { - return realStatement.execute(sql, columnNames); - } - }); + return PreparedStatementTracing.execute(realStatement, connectInfo, "execute", sql, + new PreparedStatementTracing.Executable() { + @Override + public Boolean exe(PreparedStatement realStatement, String sql) throws SQLException { + return realStatement.execute(sql, columnNames); + } + }, statementEnhanceInfos); } @Override @@ -398,107 +419,126 @@ public class SWClickHousePreparedStatement implements PreparedStatement { @Override public ResultSet executeQuery() throws SQLException { - return PreparedStatementTracing.execute(realStatement, connectInfo, "executeQuery", sql, new PreparedStatementTracing.Executable() { - @Override - public ResultSet exe(PreparedStatement realStatement, String sql) throws SQLException { - return realStatement.executeQuery(); - } - }); + return PreparedStatementTracing.execute(realStatement, connectInfo, "executeQuery", sql, + new PreparedStatementTracing.Executable() { + @Override + public ResultSet exe(PreparedStatement realStatement, String sql) throws SQLException { + return realStatement.executeQuery(); + } + }, statementEnhanceInfos); } @Override public int executeUpdate() throws SQLException { - return PreparedStatementTracing.execute(realStatement, connectInfo, "executeUpdate", sql, new PreparedStatementTracing.Executable() { - @Override - public Integer exe(PreparedStatement realStatement, String sql) throws SQLException { - return realStatement.executeUpdate(); - } - }); + return PreparedStatementTracing.execute(realStatement, connectInfo, "executeUpdate", sql, + new PreparedStatementTracing.Executable() { + @Override + public Integer exe(PreparedStatement realStatement, String sql) throws SQLException { + return realStatement.executeUpdate(); + } + }, statementEnhanceInfos); } @Override public void setNull(int parameterIndex, int sqlType) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, "NULL"); realStatement.setNull(parameterIndex, sqlType); } @Override public void setBoolean(int parameterIndex, boolean x) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, x); realStatement.setBoolean(parameterIndex, x); } @Override public void setByte(int parameterIndex, byte x) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, SQL_PARAMETER_PLACEHOLDER); realStatement.setByte(parameterIndex, x); } @Override public void setShort(int parameterIndex, short x) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, x); realStatement.setShort(parameterIndex, x); } @Override public void setInt(int parameterIndex, int x) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, x); realStatement.setInt(parameterIndex, x); } @Override public void setLong(int parameterIndex, long x) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, x); realStatement.setLong(parameterIndex, x); } @Override public void setFloat(int parameterIndex, float x) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, x); realStatement.setFloat(parameterIndex, x); } @Override public void setDouble(int parameterIndex, double x) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, x); realStatement.setDouble(parameterIndex, x); } @Override public void setBigDecimal(int parameterIndex, BigDecimal x) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, x); realStatement.setBigDecimal(parameterIndex, x); } @Override public void setString(int parameterIndex, String x) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, x); realStatement.setString(parameterIndex, x); } @Override public void setBytes(int parameterIndex, byte[] x) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, SQL_PARAMETER_PLACEHOLDER); realStatement.setBytes(parameterIndex, x); } @Override public void setDate(int parameterIndex, Date x) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, x); realStatement.setDate(parameterIndex, x); } @Override public void setTime(int parameterIndex, Time x) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, x); realStatement.setTime(parameterIndex, x); } @Override public void setTimestamp(int parameterIndex, Timestamp x) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, x); realStatement.setTimestamp(parameterIndex, x); } @Override public void setAsciiStream(int parameterIndex, InputStream x, int length) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, SQL_PARAMETER_PLACEHOLDER); realStatement.setAsciiStream(parameterIndex, x, length); } @Override @Deprecated public void setUnicodeStream(int parameterIndex, InputStream x, int length) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, SQL_PARAMETER_PLACEHOLDER); realStatement.setUnicodeStream(parameterIndex, x, length); } @Override public void setBinaryStream(int parameterIndex, InputStream x, int length) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, SQL_PARAMETER_PLACEHOLDER); realStatement.setBinaryStream(parameterIndex, x, length); } @@ -509,22 +549,25 @@ public class SWClickHousePreparedStatement implements PreparedStatement { @Override public void setObject(int parameterIndex, Object x, int targetSqlType) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, x); realStatement.setObject(parameterIndex, x, targetSqlType); } @Override public void setObject(int parameterIndex, Object x) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, x); realStatement.setObject(parameterIndex, x); } @Override public boolean execute() throws SQLException { - return PreparedStatementTracing.execute(realStatement, connectInfo, "execute", sql, new PreparedStatementTracing.Executable() { - @Override - public Boolean exe(PreparedStatement realStatement, String sql) throws SQLException { - return realStatement.execute(); - } - }); + return PreparedStatementTracing.execute(realStatement, connectInfo, "execute", sql, + new PreparedStatementTracing.Executable() { + @Override + public Boolean exe(PreparedStatement realStatement, String sql) throws SQLException { + return realStatement.execute(); + } + }, statementEnhanceInfos); } @Override @@ -539,21 +582,25 @@ public class SWClickHousePreparedStatement implements PreparedStatement { @Override public void setRef(int parameterIndex, Ref x) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, SQL_PARAMETER_PLACEHOLDER); realStatement.setRef(parameterIndex, x); } @Override public void setBlob(int parameterIndex, Blob x) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, SQL_PARAMETER_PLACEHOLDER); realStatement.setBlob(parameterIndex, x); } @Override public void setClob(int parameterIndex, Clob x) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, SQL_PARAMETER_PLACEHOLDER); realStatement.setClob(parameterIndex, x); } @Override public void setArray(int parameterIndex, Array x) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, x); realStatement.setArray(parameterIndex, x); } @@ -564,26 +611,31 @@ public class SWClickHousePreparedStatement implements PreparedStatement { @Override public void setDate(int parameterIndex, Date x, Calendar cal) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, x); realStatement.setDate(parameterIndex, x, cal); } @Override public void setTime(int parameterIndex, Time x, Calendar cal) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, x); realStatement.setTime(parameterIndex, x, cal); } @Override public void setTimestamp(int parameterIndex, Timestamp x, Calendar cal) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, x); realStatement.setTimestamp(parameterIndex, x, cal); } @Override public void setNull(int parameterIndex, int sqlType, String typeName) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, "NULL"); realStatement.setNull(parameterIndex, sqlType, typeName); } @Override public void setURL(int parameterIndex, URL x) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, x); realStatement.setURL(parameterIndex, x); } @@ -594,96 +646,115 @@ public class SWClickHousePreparedStatement implements PreparedStatement { @Override public void setRowId(int parameterIndex, RowId x) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, x); realStatement.setRowId(parameterIndex, x); } @Override public void setNString(int parameterIndex, String value) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, value); realStatement.setNString(parameterIndex, value); } @Override public void setNCharacterStream(int parameterIndex, Reader value, long length) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, SQL_PARAMETER_PLACEHOLDER); realStatement.setNCharacterStream(parameterIndex, value, length); } @Override public void setNClob(int parameterIndex, NClob value) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, SQL_PARAMETER_PLACEHOLDER); realStatement.setNClob(parameterIndex, value); } @Override public void setClob(int parameterIndex, Reader reader, long length) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, SQL_PARAMETER_PLACEHOLDER); realStatement.setClob(parameterIndex, reader, length); } @Override public void setBlob(int parameterIndex, InputStream inputStream, long length) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, SQL_PARAMETER_PLACEHOLDER); realStatement.setBlob(parameterIndex, inputStream, length); } @Override public void setNClob(int parameterIndex, Reader reader, long length) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, SQL_PARAMETER_PLACEHOLDER); realStatement.setNClob(parameterIndex, reader, length); } @Override public void setSQLXML(int parameterIndex, SQLXML xmlObject) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, SQL_PARAMETER_PLACEHOLDER); realStatement.setSQLXML(parameterIndex, xmlObject); } @Override public void setObject(int parameterIndex, Object x, int targetSqlType, int scaleOrLength) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, x); realStatement.setObject(parameterIndex, x, targetSqlType, scaleOrLength); } @Override public void setAsciiStream(int parameterIndex, InputStream x, long length) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, SQL_PARAMETER_PLACEHOLDER); realStatement.setAsciiStream(parameterIndex, x, length); } @Override public void setBinaryStream(int parameterIndex, InputStream x, long length) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, SQL_PARAMETER_PLACEHOLDER); realStatement.setBinaryStream(parameterIndex, x, length); } @Override public void setCharacterStream(int parameterIndex, Reader reader, long length) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, SQL_PARAMETER_PLACEHOLDER); realStatement.setCharacterStream(parameterIndex, reader, length); } @Override public void setAsciiStream(int parameterIndex, InputStream x) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, SQL_PARAMETER_PLACEHOLDER); realStatement.setAsciiStream(parameterIndex, x); } @Override public void setBinaryStream(int parameterIndex, InputStream x) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, SQL_PARAMETER_PLACEHOLDER); realStatement.setBinaryStream(parameterIndex, x); } @Override public void setCharacterStream(int parameterIndex, Reader reader) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, SQL_PARAMETER_PLACEHOLDER); realStatement.setCharacterStream(parameterIndex, reader); } @Override public void setNCharacterStream(int parameterIndex, Reader value) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, SQL_PARAMETER_PLACEHOLDER); realStatement.setNCharacterStream(parameterIndex, value); } @Override public void setClob(int parameterIndex, Reader reader) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, SQL_PARAMETER_PLACEHOLDER); realStatement.setClob(parameterIndex, reader); } @Override public void setBlob(int parameterIndex, InputStream inputStream) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, SQL_PARAMETER_PLACEHOLDER); realStatement.setBlob(parameterIndex, inputStream); } @Override public void setNClob(int parameterIndex, Reader reader) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, SQL_PARAMETER_PLACEHOLDER); realStatement.setNClob(parameterIndex, reader); } diff --git a/apm-sniffer/apm-sdk-plugin/jdbc-commons/src/main/java/org/apache/skywalking/apm/plugin/jdbc/trace/PreparedStatementTracing.java b/apm-sniffer/apm-sdk-plugin/jdbc-commons/src/main/java/org/apache/skywalking/apm/plugin/jdbc/trace/PreparedStatementTracing.java index 016fd6943..86989b7b3 100644 --- a/apm-sniffer/apm-sdk-plugin/jdbc-commons/src/main/java/org/apache/skywalking/apm/plugin/jdbc/trace/PreparedStatementTracing.java +++ b/apm-sniffer/apm-sdk-plugin/jdbc-commons/src/main/java/org/apache/skywalking/apm/plugin/jdbc/trace/PreparedStatementTracing.java @@ -19,10 +19,14 @@ package org.apache.skywalking.apm.plugin.jdbc.trace; import java.sql.SQLException; +import java.util.Objects; +import org.apache.skywalking.apm.agent.core.context.ContextManager; import org.apache.skywalking.apm.agent.core.context.tag.Tags; import org.apache.skywalking.apm.agent.core.context.trace.AbstractSpan; import org.apache.skywalking.apm.agent.core.context.trace.SpanLayer; -import org.apache.skywalking.apm.agent.core.context.ContextManager; +import org.apache.skywalking.apm.plugin.jdbc.JDBCPluginConfig; +import org.apache.skywalking.apm.plugin.jdbc.PreparedStatementParameterBuilder; +import org.apache.skywalking.apm.plugin.jdbc.define.StatementEnhanceInfos; /** * {@link PreparedStatementTracing} create an exit span when the client call the method in the class that extend {@link @@ -31,16 +35,23 @@ import org.apache.skywalking.apm.agent.core.context.ContextManager; public class PreparedStatementTracing { public static R execute(java.sql.PreparedStatement realStatement, ConnectionInfo connectInfo, String method, - String sql, Executable exec) throws SQLException { - final AbstractSpan span = ContextManager.createExitSpan(connectInfo.getDBType() + "/JDBC/PreparedStatement/" + method, connectInfo - .getDatabasePeer()); + String sql, Executable exec, StatementEnhanceInfos statementEnhanceInfos) throws SQLException { + final AbstractSpan span = ContextManager.createExitSpan( + connectInfo.getDBType() + "/JDBC/PreparedStatement/" + method, connectInfo + .getDatabasePeer()); try { Tags.DB_TYPE.set(span, connectInfo.getDBType()); Tags.DB_INSTANCE.set(span, connectInfo.getDatabaseName()); Tags.DB_STATEMENT.set(span, sql); span.setComponent(connectInfo.getComponent()); - SpanLayer.asDB(span); + if (JDBCPluginConfig.Plugin.JDBC.TRACE_SQL_PARAMETERS && Objects.nonNull(statementEnhanceInfos)) { + final Object[] parameters = statementEnhanceInfos.getParameters(); + if (parameters != null && parameters.length > 0) { + int maxIndex = statementEnhanceInfos.getMaxIndex(); + Tags.SQL_PARAMETERS.set(span, getParameterString(parameters, maxIndex)); + } + } return exec.exe(realStatement, sql); } catch (SQLException e) { span.log(e); @@ -50,7 +61,15 @@ public class PreparedStatementTracing { } } + private static String getParameterString(Object[] parameters, int maxIndex) { + return new PreparedStatementParameterBuilder() + .setParameters(parameters) + .setMaxIndex(maxIndex) + .build(); + } + public interface Executable { + R exe(java.sql.PreparedStatement realConnection, String sql) throws SQLException; } } diff --git a/apm-sniffer/apm-sdk-plugin/jdbc-commons/src/main/java/org/apache/skywalking/apm/plugin/jdbc/trace/SWPreparedStatement.java b/apm-sniffer/apm-sdk-plugin/jdbc-commons/src/main/java/org/apache/skywalking/apm/plugin/jdbc/trace/SWPreparedStatement.java index 3a28795e1..670d6f389 100644 --- a/apm-sniffer/apm-sdk-plugin/jdbc-commons/src/main/java/org/apache/skywalking/apm/plugin/jdbc/trace/SWPreparedStatement.java +++ b/apm-sniffer/apm-sdk-plugin/jdbc-commons/src/main/java/org/apache/skywalking/apm/plugin/jdbc/trace/SWPreparedStatement.java @@ -18,6 +18,8 @@ package org.apache.skywalking.apm.plugin.jdbc.trace; +import static org.apache.skywalking.apm.plugin.jdbc.define.Constants.SQL_PARAMETER_PLACEHOLDER; + import java.io.InputStream; import java.io.Reader; import java.math.BigDecimal; @@ -40,6 +42,7 @@ import java.sql.SQLXML; import java.sql.Time; import java.sql.Timestamp; import java.util.Calendar; +import org.apache.skywalking.apm.plugin.jdbc.define.StatementEnhanceInfos; /** * {@link SWPreparedStatement} wrapper the {@link PreparedStatement} created by client. and it will interceptor the @@ -50,37 +53,43 @@ import java.util.Calendar; * 13. {@link #addBatch()} 14. {@link #addBatch(String)} ()} */ public class SWPreparedStatement implements PreparedStatement { + private Connection realConnection; private PreparedStatement realStatement; private ConnectionInfo connectInfo; private String sql; + private StatementEnhanceInfos statementEnhanceInfos; + public SWPreparedStatement(Connection realConnection, PreparedStatement realStatement, ConnectionInfo connectInfo, - String sql) { + String sql) { this.realConnection = realConnection; this.realStatement = realStatement; this.connectInfo = connectInfo; this.sql = sql; + this.statementEnhanceInfos = new StatementEnhanceInfos(connectInfo, sql, "PreparedStatement"); } @Override public ResultSet executeQuery(String sql) throws SQLException { - return PreparedStatementTracing.execute(realStatement, connectInfo, "executeQuery", sql, new PreparedStatementTracing.Executable() { - @Override - public ResultSet exe(PreparedStatement realStatement, String sql) throws SQLException { - return realStatement.executeQuery(sql); - } - }); + return PreparedStatementTracing.execute(realStatement, connectInfo, "executeQuery", sql, + new PreparedStatementTracing.Executable() { + @Override + public ResultSet exe(PreparedStatement realStatement, String sql) throws SQLException { + return realStatement.executeQuery(sql); + } + }, statementEnhanceInfos); } @Override public int executeUpdate(String sql) throws SQLException { - return PreparedStatementTracing.execute(realStatement, connectInfo, "executeUpdate", sql, new PreparedStatementTracing.Executable() { - @Override - public Integer exe(PreparedStatement realStatement, String sql) throws SQLException { - return realStatement.executeUpdate(sql); - } - }); + return PreparedStatementTracing.execute(realStatement, connectInfo, "executeUpdate", sql, + new PreparedStatementTracing.Executable() { + @Override + public Integer exe(PreparedStatement realStatement, String sql) throws SQLException { + return realStatement.executeUpdate(sql); + } + }, statementEnhanceInfos); } @Override @@ -145,12 +154,13 @@ public class SWPreparedStatement implements PreparedStatement { @Override public boolean execute(String sql) throws SQLException { - return PreparedStatementTracing.execute(realStatement, connectInfo, "execute", sql, new PreparedStatementTracing.Executable() { - @Override - public Boolean exe(PreparedStatement realStatement, String sql) throws SQLException { - return realStatement.execute(sql); - } - }); + return PreparedStatementTracing.execute(realStatement, connectInfo, "execute", sql, + new PreparedStatementTracing.Executable() { + @Override + public Boolean exe(PreparedStatement realStatement, String sql) throws SQLException { + return realStatement.execute(sql); + } + }, statementEnhanceInfos); } @Override @@ -210,12 +220,13 @@ public class SWPreparedStatement implements PreparedStatement { @Override public int[] executeBatch() throws SQLException { - return PreparedStatementTracing.execute(realStatement, connectInfo, "executeBatch", "", new PreparedStatementTracing.Executable() { - @Override - public int[] exe(PreparedStatement realStatement, String sql) throws SQLException { - return realStatement.executeBatch(); - } - }); + return PreparedStatementTracing.execute(realStatement, connectInfo, "executeBatch", "", + new PreparedStatementTracing.Executable() { + @Override + public int[] exe(PreparedStatement realStatement, String sql) throws SQLException { + return realStatement.executeBatch(); + } + }, statementEnhanceInfos); } @Override @@ -235,62 +246,68 @@ public class SWPreparedStatement implements PreparedStatement { @Override public int executeUpdate(String sql, final int autoGeneratedKeys) throws SQLException { - return PreparedStatementTracing.execute(realStatement, connectInfo, "executeUpdate", sql, new PreparedStatementTracing.Executable() { - @Override - public Integer exe(PreparedStatement realStatement, String sql) throws SQLException { - return realStatement.executeUpdate(sql, autoGeneratedKeys); - } - }); + return PreparedStatementTracing.execute(realStatement, connectInfo, "executeUpdate", sql, + new PreparedStatementTracing.Executable() { + @Override + public Integer exe(PreparedStatement realStatement, String sql) throws SQLException { + return realStatement.executeUpdate(sql, autoGeneratedKeys); + } + }, statementEnhanceInfos); } @Override public int executeUpdate(String sql, final int[] columnIndexes) throws SQLException { - return PreparedStatementTracing.execute(realStatement, connectInfo, "executeUpdate", sql, new PreparedStatementTracing.Executable() { - @Override - public Integer exe(PreparedStatement realStatement, String sql) throws SQLException { - return realStatement.executeUpdate(sql, columnIndexes); - } - }); + return PreparedStatementTracing.execute(realStatement, connectInfo, "executeUpdate", sql, + new PreparedStatementTracing.Executable() { + @Override + public Integer exe(PreparedStatement realStatement, String sql) throws SQLException { + return realStatement.executeUpdate(sql, columnIndexes); + } + }, statementEnhanceInfos); } @Override public int executeUpdate(String sql, final String[] columnNames) throws SQLException { - return PreparedStatementTracing.execute(realStatement, connectInfo, "executeUpdate", sql, new PreparedStatementTracing.Executable() { - @Override - public Integer exe(PreparedStatement realStatement, String sql) throws SQLException { - return realStatement.executeUpdate(sql, columnNames); - } - }); + return PreparedStatementTracing.execute(realStatement, connectInfo, "executeUpdate", sql, + new PreparedStatementTracing.Executable() { + @Override + public Integer exe(PreparedStatement realStatement, String sql) throws SQLException { + return realStatement.executeUpdate(sql, columnNames); + } + }, statementEnhanceInfos); } @Override public boolean execute(String sql, final int autoGeneratedKeys) throws SQLException { - return PreparedStatementTracing.execute(realStatement, connectInfo, "execute", sql, new PreparedStatementTracing.Executable() { - @Override - public Boolean exe(PreparedStatement realStatement, String sql) throws SQLException { - return realStatement.execute(sql, autoGeneratedKeys); - } - }); + return PreparedStatementTracing.execute(realStatement, connectInfo, "execute", sql, + new PreparedStatementTracing.Executable() { + @Override + public Boolean exe(PreparedStatement realStatement, String sql) throws SQLException { + return realStatement.execute(sql, autoGeneratedKeys); + } + }, statementEnhanceInfos); } @Override public boolean execute(String sql, final int[] columnIndexes) throws SQLException { - return PreparedStatementTracing.execute(realStatement, connectInfo, "execute", sql, new PreparedStatementTracing.Executable() { - @Override - public Boolean exe(PreparedStatement realStatement, String sql) throws SQLException { - return realStatement.execute(sql, columnIndexes); - } - }); + return PreparedStatementTracing.execute(realStatement, connectInfo, "execute", sql, + new PreparedStatementTracing.Executable() { + @Override + public Boolean exe(PreparedStatement realStatement, String sql) throws SQLException { + return realStatement.execute(sql, columnIndexes); + } + }, statementEnhanceInfos); } @Override public boolean execute(String sql, final String[] columnNames) throws SQLException { - return PreparedStatementTracing.execute(realStatement, connectInfo, "execute", sql, new PreparedStatementTracing.Executable() { - @Override - public Boolean exe(PreparedStatement realStatement, String sql) throws SQLException { - return realStatement.execute(sql, columnNames); - } - }); + return PreparedStatementTracing.execute(realStatement, connectInfo, "execute", sql, + new PreparedStatementTracing.Executable() { + @Override + public Boolean exe(PreparedStatement realStatement, String sql) throws SQLException { + return realStatement.execute(sql, columnNames); + } + }, statementEnhanceInfos); } @Override @@ -335,107 +352,126 @@ public class SWPreparedStatement implements PreparedStatement { @Override public ResultSet executeQuery() throws SQLException { - return PreparedStatementTracing.execute(realStatement, connectInfo, "executeQuery", sql, new PreparedStatementTracing.Executable() { - @Override - public ResultSet exe(PreparedStatement realStatement, String sql) throws SQLException { - return realStatement.executeQuery(); - } - }); + return PreparedStatementTracing.execute(realStatement, connectInfo, "executeQuery", sql, + new PreparedStatementTracing.Executable() { + @Override + public ResultSet exe(PreparedStatement realStatement, String sql) throws SQLException { + return realStatement.executeQuery(); + } + }, statementEnhanceInfos); } @Override public int executeUpdate() throws SQLException { - return PreparedStatementTracing.execute(realStatement, connectInfo, "executeUpdate", sql, new PreparedStatementTracing.Executable() { - @Override - public Integer exe(PreparedStatement realStatement, String sql) throws SQLException { - return realStatement.executeUpdate(); - } - }); + return PreparedStatementTracing.execute(realStatement, connectInfo, "executeUpdate", sql, + new PreparedStatementTracing.Executable() { + @Override + public Integer exe(PreparedStatement realStatement, String sql) throws SQLException { + return realStatement.executeUpdate(); + } + }, statementEnhanceInfos); } @Override public void setNull(int parameterIndex, int sqlType) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, "NULL"); realStatement.setNull(parameterIndex, sqlType); } @Override public void setBoolean(int parameterIndex, boolean x) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, x); realStatement.setBoolean(parameterIndex, x); } @Override public void setByte(int parameterIndex, byte x) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, SQL_PARAMETER_PLACEHOLDER); realStatement.setByte(parameterIndex, x); } @Override public void setShort(int parameterIndex, short x) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, x); realStatement.setShort(parameterIndex, x); } @Override public void setInt(int parameterIndex, int x) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, x); realStatement.setInt(parameterIndex, x); } @Override public void setLong(int parameterIndex, long x) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, x); realStatement.setLong(parameterIndex, x); } @Override public void setFloat(int parameterIndex, float x) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, x); realStatement.setFloat(parameterIndex, x); } @Override public void setDouble(int parameterIndex, double x) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, x); realStatement.setDouble(parameterIndex, x); } @Override public void setBigDecimal(int parameterIndex, BigDecimal x) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, x); realStatement.setBigDecimal(parameterIndex, x); } @Override public void setString(int parameterIndex, String x) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, x); realStatement.setString(parameterIndex, x); } @Override public void setBytes(int parameterIndex, byte[] x) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, SQL_PARAMETER_PLACEHOLDER); realStatement.setBytes(parameterIndex, x); } @Override public void setDate(int parameterIndex, Date x) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, x); realStatement.setDate(parameterIndex, x); } @Override public void setTime(int parameterIndex, Time x) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, x); realStatement.setTime(parameterIndex, x); } @Override public void setTimestamp(int parameterIndex, Timestamp x) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, x); realStatement.setTimestamp(parameterIndex, x); } @Override public void setAsciiStream(int parameterIndex, InputStream x, int length) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, SQL_PARAMETER_PLACEHOLDER); realStatement.setAsciiStream(parameterIndex, x, length); } @Override @Deprecated public void setUnicodeStream(int parameterIndex, InputStream x, int length) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, SQL_PARAMETER_PLACEHOLDER); realStatement.setUnicodeStream(parameterIndex, x, length); } @Override public void setBinaryStream(int parameterIndex, InputStream x, int length) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, SQL_PARAMETER_PLACEHOLDER); realStatement.setBinaryStream(parameterIndex, x, length); } @@ -446,22 +482,25 @@ public class SWPreparedStatement implements PreparedStatement { @Override public void setObject(int parameterIndex, Object x, int targetSqlType) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, x); realStatement.setObject(parameterIndex, x, targetSqlType); } @Override public void setObject(int parameterIndex, Object x) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, x); realStatement.setObject(parameterIndex, x); } @Override public boolean execute() throws SQLException { - return PreparedStatementTracing.execute(realStatement, connectInfo, "execute", sql, new PreparedStatementTracing.Executable() { - @Override - public Boolean exe(PreparedStatement realStatement, String sql) throws SQLException { - return realStatement.execute(); - } - }); + return PreparedStatementTracing.execute(realStatement, connectInfo, "execute", sql, + new PreparedStatementTracing.Executable() { + @Override + public Boolean exe(PreparedStatement realStatement, String sql) throws SQLException { + return realStatement.execute(); + } + }, statementEnhanceInfos); } @Override @@ -471,26 +510,31 @@ public class SWPreparedStatement implements PreparedStatement { @Override public void setCharacterStream(int parameterIndex, Reader reader, int length) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, SQL_PARAMETER_PLACEHOLDER); realStatement.setCharacterStream(parameterIndex, reader, length); } @Override public void setRef(int parameterIndex, Ref x) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, SQL_PARAMETER_PLACEHOLDER); realStatement.setRef(parameterIndex, x); } @Override public void setBlob(int parameterIndex, Blob x) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, SQL_PARAMETER_PLACEHOLDER); realStatement.setBlob(parameterIndex, x); } @Override public void setClob(int parameterIndex, Clob x) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, SQL_PARAMETER_PLACEHOLDER); realStatement.setClob(parameterIndex, x); } @Override public void setArray(int parameterIndex, Array x) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, x); realStatement.setArray(parameterIndex, x); } @@ -501,26 +545,31 @@ public class SWPreparedStatement implements PreparedStatement { @Override public void setDate(int parameterIndex, Date x, Calendar cal) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, x); realStatement.setDate(parameterIndex, x, cal); } @Override public void setTime(int parameterIndex, Time x, Calendar cal) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, x); realStatement.setTime(parameterIndex, x, cal); } @Override public void setTimestamp(int parameterIndex, Timestamp x, Calendar cal) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, x); realStatement.setTimestamp(parameterIndex, x, cal); } @Override public void setNull(int parameterIndex, int sqlType, String typeName) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, "NULL"); realStatement.setNull(parameterIndex, sqlType, typeName); } @Override public void setURL(int parameterIndex, URL x) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, x); realStatement.setURL(parameterIndex, x); } @@ -531,96 +580,115 @@ public class SWPreparedStatement implements PreparedStatement { @Override public void setRowId(int parameterIndex, RowId x) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, x); realStatement.setRowId(parameterIndex, x); } @Override public void setNString(int parameterIndex, String value) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, value); realStatement.setNString(parameterIndex, value); } @Override public void setNCharacterStream(int parameterIndex, Reader value, long length) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, SQL_PARAMETER_PLACEHOLDER); realStatement.setNCharacterStream(parameterIndex, value, length); } @Override public void setNClob(int parameterIndex, NClob value) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, SQL_PARAMETER_PLACEHOLDER); realStatement.setNClob(parameterIndex, value); } @Override public void setClob(int parameterIndex, Reader reader, long length) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, SQL_PARAMETER_PLACEHOLDER); realStatement.setClob(parameterIndex, reader, length); } @Override public void setBlob(int parameterIndex, InputStream inputStream, long length) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, SQL_PARAMETER_PLACEHOLDER); realStatement.setBlob(parameterIndex, inputStream, length); } @Override public void setNClob(int parameterIndex, Reader reader, long length) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, SQL_PARAMETER_PLACEHOLDER); realStatement.setNClob(parameterIndex, reader, length); } @Override public void setSQLXML(int parameterIndex, SQLXML xmlObject) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, SQL_PARAMETER_PLACEHOLDER); realStatement.setSQLXML(parameterIndex, xmlObject); } @Override public void setObject(int parameterIndex, Object x, int targetSqlType, int scaleOrLength) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, x); realStatement.setObject(parameterIndex, x, targetSqlType, scaleOrLength); } @Override public void setAsciiStream(int parameterIndex, InputStream x, long length) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, SQL_PARAMETER_PLACEHOLDER); realStatement.setAsciiStream(parameterIndex, x, length); } @Override public void setBinaryStream(int parameterIndex, InputStream x, long length) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, SQL_PARAMETER_PLACEHOLDER); realStatement.setBinaryStream(parameterIndex, x, length); } @Override public void setCharacterStream(int parameterIndex, Reader reader, long length) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, SQL_PARAMETER_PLACEHOLDER); realStatement.setCharacterStream(parameterIndex, reader, length); } @Override public void setAsciiStream(int parameterIndex, InputStream x) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, SQL_PARAMETER_PLACEHOLDER); realStatement.setAsciiStream(parameterIndex, x); } @Override public void setBinaryStream(int parameterIndex, InputStream x) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, SQL_PARAMETER_PLACEHOLDER); realStatement.setBinaryStream(parameterIndex, x); } @Override public void setCharacterStream(int parameterIndex, Reader reader) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, SQL_PARAMETER_PLACEHOLDER); realStatement.setCharacterStream(parameterIndex, reader); } @Override public void setNCharacterStream(int parameterIndex, Reader value) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, SQL_PARAMETER_PLACEHOLDER); realStatement.setNCharacterStream(parameterIndex, value); } @Override public void setClob(int parameterIndex, Reader reader) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, SQL_PARAMETER_PLACEHOLDER); realStatement.setClob(parameterIndex, reader); } @Override public void setBlob(int parameterIndex, InputStream inputStream) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, SQL_PARAMETER_PLACEHOLDER); realStatement.setBlob(parameterIndex, inputStream); } @Override public void setNClob(int parameterIndex, Reader reader) throws SQLException { + statementEnhanceInfos.setParameter(parameterIndex, SQL_PARAMETER_PLACEHOLDER); realStatement.setNClob(parameterIndex, reader); } diff --git a/test/plugin/scenarios/clickhouse-0.3.1-scenario/config/expectedData.yaml b/test/plugin/scenarios/clickhouse-0.3.1-scenario/config/expectedData.yaml index 338578558..13111717c 100644 --- a/test/plugin/scenarios/clickhouse-0.3.1-scenario/config/expectedData.yaml +++ b/test/plugin/scenarios/clickhouse-0.3.1-scenario/config/expectedData.yaml @@ -171,6 +171,74 @@ segmentItems: - {key: db.type, value: ClickHouse} - {key: db.instance, value: system} - {key: db.statement, value: ''} + - operationName: ClickHouse/JDBC/Statement/executeQuery + operationId: 0 + parentSpanId: 0 + spanId: 9 + spanLayer: Database + startTime: nq 0 + endTime: nq 0 + componentId: 119 + isError: false + spanType: Exit + peer: not null + skipAnalysis: false + tags: + - {key: db.type, value: ClickHouse} + - {key: db.instance, value: system} + - {key: db.statement, value: 'select timezone(), version()'} + - {key: http.status_code, value: '200'} + - operationName: ClickHouse/JDBC/PreparedStatement/executeQuery + operationId: 0 + parentSpanId: 0 + spanId: 10 + spanLayer: Database + startTime: nq 0 + endTime: nq 0 + componentId: 119 + isError: false + spanType: Exit + peer: not null + skipAnalysis: false + tags: + - {key: db.type, value: ClickHouse} + - {key: db.instance, value: system} + - {key: db.statement, value: 'SELECT * FROM clusters WHERE cluster = ?'} + - {key: db.sql.parameters, value: '[1]'} + - {key: http.status_code, value: '200'} + - operationName: ClickHouse/JDBC/Statement/execute + operationId: 0 + parentSpanId: 0 + spanId: 11 + spanLayer: Database + startTime: nq 0 + endTime: nq 0 + componentId: 119 + isError: false + spanType: Exit + peer: not null + skipAnalysis: false + tags: + - {key: db.type, value: ClickHouse} + - {key: db.instance, value: system} + - {key: db.statement, value: SELECT 1} + - {key: http.status_code, value: '200'} + - operationName: ClickHouse/JDBC/Connection/close + operationId: 0 + parentSpanId: 0 + spanId: 12 + spanLayer: Database + startTime: nq 0 + endTime: nq 0 + componentId: 119 + isError: false + spanType: Exit + peer: not null + skipAnalysis: false + tags: + - {key: db.type, value: ClickHouse} + - {key: db.instance, value: system} + - {key: db.statement, value: ''} - operationName: GET:/clickhouse-scenario/case/clickhouse-scenario operationId: 0 parentSpanId: -1 diff --git a/test/plugin/scenarios/clickhouse-0.3.1-scenario/configuration.yml b/test/plugin/scenarios/clickhouse-0.3.1-scenario/configuration.yml index 6b8bd1f7f..d98a13101 100644 --- a/test/plugin/scenarios/clickhouse-0.3.1-scenario/configuration.yml +++ b/test/plugin/scenarios/clickhouse-0.3.1-scenario/configuration.yml @@ -19,6 +19,7 @@ entryService: http://localhost:8080/clickhouse-scenario/case/clickhouse-scenario healthCheck: http://localhost:8080/clickhouse-scenario/case/healthCheck startScript: ./bin/startup.sh environment: + - SW_JDBC_TRACE_SQL_PARAMETERS=true depends_on: - clickhouse-server dependencies: diff --git a/test/plugin/scenarios/clickhouse-0.3.1-scenario/src/main/java/org/apache/skywalking/apm/testcase/neo4j/controller/CaseController.java b/test/plugin/scenarios/clickhouse-0.3.1-scenario/src/main/java/org/apache/skywalking/apm/testcase/neo4j/controller/CaseController.java index c561c56d8..1e4f1a81f 100644 --- a/test/plugin/scenarios/clickhouse-0.3.1-scenario/src/main/java/org/apache/skywalking/apm/testcase/neo4j/controller/CaseController.java +++ b/test/plugin/scenarios/clickhouse-0.3.1-scenario/src/main/java/org/apache/skywalking/apm/testcase/neo4j/controller/CaseController.java @@ -34,6 +34,7 @@ public class CaseController { private static final String SUCCESS = "Success"; private static final String SQL = "SELECT * FROM clusters"; + private static final String PREPARED_STATEMENT_SQL = "SELECT * FROM clusters WHERE cluster = ?"; @Resource private ClickHouseDataSource dataSource; @@ -51,6 +52,13 @@ public class CaseController { final ResultSet ignored = preparedStatement.executeQuery()) { connection.isValid(3); } + + try (final ClickHouseConnection connection = dataSource.getConnection(); + PreparedStatement preparedStatement = connection.prepareStatement(PREPARED_STATEMENT_SQL)) { + preparedStatement.setString(1, "1"); + ResultSet ignored = preparedStatement.executeQuery(); + connection.isValid(3); + } return SUCCESS; } diff --git a/test/plugin/scenarios/clickhouse-0.3.2.x-scenario/config/expectedData.yaml b/test/plugin/scenarios/clickhouse-0.3.2.x-scenario/config/expectedData.yaml index 762646879..e8fe48705 100644 --- a/test/plugin/scenarios/clickhouse-0.3.2.x-scenario/config/expectedData.yaml +++ b/test/plugin/scenarios/clickhouse-0.3.2.x-scenario/config/expectedData.yaml @@ -101,6 +101,39 @@ segmentItems: - {key: db.type, value: ClickHouse} - {key: db.instance, value: system} - {key: db.statement, value: ''} + - operationName: ClickHouse/JDBC/PreparedStatement/executeQuery + operationId: 0 + parentSpanId: 0 + spanId: 5 + spanLayer: Database + startTime: nq 0 + endTime: nq 0 + componentId: 119 + isError: false + spanType: Exit + peer: not null + skipAnalysis: false + tags: + - {key: db.type, value: ClickHouse} + - {key: db.instance, value: system} + - {key: db.statement, value: 'SELECT * FROM clusters WHERE cluster = ?'} + - {key: db.sql.parameters, value: '[1]'} + - operationName: ClickHouse/JDBC/Connection/close + operationId: 0 + parentSpanId: 0 + spanId: 6 + spanLayer: Database + startTime: nq 0 + endTime: nq 0 + componentId: 119 + isError: false + spanType: Exit + peer: not null + skipAnalysis: false + tags: + - {key: db.type, value: ClickHouse} + - {key: db.instance, value: system} + - {key: db.statement, value: ''} - operationName: GET:/clickhouse-scenario/case/clickhouse-scenario operationId: 0 parentSpanId: -1 diff --git a/test/plugin/scenarios/clickhouse-0.3.2.x-scenario/configuration.yml b/test/plugin/scenarios/clickhouse-0.3.2.x-scenario/configuration.yml index 6b8bd1f7f..d98a13101 100644 --- a/test/plugin/scenarios/clickhouse-0.3.2.x-scenario/configuration.yml +++ b/test/plugin/scenarios/clickhouse-0.3.2.x-scenario/configuration.yml @@ -19,6 +19,7 @@ entryService: http://localhost:8080/clickhouse-scenario/case/clickhouse-scenario healthCheck: http://localhost:8080/clickhouse-scenario/case/healthCheck startScript: ./bin/startup.sh environment: + - SW_JDBC_TRACE_SQL_PARAMETERS=true depends_on: - clickhouse-server dependencies: diff --git a/test/plugin/scenarios/clickhouse-0.3.2.x-scenario/src/main/java/org/apache/skywalking/apm/testcase/neo4j/controller/CaseController.java b/test/plugin/scenarios/clickhouse-0.3.2.x-scenario/src/main/java/org/apache/skywalking/apm/testcase/neo4j/controller/CaseController.java index 2dc26c4a9..13fac8e7a 100644 --- a/test/plugin/scenarios/clickhouse-0.3.2.x-scenario/src/main/java/org/apache/skywalking/apm/testcase/neo4j/controller/CaseController.java +++ b/test/plugin/scenarios/clickhouse-0.3.2.x-scenario/src/main/java/org/apache/skywalking/apm/testcase/neo4j/controller/CaseController.java @@ -18,13 +18,12 @@ package org.apache.skywalking.apm.testcase.neo4j.controller; -import java.sql.PreparedStatement; -import java.sql.ResultSet; -import javax.annotation.Resource; - import com.clickhouse.jdbc.ClickHouseConnection; import com.clickhouse.jdbc.ClickHouseDataSource; import com.clickhouse.jdbc.ClickHouseStatement; +import java.sql.PreparedStatement; +import java.sql.ResultSet; +import javax.annotation.Resource; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.ResponseBody; import org.springframework.web.bind.annotation.RestController; @@ -35,6 +34,7 @@ public class CaseController { private static final String SUCCESS = "Success"; private static final String SQL = "SELECT * FROM clusters"; + private static final String PREPARED_STATEMENT_SQL = "SELECT * FROM clusters WHERE cluster = ?"; @Resource private ClickHouseDataSource dataSource; @@ -42,8 +42,8 @@ public class CaseController { @ResponseBody public String testcase() throws Exception { try (ClickHouseConnection conn = dataSource.getConnection(); - ClickHouseStatement stmt = conn.createStatement(); - ResultSet ignored = stmt.executeQuery(SQL)) { + ClickHouseStatement stmt = conn.createStatement(); + ResultSet ignored = stmt.executeQuery(SQL)) { conn.isValid(3); } @@ -52,6 +52,13 @@ public class CaseController { final ResultSet ignored = preparedStatement.executeQuery()) { connection.isValid(3); } + + try (final ClickHouseConnection connection = dataSource.getConnection(); + PreparedStatement preparedStatement = connection.prepareStatement(PREPARED_STATEMENT_SQL)) { + preparedStatement.setString(1, "1"); + ResultSet ignored = preparedStatement.executeQuery(); + connection.isValid(3); + } return SUCCESS; }