Skip to content

Unify jdbc tests across javaagent and library instrumentation #15136

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Closed
wants to merge 4 commits into from
Closed

Unify jdbc tests across javaagent and library instrumentation #15136

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
4 commits
Select commit Hold shift + click to select a range
9252946
Unify jdbc tests
trask Oct 22, 2025
eaaa8ce
more
trask Oct 23, 2025
237983d
wrap
trask Oct 24, 2025
504cd8f
update
trask Oct 24, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
1,841 changes: 5 additions & 1,836 deletions ...st/java/io/opentelemetry/javaagent/instrumentation/jdbc/test/JdbcInstrumentationTest.java
View file
Open in desktop

Large diffs are not rendered by default.

598 changes: 5 additions & 593 deletions ...io/opentelemetry/javaagent/instrumentation/jdbc/test/PreparedStatementParametersTest.java
View file
Open in desktop

Large diffs are not rendered by default.

167 changes: 5 additions & 162 deletions .../src/test/java/io/opentelemetry/javaagent/instrumentation/jdbc/test/SqlCommenterTest.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -5,175 +5,18 @@

package io.opentelemetry.javaagent.instrumentation.jdbc.test;

import static org.assertj.core.api.Assertions.assertThat;

import io.opentelemetry.instrumentation.api.internal.SemconvStability;
import io.opentelemetry.instrumentation.jdbc.TestConnection;
import io.opentelemetry.instrumentation.testing.internal.AutoCleanupExtension;
import io.opentelemetry.instrumentation.jdbc.testing.AbstractSqlCommenterTest;
import io.opentelemetry.instrumentation.testing.junit.AgentInstrumentationExtension;
import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.RegisterExtension;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.ValueSource;

class SqlCommenterTest {
@RegisterExtension static final AutoCleanupExtension cleanup = AutoCleanupExtension.create();
class SqlCommenterTest extends AbstractSqlCommenterTest {

@RegisterExtension
static final InstrumentationExtension testing = AgentInstrumentationExtension.create();

@Test
void testSqlCommenterStatement() throws SQLException {
List<String> executedSql = new ArrayList<>();
Connection connection = new TestConnection(executedSql::add);
Statement statement = connection.createStatement();

cleanup.deferCleanup(statement);
cleanup.deferCleanup(connection);

String query = "SELECT 1";
testing.runWithSpan("parent", () -> statement.execute(query));

testing.waitAndAssertTraces(
trace ->
trace.hasSpansSatisfyingExactly(
span -> span.hasName("parent").hasNoParent(),
span -> span.hasName("SELECT dbname").hasParent(trace.getSpan(0))));

assertThat(executedSql).hasSize(1);
assertThat(executedSql.get(0)).contains(query).contains("traceparent");
}

@ParameterizedTest
@ValueSource(booleans = {true, false})
void testSqlCommenterStatementUpdate(boolean largeUpdate) throws SQLException {
List<String> executedSql = new ArrayList<>();
Connection connection = new TestConnection(executedSql::add);
Statement statement = connection.createStatement();

cleanup.deferCleanup(statement);
cleanup.deferCleanup(connection);

String query = "INSERT INTO test VALUES(1)";
testing.runWithSpan(
"parent",
() -> {
if (largeUpdate) {
statement.executeLargeUpdate(query);
} else {
statement.execute(query);
}
});

testing.waitAndAssertTraces(
trace ->
trace.hasSpansSatisfyingExactly(
span -> span.hasName("parent").hasNoParent(),
span -> span.hasName("INSERT dbname.test").hasParent(trace.getSpan(0))));

assertThat(executedSql).hasSize(1);
assertThat(executedSql.get(0)).contains(query).contains("traceparent");
}

@ParameterizedTest
@ValueSource(booleans = {true, false})
void testSqlCommenterStatementBatch(boolean largeUpdate) throws SQLException {
List<String> executedSql = new ArrayList<>();
Connection connection = new TestConnection(executedSql::add);
Statement statement = connection.createStatement();

cleanup.deferCleanup(statement);
cleanup.deferCleanup(connection);

testing.runWithSpan(
"parent",
() -> {
statement.addBatch("INSERT INTO test VALUES(1)");
statement.addBatch("INSERT INTO test VALUES(2)");
if (largeUpdate) {
statement.executeLargeBatch();
} else {
statement.executeBatch();
}
});

testing.waitAndAssertTraces(
trace ->
trace.hasSpansSatisfyingExactly(
span -> span.hasName("parent").hasNoParent(),
span ->
span.hasName(
SemconvStability.emitStableDatabaseSemconv()
? "BATCH INSERT dbname.test"
: "dbname")
.hasParent(trace.getSpan(0))));

assertThat(executedSql).hasSize(2);
assertThat(executedSql.get(0)).contains("INSERT INTO test VALUES(1)").contains("traceparent");
assertThat(executedSql.get(1)).contains("INSERT INTO test VALUES(2)").contains("traceparent");
}

@Test
void testSqlCommenterPreparedStatement() throws SQLException {
List<String> executedSql = new ArrayList<>();
Connection connection = new TestConnection(executedSql::add);

String query = "SELECT 1";
testing.runWithSpan(
"parent",
() -> {
PreparedStatement statement = connection.prepareStatement(query);
cleanup.deferCleanup(statement);
cleanup.deferCleanup(connection);

statement.execute();
});

testing.waitAndAssertTraces(
trace ->
trace.hasSpansSatisfyingExactly(
span -> span.hasName("parent").hasNoParent(),
span -> span.hasName("SELECT dbname").hasParent(trace.getSpan(0))));

assertThat(executedSql).hasSize(1);
assertThat(executedSql.get(0)).contains(query).contains("traceparent");
}

@ParameterizedTest
@ValueSource(booleans = {true, false})
void testSqlCommenterPreparedStatementUpdate(boolean largeUpdate) throws SQLException {
List<String> executedSql = new ArrayList<>();
Connection connection = new TestConnection(executedSql::add);

String query = "INSERT INTO test VALUES(1)";
testing.runWithSpan(
"parent",
() -> {
PreparedStatement statement = connection.prepareStatement(query);
cleanup.deferCleanup(statement);
cleanup.deferCleanup(connection);

if (largeUpdate) {
statement.executeLargeUpdate();
} else {
statement.executeUpdate();
}
});

testing.waitAndAssertTraces(
trace ->
trace.hasSpansSatisfyingExactly(
span -> span.hasName("parent").hasNoParent(),
span -> span.hasName("INSERT dbname.test").hasParent(trace.getSpan(0))));

assertThat(executedSql).hasSize(1);
assertThat(executedSql.get(0)).contains(query).contains("traceparent");
@Override
protected InstrumentationExtension testing() {
return testing;
}
}
16 changes: 15 additions & 1 deletion ...n/java/io/opentelemetry/instrumentation/jdbc/internal/OpenTelemetryPreparedStatement.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -244,18 +244,21 @@ public void setBinaryStream(int parameterIndex, InputStream x) throws SQLExcepti
@Override
public void setObject(int parameterIndex, Object x, int targetSqlType) throws SQLException {
delegate.setObject(parameterIndex, x, targetSqlType);
putParameter(parameterIndex, x);
}

@SuppressWarnings("UngroupedOverloads")
@Override
public void setObject(int parameterIndex, Object x) throws SQLException {
delegate.setObject(parameterIndex, x);
putParameter(parameterIndex, x);
}

@Override
public void setObject(int parameterIndex, Object x, int targetSqlType, int scaleOrLength)
throws SQLException {
delegate.setObject(parameterIndex, x, targetSqlType, scaleOrLength);
putParameter(parameterIndex, x);
}

@Override
Expand Down Expand Up @@ -419,15 +422,26 @@ private <T, E extends Exception> T wrapBatchCall(ThrowingSupplier<T, E> callable
public void setObject(int parameterIndex, Object x, SQLType targetSqlType, int scaleOrLength)
throws SQLException {
delegate.setObject(parameterIndex, x, targetSqlType, scaleOrLength);
putParameter(parameterIndex, x);
}

@Override
public void setObject(int parameterIndex, Object x, SQLType targetSqlType) throws SQLException {
delegate.setObject(parameterIndex, x, targetSqlType);
putParameter(parameterIndex, x);
}

@Override
public long executeLargeUpdate() throws SQLException {
return wrapCall(query, delegate::executeLargeUpdate);
return wrapCall(
query,
() -> {
try {
return delegate.executeLargeUpdate();
} catch (UnsupportedOperationException ignored) {
// Fallback for drivers that only implement executeUpdate
return (long) delegate.executeUpdate();
}
});
}
}
18 changes: 17 additions & 1 deletion .../src/main/java/io/opentelemetry/instrumentation/jdbc/internal/OpenTelemetryStatement.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -28,6 +28,7 @@
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.SQLFeatureNotSupportedException;
import java.sql.SQLWarning;
import java.sql.Statement;
import java.util.ArrayList;
Expand Down Expand Up @@ -329,7 +330,22 @@ public long getLargeMaxRows() throws SQLException {

@Override
public long[] executeLargeBatch() throws SQLException {
return wrapBatchCall(delegate::executeLargeBatch);
return wrapBatchCall(
() -> {
try {
return delegate.executeLargeBatch();
} catch (UnsupportedOperationException
| SQLFeatureNotSupportedException
| AbstractMethodError ignored) {
// Older drivers rely on the default executeLargeBatch implementation, which throws.
int[] batchResult = delegate.executeBatch();
long[] converted = new long[batchResult.length];
for (int index = 0; index < batchResult.length; index++) {
converted[index] = batchResult[index];
}
return converted;
}
});
}

@Override
Expand Down
Loading
Loading