From d02f80b2258d6184d140c0bece9434064b8b5eac Mon Sep 17 00:00:00 2001 From: Onkar Sarvade Date: Wed, 26 Feb 2025 21:21:55 +0530 Subject: [PATCH 1/8] added vertx postgresql client instrumentation --- .../vertx-pg-client-4.2.0/build.gradle | 35 ++ .../CursorImplInstrumentation.java | 47 +++ .../CursorReadAdvice.java | 56 +++ .../PgConnectionFactoryConstructorAdvice.java | 31 ++ .../PgConnectionFactoryInstrumentation.java | 40 +++ .../PgConnectionImplConstructorAdvice.java | 22 ++ .../PgConnectionImplInstrumentation.java | 40 +++ .../PgPoolImplAdvice.java | 31 ++ .../PgPoolImplInstrumentation.java | 45 +++ .../PrepareHandlerWrapper.java | 32 ++ .../PreparedQueryInstrumentation.java | 72 ++++ .../PreparedStatementImplInstrumentation.java | 40 +++ .../PreparedStatementQueryAdvice.java | 22 ++ .../vertx_pg_client_4_2_0/QueryAdvice.java | 82 +++++ .../QueryImplInstrumentation.java | 57 +++ .../QueryResultHandlerWrapper.java | 41 +++ .../SqlClientBaseAdvice.java | 51 +++ .../SqlClientBaseInstrumentation.java | 53 +++ .../SqlConnectionBaseInstrumentation.java | 52 +++ .../SqlConnectionBasePrepareAdvice.java | 35 ++ .../VertxSqlClientDecorator.java | 115 ++++++ .../groovy/VertxSqlClientForkedTest.groovy | 340 ++++++++++++++++++ .../src/test/java/TestDatabases.java | 101 ++++++ settings.gradle | 1 + 24 files changed, 1441 insertions(+) create mode 100644 dd-java-agent/instrumentation/vertx-pg-client-4.2.0/build.gradle create mode 100644 dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/CursorImplInstrumentation.java create mode 100644 dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/CursorReadAdvice.java create mode 100644 dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PgConnectionFactoryConstructorAdvice.java create mode 100644 dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PgConnectionFactoryInstrumentation.java create mode 100644 dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PgConnectionImplConstructorAdvice.java create mode 100644 dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PgConnectionImplInstrumentation.java create mode 100644 dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PgPoolImplAdvice.java create mode 100644 dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PgPoolImplInstrumentation.java create mode 100644 dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PrepareHandlerWrapper.java create mode 100644 dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PreparedQueryInstrumentation.java create mode 100644 dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PreparedStatementImplInstrumentation.java create mode 100644 dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PreparedStatementQueryAdvice.java create mode 100644 dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/QueryAdvice.java create mode 100644 dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/QueryImplInstrumentation.java create mode 100644 dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/QueryResultHandlerWrapper.java create mode 100644 dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/SqlClientBaseAdvice.java create mode 100644 dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/SqlClientBaseInstrumentation.java create mode 100644 dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/SqlConnectionBaseInstrumentation.java create mode 100644 dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/SqlConnectionBasePrepareAdvice.java create mode 100644 dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/VertxSqlClientDecorator.java create mode 100644 dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/test/groovy/VertxSqlClientForkedTest.groovy create mode 100644 dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/test/java/TestDatabases.java diff --git a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/build.gradle b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/build.gradle new file mode 100644 index 00000000000..ca4c07922c6 --- /dev/null +++ b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/build.gradle @@ -0,0 +1,35 @@ + +apply from: "$rootDir/gradle/java.gradle" + +muzzle { + pass { + group = 'io.vertx' + module = 'vertx-pg-client' + versions = '[4.2.0)' + assertInverse = true + } +} + +addTestSuiteForDir('latestDepTest', 'test') +addTestSuiteExtendingForDir('latestDepForkedTest', 'latestDepTest', 'test') + +apply from: "$rootDir/gradle/configure_tests.gradle" + +latestDepTest { + finalizedBy 'latestDepForkedTest' +} + +dependencies { + compileOnly group: 'io.vertx', name: 'vertx-pg-client', version: '4.2.0' + + testImplementation group: 'io.vertx', name: 'vertx-pg-client', version: '4.2.0' + + // This is needed for the test container to start + testImplementation group: 'org.testcontainers', name: 'postgresql', version: libs.versions.testcontainers.get() + + latestDepTestImplementation group: 'io.vertx', name: 'vertx-pg-client', version: '4.2.+' +} + +tasks.withType(Test).configureEach { + usesService(testcontainersLimit) +} diff --git a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/CursorImplInstrumentation.java b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/CursorImplInstrumentation.java new file mode 100644 index 00000000000..a7bfb501fdc --- /dev/null +++ b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/CursorImplInstrumentation.java @@ -0,0 +1,47 @@ +package datadog.trace.instrumentation.vertx_pg_client_4_2_0; + +import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; +import static java.util.Collections.singletonMap; +import static net.bytebuddy.matcher.ElementMatchers.isMethod; +import static net.bytebuddy.matcher.ElementMatchers.isPublic; +import static net.bytebuddy.matcher.ElementMatchers.takesArgument; + +import com.google.auto.service.AutoService; +import datadog.trace.agent.tooling.Instrumenter; +import datadog.trace.agent.tooling.InstrumenterModule; +import java.util.Map; + +@AutoService(InstrumenterModule.class) +public class CursorImplInstrumentation extends InstrumenterModule.Tracing + implements Instrumenter.ForSingleType, Instrumenter.HasMethodAdvice { + public CursorImplInstrumentation() { + super("vertx", "vertx-sql-client"); + } + + @Override + public Map contextStore() { + return singletonMap("io.vertx.sqlclient.PreparedStatement", "datadog.trace.api.Pair"); + } + + @Override + public String[] helperClassNames() { + return new String[] { + packageName + ".QueryResultHandlerWrapper", packageName + ".VertxSqlClientDecorator", + }; + } + + @Override + public String instrumentedType() { + return "io.vertx.sqlclient.impl.CursorImpl"; + } + + @Override + public void methodAdvice(MethodTransformer transformer) { + transformer.applyAdvice( + isMethod() + .and(isPublic()) + .and(named("read")) + .and(takesArgument(1, named("io.vertx.core.Handler"))), + packageName + ".CursorReadAdvice"); + } +} diff --git a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/CursorReadAdvice.java b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/CursorReadAdvice.java new file mode 100644 index 00000000000..3cad4136a3d --- /dev/null +++ b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/CursorReadAdvice.java @@ -0,0 +1,56 @@ +package datadog.trace.instrumentation.vertx_pg_client_4_2_0; + +import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.activateSpan; +import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.activeSpan; +import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.captureSpan; +import static datadog.trace.instrumentation.vertx_pg_client_4_2_0.VertxSqlClientDecorator.DECORATE; + +import datadog.trace.api.Pair; +import datadog.trace.bootstrap.InstrumentationContext; +import datadog.trace.bootstrap.instrumentation.api.AgentScope; +import datadog.trace.bootstrap.instrumentation.api.AgentSpan; +import io.vertx.core.AsyncResult; +import io.vertx.core.Handler; +import io.vertx.pgclient.PgConnection; +import io.vertx.sqlclient.PreparedStatement; +import io.vertx.sqlclient.Row; +import io.vertx.sqlclient.RowSet; +import net.bytebuddy.asm.Advice; +import net.bytebuddy.implementation.bytecode.assign.Assigner; + +public class CursorReadAdvice { + @Advice.OnMethodEnter(suppress = Throwable.class) + public static AgentScope beforeRead( + @Advice.Argument(value = 1, readOnly = false) Handler>> handler, + @Advice.FieldValue(value = "ps", typing = Assigner.Typing.DYNAMIC) + final PreparedStatement ps) { + if (handler instanceof QueryResultHandlerWrapper) { + return null; + } + final AgentSpan parentSpan = activeSpan(); + final AgentScope.Continuation parentContinuation = + null == parentSpan ? null : captureSpan(parentSpan); + final AgentSpan clientSpan = + DECORATE.startAndDecorateSpanForStatement( + ps, InstrumentationContext.get(PreparedStatement.class, Pair.class), true); + if (null == clientSpan) { + return null; + } + handler = new QueryResultHandlerWrapper<>(handler, clientSpan, parentContinuation); + + return activateSpan(clientSpan, true); + } + + @Advice.OnMethodExit(onThrowable = Throwable.class, suppress = Throwable.class) + public static void afterRead( + @Advice.Thrown final Throwable throwable, @Advice.Enter final AgentScope clientScope) { + if (null != clientScope) { + clientScope.close(); + } + } + + // Limit ourselves to 4.x by checking for the ping() method that was added in 4.x + private static void muzzleCheck(PgConnection connection) { + connection.query("SELECT 1"); + } +} diff --git a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PgConnectionFactoryConstructorAdvice.java b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PgConnectionFactoryConstructorAdvice.java new file mode 100644 index 00000000000..222adeb908a --- /dev/null +++ b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PgConnectionFactoryConstructorAdvice.java @@ -0,0 +1,31 @@ +package datadog.trace.instrumentation.vertx_pg_client_4_2_0; + +import datadog.trace.bootstrap.InstrumentationContext; +import datadog.trace.bootstrap.instrumentation.jdbc.DBInfo; +import io.vertx.pgclient.PgConnectOptions; +import io.vertx.pgclient.PgConnection; +import io.vertx.pgclient.impl.PgConnectionFactory; +import net.bytebuddy.asm.Advice; + +public class PgConnectionFactoryConstructorAdvice { + @Advice.OnMethodExit(suppress = Throwable.class) + public static void afterConstructor( + @Advice.This final PgConnectionFactory zis, + @Advice.Argument(1) final PgConnectOptions options) { + DBInfo.Builder builder = DBInfo.DEFAULT.toBuilder(); + DBInfo info = + builder + .host(options.getHost()) + .port(options.getPort()) + .db(options.getDatabase()) + .user(options.getUser()) + .type("postgresql") + .build(); + InstrumentationContext.get(PgConnectionFactory.class, DBInfo.class).put(zis, info); + } + + // Limit ourselves to 4.x by checking for the ping() method that was added in 4.x + private static void muzzleCheck(PgConnection connection) { + connection.query("SELECT 1"); + } +} diff --git a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PgConnectionFactoryInstrumentation.java b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PgConnectionFactoryInstrumentation.java new file mode 100644 index 00000000000..8ea364f6d53 --- /dev/null +++ b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PgConnectionFactoryInstrumentation.java @@ -0,0 +1,40 @@ +package datadog.trace.instrumentation.vertx_pg_client_4_2_0; + +import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; +import static java.util.Collections.singletonMap; +import static net.bytebuddy.matcher.ElementMatchers.isConstructor; +import static net.bytebuddy.matcher.ElementMatchers.takesArgument; +import static net.bytebuddy.matcher.ElementMatchers.takesArguments; + +import com.google.auto.service.AutoService; +import datadog.trace.agent.tooling.Instrumenter; +import datadog.trace.agent.tooling.InstrumenterModule; +import datadog.trace.bootstrap.instrumentation.jdbc.DBInfo; +import java.util.Map; + +@AutoService(InstrumenterModule.class) +public class PgConnectionFactoryInstrumentation extends InstrumenterModule.Tracing + implements Instrumenter.ForSingleType, Instrumenter.HasMethodAdvice { + public PgConnectionFactoryInstrumentation() { + super("vertx", "vertx-sql-client"); + } + + @Override + public Map contextStore() { + return singletonMap("io.vertx.pgclient.impl.PgConnectionFactory", DBInfo.class.getName()); + } + + @Override + public String instrumentedType() { + return "io.vertx.pgclient.impl.PgConnectionFactory"; + } + + @Override + public void methodAdvice(MethodTransformer transformer) { + transformer.applyAdvice( + isConstructor() + .and(takesArguments(2)) + .and(takesArgument(1, named("io.vertx.pgclient.PgConnectOptions"))), + packageName + ".PgConnectionFactoryConstructorAdvice"); + } +} diff --git a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PgConnectionImplConstructorAdvice.java b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PgConnectionImplConstructorAdvice.java new file mode 100644 index 00000000000..ecb46485913 --- /dev/null +++ b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PgConnectionImplConstructorAdvice.java @@ -0,0 +1,22 @@ +package datadog.trace.instrumentation.vertx_pg_client_4_2_0; + +import datadog.trace.bootstrap.InstrumentationContext; +import datadog.trace.bootstrap.instrumentation.jdbc.DBInfo; +import io.vertx.pgclient.PgConnection; +import io.vertx.pgclient.impl.PgConnectionFactory; +import io.vertx.sqlclient.SqlClient; +import net.bytebuddy.asm.Advice; + +public class PgConnectionImplConstructorAdvice { + @Advice.OnMethodExit(suppress = Throwable.class) + public static void afterConstructor( + @Advice.This final SqlClient zis, @Advice.Argument(0) final PgConnectionFactory factory) { + InstrumentationContext.get(SqlClient.class, DBInfo.class) + .put(zis, InstrumentationContext.get(PgConnectionFactory.class, DBInfo.class).get(factory)); + } + + // Limit ourselves to 4.x by checking for the ping() method that was added in 4.x + private static void muzzleCheck(PgConnection connection) { + connection.query("SELECT 1"); + } +} diff --git a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PgConnectionImplInstrumentation.java b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PgConnectionImplInstrumentation.java new file mode 100644 index 00000000000..110cf9af591 --- /dev/null +++ b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PgConnectionImplInstrumentation.java @@ -0,0 +1,40 @@ +package datadog.trace.instrumentation.vertx_pg_client_4_2_0; + +import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; +import static net.bytebuddy.matcher.ElementMatchers.isConstructor; +import static net.bytebuddy.matcher.ElementMatchers.takesArgument; + +import com.google.auto.service.AutoService; +import datadog.trace.agent.tooling.Instrumenter; +import datadog.trace.agent.tooling.InstrumenterModule; +import datadog.trace.bootstrap.instrumentation.jdbc.DBInfo; +import java.util.HashMap; +import java.util.Map; + +@AutoService(InstrumenterModule.class) +public class PgConnectionImplInstrumentation extends InstrumenterModule.Tracing + implements Instrumenter.ForSingleType, Instrumenter.HasMethodAdvice { + public PgConnectionImplInstrumentation() { + super("vertx", "vertx-sql-client"); + } + + @Override + public Map contextStore() { + Map contextStores = new HashMap<>(); + contextStores.put("io.vertx.pgclient.impl.PgConnectionFactory", DBInfo.class.getName()); + contextStores.put("io.vertx.sqlclient.SqlClient", DBInfo.class.getName()); + return contextStores; + } + + @Override + public String instrumentedType() { + return "io.vertx.pgclient.impl.PgConnectionImpl"; + } + + @Override + public void methodAdvice(MethodTransformer transformer) { + transformer.applyAdvice( + isConstructor().and(takesArgument(0, named("io.vertx.pgclient.impl.PgConnectionFactory"))), + packageName + ".PgConnectionImplConstructorAdvice"); + } +} diff --git a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PgPoolImplAdvice.java b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PgPoolImplAdvice.java new file mode 100644 index 00000000000..cd2f2f76068 --- /dev/null +++ b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PgPoolImplAdvice.java @@ -0,0 +1,31 @@ +package datadog.trace.instrumentation.vertx_pg_client_4_2_0; + +import datadog.trace.bootstrap.InstrumentationContext; +import datadog.trace.bootstrap.instrumentation.jdbc.DBInfo; +import io.vertx.pgclient.PgConnectOptions; +import io.vertx.pgclient.PgConnection; +import io.vertx.sqlclient.SqlClient; +import net.bytebuddy.asm.Advice; + +public class PgPoolImplAdvice { + + @Advice.OnMethodExit(suppress = Throwable.class) + public static void afterCreate( + @Advice.Return final SqlClient zis, @Advice.Argument(2) PgConnectOptions options) { + DBInfo.Builder builder = DBInfo.DEFAULT.toBuilder(); + DBInfo info = + builder + .host(options.getHost()) + .port(options.getPort()) + .db(options.getDatabase()) + .user(options.getUser()) + .type("postgresql") + .build(); + InstrumentationContext.get(SqlClient.class, DBInfo.class).put(zis, info); + } + + // Limit ourselves to 4.x by checking for the ping() method that was added in 4.x + private static void muzzleCheck(PgConnection connection) { + connection.query("SELECT 1"); + } +} diff --git a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PgPoolImplInstrumentation.java b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PgPoolImplInstrumentation.java new file mode 100644 index 00000000000..47ab7841f16 --- /dev/null +++ b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PgPoolImplInstrumentation.java @@ -0,0 +1,45 @@ +package datadog.trace.instrumentation.vertx_pg_client_4_2_0; + +import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; +import static java.util.Collections.singletonMap; +import static net.bytebuddy.matcher.ElementMatchers.isMethod; +import static net.bytebuddy.matcher.ElementMatchers.isPublic; +import static net.bytebuddy.matcher.ElementMatchers.isStatic; +import static net.bytebuddy.matcher.ElementMatchers.takesArgument; +import static net.bytebuddy.matcher.ElementMatchers.takesArguments; + +import com.google.auto.service.AutoService; +import datadog.trace.agent.tooling.Instrumenter; +import datadog.trace.agent.tooling.InstrumenterModule; +import datadog.trace.bootstrap.instrumentation.jdbc.DBInfo; +import java.util.Map; + +@AutoService(InstrumenterModule.class) +public class PgPoolImplInstrumentation extends InstrumenterModule.Tracing + implements Instrumenter.ForSingleType, Instrumenter.HasMethodAdvice { + public PgPoolImplInstrumentation() { + super("vertx", "vertx-sql-client"); + } + + @Override + public Map contextStore() { + return singletonMap("io.vertx.sqlclient.SqlClient", DBInfo.class.getName()); + } + + @Override + public String instrumentedType() { + return "io.vertx.pgclient.impl.PgPoolImpl"; + } + + @Override + public void methodAdvice(MethodTransformer transformer) { + transformer.applyAdvice( + isStatic() + .and(isPublic()) + .and(isMethod()) + .and(named("create")) + .and(takesArguments(4)) + .and(takesArgument(2, named("io.vertx.pgclient.PgConnectOptions"))), + packageName + ".PgPoolImplAdvice"); + } +} diff --git a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PrepareHandlerWrapper.java b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PrepareHandlerWrapper.java new file mode 100644 index 00000000000..fcedcde16c7 --- /dev/null +++ b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PrepareHandlerWrapper.java @@ -0,0 +1,32 @@ +package datadog.trace.instrumentation.vertx_pg_client_4_2_0; + +import datadog.trace.api.Pair; +import datadog.trace.bootstrap.ContextStore; +import datadog.trace.bootstrap.instrumentation.jdbc.DBInfo; +import datadog.trace.bootstrap.instrumentation.jdbc.DBQueryInfo; +import io.vertx.core.AsyncResult; +import io.vertx.core.Handler; +import io.vertx.sqlclient.PreparedStatement; + +public class PrepareHandlerWrapper implements Handler> { + private final Handler> handler; + private final ContextStore contextStore; + private final Pair queryInfo; + + public PrepareHandlerWrapper( + Handler> handler, + ContextStore contextStore, + Pair queryInfo) { + this.handler = handler; + this.contextStore = contextStore; + this.queryInfo = queryInfo; + } + + @Override + public void handle(AsyncResult event) { + if (event.succeeded()) { + contextStore.put(event.result(), queryInfo); + } + handler.handle(event); + } +} diff --git a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PreparedQueryInstrumentation.java b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PreparedQueryInstrumentation.java new file mode 100644 index 00000000000..57877e96263 --- /dev/null +++ b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PreparedQueryInstrumentation.java @@ -0,0 +1,72 @@ +package datadog.trace.instrumentation.vertx_pg_client_4_2_0; + +import static datadog.trace.agent.tooling.bytebuddy.matcher.HierarchyMatchers.implementsInterface; +import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; +import static java.util.Collections.singletonMap; +import static net.bytebuddy.matcher.ElementMatchers.isMethod; +import static net.bytebuddy.matcher.ElementMatchers.isPublic; +import static net.bytebuddy.matcher.ElementMatchers.isVirtual; +import static net.bytebuddy.matcher.ElementMatchers.returns; +import static net.bytebuddy.matcher.ElementMatchers.takesArgument; +import static net.bytebuddy.matcher.ElementMatchers.takesArguments; + +import com.google.auto.service.AutoService; +import datadog.trace.agent.tooling.Instrumenter; +import datadog.trace.agent.tooling.InstrumenterModule; +import java.util.Map; +import net.bytebuddy.description.type.TypeDescription; +import net.bytebuddy.matcher.ElementMatcher; + +@AutoService(InstrumenterModule.class) +public class PreparedQueryInstrumentation extends InstrumenterModule.Tracing + implements Instrumenter.ForTypeHierarchy, Instrumenter.HasMethodAdvice { + public PreparedQueryInstrumentation() { + super("vertx", "vertx-sql-client"); + } + + @Override + public Map contextStore() { + return singletonMap("io.vertx.sqlclient.Query", "datadog.trace.api.Pair"); + } + + @Override + public String[] helperClassNames() { + return new String[] { + packageName + ".QueryResultHandlerWrapper", packageName + ".VertxSqlClientDecorator", + }; + } + + @Override + public String hierarchyMarkerType() { + return "io.vertx.sqlclient.PreparedQuery"; + } + + @Override + public ElementMatcher hierarchyMatcher() { + return implementsInterface(named(hierarchyMarkerType())); + } + + @Override + public void methodAdvice(MethodTransformer transformer) { + transformer.applyAdvice( + isMethod() + .and(isPublic()) + .and(named("execute")) + .and(takesArguments(2)) + .and(takesArgument(1, named("io.vertx.core.Handler"))), + packageName + ".QueryAdvice$Execute"); + transformer.applyAdvice( + isMethod() + .and(isPublic()) + .and(named("executeBatch")) + .and(takesArguments(2)) + .and(takesArgument(1, named("io.vertx.core.Handler"))), + packageName + ".QueryAdvice$Execute"); + transformer.applyAdvice( + isMethod() + .and(isVirtual()) + .and(named("copy")) + .and(returns(named("io.vertx.sqlclient.impl.QueryBase"))), + packageName + ".QueryAdvice$Copy"); + } +} diff --git a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PreparedStatementImplInstrumentation.java b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PreparedStatementImplInstrumentation.java new file mode 100644 index 00000000000..5fdb7c8a9dd --- /dev/null +++ b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PreparedStatementImplInstrumentation.java @@ -0,0 +1,40 @@ +package datadog.trace.instrumentation.vertx_pg_client_4_2_0; + +import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; +import static net.bytebuddy.matcher.ElementMatchers.isMethod; +import static net.bytebuddy.matcher.ElementMatchers.isPublic; +import static net.bytebuddy.matcher.ElementMatchers.takesNoArguments; + +import com.google.auto.service.AutoService; +import datadog.trace.agent.tooling.Instrumenter; +import datadog.trace.agent.tooling.InstrumenterModule; +import java.util.HashMap; +import java.util.Map; + +@AutoService(InstrumenterModule.class) +public class PreparedStatementImplInstrumentation extends InstrumenterModule.Tracing + implements Instrumenter.ForSingleType, Instrumenter.HasMethodAdvice { + public PreparedStatementImplInstrumentation() { + super("vertx", "vertx-sql-client"); + } + + @Override + public Map contextStore() { + Map contextStores = new HashMap<>(); + contextStores.put("io.vertx.sqlclient.PreparedStatement", "datadog.trace.api.Pair"); + contextStores.put("io.vertx.sqlclient.Query", "datadog.trace.api.Pair"); + return contextStores; + } + + @Override + public String instrumentedType() { + return "io.vertx.sqlclient.impl.PreparedStatementImpl"; + } + + @Override + public void methodAdvice(MethodTransformer transformer) { + transformer.applyAdvice( + isMethod().and(isPublic()).and(named("query")).and(takesNoArguments()), + packageName + ".PreparedStatementQueryAdvice"); + } +} diff --git a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PreparedStatementQueryAdvice.java b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PreparedStatementQueryAdvice.java new file mode 100644 index 00000000000..5e74253d9ba --- /dev/null +++ b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PreparedStatementQueryAdvice.java @@ -0,0 +1,22 @@ +package datadog.trace.instrumentation.vertx_pg_client_4_2_0; + +import datadog.trace.api.Pair; +import datadog.trace.bootstrap.InstrumentationContext; +import io.vertx.pgclient.PgConnection; +import io.vertx.sqlclient.PreparedStatement; +import io.vertx.sqlclient.Query; +import net.bytebuddy.asm.Advice; + +public class PreparedStatementQueryAdvice { + @Advice.OnMethodExit(suppress = Throwable.class) + public static void afterQuery( + @Advice.This final PreparedStatement zis, @Advice.Return final Query query) { + InstrumentationContext.get(Query.class, Pair.class) + .put(query, InstrumentationContext.get(PreparedStatement.class, Pair.class).get(zis)); + } + + // Limit ourselves to 4.x by checking for the ping() method that was added in 4.x + private static void muzzleCheck(PgConnection connection) { + connection.query("SELECT 1"); + } +} diff --git a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/QueryAdvice.java b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/QueryAdvice.java new file mode 100644 index 00000000000..142b2876516 --- /dev/null +++ b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/QueryAdvice.java @@ -0,0 +1,82 @@ +package datadog.trace.instrumentation.vertx_pg_client_4_2_0; + +import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.activateSpan; +import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.activeSpan; +import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.captureSpan; +import static datadog.trace.instrumentation.vertx_pg_client_4_2_0.VertxSqlClientDecorator.DECORATE; + +import datadog.trace.api.Pair; +import datadog.trace.bootstrap.ContextStore; +import datadog.trace.bootstrap.InstrumentationContext; +import datadog.trace.bootstrap.instrumentation.api.AgentScope; +import datadog.trace.bootstrap.instrumentation.api.AgentSpan; +import io.vertx.core.AsyncResult; +import io.vertx.core.Handler; +import io.vertx.pgclient.PgConnection; +import io.vertx.sqlclient.Query; +import io.vertx.sqlclient.SqlResult; +import net.bytebuddy.asm.Advice; +import net.bytebuddy.implementation.bytecode.assign.Assigner; + +public class QueryAdvice { + public static class Copy { + @Advice.OnMethodExit(suppress = Throwable.class) + public static void afterCopy( + @Advice.This final Query zis, @Advice.Return final Query ret) { + ContextStore contextStore = InstrumentationContext.get(Query.class, Pair.class); + contextStore.put(ret, contextStore.get(zis)); + } + + // Limit ourselves to 4.x by checking for the ping() method that was added in 4.x + private static void muzzleCheck(PgConnection connection) { + connection.query("SELECT 1"); + } + } + + public static class Execute { + @Advice.OnMethodEnter(suppress = Throwable.class) + public static > AgentScope beforeExecute( + @Advice.This final Query zis, + @Advice.Argument( + value = 0, + readOnly = false, + optional = true, + typing = Assigner.Typing.DYNAMIC) + Object maybeHandler, + @Advice.Argument(value = 1, readOnly = false, optional = true) + Handler> handler) { + final boolean prepared = !(maybeHandler instanceof Handler); + + final AgentSpan parentSpan = activeSpan(); + final AgentScope.Continuation parentContinuation = + null == parentSpan ? null : captureSpan(parentSpan); + final AgentSpan clientSpan = + DECORATE.startAndDecorateSpanForStatement( + zis, InstrumentationContext.get(Query.class, Pair.class), prepared); + if (null == clientSpan) { + return null; + } + if (prepared) { + handler = new QueryResultHandlerWrapper<>(handler, clientSpan, parentContinuation); + } else { + maybeHandler = + new QueryResultHandlerWrapper<>( + (Handler>) maybeHandler, clientSpan, parentContinuation); + } + return activateSpan(clientSpan); + } + + @Advice.OnMethodExit(onThrowable = Throwable.class, suppress = Throwable.class) + public static void afterExecute( + @Advice.Thrown final Throwable throwable, @Advice.Enter final AgentScope clientScope) { + if (null != clientScope) { + clientScope.close(); + } + } + + // Limit ourselves to 4.x by checking for the ping() method that was added in 4.x + private static void muzzleCheck(PgConnection connection) { + connection.query("SELECT 1"); + } + } +} diff --git a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/QueryImplInstrumentation.java b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/QueryImplInstrumentation.java new file mode 100644 index 00000000000..d5a1182c097 --- /dev/null +++ b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/QueryImplInstrumentation.java @@ -0,0 +1,57 @@ +package datadog.trace.instrumentation.vertx_pg_client_4_2_0; + +import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; +import static java.util.Collections.singletonMap; +import static net.bytebuddy.matcher.ElementMatchers.isMethod; +import static net.bytebuddy.matcher.ElementMatchers.isPublic; +import static net.bytebuddy.matcher.ElementMatchers.isVirtual; +import static net.bytebuddy.matcher.ElementMatchers.returns; +import static net.bytebuddy.matcher.ElementMatchers.takesArgument; +import static net.bytebuddy.matcher.ElementMatchers.takesArguments; + +import com.google.auto.service.AutoService; +import datadog.trace.agent.tooling.Instrumenter; +import datadog.trace.agent.tooling.InstrumenterModule; +import java.util.Map; + +@AutoService(InstrumenterModule.class) +public class QueryImplInstrumentation extends InstrumenterModule.Tracing + implements Instrumenter.ForSingleType, Instrumenter.HasMethodAdvice { + public QueryImplInstrumentation() { + super("vertx", "vertx-sql-client"); + } + + @Override + public Map contextStore() { + return singletonMap("io.vertx.sqlclient.Query", "datadog.trace.api.Pair"); + } + + @Override + public String[] helperClassNames() { + return new String[] { + packageName + ".QueryResultHandlerWrapper", packageName + ".VertxSqlClientDecorator", + }; + } + + @Override + public String instrumentedType() { + return "io.vertx.sqlclient.impl.SqlClientBase$QueryImpl"; + } + + @Override + public void methodAdvice(MethodTransformer transformer) { + transformer.applyAdvice( + isMethod() + .and(isPublic()) + .and(named("execute")) + .and(takesArguments(1)) + .and(takesArgument(0, named("io.vertx.core.Handler"))), + packageName + ".QueryAdvice$Execute"); + transformer.applyAdvice( + isMethod() + .and(isVirtual()) + .and(named("copy")) + .and(returns(named("io.vertx.sqlclient.impl.QueryBase"))), + packageName + ".QueryAdvice$Copy"); + } +} diff --git a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/QueryResultHandlerWrapper.java b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/QueryResultHandlerWrapper.java new file mode 100644 index 00000000000..537ab6f42fc --- /dev/null +++ b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/QueryResultHandlerWrapper.java @@ -0,0 +1,41 @@ +package datadog.trace.instrumentation.vertx_pg_client_4_2_0; + +import datadog.trace.bootstrap.instrumentation.api.AgentScope; +import datadog.trace.bootstrap.instrumentation.api.AgentSpan; +import io.vertx.core.AsyncResult; +import io.vertx.core.Handler; +import io.vertx.sqlclient.SqlResult; + +public class QueryResultHandlerWrapper> + implements Handler> { + private final Handler> handler; + private final AgentSpan clientSpan; + private final AgentScope.Continuation parentContinuation; + + public QueryResultHandlerWrapper( + final Handler> handler, + final AgentSpan clientSpan, + final AgentScope.Continuation parentContinuation) { + this.handler = handler; + this.clientSpan = clientSpan; + this.parentContinuation = parentContinuation; + } + + @Override + public void handle(final AsyncResult event) { + AgentScope scope = null; + try { + if (null != clientSpan) { + clientSpan.finish(); + } + if (null != parentContinuation) { + scope = parentContinuation.activate(); + } + handler.handle(event); + } finally { + if (null != scope) { + scope.close(); + } + } + } +} diff --git a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/SqlClientBaseAdvice.java b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/SqlClientBaseAdvice.java new file mode 100644 index 00000000000..d0b4532b837 --- /dev/null +++ b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/SqlClientBaseAdvice.java @@ -0,0 +1,51 @@ +package datadog.trace.instrumentation.vertx_pg_client_4_2_0; + +import datadog.trace.api.Pair; +import datadog.trace.bootstrap.InstrumentationContext; +import datadog.trace.bootstrap.instrumentation.jdbc.DBInfo; +import datadog.trace.bootstrap.instrumentation.jdbc.DBQueryInfo; +import io.vertx.pgclient.PgConnection; +import io.vertx.sqlclient.Query; +import io.vertx.sqlclient.SqlClient; +import net.bytebuddy.asm.Advice; + +public class SqlClientBaseAdvice { + public static class NormalQuery { + @Advice.OnMethodExit(suppress = Throwable.class) + public static void afterQuery( + @Advice.This final SqlClient zis, + @Advice.Argument(0) final String sql, + @Advice.Return final Query query) { + + Pair info = + Pair.of( + InstrumentationContext.get(SqlClient.class, DBInfo.class).get(zis), + DBQueryInfo.ofStatement(sql)); + InstrumentationContext.get(Query.class, Pair.class).put(query, info); + } + + // Limit ourselves to 4.x by checking for the ping() method that was added in 4.x + private static void muzzleCheck(PgConnection connection) { + connection.query("SELECT 1"); + } + } + + public static class PreparedQuery { + @Advice.OnMethodExit(suppress = Throwable.class) + public static void afterPreparedQuery( + @Advice.This final SqlClient zis, + @Advice.Argument(0) final String sql, + @Advice.Return final Query query) { + Pair info = + Pair.of( + InstrumentationContext.get(SqlClient.class, DBInfo.class).get(zis), + DBQueryInfo.ofPreparedStatement(sql)); + InstrumentationContext.get(Query.class, Pair.class).put(query, info); + } + + // Limit ourselves to 4.x by checking for the ping() method that was added in 4.x + private static void muzzleCheck(PgConnection connection) { + connection.query("SELECT 1"); + } + } +} diff --git a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/SqlClientBaseInstrumentation.java b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/SqlClientBaseInstrumentation.java new file mode 100644 index 00000000000..d811fa19f29 --- /dev/null +++ b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/SqlClientBaseInstrumentation.java @@ -0,0 +1,53 @@ +package datadog.trace.instrumentation.vertx_pg_client_4_2_0; + +import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; +import static net.bytebuddy.matcher.ElementMatchers.isMethod; +import static net.bytebuddy.matcher.ElementMatchers.isPublic; +import static net.bytebuddy.matcher.ElementMatchers.takesArgument; +import static net.bytebuddy.matcher.ElementMatchers.takesArguments; + +import com.google.auto.service.AutoService; +import datadog.trace.agent.tooling.Instrumenter; +import datadog.trace.agent.tooling.InstrumenterModule; +import datadog.trace.bootstrap.instrumentation.jdbc.DBInfo; +import java.util.HashMap; +import java.util.Map; + +@AutoService(InstrumenterModule.class) +public class SqlClientBaseInstrumentation extends InstrumenterModule.Tracing + implements Instrumenter.ForSingleType, Instrumenter.HasMethodAdvice { + public SqlClientBaseInstrumentation() { + super("vertx", "vertx-sql-client"); + } + + @Override + public Map contextStore() { + Map contextStores = new HashMap<>(); + contextStores.put("io.vertx.sqlclient.SqlClient", DBInfo.class.getName()); + contextStores.put("io.vertx.sqlclient.Query", "datadog.trace.api.Pair"); + return contextStores; + } + + @Override + public String instrumentedType() { + return "io.vertx.sqlclient.impl.SqlClientBase"; + } + + @Override + public void methodAdvice(MethodTransformer transformer) { + transformer.applyAdvice( + isMethod() + .and(isPublic()) + .and(named("query")) + .and(takesArguments(1)) + .and(takesArgument(0, named("java.lang.String"))), + packageName + ".SqlClientBaseAdvice$NormalQuery"); + transformer.applyAdvice( + isMethod() + .and(isPublic()) + .and(named("preparedQuery")) + .and(takesArguments(1)) + .and(takesArgument(0, named("java.lang.String"))), + packageName + ".SqlClientBaseAdvice$PreparedQuery"); + } +} diff --git a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/SqlConnectionBaseInstrumentation.java b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/SqlConnectionBaseInstrumentation.java new file mode 100644 index 00000000000..9e1f49cbc5b --- /dev/null +++ b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/SqlConnectionBaseInstrumentation.java @@ -0,0 +1,52 @@ +package datadog.trace.instrumentation.vertx_pg_client_4_2_0; + +import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; +import static net.bytebuddy.matcher.ElementMatchers.isMethod; +import static net.bytebuddy.matcher.ElementMatchers.isPublic; +import static net.bytebuddy.matcher.ElementMatchers.takesArgument; +import static net.bytebuddy.matcher.ElementMatchers.takesArguments; + +import com.google.auto.service.AutoService; +import datadog.trace.agent.tooling.Instrumenter; +import datadog.trace.agent.tooling.InstrumenterModule; +import datadog.trace.bootstrap.instrumentation.jdbc.DBInfo; +import java.util.HashMap; +import java.util.Map; + +@AutoService(InstrumenterModule.class) +public class SqlConnectionBaseInstrumentation extends InstrumenterModule.Tracing + implements Instrumenter.ForSingleType, Instrumenter.HasMethodAdvice { + public SqlConnectionBaseInstrumentation() { + super("vertx", "vertx-sql-client"); + } + + @Override + public Map contextStore() { + Map contextStores = new HashMap<>(); + contextStores.put("io.vertx.sqlclient.SqlClient", DBInfo.class.getName()); + contextStores.put("io.vertx.sqlclient.PreparedStatement", "datadog.trace.api.Pair"); + return contextStores; + } + + @Override + public String[] helperClassNames() { + return new String[] {packageName + ".PrepareHandlerWrapper"}; + } + + @Override + public String instrumentedType() { + return "io.vertx.sqlclient.impl.SqlConnectionBase"; + } + + @Override + public void methodAdvice(MethodTransformer transformer) { + transformer.applyAdvice( + isMethod() + .and(isPublic()) + .and(named("prepare")) + .and(takesArguments(2)) + .and(takesArgument(0, named("java.lang.String"))) + .and(takesArgument(1, named("io.vertx.core.Handler"))), + packageName + ".SqlConnectionBasePrepareAdvice"); + } +} diff --git a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/SqlConnectionBasePrepareAdvice.java b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/SqlConnectionBasePrepareAdvice.java new file mode 100644 index 00000000000..6872473b198 --- /dev/null +++ b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/SqlConnectionBasePrepareAdvice.java @@ -0,0 +1,35 @@ +package datadog.trace.instrumentation.vertx_pg_client_4_2_0; + +import datadog.trace.api.Pair; +import datadog.trace.bootstrap.InstrumentationContext; +import datadog.trace.bootstrap.instrumentation.jdbc.DBInfo; +import datadog.trace.bootstrap.instrumentation.jdbc.DBQueryInfo; +import io.vertx.core.AsyncResult; +import io.vertx.core.Handler; +import io.vertx.pgclient.PgConnection; +import io.vertx.sqlclient.PreparedStatement; +import io.vertx.sqlclient.SqlClient; +import net.bytebuddy.asm.Advice; + +public class SqlConnectionBasePrepareAdvice { + @Advice.OnMethodEnter(suppress = Throwable.class) + public static void beforePrepare( + @Advice.This final SqlClient zis, + @Advice.Argument(0) final String sql, + @Advice.Argument(value = 1, readOnly = false) + Handler> handler) { + Pair info = + Pair.of( + InstrumentationContext.get(SqlClient.class, DBInfo.class).get(zis), + DBQueryInfo.ofStatement(sql)); + + handler = + new PrepareHandlerWrapper( + handler, InstrumentationContext.get(PreparedStatement.class, Pair.class), info); + } + + // Limit ourselves to 4.x by checking for the ping() method that was added in 4.x + private static void muzzleCheck(PgConnection connection) { + connection.query("SELECT 1"); + } +} diff --git a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/VertxSqlClientDecorator.java b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/VertxSqlClientDecorator.java new file mode 100644 index 00000000000..76a4167472b --- /dev/null +++ b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/VertxSqlClientDecorator.java @@ -0,0 +1,115 @@ +package datadog.trace.instrumentation.vertx_pg_client_4_2_0; + +import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.startSpan; +import static datadog.trace.bootstrap.instrumentation.api.Tags.DB_OPERATION; + +import datadog.trace.api.Pair; +import datadog.trace.api.naming.SpanNaming; +import datadog.trace.bootstrap.ContextStore; +import datadog.trace.bootstrap.instrumentation.api.AgentSpan; +import datadog.trace.bootstrap.instrumentation.api.InternalSpanTypes; +import datadog.trace.bootstrap.instrumentation.api.Tags; +import datadog.trace.bootstrap.instrumentation.api.UTF8BytesString; +import datadog.trace.bootstrap.instrumentation.decorator.DatabaseClientDecorator; +import datadog.trace.bootstrap.instrumentation.jdbc.DBInfo; +import datadog.trace.bootstrap.instrumentation.jdbc.DBQueryInfo; + +public class VertxSqlClientDecorator extends DatabaseClientDecorator { + + public static final VertxSqlClientDecorator DECORATE = new VertxSqlClientDecorator(); + + private static final CharSequence VERTX_SQL = UTF8BytesString.create("vertx-sql"); + private static final CharSequence DATABASE_QUERY = UTF8BytesString.create("database.query"); + private static final UTF8BytesString DB_QUERY = UTF8BytesString.create("DB Query"); + private static final UTF8BytesString VERTX_STATEMENT = + UTF8BytesString.create("vertx-sql-statement"); + private static final UTF8BytesString VERTX_PREPARED_STATEMENT = + UTF8BytesString.create("vertx-sql-prepared_statement"); + private static final String DEFAULT_SERVICE_NAME = + SpanNaming.instance().namingSchema().database().service("postgresql"); + + @Override + protected String[] instrumentationNames() { + return new String[] {"vertx", "vertx-sql-client"}; + } + + @Override + protected String service() { + return DEFAULT_SERVICE_NAME; // Overridden by onConnection + } + + @Override + protected CharSequence component() { + return VERTX_SQL; // Overridden by onStatement and onPreparedStatement + } + + @Override + protected CharSequence spanType() { + return InternalSpanTypes.SQL; + } + + @Override + protected String dbType() { + return "vertx-sql"; + } + + @Override + protected String dbUser(final DBInfo info) { + return info.getUser(); + } + + @Override + protected String dbInstance(final DBInfo info) { + if (info.getInstance() != null) { + return info.getInstance(); + } else { + return info.getDb(); + } + } + + @Override + protected String dbHostname(final DBInfo info) { + return info.getHost(); + } + + public AgentSpan startAndDecorateSpanForStatement( + T query, ContextStore contextStore, boolean prepared) { + CharSequence component = prepared ? VERTX_PREPARED_STATEMENT : VERTX_STATEMENT; + AgentSpan span = startSpan(DATABASE_QUERY); + if (null == span) { + return null; + } + afterStart(span); + + DBInfo dbInfo = null; + DBQueryInfo dbQueryInfo = null; + Pair queryInfo = contextStore.get(query); + if (queryInfo != null) { + dbInfo = queryInfo.getLeft(); + dbQueryInfo = queryInfo.getRight(); + } + + if (dbInfo != null) { + processDatabaseType(span, dbInfo.getType()); + } + super.onConnection(span, dbInfo); + if (null != dbQueryInfo) { + span.setResourceName(dbQueryInfo.getSql()); + span.setTag(DB_OPERATION, dbQueryInfo.getOperation()); + } else { + span.setResourceName(DB_QUERY); + } + span.setTag(Tags.COMPONENT, component); + + return span; + } + + @Override + protected void postProcessServiceAndOperationName( + AgentSpan span, DatabaseClientDecorator.NamingEntry namingEntry) { + if (namingEntry.getService() != null) { + span.setServiceName(namingEntry.getService()); + } + span.setOperationName(namingEntry.getOperation()); + } +} diff --git a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/test/groovy/VertxSqlClientForkedTest.groovy b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/test/groovy/VertxSqlClientForkedTest.groovy new file mode 100644 index 00000000000..b0852aff4a8 --- /dev/null +++ b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/test/groovy/VertxSqlClientForkedTest.groovy @@ -0,0 +1,340 @@ +import TestDatabases.TestDBInfo +import datadog.trace.agent.test.AgentTestRunner +import datadog.trace.agent.test.asserts.TraceAssert +import datadog.trace.bootstrap.instrumentation.api.Tags +import datadog.trace.core.DDSpan +import io.vertx.core.AsyncResult +import io.vertx.core.Vertx +import io.vertx.core.VertxOptions +import io.vertx.pgclient.PgConnectOptions +import io.vertx.pgclient.PgPool +import io.vertx.sqlclient.Cursor +import io.vertx.sqlclient.Pool +import io.vertx.sqlclient.PoolOptions +import io.vertx.sqlclient.PreparedQuery +import io.vertx.sqlclient.PreparedStatement +import io.vertx.sqlclient.Query +import io.vertx.sqlclient.Row +import io.vertx.sqlclient.RowSet +import io.vertx.sqlclient.SqlConnection +import io.vertx.sqlclient.Tuple +import io.vertx.sqlclient.impl.ArrayTuple +import spock.lang.AutoCleanup +import spock.lang.Shared + +import java.util.concurrent.CountDownLatch +import java.util.concurrent.TimeUnit +import java.util.concurrent.atomic.AtomicReference + +import static datadog.trace.agent.test.utils.TraceUtils.basicSpan +import static datadog.trace.agent.test.utils.TraceUtils.runUnderTrace + +class VertxSqlClientForkedTest extends AgentTestRunner { + @AutoCleanup + @Shared + // This database name must match up with the name in the CircleCI PG Docker definition + def dbs = TestDatabases.initialise("jdbcUnitTest") + + @AutoCleanup + @Shared + def vertx = Vertx.vertx(new VertxOptions()) + + def "test #type"() { + when: + AsyncResult> asyncResult = runUnderTrace("parent") { + return executeQueryWithHandler(query) + } + + then: + asyncResult.succeeded() + + when: + def result = asyncResult.result() + + then: + result.size() == 1 + result[0].getInteger(0) == 7 + assertTraces(1) { + trace(3, true) { + basicSpan(it, "handler", span(2)) + checkDBSpan(it, span(2), "SELECT ?", "SELECT", dbs.DBInfos.postgresql, prepared) + basicSpan(it, "parent") + } + } + + cleanup: + pool.close() + + where: + type | pool | query | prepared + 'query' | pool() | pool.query('SELECT 7') | false + 'prepared query' | pool() | pool.preparedQuery("SELECT ?") | true + 'prepared statement' | pool() | prepare(connection(pool), "SELECT ?").query() | true + } + + def "test #type without parent"() { + when: + AsyncResult> asyncResult = executeQueryWithHandler(query) + + then: + asyncResult.succeeded() + + when: + def result = asyncResult.result() + + then: + result.size() == 1 + result[0].getInteger(0) == 7 + assertTraces(2) { + trace(1) { + checkDBSpan(it, null, "SELECT ?", "SELECT", dbs.DBInfos.postgresql, prepared) + } + trace(1) { + basicSpan(it, "handler") + } + } + + cleanup: + pool.close() + + where: + type | pool | query | prepared + 'query' | pool() | pool.query('SELECT 7') | false + 'prepared query' | pool() | pool.preparedQuery("SELECT ?") | true + 'prepared statement' | pool() | prepare(connection(pool), "SELECT ?").query() | true + } + + def "test #type mapped"() { + setup: + def mapped = query.mapping({ row -> + return row.getInteger(0) + }) + + when: + AsyncResult> asyncResult = runUnderTrace("parent") { + return executeQueryWithHandler(mapped) + } + + then: + asyncResult.succeeded() + + when: + def result = asyncResult.result() + + then: + result.size() == 1 + result[0] == 7 + assertTraces(1) { + trace(3, true) { + basicSpan(it, "handler", span(2)) + checkDBSpan(it, span(2), "SELECT ?", "SELECT", dbs.DBInfos.postgresql, prepared) + basicSpan(it, "parent") + } + } + + cleanup: + pool.close() + + where: + type | pool | query | prepared + 'query' | pool() | pool.query('SELECT 7') | false + 'prepared query' | pool() | pool.preparedQuery("SELECT ?") | true + 'prepared statement' | pool() | prepare(connection(pool), "SELECT ?").query() | true + } + + def "test #type mapped without parent"() { + setup: + def mapped = query.mapping({ row -> + return row.getInteger(0) + }) + + when: + AsyncResult> asyncResult = executeQueryWithHandler(mapped) + + then: + asyncResult.succeeded() + + when: + def result = asyncResult.result() + + then: + result.size() == 1 + result[0] == 7 + assertTraces(2) { + trace(1) { + checkDBSpan(it, null, "SELECT ?", "SELECT", dbs.DBInfos.postgresql, prepared) + } + trace(1) { + basicSpan(it, "handler") + } + } + + cleanup: + pool.close() + + where: + type | pool | query | prepared + 'query' | pool() | pool.query('SELECT 7') | false + 'prepared query' | pool() | pool.preparedQuery("SELECT ?") | true + 'prepared statement' | pool() | prepare(connection(pool), "SELECT ?").query() | true + } + + def "test cursor"() { + setup: + def pool = pool() + def cursor = prepare(connection(pool), "SELECT 7").cursor() + + when: + def asyncResult = runUnderTrace("parent") { + queryCursorWithHandler(cursor) + } + + then: + asyncResult.succeeded() + + when: + def result = asyncResult.result() + + then: + result.size() == 1 + result[0].getInteger(0) == 7 + assertTraces(1) { + trace(3, true) { + basicSpan(it, "handler", span(2)) + checkDBSpan(it, span(2), "SELECT ?", "SELECT", dbs.DBInfos.postgresql, true) + basicSpan(it, "parent") + } + } + + cleanup: + pool.close() + } + + def "test row stream"() { + setup: + def pool = pool() + def connection = connection(pool) + def statement = prepare(connection, "SELECT 7") + def result = new AtomicReference() + def latch = new CountDownLatch(1) + + when: + def tx = connection.begin() + def stream = statement.createStream(0, ArrayTuple.EMPTY) + stream.endHandler({ + tx.commit() + }) + runUnderTrace("parent") { + stream.handler({ row -> + if (latch.getCount() != 0) { + runUnderTrace("handler") { + result.set(row) + stream.close() + } + latch.countDown() + } + }) + } + assert latch.await(10, TimeUnit.SECONDS) + + then: + result.get().getInteger(0) == 7 + assertTraces(1) { + trace(3, true) { + basicSpan(it, "handler", span(2)) + checkDBSpan(it, span(2), "SELECT ?", "SELECT", dbs.DBInfos.pos, true) + basicSpan(it, "parent") + } + } + + cleanup: + pool.close() + } + + Pool pool() { + def connectOptions = PgConnectOptions.fromUri(dbs.DBInfos.postgresql.uri) + def poolOptions = new PoolOptions().setMaxSize(2) + return PgPool.pool(vertx, connectOptions, poolOptions) + } + + def AsyncResult> executeQueryWithHandler(Query> query) { + def latch = new CountDownLatch(1) + AsyncResult> result = null + + if (query instanceof PreparedQuery) { + query.execute(Tuple.of(7)) { rowSetAR -> + runUnderTrace("handler") { + result = rowSetAR + } + latch.countDown() + } + } else { + query.execute { rowSetAR -> + runUnderTrace("handler") { + result = rowSetAR + } + latch.countDown() + } + } + assert latch.await(10, TimeUnit.SECONDS) + return result + } + + AsyncResult> queryCursorWithHandler(Cursor cursor) { + def latch = new CountDownLatch(1) + AsyncResult> result = null + cursor.read(0) { rowSetAR -> + runUnderTrace("handler") { + result = rowSetAR + } + latch.countDown() + } + assert latch.await(10, TimeUnit.SECONDS) + return result + } + + SqlConnection connection(Pool pool) { + def latch = new CountDownLatch(1) + SqlConnection result = null + pool.getConnection({ connectionAR -> + result = connectionAR.result() + latch.countDown() + }) + assert latch.await(10, TimeUnit.SECONDS) + return result + } + + PreparedStatement prepare(SqlConnection connection, String sql) { + def latch = new CountDownLatch(1) + PreparedStatement result = null + connection.prepare(sql, { statementAR -> + result = statementAR.result() + latch.countDown() + }) + assert latch.await(10, TimeUnit.SECONDS) + return result + } + + void checkDBSpan(TraceAssert ta, DDSpan parent, String resource, String operation, TestDBInfo info, boolean prepared = false) { + ta.span(ta.nextSpanId()) { + if (parent != null) { + childOf(parent) + } + operationName info ? "${info.type}.query" : "database.query" + resourceName resource + spanType "sql" + tags { + "$Tags.COMPONENT" prepared ? "vertx-sql-prepared_statement" : "vertx-sql-statement" + "$Tags.SPAN_KIND" Tags.SPAN_KIND_CLIENT + "$Tags.DB_OPERATION" operation + if (info) { + "$Tags.DB_TYPE" info.type + "$Tags.DB_INSTANCE" info.dbName + "$Tags.DB_USER" info.user + "$Tags.PEER_HOSTNAME" info.host + } + defaultTags() + } + } + } +} diff --git a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/test/java/TestDatabases.java b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/test/java/TestDatabases.java new file mode 100644 index 00000000000..f84d20f26d2 --- /dev/null +++ b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/test/java/TestDatabases.java @@ -0,0 +1,101 @@ +import datadog.trace.agent.test.utils.PortUtils; +import java.io.Closeable; +import java.io.IOException; +import java.util.Collections; +import java.util.HashMap; +import java.util.Map; +import java.util.concurrent.TimeUnit; +import org.testcontainers.containers.PostgreSQLContainer; + +public class TestDatabases implements Closeable { + + private final PostgreSQLContainer pgsql; + private final Map dbInfos; + + private TestDatabases(String dbName) { + Map infos = new HashMap<>(); + pgsql = + new PostgreSQLContainer("postgres:16-alpine") + .withDatabaseName(dbName) + .withUsername("sa") + .withPassword("sa"); + // https://github.com/testcontainers/testcontainers-java/issues/914 + pgsql.addParameter("TC_MY_CNF", null); + pgsql.start(); + TestDBInfo info = + new TestDBInfo( + pgsql.getUsername(), + pgsql.getPassword(), + pgsql.getHost(), + pgsql.getMappedPort(PostgreSQLContainer.POSTGRESQL_PORT), + "postgresql", + dbName); + PortUtils.waitForPortToOpen(info.host, info.port, 5, TimeUnit.SECONDS); + infos.put("postgresql", info); + dbInfos = Collections.unmodifiableMap(infos); + } + + public static TestDatabases initialise(String dbName) { + return new TestDatabases(dbName); + } + + @Override + public void close() throws IOException { + if (null != pgsql) { + pgsql.close(); + } + } + + public Map getDBInfos() { + return dbInfos; + } + + public static class TestDBInfo { + private final String user; + private final String password; + private final String host; + private final Integer port; + private final String type; + private final String dbName; + private final String uri; + + public TestDBInfo( + String user, String password, String host, Integer port, String type, String dbName) { + this.user = user; + this.password = password; + this.host = host; + this.port = port; + this.type = type; + this.dbName = dbName; + this.uri = type + "://" + user + ":" + password + "@" + host + ":" + port + "/" + dbName; + } + + public String getUser() { + return user; + } + + public String getPassword() { + return password; + } + + public String getHost() { + return host; + } + + public String getPort() { + return port.toString(); + } + + public String getType() { + return type; + } + + public String getDbName() { + return dbName; + } + + public String getUri() { + return uri; + } + } +} diff --git a/settings.gradle b/settings.gradle index c79530dd5ba..4db45c5a4f2 100644 --- a/settings.gradle +++ b/settings.gradle @@ -501,6 +501,7 @@ include ':dd-java-agent:instrumentation:velocity' include ':dd-java-agent:instrumentation:vertx-mysql-client-3.9' include ':dd-java-agent:instrumentation:vertx-mysql-client-4.0' include ':dd-java-agent:instrumentation:vertx-mysql-client-4.4.2' +include ':dd-java-agent:instrumentation:vertx-pg-client-4.2.0' include ':dd-java-agent:instrumentation:vertx-redis-client-3.9' include ':dd-java-agent:instrumentation:vertx-redis-client-3.9:stubs' include ':dd-java-agent:instrumentation:vertx-rx-3.5' From 636a03099c43a2835b25aea4e64b73c9246ab51a Mon Sep 17 00:00:00 2001 From: Onkar Sarvade Date: Fri, 28 Feb 2025 10:35:06 +0530 Subject: [PATCH 2/8] Updated code --- .../vertx-pg-client-4.2.0/build.gradle | 2 + .../CursorImplInstrumentation.java | 11 +- .../CursorReadAdvice.java | 14 +- .../PgConnectionFactoryConstructorAdvice.java | 6 - .../PgConnectionFactoryInstrumentation.java | 11 +- .../PgConnectionImplConstructorAdvice.java | 10 +- .../PgConnectionImplInstrumentation.java | 12 +- .../PgPoolImplAdvice.java | 6 - .../PgPoolImplInstrumentation.java | 13 +- .../PreparedQueryInstrumentation.java | 18 +- .../PreparedStatementImplInstrumentation.java | 9 +- .../PreparedStatementQueryAdvice.java | 6 - .../vertx_pg_client_4_2_0/QueryAdvice.java | 19 +- .../QueryImplInstrumentation.java | 14 +- .../SqlClientBaseAdvice.java | 11 - .../SqlClientBaseInstrumentation.java | 10 +- .../SqlConnectionBaseInstrumentation.java | 10 +- .../SqlConnectionBasePrepareAdvice.java | 6 - .../VertxSqlClientDecorator.java | 10 +- .../VertxPostgresSqlClientForkedTest.groovy | 146 ++++++++ .../groovy/VertxSqlClientForkedTest.groovy | 340 ------------------ .../src/test/java/TestDatabases.java | 6 +- 22 files changed, 210 insertions(+), 480 deletions(-) create mode 100644 dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/test/groovy/VertxPostgresSqlClientForkedTest.groovy delete mode 100644 dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/test/groovy/VertxSqlClientForkedTest.groovy diff --git a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/build.gradle b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/build.gradle index ca4c07922c6..191a6dab7f5 100644 --- a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/build.gradle +++ b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/build.gradle @@ -25,6 +25,8 @@ dependencies { testImplementation group: 'io.vertx', name: 'vertx-pg-client', version: '4.2.0' // This is needed for the test container to start + testImplementation group: 'com.ongres.scram', name: 'client', version: '2.1' + testImplementation group: 'org.postgresql', name: 'postgresql', version: '42.7.4' testImplementation group: 'org.testcontainers', name: 'postgresql', version: libs.versions.testcontainers.get() latestDepTestImplementation group: 'io.vertx', name: 'vertx-pg-client', version: '4.2.+' diff --git a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/CursorImplInstrumentation.java b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/CursorImplInstrumentation.java index a7bfb501fdc..5634eeaf565 100644 --- a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/CursorImplInstrumentation.java +++ b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/CursorImplInstrumentation.java @@ -1,16 +1,15 @@ package datadog.trace.instrumentation.vertx_pg_client_4_2_0; -import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; -import static java.util.Collections.singletonMap; -import static net.bytebuddy.matcher.ElementMatchers.isMethod; -import static net.bytebuddy.matcher.ElementMatchers.isPublic; -import static net.bytebuddy.matcher.ElementMatchers.takesArgument; - import com.google.auto.service.AutoService; import datadog.trace.agent.tooling.Instrumenter; import datadog.trace.agent.tooling.InstrumenterModule; + import java.util.Map; +import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; +import static java.util.Collections.singletonMap; +import static net.bytebuddy.matcher.ElementMatchers.*; + @AutoService(InstrumenterModule.class) public class CursorImplInstrumentation extends InstrumenterModule.Tracing implements Instrumenter.ForSingleType, Instrumenter.HasMethodAdvice { diff --git a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/CursorReadAdvice.java b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/CursorReadAdvice.java index 3cad4136a3d..687292add20 100644 --- a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/CursorReadAdvice.java +++ b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/CursorReadAdvice.java @@ -1,23 +1,20 @@ package datadog.trace.instrumentation.vertx_pg_client_4_2_0; -import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.activateSpan; -import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.activeSpan; -import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.captureSpan; -import static datadog.trace.instrumentation.vertx_pg_client_4_2_0.VertxSqlClientDecorator.DECORATE; - import datadog.trace.api.Pair; import datadog.trace.bootstrap.InstrumentationContext; import datadog.trace.bootstrap.instrumentation.api.AgentScope; import datadog.trace.bootstrap.instrumentation.api.AgentSpan; import io.vertx.core.AsyncResult; import io.vertx.core.Handler; -import io.vertx.pgclient.PgConnection; import io.vertx.sqlclient.PreparedStatement; import io.vertx.sqlclient.Row; import io.vertx.sqlclient.RowSet; import net.bytebuddy.asm.Advice; import net.bytebuddy.implementation.bytecode.assign.Assigner; +import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.*; +import static datadog.trace.instrumentation.vertx_pg_client_4_2_0.VertxSqlClientDecorator.DECORATE; + public class CursorReadAdvice { @Advice.OnMethodEnter(suppress = Throwable.class) public static AgentScope beforeRead( @@ -48,9 +45,4 @@ public static void afterRead( clientScope.close(); } } - - // Limit ourselves to 4.x by checking for the ping() method that was added in 4.x - private static void muzzleCheck(PgConnection connection) { - connection.query("SELECT 1"); - } } diff --git a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PgConnectionFactoryConstructorAdvice.java b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PgConnectionFactoryConstructorAdvice.java index 222adeb908a..3acce8ef900 100644 --- a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PgConnectionFactoryConstructorAdvice.java +++ b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PgConnectionFactoryConstructorAdvice.java @@ -3,7 +3,6 @@ import datadog.trace.bootstrap.InstrumentationContext; import datadog.trace.bootstrap.instrumentation.jdbc.DBInfo; import io.vertx.pgclient.PgConnectOptions; -import io.vertx.pgclient.PgConnection; import io.vertx.pgclient.impl.PgConnectionFactory; import net.bytebuddy.asm.Advice; @@ -23,9 +22,4 @@ public static void afterConstructor( .build(); InstrumentationContext.get(PgConnectionFactory.class, DBInfo.class).put(zis, info); } - - // Limit ourselves to 4.x by checking for the ping() method that was added in 4.x - private static void muzzleCheck(PgConnection connection) { - connection.query("SELECT 1"); - } } diff --git a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PgConnectionFactoryInstrumentation.java b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PgConnectionFactoryInstrumentation.java index 8ea364f6d53..9916cfc0071 100644 --- a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PgConnectionFactoryInstrumentation.java +++ b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PgConnectionFactoryInstrumentation.java @@ -1,17 +1,16 @@ package datadog.trace.instrumentation.vertx_pg_client_4_2_0; -import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; -import static java.util.Collections.singletonMap; -import static net.bytebuddy.matcher.ElementMatchers.isConstructor; -import static net.bytebuddy.matcher.ElementMatchers.takesArgument; -import static net.bytebuddy.matcher.ElementMatchers.takesArguments; - import com.google.auto.service.AutoService; import datadog.trace.agent.tooling.Instrumenter; import datadog.trace.agent.tooling.InstrumenterModule; import datadog.trace.bootstrap.instrumentation.jdbc.DBInfo; + import java.util.Map; +import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; +import static java.util.Collections.singletonMap; +import static net.bytebuddy.matcher.ElementMatchers.*; + @AutoService(InstrumenterModule.class) public class PgConnectionFactoryInstrumentation extends InstrumenterModule.Tracing implements Instrumenter.ForSingleType, Instrumenter.HasMethodAdvice { diff --git a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PgConnectionImplConstructorAdvice.java b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PgConnectionImplConstructorAdvice.java index ecb46485913..3c1c84d98cf 100644 --- a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PgConnectionImplConstructorAdvice.java +++ b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PgConnectionImplConstructorAdvice.java @@ -2,7 +2,6 @@ import datadog.trace.bootstrap.InstrumentationContext; import datadog.trace.bootstrap.instrumentation.jdbc.DBInfo; -import io.vertx.pgclient.PgConnection; import io.vertx.pgclient.impl.PgConnectionFactory; import io.vertx.sqlclient.SqlClient; import net.bytebuddy.asm.Advice; @@ -12,11 +11,8 @@ public class PgConnectionImplConstructorAdvice { public static void afterConstructor( @Advice.This final SqlClient zis, @Advice.Argument(0) final PgConnectionFactory factory) { InstrumentationContext.get(SqlClient.class, DBInfo.class) - .put(zis, InstrumentationContext.get(PgConnectionFactory.class, DBInfo.class).get(factory)); - } - - // Limit ourselves to 4.x by checking for the ping() method that was added in 4.x - private static void muzzleCheck(PgConnection connection) { - connection.query("SELECT 1"); + .put( + zis, + InstrumentationContext.get(PgConnectionFactory.class, DBInfo.class).get(factory)); } } diff --git a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PgConnectionImplInstrumentation.java b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PgConnectionImplInstrumentation.java index 110cf9af591..86088d9f7fd 100644 --- a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PgConnectionImplInstrumentation.java +++ b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PgConnectionImplInstrumentation.java @@ -1,16 +1,17 @@ package datadog.trace.instrumentation.vertx_pg_client_4_2_0; -import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; -import static net.bytebuddy.matcher.ElementMatchers.isConstructor; -import static net.bytebuddy.matcher.ElementMatchers.takesArgument; - import com.google.auto.service.AutoService; import datadog.trace.agent.tooling.Instrumenter; import datadog.trace.agent.tooling.InstrumenterModule; import datadog.trace.bootstrap.instrumentation.jdbc.DBInfo; + import java.util.HashMap; import java.util.Map; +import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; +import static net.bytebuddy.matcher.ElementMatchers.isConstructor; +import static net.bytebuddy.matcher.ElementMatchers.takesArgument; + @AutoService(InstrumenterModule.class) public class PgConnectionImplInstrumentation extends InstrumenterModule.Tracing implements Instrumenter.ForSingleType, Instrumenter.HasMethodAdvice { @@ -34,7 +35,8 @@ public String instrumentedType() { @Override public void methodAdvice(MethodTransformer transformer) { transformer.applyAdvice( - isConstructor().and(takesArgument(0, named("io.vertx.pgclient.impl.PgConnectionFactory"))), + isConstructor() + .and(takesArgument(0, named("io.vertx.pgclient.impl.PgConnectionFactory"))), packageName + ".PgConnectionImplConstructorAdvice"); } } diff --git a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PgPoolImplAdvice.java b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PgPoolImplAdvice.java index cd2f2f76068..d1c30e77669 100644 --- a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PgPoolImplAdvice.java +++ b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PgPoolImplAdvice.java @@ -3,7 +3,6 @@ import datadog.trace.bootstrap.InstrumentationContext; import datadog.trace.bootstrap.instrumentation.jdbc.DBInfo; import io.vertx.pgclient.PgConnectOptions; -import io.vertx.pgclient.PgConnection; import io.vertx.sqlclient.SqlClient; import net.bytebuddy.asm.Advice; @@ -23,9 +22,4 @@ public static void afterCreate( .build(); InstrumentationContext.get(SqlClient.class, DBInfo.class).put(zis, info); } - - // Limit ourselves to 4.x by checking for the ping() method that was added in 4.x - private static void muzzleCheck(PgConnection connection) { - connection.query("SELECT 1"); - } } diff --git a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PgPoolImplInstrumentation.java b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PgPoolImplInstrumentation.java index 47ab7841f16..5c2af8fc56b 100644 --- a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PgPoolImplInstrumentation.java +++ b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PgPoolImplInstrumentation.java @@ -1,19 +1,16 @@ package datadog.trace.instrumentation.vertx_pg_client_4_2_0; -import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; -import static java.util.Collections.singletonMap; -import static net.bytebuddy.matcher.ElementMatchers.isMethod; -import static net.bytebuddy.matcher.ElementMatchers.isPublic; -import static net.bytebuddy.matcher.ElementMatchers.isStatic; -import static net.bytebuddy.matcher.ElementMatchers.takesArgument; -import static net.bytebuddy.matcher.ElementMatchers.takesArguments; - import com.google.auto.service.AutoService; import datadog.trace.agent.tooling.Instrumenter; import datadog.trace.agent.tooling.InstrumenterModule; import datadog.trace.bootstrap.instrumentation.jdbc.DBInfo; + import java.util.Map; +import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; +import static java.util.Collections.singletonMap; +import static net.bytebuddy.matcher.ElementMatchers.*; + @AutoService(InstrumenterModule.class) public class PgPoolImplInstrumentation extends InstrumenterModule.Tracing implements Instrumenter.ForSingleType, Instrumenter.HasMethodAdvice { diff --git a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PreparedQueryInstrumentation.java b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PreparedQueryInstrumentation.java index 57877e96263..9cfe2c8410f 100644 --- a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PreparedQueryInstrumentation.java +++ b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PreparedQueryInstrumentation.java @@ -1,22 +1,18 @@ package datadog.trace.instrumentation.vertx_pg_client_4_2_0; -import static datadog.trace.agent.tooling.bytebuddy.matcher.HierarchyMatchers.implementsInterface; -import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; -import static java.util.Collections.singletonMap; -import static net.bytebuddy.matcher.ElementMatchers.isMethod; -import static net.bytebuddy.matcher.ElementMatchers.isPublic; -import static net.bytebuddy.matcher.ElementMatchers.isVirtual; -import static net.bytebuddy.matcher.ElementMatchers.returns; -import static net.bytebuddy.matcher.ElementMatchers.takesArgument; -import static net.bytebuddy.matcher.ElementMatchers.takesArguments; - import com.google.auto.service.AutoService; import datadog.trace.agent.tooling.Instrumenter; import datadog.trace.agent.tooling.InstrumenterModule; -import java.util.Map; import net.bytebuddy.description.type.TypeDescription; import net.bytebuddy.matcher.ElementMatcher; +import java.util.Map; + +import static datadog.trace.agent.tooling.bytebuddy.matcher.HierarchyMatchers.implementsInterface; +import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; +import static java.util.Collections.singletonMap; +import static net.bytebuddy.matcher.ElementMatchers.*; + @AutoService(InstrumenterModule.class) public class PreparedQueryInstrumentation extends InstrumenterModule.Tracing implements Instrumenter.ForTypeHierarchy, Instrumenter.HasMethodAdvice { diff --git a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PreparedStatementImplInstrumentation.java b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PreparedStatementImplInstrumentation.java index 5fdb7c8a9dd..f770389f985 100644 --- a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PreparedStatementImplInstrumentation.java +++ b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PreparedStatementImplInstrumentation.java @@ -1,16 +1,15 @@ package datadog.trace.instrumentation.vertx_pg_client_4_2_0; -import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; -import static net.bytebuddy.matcher.ElementMatchers.isMethod; -import static net.bytebuddy.matcher.ElementMatchers.isPublic; -import static net.bytebuddy.matcher.ElementMatchers.takesNoArguments; - import com.google.auto.service.AutoService; import datadog.trace.agent.tooling.Instrumenter; import datadog.trace.agent.tooling.InstrumenterModule; + import java.util.HashMap; import java.util.Map; +import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; +import static net.bytebuddy.matcher.ElementMatchers.*; + @AutoService(InstrumenterModule.class) public class PreparedStatementImplInstrumentation extends InstrumenterModule.Tracing implements Instrumenter.ForSingleType, Instrumenter.HasMethodAdvice { diff --git a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PreparedStatementQueryAdvice.java b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PreparedStatementQueryAdvice.java index 5e74253d9ba..3845523cc27 100644 --- a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PreparedStatementQueryAdvice.java +++ b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PreparedStatementQueryAdvice.java @@ -2,7 +2,6 @@ import datadog.trace.api.Pair; import datadog.trace.bootstrap.InstrumentationContext; -import io.vertx.pgclient.PgConnection; import io.vertx.sqlclient.PreparedStatement; import io.vertx.sqlclient.Query; import net.bytebuddy.asm.Advice; @@ -14,9 +13,4 @@ public static void afterQuery( InstrumentationContext.get(Query.class, Pair.class) .put(query, InstrumentationContext.get(PreparedStatement.class, Pair.class).get(zis)); } - - // Limit ourselves to 4.x by checking for the ping() method that was added in 4.x - private static void muzzleCheck(PgConnection connection) { - connection.query("SELECT 1"); - } } diff --git a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/QueryAdvice.java b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/QueryAdvice.java index 142b2876516..031d9349bca 100644 --- a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/QueryAdvice.java +++ b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/QueryAdvice.java @@ -1,10 +1,5 @@ package datadog.trace.instrumentation.vertx_pg_client_4_2_0; -import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.activateSpan; -import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.activeSpan; -import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.captureSpan; -import static datadog.trace.instrumentation.vertx_pg_client_4_2_0.VertxSqlClientDecorator.DECORATE; - import datadog.trace.api.Pair; import datadog.trace.bootstrap.ContextStore; import datadog.trace.bootstrap.InstrumentationContext; @@ -12,12 +7,14 @@ import datadog.trace.bootstrap.instrumentation.api.AgentSpan; import io.vertx.core.AsyncResult; import io.vertx.core.Handler; -import io.vertx.pgclient.PgConnection; import io.vertx.sqlclient.Query; import io.vertx.sqlclient.SqlResult; import net.bytebuddy.asm.Advice; import net.bytebuddy.implementation.bytecode.assign.Assigner; +import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.*; +import static datadog.trace.instrumentation.vertx_pg_client_4_2_0.VertxSqlClientDecorator.DECORATE; + public class QueryAdvice { public static class Copy { @Advice.OnMethodExit(suppress = Throwable.class) @@ -26,11 +23,6 @@ public static void afterCopy( ContextStore contextStore = InstrumentationContext.get(Query.class, Pair.class); contextStore.put(ret, contextStore.get(zis)); } - - // Limit ourselves to 4.x by checking for the ping() method that was added in 4.x - private static void muzzleCheck(PgConnection connection) { - connection.query("SELECT 1"); - } } public static class Execute { @@ -73,10 +65,5 @@ public static void afterExecute( clientScope.close(); } } - - // Limit ourselves to 4.x by checking for the ping() method that was added in 4.x - private static void muzzleCheck(PgConnection connection) { - connection.query("SELECT 1"); - } } } diff --git a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/QueryImplInstrumentation.java b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/QueryImplInstrumentation.java index d5a1182c097..32a177e44c6 100644 --- a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/QueryImplInstrumentation.java +++ b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/QueryImplInstrumentation.java @@ -1,19 +1,15 @@ package datadog.trace.instrumentation.vertx_pg_client_4_2_0; -import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; -import static java.util.Collections.singletonMap; -import static net.bytebuddy.matcher.ElementMatchers.isMethod; -import static net.bytebuddy.matcher.ElementMatchers.isPublic; -import static net.bytebuddy.matcher.ElementMatchers.isVirtual; -import static net.bytebuddy.matcher.ElementMatchers.returns; -import static net.bytebuddy.matcher.ElementMatchers.takesArgument; -import static net.bytebuddy.matcher.ElementMatchers.takesArguments; - import com.google.auto.service.AutoService; import datadog.trace.agent.tooling.Instrumenter; import datadog.trace.agent.tooling.InstrumenterModule; + import java.util.Map; +import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; +import static java.util.Collections.singletonMap; +import static net.bytebuddy.matcher.ElementMatchers.*; + @AutoService(InstrumenterModule.class) public class QueryImplInstrumentation extends InstrumenterModule.Tracing implements Instrumenter.ForSingleType, Instrumenter.HasMethodAdvice { diff --git a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/SqlClientBaseAdvice.java b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/SqlClientBaseAdvice.java index d0b4532b837..6051e6aa3c0 100644 --- a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/SqlClientBaseAdvice.java +++ b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/SqlClientBaseAdvice.java @@ -4,7 +4,6 @@ import datadog.trace.bootstrap.InstrumentationContext; import datadog.trace.bootstrap.instrumentation.jdbc.DBInfo; import datadog.trace.bootstrap.instrumentation.jdbc.DBQueryInfo; -import io.vertx.pgclient.PgConnection; import io.vertx.sqlclient.Query; import io.vertx.sqlclient.SqlClient; import net.bytebuddy.asm.Advice; @@ -23,11 +22,6 @@ public static void afterQuery( DBQueryInfo.ofStatement(sql)); InstrumentationContext.get(Query.class, Pair.class).put(query, info); } - - // Limit ourselves to 4.x by checking for the ping() method that was added in 4.x - private static void muzzleCheck(PgConnection connection) { - connection.query("SELECT 1"); - } } public static class PreparedQuery { @@ -42,10 +36,5 @@ public static void afterPreparedQuery( DBQueryInfo.ofPreparedStatement(sql)); InstrumentationContext.get(Query.class, Pair.class).put(query, info); } - - // Limit ourselves to 4.x by checking for the ping() method that was added in 4.x - private static void muzzleCheck(PgConnection connection) { - connection.query("SELECT 1"); - } } } diff --git a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/SqlClientBaseInstrumentation.java b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/SqlClientBaseInstrumentation.java index d811fa19f29..993b3e0fac3 100644 --- a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/SqlClientBaseInstrumentation.java +++ b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/SqlClientBaseInstrumentation.java @@ -1,18 +1,16 @@ package datadog.trace.instrumentation.vertx_pg_client_4_2_0; -import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; -import static net.bytebuddy.matcher.ElementMatchers.isMethod; -import static net.bytebuddy.matcher.ElementMatchers.isPublic; -import static net.bytebuddy.matcher.ElementMatchers.takesArgument; -import static net.bytebuddy.matcher.ElementMatchers.takesArguments; - import com.google.auto.service.AutoService; import datadog.trace.agent.tooling.Instrumenter; import datadog.trace.agent.tooling.InstrumenterModule; import datadog.trace.bootstrap.instrumentation.jdbc.DBInfo; + import java.util.HashMap; import java.util.Map; +import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; +import static net.bytebuddy.matcher.ElementMatchers.*; + @AutoService(InstrumenterModule.class) public class SqlClientBaseInstrumentation extends InstrumenterModule.Tracing implements Instrumenter.ForSingleType, Instrumenter.HasMethodAdvice { diff --git a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/SqlConnectionBaseInstrumentation.java b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/SqlConnectionBaseInstrumentation.java index 9e1f49cbc5b..f1ec73aec42 100644 --- a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/SqlConnectionBaseInstrumentation.java +++ b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/SqlConnectionBaseInstrumentation.java @@ -1,18 +1,16 @@ package datadog.trace.instrumentation.vertx_pg_client_4_2_0; -import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; -import static net.bytebuddy.matcher.ElementMatchers.isMethod; -import static net.bytebuddy.matcher.ElementMatchers.isPublic; -import static net.bytebuddy.matcher.ElementMatchers.takesArgument; -import static net.bytebuddy.matcher.ElementMatchers.takesArguments; - import com.google.auto.service.AutoService; import datadog.trace.agent.tooling.Instrumenter; import datadog.trace.agent.tooling.InstrumenterModule; import datadog.trace.bootstrap.instrumentation.jdbc.DBInfo; + import java.util.HashMap; import java.util.Map; +import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; +import static net.bytebuddy.matcher.ElementMatchers.*; + @AutoService(InstrumenterModule.class) public class SqlConnectionBaseInstrumentation extends InstrumenterModule.Tracing implements Instrumenter.ForSingleType, Instrumenter.HasMethodAdvice { diff --git a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/SqlConnectionBasePrepareAdvice.java b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/SqlConnectionBasePrepareAdvice.java index 6872473b198..5cdf845c226 100644 --- a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/SqlConnectionBasePrepareAdvice.java +++ b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/SqlConnectionBasePrepareAdvice.java @@ -6,7 +6,6 @@ import datadog.trace.bootstrap.instrumentation.jdbc.DBQueryInfo; import io.vertx.core.AsyncResult; import io.vertx.core.Handler; -import io.vertx.pgclient.PgConnection; import io.vertx.sqlclient.PreparedStatement; import io.vertx.sqlclient.SqlClient; import net.bytebuddy.asm.Advice; @@ -27,9 +26,4 @@ public static void beforePrepare( new PrepareHandlerWrapper( handler, InstrumentationContext.get(PreparedStatement.class, Pair.class), info); } - - // Limit ourselves to 4.x by checking for the ping() method that was added in 4.x - private static void muzzleCheck(PgConnection connection) { - connection.query("SELECT 1"); - } } diff --git a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/VertxSqlClientDecorator.java b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/VertxSqlClientDecorator.java index 76a4167472b..69027191564 100644 --- a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/VertxSqlClientDecorator.java +++ b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/VertxSqlClientDecorator.java @@ -1,8 +1,5 @@ package datadog.trace.instrumentation.vertx_pg_client_4_2_0; -import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.startSpan; -import static datadog.trace.bootstrap.instrumentation.api.Tags.DB_OPERATION; - import datadog.trace.api.Pair; import datadog.trace.api.naming.SpanNaming; import datadog.trace.bootstrap.ContextStore; @@ -14,12 +11,15 @@ import datadog.trace.bootstrap.instrumentation.jdbc.DBInfo; import datadog.trace.bootstrap.instrumentation.jdbc.DBQueryInfo; +import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.startSpan; +import static datadog.trace.bootstrap.instrumentation.api.Tags.DB_OPERATION; + public class VertxSqlClientDecorator extends DatabaseClientDecorator { public static final VertxSqlClientDecorator DECORATE = new VertxSqlClientDecorator(); private static final CharSequence VERTX_SQL = UTF8BytesString.create("vertx-sql"); - private static final CharSequence DATABASE_QUERY = UTF8BytesString.create("database.query"); + private static final CharSequence DATABASE_QUERY = UTF8BytesString.create("handler"); private static final UTF8BytesString DB_QUERY = UTF8BytesString.create("DB Query"); private static final UTF8BytesString VERTX_STATEMENT = UTF8BytesString.create("vertx-sql-statement"); @@ -106,7 +106,7 @@ public AgentSpan startAndDecorateSpanForStatement( @Override protected void postProcessServiceAndOperationName( - AgentSpan span, DatabaseClientDecorator.NamingEntry namingEntry) { + AgentSpan span, NamingEntry namingEntry) { if (namingEntry.getService() != null) { span.setServiceName(namingEntry.getService()); } diff --git a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/test/groovy/VertxPostgresSqlClientForkedTest.groovy b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/test/groovy/VertxPostgresSqlClientForkedTest.groovy new file mode 100644 index 00000000000..beb8baf354d --- /dev/null +++ b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/test/groovy/VertxPostgresSqlClientForkedTest.groovy @@ -0,0 +1,146 @@ +import TestDatabases.TestDBInfo +import datadog.trace.agent.test.AgentTestRunner +import datadog.trace.agent.test.asserts.TraceAssert +import datadog.trace.bootstrap.instrumentation.api.Tags +import datadog.trace.core.DDSpan +import io.vertx.core.AsyncResult +import io.vertx.core.Vertx +import io.vertx.core.VertxOptions +import io.vertx.pgclient.PgConnectOptions +import io.vertx.pgclient.PgPool +import io.vertx.sqlclient.* +import spock.lang.AutoCleanup +import spock.lang.Shared + +import java.util.concurrent.CountDownLatch +import java.util.concurrent.TimeUnit + +import static datadog.trace.agent.test.utils.TraceUtils.basicSpan +import static datadog.trace.agent.test.utils.TraceUtils.runUnderTrace + +class VertxPostgresSqlClientForkedTest extends AgentTestRunner { + @AutoCleanup + @Shared + def dbs = TestDatabases.initialise("postgres") + + @AutoCleanup + @Shared + def vertx = Vertx.vertx(new VertxOptions()) + + def "test #type without parent"() { + when: + AsyncResult> asyncResult = executeQueryWithHandler(query) + + then: + asyncResult.succeeded() + + when: + def result = asyncResult.result() + + then: + result.size() == 1 + result[0].getString(0) == '7' + assertTraces(2) { + trace(1) { + checkDBSpan(it, null, 'SELECT $1', "SELECT", dbs.DBInfos.postgresql, prepared) + } + trace(1) { + basicSpan(it, "handler") + } + } + + cleanup: + pool.close() + + where: + type | pool | query | prepared + 'prepared statement' | pool() | prepare(connection(pool), 'SELECT $1').query() | true + } + + Pool pool() { + def connectOptions = PgConnectOptions.fromUri(dbs.DBInfos.postgresql.uri) + def poolOptions = new PoolOptions().setMaxSize(2) + return PgPool.pool(vertx, connectOptions, poolOptions) + } + + def AsyncResult> executeQueryWithHandler(Query> query) { + def latch = new CountDownLatch(1) + AsyncResult> result = null + + if (query instanceof PreparedQuery) { + query.execute(Tuple.of("7")) { rowSetAR -> + runUnderTrace("handler") { + result = rowSetAR + } + latch.countDown() + } + } else { + query.execute { rowSetAR -> + runUnderTrace("handler") { + result = rowSetAR + } + latch.countDown() + } + } + assert latch.await(10, TimeUnit.SECONDS) + return result + } + + AsyncResult> queryCursorWithHandler(Cursor cursor) { + def latch = new CountDownLatch(1) + AsyncResult> result = null + cursor.read(0) { rowSetAR -> + runUnderTrace("handler") { + result = rowSetAR + } + latch.countDown() + } + assert latch.await(10, TimeUnit.SECONDS) + return result + } + + SqlConnection connection(Pool pool) { + def latch = new CountDownLatch(1) + SqlConnection result = null + pool.getConnection({ connectionAR -> + result = connectionAR.result() + latch.countDown() + }) + assert latch.await(10, TimeUnit.SECONDS) + return result + } + + PreparedStatement prepare(SqlConnection connection, String sql) { + def latch = new CountDownLatch(1) + PreparedStatement result = null + connection.prepare(sql, { statementAR -> + result = statementAR.result() + latch.countDown() + }) + assert latch.await(10, TimeUnit.SECONDS) + return result + } + + void checkDBSpan(TraceAssert ta, DDSpan parent, String resource, String operation, TestDBInfo info, boolean prepared = false) { + ta.span(ta.nextSpanId()) { + if (parent != null) { + childOf(parent) + } + operationName info ? "${info.type}.query" : "database.query" + resourceName resource + spanType "sql" + tags { + "$Tags.COMPONENT" prepared ? "vertx-sql-prepared_statement" : "vertx-sql-statement" + "$Tags.SPAN_KIND" Tags.SPAN_KIND_CLIENT + "$Tags.DB_OPERATION" operation + if (info) { + "$Tags.DB_TYPE" info.type + "$Tags.DB_INSTANCE" info.dbName + "$Tags.DB_USER" info.user + "$Tags.PEER_HOSTNAME" info.host + } + defaultTags() + } + } + } +} diff --git a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/test/groovy/VertxSqlClientForkedTest.groovy b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/test/groovy/VertxSqlClientForkedTest.groovy deleted file mode 100644 index b0852aff4a8..00000000000 --- a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/test/groovy/VertxSqlClientForkedTest.groovy +++ /dev/null @@ -1,340 +0,0 @@ -import TestDatabases.TestDBInfo -import datadog.trace.agent.test.AgentTestRunner -import datadog.trace.agent.test.asserts.TraceAssert -import datadog.trace.bootstrap.instrumentation.api.Tags -import datadog.trace.core.DDSpan -import io.vertx.core.AsyncResult -import io.vertx.core.Vertx -import io.vertx.core.VertxOptions -import io.vertx.pgclient.PgConnectOptions -import io.vertx.pgclient.PgPool -import io.vertx.sqlclient.Cursor -import io.vertx.sqlclient.Pool -import io.vertx.sqlclient.PoolOptions -import io.vertx.sqlclient.PreparedQuery -import io.vertx.sqlclient.PreparedStatement -import io.vertx.sqlclient.Query -import io.vertx.sqlclient.Row -import io.vertx.sqlclient.RowSet -import io.vertx.sqlclient.SqlConnection -import io.vertx.sqlclient.Tuple -import io.vertx.sqlclient.impl.ArrayTuple -import spock.lang.AutoCleanup -import spock.lang.Shared - -import java.util.concurrent.CountDownLatch -import java.util.concurrent.TimeUnit -import java.util.concurrent.atomic.AtomicReference - -import static datadog.trace.agent.test.utils.TraceUtils.basicSpan -import static datadog.trace.agent.test.utils.TraceUtils.runUnderTrace - -class VertxSqlClientForkedTest extends AgentTestRunner { - @AutoCleanup - @Shared - // This database name must match up with the name in the CircleCI PG Docker definition - def dbs = TestDatabases.initialise("jdbcUnitTest") - - @AutoCleanup - @Shared - def vertx = Vertx.vertx(new VertxOptions()) - - def "test #type"() { - when: - AsyncResult> asyncResult = runUnderTrace("parent") { - return executeQueryWithHandler(query) - } - - then: - asyncResult.succeeded() - - when: - def result = asyncResult.result() - - then: - result.size() == 1 - result[0].getInteger(0) == 7 - assertTraces(1) { - trace(3, true) { - basicSpan(it, "handler", span(2)) - checkDBSpan(it, span(2), "SELECT ?", "SELECT", dbs.DBInfos.postgresql, prepared) - basicSpan(it, "parent") - } - } - - cleanup: - pool.close() - - where: - type | pool | query | prepared - 'query' | pool() | pool.query('SELECT 7') | false - 'prepared query' | pool() | pool.preparedQuery("SELECT ?") | true - 'prepared statement' | pool() | prepare(connection(pool), "SELECT ?").query() | true - } - - def "test #type without parent"() { - when: - AsyncResult> asyncResult = executeQueryWithHandler(query) - - then: - asyncResult.succeeded() - - when: - def result = asyncResult.result() - - then: - result.size() == 1 - result[0].getInteger(0) == 7 - assertTraces(2) { - trace(1) { - checkDBSpan(it, null, "SELECT ?", "SELECT", dbs.DBInfos.postgresql, prepared) - } - trace(1) { - basicSpan(it, "handler") - } - } - - cleanup: - pool.close() - - where: - type | pool | query | prepared - 'query' | pool() | pool.query('SELECT 7') | false - 'prepared query' | pool() | pool.preparedQuery("SELECT ?") | true - 'prepared statement' | pool() | prepare(connection(pool), "SELECT ?").query() | true - } - - def "test #type mapped"() { - setup: - def mapped = query.mapping({ row -> - return row.getInteger(0) - }) - - when: - AsyncResult> asyncResult = runUnderTrace("parent") { - return executeQueryWithHandler(mapped) - } - - then: - asyncResult.succeeded() - - when: - def result = asyncResult.result() - - then: - result.size() == 1 - result[0] == 7 - assertTraces(1) { - trace(3, true) { - basicSpan(it, "handler", span(2)) - checkDBSpan(it, span(2), "SELECT ?", "SELECT", dbs.DBInfos.postgresql, prepared) - basicSpan(it, "parent") - } - } - - cleanup: - pool.close() - - where: - type | pool | query | prepared - 'query' | pool() | pool.query('SELECT 7') | false - 'prepared query' | pool() | pool.preparedQuery("SELECT ?") | true - 'prepared statement' | pool() | prepare(connection(pool), "SELECT ?").query() | true - } - - def "test #type mapped without parent"() { - setup: - def mapped = query.mapping({ row -> - return row.getInteger(0) - }) - - when: - AsyncResult> asyncResult = executeQueryWithHandler(mapped) - - then: - asyncResult.succeeded() - - when: - def result = asyncResult.result() - - then: - result.size() == 1 - result[0] == 7 - assertTraces(2) { - trace(1) { - checkDBSpan(it, null, "SELECT ?", "SELECT", dbs.DBInfos.postgresql, prepared) - } - trace(1) { - basicSpan(it, "handler") - } - } - - cleanup: - pool.close() - - where: - type | pool | query | prepared - 'query' | pool() | pool.query('SELECT 7') | false - 'prepared query' | pool() | pool.preparedQuery("SELECT ?") | true - 'prepared statement' | pool() | prepare(connection(pool), "SELECT ?").query() | true - } - - def "test cursor"() { - setup: - def pool = pool() - def cursor = prepare(connection(pool), "SELECT 7").cursor() - - when: - def asyncResult = runUnderTrace("parent") { - queryCursorWithHandler(cursor) - } - - then: - asyncResult.succeeded() - - when: - def result = asyncResult.result() - - then: - result.size() == 1 - result[0].getInteger(0) == 7 - assertTraces(1) { - trace(3, true) { - basicSpan(it, "handler", span(2)) - checkDBSpan(it, span(2), "SELECT ?", "SELECT", dbs.DBInfos.postgresql, true) - basicSpan(it, "parent") - } - } - - cleanup: - pool.close() - } - - def "test row stream"() { - setup: - def pool = pool() - def connection = connection(pool) - def statement = prepare(connection, "SELECT 7") - def result = new AtomicReference() - def latch = new CountDownLatch(1) - - when: - def tx = connection.begin() - def stream = statement.createStream(0, ArrayTuple.EMPTY) - stream.endHandler({ - tx.commit() - }) - runUnderTrace("parent") { - stream.handler({ row -> - if (latch.getCount() != 0) { - runUnderTrace("handler") { - result.set(row) - stream.close() - } - latch.countDown() - } - }) - } - assert latch.await(10, TimeUnit.SECONDS) - - then: - result.get().getInteger(0) == 7 - assertTraces(1) { - trace(3, true) { - basicSpan(it, "handler", span(2)) - checkDBSpan(it, span(2), "SELECT ?", "SELECT", dbs.DBInfos.pos, true) - basicSpan(it, "parent") - } - } - - cleanup: - pool.close() - } - - Pool pool() { - def connectOptions = PgConnectOptions.fromUri(dbs.DBInfos.postgresql.uri) - def poolOptions = new PoolOptions().setMaxSize(2) - return PgPool.pool(vertx, connectOptions, poolOptions) - } - - def AsyncResult> executeQueryWithHandler(Query> query) { - def latch = new CountDownLatch(1) - AsyncResult> result = null - - if (query instanceof PreparedQuery) { - query.execute(Tuple.of(7)) { rowSetAR -> - runUnderTrace("handler") { - result = rowSetAR - } - latch.countDown() - } - } else { - query.execute { rowSetAR -> - runUnderTrace("handler") { - result = rowSetAR - } - latch.countDown() - } - } - assert latch.await(10, TimeUnit.SECONDS) - return result - } - - AsyncResult> queryCursorWithHandler(Cursor cursor) { - def latch = new CountDownLatch(1) - AsyncResult> result = null - cursor.read(0) { rowSetAR -> - runUnderTrace("handler") { - result = rowSetAR - } - latch.countDown() - } - assert latch.await(10, TimeUnit.SECONDS) - return result - } - - SqlConnection connection(Pool pool) { - def latch = new CountDownLatch(1) - SqlConnection result = null - pool.getConnection({ connectionAR -> - result = connectionAR.result() - latch.countDown() - }) - assert latch.await(10, TimeUnit.SECONDS) - return result - } - - PreparedStatement prepare(SqlConnection connection, String sql) { - def latch = new CountDownLatch(1) - PreparedStatement result = null - connection.prepare(sql, { statementAR -> - result = statementAR.result() - latch.countDown() - }) - assert latch.await(10, TimeUnit.SECONDS) - return result - } - - void checkDBSpan(TraceAssert ta, DDSpan parent, String resource, String operation, TestDBInfo info, boolean prepared = false) { - ta.span(ta.nextSpanId()) { - if (parent != null) { - childOf(parent) - } - operationName info ? "${info.type}.query" : "database.query" - resourceName resource - spanType "sql" - tags { - "$Tags.COMPONENT" prepared ? "vertx-sql-prepared_statement" : "vertx-sql-statement" - "$Tags.SPAN_KIND" Tags.SPAN_KIND_CLIENT - "$Tags.DB_OPERATION" operation - if (info) { - "$Tags.DB_TYPE" info.type - "$Tags.DB_INSTANCE" info.dbName - "$Tags.DB_USER" info.user - "$Tags.PEER_HOSTNAME" info.host - } - defaultTags() - } - } - } -} diff --git a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/test/java/TestDatabases.java b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/test/java/TestDatabases.java index f84d20f26d2..1e31905cf79 100644 --- a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/test/java/TestDatabases.java +++ b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/test/java/TestDatabases.java @@ -17,10 +17,8 @@ private TestDatabases(String dbName) { pgsql = new PostgreSQLContainer("postgres:16-alpine") .withDatabaseName(dbName) - .withUsername("sa") - .withPassword("sa"); - // https://github.com/testcontainers/testcontainers-java/issues/914 - pgsql.addParameter("TC_MY_CNF", null); + .withUsername("postgres") + .withPassword("postgres"); pgsql.start(); TestDBInfo info = new TestDBInfo( From f84b146a2cbb47480171c496cf4d7e287009969c Mon Sep 17 00:00:00 2001 From: Onkar Sarvade Date: Fri, 28 Feb 2025 10:47:59 +0530 Subject: [PATCH 3/8] Applied spotless formatting --- .../CursorImplInstrumentation.java | 9 ++++----- .../vertx_pg_client_4_2_0/CursorReadAdvice.java | 6 +++--- .../PgConnectionFactoryInstrumentation.java | 9 ++++----- .../PgConnectionImplConstructorAdvice.java | 4 +--- .../PgConnectionImplInstrumentation.java | 12 +++++------- .../PgPoolImplInstrumentation.java | 9 ++++----- .../PreparedQueryInstrumentation.java | 13 ++++++------- .../PreparedStatementImplInstrumentation.java | 7 +++---- .../vertx_pg_client_4_2_0/QueryAdvice.java | 6 +++--- .../QueryImplInstrumentation.java | 9 ++++----- .../SqlClientBaseInstrumentation.java | 7 +++---- .../SqlConnectionBaseInstrumentation.java | 7 +++---- .../VertxSqlClientDecorator.java | 9 ++++----- 13 files changed, 47 insertions(+), 60 deletions(-) diff --git a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/CursorImplInstrumentation.java b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/CursorImplInstrumentation.java index 5634eeaf565..4aec9a6ce79 100644 --- a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/CursorImplInstrumentation.java +++ b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/CursorImplInstrumentation.java @@ -1,15 +1,14 @@ package datadog.trace.instrumentation.vertx_pg_client_4_2_0; +import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; +import static java.util.Collections.singletonMap; +import static net.bytebuddy.matcher.ElementMatchers.*; + import com.google.auto.service.AutoService; import datadog.trace.agent.tooling.Instrumenter; import datadog.trace.agent.tooling.InstrumenterModule; - import java.util.Map; -import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; -import static java.util.Collections.singletonMap; -import static net.bytebuddy.matcher.ElementMatchers.*; - @AutoService(InstrumenterModule.class) public class CursorImplInstrumentation extends InstrumenterModule.Tracing implements Instrumenter.ForSingleType, Instrumenter.HasMethodAdvice { diff --git a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/CursorReadAdvice.java b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/CursorReadAdvice.java index 687292add20..8dac2262b74 100644 --- a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/CursorReadAdvice.java +++ b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/CursorReadAdvice.java @@ -1,5 +1,8 @@ package datadog.trace.instrumentation.vertx_pg_client_4_2_0; +import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.*; +import static datadog.trace.instrumentation.vertx_pg_client_4_2_0.VertxSqlClientDecorator.DECORATE; + import datadog.trace.api.Pair; import datadog.trace.bootstrap.InstrumentationContext; import datadog.trace.bootstrap.instrumentation.api.AgentScope; @@ -12,9 +15,6 @@ import net.bytebuddy.asm.Advice; import net.bytebuddy.implementation.bytecode.assign.Assigner; -import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.*; -import static datadog.trace.instrumentation.vertx_pg_client_4_2_0.VertxSqlClientDecorator.DECORATE; - public class CursorReadAdvice { @Advice.OnMethodEnter(suppress = Throwable.class) public static AgentScope beforeRead( diff --git a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PgConnectionFactoryInstrumentation.java b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PgConnectionFactoryInstrumentation.java index 9916cfc0071..b6c2390ef22 100644 --- a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PgConnectionFactoryInstrumentation.java +++ b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PgConnectionFactoryInstrumentation.java @@ -1,16 +1,15 @@ package datadog.trace.instrumentation.vertx_pg_client_4_2_0; +import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; +import static java.util.Collections.singletonMap; +import static net.bytebuddy.matcher.ElementMatchers.*; + import com.google.auto.service.AutoService; import datadog.trace.agent.tooling.Instrumenter; import datadog.trace.agent.tooling.InstrumenterModule; import datadog.trace.bootstrap.instrumentation.jdbc.DBInfo; - import java.util.Map; -import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; -import static java.util.Collections.singletonMap; -import static net.bytebuddy.matcher.ElementMatchers.*; - @AutoService(InstrumenterModule.class) public class PgConnectionFactoryInstrumentation extends InstrumenterModule.Tracing implements Instrumenter.ForSingleType, Instrumenter.HasMethodAdvice { diff --git a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PgConnectionImplConstructorAdvice.java b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PgConnectionImplConstructorAdvice.java index 3c1c84d98cf..acbd4cc7292 100644 --- a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PgConnectionImplConstructorAdvice.java +++ b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PgConnectionImplConstructorAdvice.java @@ -11,8 +11,6 @@ public class PgConnectionImplConstructorAdvice { public static void afterConstructor( @Advice.This final SqlClient zis, @Advice.Argument(0) final PgConnectionFactory factory) { InstrumentationContext.get(SqlClient.class, DBInfo.class) - .put( - zis, - InstrumentationContext.get(PgConnectionFactory.class, DBInfo.class).get(factory)); + .put(zis, InstrumentationContext.get(PgConnectionFactory.class, DBInfo.class).get(factory)); } } diff --git a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PgConnectionImplInstrumentation.java b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PgConnectionImplInstrumentation.java index 86088d9f7fd..110cf9af591 100644 --- a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PgConnectionImplInstrumentation.java +++ b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PgConnectionImplInstrumentation.java @@ -1,17 +1,16 @@ package datadog.trace.instrumentation.vertx_pg_client_4_2_0; +import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; +import static net.bytebuddy.matcher.ElementMatchers.isConstructor; +import static net.bytebuddy.matcher.ElementMatchers.takesArgument; + import com.google.auto.service.AutoService; import datadog.trace.agent.tooling.Instrumenter; import datadog.trace.agent.tooling.InstrumenterModule; import datadog.trace.bootstrap.instrumentation.jdbc.DBInfo; - import java.util.HashMap; import java.util.Map; -import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; -import static net.bytebuddy.matcher.ElementMatchers.isConstructor; -import static net.bytebuddy.matcher.ElementMatchers.takesArgument; - @AutoService(InstrumenterModule.class) public class PgConnectionImplInstrumentation extends InstrumenterModule.Tracing implements Instrumenter.ForSingleType, Instrumenter.HasMethodAdvice { @@ -35,8 +34,7 @@ public String instrumentedType() { @Override public void methodAdvice(MethodTransformer transformer) { transformer.applyAdvice( - isConstructor() - .and(takesArgument(0, named("io.vertx.pgclient.impl.PgConnectionFactory"))), + isConstructor().and(takesArgument(0, named("io.vertx.pgclient.impl.PgConnectionFactory"))), packageName + ".PgConnectionImplConstructorAdvice"); } } diff --git a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PgPoolImplInstrumentation.java b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PgPoolImplInstrumentation.java index 5c2af8fc56b..c97044540ea 100644 --- a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PgPoolImplInstrumentation.java +++ b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PgPoolImplInstrumentation.java @@ -1,16 +1,15 @@ package datadog.trace.instrumentation.vertx_pg_client_4_2_0; +import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; +import static java.util.Collections.singletonMap; +import static net.bytebuddy.matcher.ElementMatchers.*; + import com.google.auto.service.AutoService; import datadog.trace.agent.tooling.Instrumenter; import datadog.trace.agent.tooling.InstrumenterModule; import datadog.trace.bootstrap.instrumentation.jdbc.DBInfo; - import java.util.Map; -import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; -import static java.util.Collections.singletonMap; -import static net.bytebuddy.matcher.ElementMatchers.*; - @AutoService(InstrumenterModule.class) public class PgPoolImplInstrumentation extends InstrumenterModule.Tracing implements Instrumenter.ForSingleType, Instrumenter.HasMethodAdvice { diff --git a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PreparedQueryInstrumentation.java b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PreparedQueryInstrumentation.java index 9cfe2c8410f..505186c7def 100644 --- a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PreparedQueryInstrumentation.java +++ b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PreparedQueryInstrumentation.java @@ -1,18 +1,17 @@ package datadog.trace.instrumentation.vertx_pg_client_4_2_0; +import static datadog.trace.agent.tooling.bytebuddy.matcher.HierarchyMatchers.implementsInterface; +import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; +import static java.util.Collections.singletonMap; +import static net.bytebuddy.matcher.ElementMatchers.*; + import com.google.auto.service.AutoService; import datadog.trace.agent.tooling.Instrumenter; import datadog.trace.agent.tooling.InstrumenterModule; +import java.util.Map; import net.bytebuddy.description.type.TypeDescription; import net.bytebuddy.matcher.ElementMatcher; -import java.util.Map; - -import static datadog.trace.agent.tooling.bytebuddy.matcher.HierarchyMatchers.implementsInterface; -import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; -import static java.util.Collections.singletonMap; -import static net.bytebuddy.matcher.ElementMatchers.*; - @AutoService(InstrumenterModule.class) public class PreparedQueryInstrumentation extends InstrumenterModule.Tracing implements Instrumenter.ForTypeHierarchy, Instrumenter.HasMethodAdvice { diff --git a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PreparedStatementImplInstrumentation.java b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PreparedStatementImplInstrumentation.java index f770389f985..d023e2483c3 100644 --- a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PreparedStatementImplInstrumentation.java +++ b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PreparedStatementImplInstrumentation.java @@ -1,15 +1,14 @@ package datadog.trace.instrumentation.vertx_pg_client_4_2_0; +import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; +import static net.bytebuddy.matcher.ElementMatchers.*; + import com.google.auto.service.AutoService; import datadog.trace.agent.tooling.Instrumenter; import datadog.trace.agent.tooling.InstrumenterModule; - import java.util.HashMap; import java.util.Map; -import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; -import static net.bytebuddy.matcher.ElementMatchers.*; - @AutoService(InstrumenterModule.class) public class PreparedStatementImplInstrumentation extends InstrumenterModule.Tracing implements Instrumenter.ForSingleType, Instrumenter.HasMethodAdvice { diff --git a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/QueryAdvice.java b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/QueryAdvice.java index 031d9349bca..db2e3444a52 100644 --- a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/QueryAdvice.java +++ b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/QueryAdvice.java @@ -1,5 +1,8 @@ package datadog.trace.instrumentation.vertx_pg_client_4_2_0; +import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.*; +import static datadog.trace.instrumentation.vertx_pg_client_4_2_0.VertxSqlClientDecorator.DECORATE; + import datadog.trace.api.Pair; import datadog.trace.bootstrap.ContextStore; import datadog.trace.bootstrap.InstrumentationContext; @@ -12,9 +15,6 @@ import net.bytebuddy.asm.Advice; import net.bytebuddy.implementation.bytecode.assign.Assigner; -import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.*; -import static datadog.trace.instrumentation.vertx_pg_client_4_2_0.VertxSqlClientDecorator.DECORATE; - public class QueryAdvice { public static class Copy { @Advice.OnMethodExit(suppress = Throwable.class) diff --git a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/QueryImplInstrumentation.java b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/QueryImplInstrumentation.java index 32a177e44c6..cfa5395e9ba 100644 --- a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/QueryImplInstrumentation.java +++ b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/QueryImplInstrumentation.java @@ -1,15 +1,14 @@ package datadog.trace.instrumentation.vertx_pg_client_4_2_0; +import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; +import static java.util.Collections.singletonMap; +import static net.bytebuddy.matcher.ElementMatchers.*; + import com.google.auto.service.AutoService; import datadog.trace.agent.tooling.Instrumenter; import datadog.trace.agent.tooling.InstrumenterModule; - import java.util.Map; -import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; -import static java.util.Collections.singletonMap; -import static net.bytebuddy.matcher.ElementMatchers.*; - @AutoService(InstrumenterModule.class) public class QueryImplInstrumentation extends InstrumenterModule.Tracing implements Instrumenter.ForSingleType, Instrumenter.HasMethodAdvice { diff --git a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/SqlClientBaseInstrumentation.java b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/SqlClientBaseInstrumentation.java index 993b3e0fac3..1ba011ee9ae 100644 --- a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/SqlClientBaseInstrumentation.java +++ b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/SqlClientBaseInstrumentation.java @@ -1,16 +1,15 @@ package datadog.trace.instrumentation.vertx_pg_client_4_2_0; +import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; +import static net.bytebuddy.matcher.ElementMatchers.*; + import com.google.auto.service.AutoService; import datadog.trace.agent.tooling.Instrumenter; import datadog.trace.agent.tooling.InstrumenterModule; import datadog.trace.bootstrap.instrumentation.jdbc.DBInfo; - import java.util.HashMap; import java.util.Map; -import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; -import static net.bytebuddy.matcher.ElementMatchers.*; - @AutoService(InstrumenterModule.class) public class SqlClientBaseInstrumentation extends InstrumenterModule.Tracing implements Instrumenter.ForSingleType, Instrumenter.HasMethodAdvice { diff --git a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/SqlConnectionBaseInstrumentation.java b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/SqlConnectionBaseInstrumentation.java index f1ec73aec42..b2031c5105d 100644 --- a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/SqlConnectionBaseInstrumentation.java +++ b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/SqlConnectionBaseInstrumentation.java @@ -1,16 +1,15 @@ package datadog.trace.instrumentation.vertx_pg_client_4_2_0; +import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; +import static net.bytebuddy.matcher.ElementMatchers.*; + import com.google.auto.service.AutoService; import datadog.trace.agent.tooling.Instrumenter; import datadog.trace.agent.tooling.InstrumenterModule; import datadog.trace.bootstrap.instrumentation.jdbc.DBInfo; - import java.util.HashMap; import java.util.Map; -import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; -import static net.bytebuddy.matcher.ElementMatchers.*; - @AutoService(InstrumenterModule.class) public class SqlConnectionBaseInstrumentation extends InstrumenterModule.Tracing implements Instrumenter.ForSingleType, Instrumenter.HasMethodAdvice { diff --git a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/VertxSqlClientDecorator.java b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/VertxSqlClientDecorator.java index 69027191564..785a431b18e 100644 --- a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/VertxSqlClientDecorator.java +++ b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/VertxSqlClientDecorator.java @@ -1,5 +1,8 @@ package datadog.trace.instrumentation.vertx_pg_client_4_2_0; +import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.startSpan; +import static datadog.trace.bootstrap.instrumentation.api.Tags.DB_OPERATION; + import datadog.trace.api.Pair; import datadog.trace.api.naming.SpanNaming; import datadog.trace.bootstrap.ContextStore; @@ -11,9 +14,6 @@ import datadog.trace.bootstrap.instrumentation.jdbc.DBInfo; import datadog.trace.bootstrap.instrumentation.jdbc.DBQueryInfo; -import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.startSpan; -import static datadog.trace.bootstrap.instrumentation.api.Tags.DB_OPERATION; - public class VertxSqlClientDecorator extends DatabaseClientDecorator { public static final VertxSqlClientDecorator DECORATE = new VertxSqlClientDecorator(); @@ -105,8 +105,7 @@ public AgentSpan startAndDecorateSpanForStatement( } @Override - protected void postProcessServiceAndOperationName( - AgentSpan span, NamingEntry namingEntry) { + protected void postProcessServiceAndOperationName(AgentSpan span, NamingEntry namingEntry) { if (namingEntry.getService() != null) { span.setServiceName(namingEntry.getService()); } From 741b2d7c6be98b478ac2c4ea549845c131f1719d Mon Sep 17 00:00:00 2001 From: Onkar Sarvade Date: Fri, 28 Feb 2025 15:13:33 +0530 Subject: [PATCH 4/8] Updated version support for postgres --- .../instrumentation/vertx-pg-client-4.2.0/build.gradle | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/build.gradle b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/build.gradle index 191a6dab7f5..7fa0eb8d07e 100644 --- a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/build.gradle +++ b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/build.gradle @@ -5,7 +5,7 @@ muzzle { pass { group = 'io.vertx' module = 'vertx-pg-client' - versions = '[4.2.0)' + versions = '[4.2.0,5)' assertInverse = true } } @@ -29,7 +29,7 @@ dependencies { testImplementation group: 'org.postgresql', name: 'postgresql', version: '42.7.4' testImplementation group: 'org.testcontainers', name: 'postgresql', version: libs.versions.testcontainers.get() - latestDepTestImplementation group: 'io.vertx', name: 'vertx-pg-client', version: '4.2.+' + latestDepTestImplementation group: 'io.vertx', name: 'vertx-pg-client', version: '4.+' } tasks.withType(Test).configureEach { From 2fbadf412322941626af7e8dd2a9e8411026873f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rapha=C3=ABl=20Vandon?= Date: Fri, 28 Feb 2025 11:48:46 +0100 Subject: [PATCH 5/8] move common vertx sql code --- .../vertx_sql_client_4/CursorReadAdvice.java | 56 --------- .../vertx_sql_client_4/QueryAdvice.java | 82 ------------- .../CursorImplInstrumentation.java | 45 ------- .../PrepareHandlerWrapper.java | 32 ----- .../PreparedQueryInstrumentation.java | 67 ---------- .../QueryImplInstrumentation.java | 52 -------- .../QueryResultHandlerWrapper.java | 41 ------- .../SqlClientBaseAdvice.java | 40 ------ .../SqlClientBaseInstrumentation.java | 50 -------- .../SqlConnectionBaseInstrumentation.java | 49 -------- .../SqlConnectionBasePrepareAdvice.java | 29 ----- .../VertxSqlClientDecorator.java | 114 ------------------ .../vertx-sql-common/build.gradle | 36 ++++++ .../CursorImplInstrumentation.java | 2 +- .../vertx_sql_common}/CursorReadAdvice.java | 8 +- .../PrepareHandlerWrapper.java | 2 +- .../PreparedQueryInstrumentation.java | 2 +- .../vertx_sql_common}/QueryAdvice.java | 8 +- .../QueryImplInstrumentation.java | 2 +- .../QueryResultHandlerWrapper.java | 2 +- .../SqlClientBaseAdvice.java | 2 +- .../SqlClientBaseInstrumentation.java | 2 +- .../SqlConnectionBaseInstrumentation.java | 2 +- .../SqlConnectionBasePrepareAdvice.java | 2 +- .../VertxSqlClientDecorator.java | 2 +- settings.gradle | 1 + 26 files changed, 57 insertions(+), 673 deletions(-) delete mode 100644 dd-java-agent/instrumentation/vertx-mysql-client-4.0/src/main/java/datadog/trace/instrumentation/vertx_sql_client_4/CursorReadAdvice.java delete mode 100644 dd-java-agent/instrumentation/vertx-mysql-client-4.0/src/main/java/datadog/trace/instrumentation/vertx_sql_client_4/QueryAdvice.java delete mode 100644 dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/CursorImplInstrumentation.java delete mode 100644 dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PrepareHandlerWrapper.java delete mode 100644 dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PreparedQueryInstrumentation.java delete mode 100644 dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/QueryImplInstrumentation.java delete mode 100644 dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/QueryResultHandlerWrapper.java delete mode 100644 dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/SqlClientBaseAdvice.java delete mode 100644 dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/SqlClientBaseInstrumentation.java delete mode 100644 dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/SqlConnectionBaseInstrumentation.java delete mode 100644 dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/SqlConnectionBasePrepareAdvice.java delete mode 100644 dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/VertxSqlClientDecorator.java create mode 100644 dd-java-agent/instrumentation/vertx-sql-common/build.gradle rename dd-java-agent/instrumentation/{vertx-mysql-client-4.0/src/main/java/datadog/trace/instrumentation/vertx_sql_client_4 => vertx-sql-common/src/main/java/datadog/trace/instrumentation/vertx_sql_common}/CursorImplInstrumentation.java (96%) rename dd-java-agent/instrumentation/{vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0 => vertx-sql-common/src/main/java/datadog/trace/instrumentation/vertx_sql_common}/CursorReadAdvice.java (84%) rename dd-java-agent/instrumentation/{vertx-mysql-client-4.0/src/main/java/datadog/trace/instrumentation/vertx_sql_client_4 => vertx-sql-common/src/main/java/datadog/trace/instrumentation/vertx_sql_common}/PrepareHandlerWrapper.java (94%) rename dd-java-agent/instrumentation/{vertx-mysql-client-4.0/src/main/java/datadog/trace/instrumentation/vertx_sql_client_4 => vertx-sql-common/src/main/java/datadog/trace/instrumentation/vertx_sql_common}/PreparedQueryInstrumentation.java (97%) rename dd-java-agent/instrumentation/{vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0 => vertx-sql-common/src/main/java/datadog/trace/instrumentation/vertx_sql_common}/QueryAdvice.java (88%) rename dd-java-agent/instrumentation/{vertx-mysql-client-4.0/src/main/java/datadog/trace/instrumentation/vertx_sql_client_4 => vertx-sql-common/src/main/java/datadog/trace/instrumentation/vertx_sql_common}/QueryImplInstrumentation.java (97%) rename dd-java-agent/instrumentation/{vertx-mysql-client-4.0/src/main/java/datadog/trace/instrumentation/vertx_sql_client_4 => vertx-sql-common/src/main/java/datadog/trace/instrumentation/vertx_sql_common}/QueryResultHandlerWrapper.java (95%) rename dd-java-agent/instrumentation/{vertx-mysql-client-4.0/src/main/java/datadog/trace/instrumentation/vertx_sql_client_4 => vertx-sql-common/src/main/java/datadog/trace/instrumentation/vertx_sql_common}/SqlClientBaseAdvice.java (96%) rename dd-java-agent/instrumentation/{vertx-mysql-client-4.0/src/main/java/datadog/trace/instrumentation/vertx_sql_client_4 => vertx-sql-common/src/main/java/datadog/trace/instrumentation/vertx_sql_common}/SqlClientBaseInstrumentation.java (97%) rename dd-java-agent/instrumentation/{vertx-mysql-client-4.0/src/main/java/datadog/trace/instrumentation/vertx_sql_client_4 => vertx-sql-common/src/main/java/datadog/trace/instrumentation/vertx_sql_common}/SqlConnectionBaseInstrumentation.java (96%) rename dd-java-agent/instrumentation/{vertx-mysql-client-4.0/src/main/java/datadog/trace/instrumentation/vertx_sql_client_4 => vertx-sql-common/src/main/java/datadog/trace/instrumentation/vertx_sql_common}/SqlConnectionBasePrepareAdvice.java (95%) rename dd-java-agent/instrumentation/{vertx-mysql-client-4.0/src/main/java/datadog/trace/instrumentation/vertx_sql_client_4 => vertx-sql-common/src/main/java/datadog/trace/instrumentation/vertx_sql_common}/VertxSqlClientDecorator.java (98%) diff --git a/dd-java-agent/instrumentation/vertx-mysql-client-4.0/src/main/java/datadog/trace/instrumentation/vertx_sql_client_4/CursorReadAdvice.java b/dd-java-agent/instrumentation/vertx-mysql-client-4.0/src/main/java/datadog/trace/instrumentation/vertx_sql_client_4/CursorReadAdvice.java deleted file mode 100644 index f02405d8f58..00000000000 --- a/dd-java-agent/instrumentation/vertx-mysql-client-4.0/src/main/java/datadog/trace/instrumentation/vertx_sql_client_4/CursorReadAdvice.java +++ /dev/null @@ -1,56 +0,0 @@ -package datadog.trace.instrumentation.vertx_sql_client_4; - -import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.activateSpan; -import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.activeSpan; -import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.captureSpan; -import static datadog.trace.instrumentation.vertx_sql_client_4.VertxSqlClientDecorator.DECORATE; - -import datadog.trace.api.Pair; -import datadog.trace.bootstrap.InstrumentationContext; -import datadog.trace.bootstrap.instrumentation.api.AgentScope; -import datadog.trace.bootstrap.instrumentation.api.AgentSpan; -import io.vertx.core.AsyncResult; -import io.vertx.core.Handler; -import io.vertx.mysqlclient.MySQLConnection; -import io.vertx.sqlclient.PreparedStatement; -import io.vertx.sqlclient.Row; -import io.vertx.sqlclient.RowSet; -import net.bytebuddy.asm.Advice; -import net.bytebuddy.implementation.bytecode.assign.Assigner; - -public class CursorReadAdvice { - @Advice.OnMethodEnter(suppress = Throwable.class) - public static AgentScope beforeRead( - @Advice.Argument(value = 1, readOnly = false) Handler>> handler, - @Advice.FieldValue(value = "ps", typing = Assigner.Typing.DYNAMIC) - final PreparedStatement ps) { - if (handler instanceof QueryResultHandlerWrapper) { - return null; - } - final AgentSpan parentSpan = activeSpan(); - final AgentScope.Continuation parentContinuation = - null == parentSpan ? null : captureSpan(parentSpan); - final AgentSpan clientSpan = - DECORATE.startAndDecorateSpanForStatement( - ps, InstrumentationContext.get(PreparedStatement.class, Pair.class), true); - if (null == clientSpan) { - return null; - } - handler = new QueryResultHandlerWrapper<>(handler, clientSpan, parentContinuation); - - return activateSpan(clientSpan, true); - } - - @Advice.OnMethodExit(onThrowable = Throwable.class, suppress = Throwable.class) - public static void afterRead( - @Advice.Thrown final Throwable throwable, @Advice.Enter final AgentScope clientScope) { - if (null != clientScope) { - clientScope.close(); - } - } - - // Limit ourselves to 4.x by checking for the ping() method that was added in 4.x - private static void muzzleCheck(MySQLConnection connection) { - connection.ping(); - } -} diff --git a/dd-java-agent/instrumentation/vertx-mysql-client-4.0/src/main/java/datadog/trace/instrumentation/vertx_sql_client_4/QueryAdvice.java b/dd-java-agent/instrumentation/vertx-mysql-client-4.0/src/main/java/datadog/trace/instrumentation/vertx_sql_client_4/QueryAdvice.java deleted file mode 100644 index 3ee9ba79e59..00000000000 --- a/dd-java-agent/instrumentation/vertx-mysql-client-4.0/src/main/java/datadog/trace/instrumentation/vertx_sql_client_4/QueryAdvice.java +++ /dev/null @@ -1,82 +0,0 @@ -package datadog.trace.instrumentation.vertx_sql_client_4; - -import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.activateSpan; -import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.activeSpan; -import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.captureSpan; -import static datadog.trace.instrumentation.vertx_sql_client_4.VertxSqlClientDecorator.DECORATE; - -import datadog.trace.api.Pair; -import datadog.trace.bootstrap.ContextStore; -import datadog.trace.bootstrap.InstrumentationContext; -import datadog.trace.bootstrap.instrumentation.api.AgentScope; -import datadog.trace.bootstrap.instrumentation.api.AgentSpan; -import io.vertx.core.AsyncResult; -import io.vertx.core.Handler; -import io.vertx.mysqlclient.MySQLConnection; -import io.vertx.sqlclient.Query; -import io.vertx.sqlclient.SqlResult; -import net.bytebuddy.asm.Advice; -import net.bytebuddy.implementation.bytecode.assign.Assigner; - -public class QueryAdvice { - public static class Copy { - @Advice.OnMethodExit(suppress = Throwable.class) - public static void afterCopy( - @Advice.This final Query zis, @Advice.Return final Query ret) { - ContextStore contextStore = InstrumentationContext.get(Query.class, Pair.class); - contextStore.put(ret, contextStore.get(zis)); - } - - // Limit ourselves to 4.x by checking for the ping() method that was added in 4.x - private static void muzzleCheck(MySQLConnection connection) { - connection.ping(); - } - } - - public static class Execute { - @Advice.OnMethodEnter(suppress = Throwable.class) - public static > AgentScope beforeExecute( - @Advice.This final Query zis, - @Advice.Argument( - value = 0, - readOnly = false, - optional = true, - typing = Assigner.Typing.DYNAMIC) - Object maybeHandler, - @Advice.Argument(value = 1, readOnly = false, optional = true) - Handler> handler) { - final boolean prepared = !(maybeHandler instanceof Handler); - - final AgentSpan parentSpan = activeSpan(); - final AgentScope.Continuation parentContinuation = - null == parentSpan ? null : captureSpan(parentSpan); - final AgentSpan clientSpan = - DECORATE.startAndDecorateSpanForStatement( - zis, InstrumentationContext.get(Query.class, Pair.class), prepared); - if (null == clientSpan) { - return null; - } - if (prepared) { - handler = new QueryResultHandlerWrapper<>(handler, clientSpan, parentContinuation); - } else { - maybeHandler = - new QueryResultHandlerWrapper<>( - (Handler>) maybeHandler, clientSpan, parentContinuation); - } - return activateSpan(clientSpan); - } - - @Advice.OnMethodExit(onThrowable = Throwable.class, suppress = Throwable.class) - public static void afterExecute( - @Advice.Thrown final Throwable throwable, @Advice.Enter final AgentScope clientScope) { - if (null != clientScope) { - clientScope.close(); - } - } - - // Limit ourselves to 4.x by checking for the ping() method that was added in 4.x - private static void muzzleCheck(MySQLConnection connection) { - connection.ping(); - } - } -} diff --git a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/CursorImplInstrumentation.java b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/CursorImplInstrumentation.java deleted file mode 100644 index 4aec9a6ce79..00000000000 --- a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/CursorImplInstrumentation.java +++ /dev/null @@ -1,45 +0,0 @@ -package datadog.trace.instrumentation.vertx_pg_client_4_2_0; - -import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; -import static java.util.Collections.singletonMap; -import static net.bytebuddy.matcher.ElementMatchers.*; - -import com.google.auto.service.AutoService; -import datadog.trace.agent.tooling.Instrumenter; -import datadog.trace.agent.tooling.InstrumenterModule; -import java.util.Map; - -@AutoService(InstrumenterModule.class) -public class CursorImplInstrumentation extends InstrumenterModule.Tracing - implements Instrumenter.ForSingleType, Instrumenter.HasMethodAdvice { - public CursorImplInstrumentation() { - super("vertx", "vertx-sql-client"); - } - - @Override - public Map contextStore() { - return singletonMap("io.vertx.sqlclient.PreparedStatement", "datadog.trace.api.Pair"); - } - - @Override - public String[] helperClassNames() { - return new String[] { - packageName + ".QueryResultHandlerWrapper", packageName + ".VertxSqlClientDecorator", - }; - } - - @Override - public String instrumentedType() { - return "io.vertx.sqlclient.impl.CursorImpl"; - } - - @Override - public void methodAdvice(MethodTransformer transformer) { - transformer.applyAdvice( - isMethod() - .and(isPublic()) - .and(named("read")) - .and(takesArgument(1, named("io.vertx.core.Handler"))), - packageName + ".CursorReadAdvice"); - } -} diff --git a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PrepareHandlerWrapper.java b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PrepareHandlerWrapper.java deleted file mode 100644 index fcedcde16c7..00000000000 --- a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PrepareHandlerWrapper.java +++ /dev/null @@ -1,32 +0,0 @@ -package datadog.trace.instrumentation.vertx_pg_client_4_2_0; - -import datadog.trace.api.Pair; -import datadog.trace.bootstrap.ContextStore; -import datadog.trace.bootstrap.instrumentation.jdbc.DBInfo; -import datadog.trace.bootstrap.instrumentation.jdbc.DBQueryInfo; -import io.vertx.core.AsyncResult; -import io.vertx.core.Handler; -import io.vertx.sqlclient.PreparedStatement; - -public class PrepareHandlerWrapper implements Handler> { - private final Handler> handler; - private final ContextStore contextStore; - private final Pair queryInfo; - - public PrepareHandlerWrapper( - Handler> handler, - ContextStore contextStore, - Pair queryInfo) { - this.handler = handler; - this.contextStore = contextStore; - this.queryInfo = queryInfo; - } - - @Override - public void handle(AsyncResult event) { - if (event.succeeded()) { - contextStore.put(event.result(), queryInfo); - } - handler.handle(event); - } -} diff --git a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PreparedQueryInstrumentation.java b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PreparedQueryInstrumentation.java deleted file mode 100644 index 505186c7def..00000000000 --- a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/PreparedQueryInstrumentation.java +++ /dev/null @@ -1,67 +0,0 @@ -package datadog.trace.instrumentation.vertx_pg_client_4_2_0; - -import static datadog.trace.agent.tooling.bytebuddy.matcher.HierarchyMatchers.implementsInterface; -import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; -import static java.util.Collections.singletonMap; -import static net.bytebuddy.matcher.ElementMatchers.*; - -import com.google.auto.service.AutoService; -import datadog.trace.agent.tooling.Instrumenter; -import datadog.trace.agent.tooling.InstrumenterModule; -import java.util.Map; -import net.bytebuddy.description.type.TypeDescription; -import net.bytebuddy.matcher.ElementMatcher; - -@AutoService(InstrumenterModule.class) -public class PreparedQueryInstrumentation extends InstrumenterModule.Tracing - implements Instrumenter.ForTypeHierarchy, Instrumenter.HasMethodAdvice { - public PreparedQueryInstrumentation() { - super("vertx", "vertx-sql-client"); - } - - @Override - public Map contextStore() { - return singletonMap("io.vertx.sqlclient.Query", "datadog.trace.api.Pair"); - } - - @Override - public String[] helperClassNames() { - return new String[] { - packageName + ".QueryResultHandlerWrapper", packageName + ".VertxSqlClientDecorator", - }; - } - - @Override - public String hierarchyMarkerType() { - return "io.vertx.sqlclient.PreparedQuery"; - } - - @Override - public ElementMatcher hierarchyMatcher() { - return implementsInterface(named(hierarchyMarkerType())); - } - - @Override - public void methodAdvice(MethodTransformer transformer) { - transformer.applyAdvice( - isMethod() - .and(isPublic()) - .and(named("execute")) - .and(takesArguments(2)) - .and(takesArgument(1, named("io.vertx.core.Handler"))), - packageName + ".QueryAdvice$Execute"); - transformer.applyAdvice( - isMethod() - .and(isPublic()) - .and(named("executeBatch")) - .and(takesArguments(2)) - .and(takesArgument(1, named("io.vertx.core.Handler"))), - packageName + ".QueryAdvice$Execute"); - transformer.applyAdvice( - isMethod() - .and(isVirtual()) - .and(named("copy")) - .and(returns(named("io.vertx.sqlclient.impl.QueryBase"))), - packageName + ".QueryAdvice$Copy"); - } -} diff --git a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/QueryImplInstrumentation.java b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/QueryImplInstrumentation.java deleted file mode 100644 index cfa5395e9ba..00000000000 --- a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/QueryImplInstrumentation.java +++ /dev/null @@ -1,52 +0,0 @@ -package datadog.trace.instrumentation.vertx_pg_client_4_2_0; - -import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; -import static java.util.Collections.singletonMap; -import static net.bytebuddy.matcher.ElementMatchers.*; - -import com.google.auto.service.AutoService; -import datadog.trace.agent.tooling.Instrumenter; -import datadog.trace.agent.tooling.InstrumenterModule; -import java.util.Map; - -@AutoService(InstrumenterModule.class) -public class QueryImplInstrumentation extends InstrumenterModule.Tracing - implements Instrumenter.ForSingleType, Instrumenter.HasMethodAdvice { - public QueryImplInstrumentation() { - super("vertx", "vertx-sql-client"); - } - - @Override - public Map contextStore() { - return singletonMap("io.vertx.sqlclient.Query", "datadog.trace.api.Pair"); - } - - @Override - public String[] helperClassNames() { - return new String[] { - packageName + ".QueryResultHandlerWrapper", packageName + ".VertxSqlClientDecorator", - }; - } - - @Override - public String instrumentedType() { - return "io.vertx.sqlclient.impl.SqlClientBase$QueryImpl"; - } - - @Override - public void methodAdvice(MethodTransformer transformer) { - transformer.applyAdvice( - isMethod() - .and(isPublic()) - .and(named("execute")) - .and(takesArguments(1)) - .and(takesArgument(0, named("io.vertx.core.Handler"))), - packageName + ".QueryAdvice$Execute"); - transformer.applyAdvice( - isMethod() - .and(isVirtual()) - .and(named("copy")) - .and(returns(named("io.vertx.sqlclient.impl.QueryBase"))), - packageName + ".QueryAdvice$Copy"); - } -} diff --git a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/QueryResultHandlerWrapper.java b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/QueryResultHandlerWrapper.java deleted file mode 100644 index 537ab6f42fc..00000000000 --- a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/QueryResultHandlerWrapper.java +++ /dev/null @@ -1,41 +0,0 @@ -package datadog.trace.instrumentation.vertx_pg_client_4_2_0; - -import datadog.trace.bootstrap.instrumentation.api.AgentScope; -import datadog.trace.bootstrap.instrumentation.api.AgentSpan; -import io.vertx.core.AsyncResult; -import io.vertx.core.Handler; -import io.vertx.sqlclient.SqlResult; - -public class QueryResultHandlerWrapper> - implements Handler> { - private final Handler> handler; - private final AgentSpan clientSpan; - private final AgentScope.Continuation parentContinuation; - - public QueryResultHandlerWrapper( - final Handler> handler, - final AgentSpan clientSpan, - final AgentScope.Continuation parentContinuation) { - this.handler = handler; - this.clientSpan = clientSpan; - this.parentContinuation = parentContinuation; - } - - @Override - public void handle(final AsyncResult event) { - AgentScope scope = null; - try { - if (null != clientSpan) { - clientSpan.finish(); - } - if (null != parentContinuation) { - scope = parentContinuation.activate(); - } - handler.handle(event); - } finally { - if (null != scope) { - scope.close(); - } - } - } -} diff --git a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/SqlClientBaseAdvice.java b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/SqlClientBaseAdvice.java deleted file mode 100644 index 6051e6aa3c0..00000000000 --- a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/SqlClientBaseAdvice.java +++ /dev/null @@ -1,40 +0,0 @@ -package datadog.trace.instrumentation.vertx_pg_client_4_2_0; - -import datadog.trace.api.Pair; -import datadog.trace.bootstrap.InstrumentationContext; -import datadog.trace.bootstrap.instrumentation.jdbc.DBInfo; -import datadog.trace.bootstrap.instrumentation.jdbc.DBQueryInfo; -import io.vertx.sqlclient.Query; -import io.vertx.sqlclient.SqlClient; -import net.bytebuddy.asm.Advice; - -public class SqlClientBaseAdvice { - public static class NormalQuery { - @Advice.OnMethodExit(suppress = Throwable.class) - public static void afterQuery( - @Advice.This final SqlClient zis, - @Advice.Argument(0) final String sql, - @Advice.Return final Query query) { - - Pair info = - Pair.of( - InstrumentationContext.get(SqlClient.class, DBInfo.class).get(zis), - DBQueryInfo.ofStatement(sql)); - InstrumentationContext.get(Query.class, Pair.class).put(query, info); - } - } - - public static class PreparedQuery { - @Advice.OnMethodExit(suppress = Throwable.class) - public static void afterPreparedQuery( - @Advice.This final SqlClient zis, - @Advice.Argument(0) final String sql, - @Advice.Return final Query query) { - Pair info = - Pair.of( - InstrumentationContext.get(SqlClient.class, DBInfo.class).get(zis), - DBQueryInfo.ofPreparedStatement(sql)); - InstrumentationContext.get(Query.class, Pair.class).put(query, info); - } - } -} diff --git a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/SqlClientBaseInstrumentation.java b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/SqlClientBaseInstrumentation.java deleted file mode 100644 index 1ba011ee9ae..00000000000 --- a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/SqlClientBaseInstrumentation.java +++ /dev/null @@ -1,50 +0,0 @@ -package datadog.trace.instrumentation.vertx_pg_client_4_2_0; - -import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; -import static net.bytebuddy.matcher.ElementMatchers.*; - -import com.google.auto.service.AutoService; -import datadog.trace.agent.tooling.Instrumenter; -import datadog.trace.agent.tooling.InstrumenterModule; -import datadog.trace.bootstrap.instrumentation.jdbc.DBInfo; -import java.util.HashMap; -import java.util.Map; - -@AutoService(InstrumenterModule.class) -public class SqlClientBaseInstrumentation extends InstrumenterModule.Tracing - implements Instrumenter.ForSingleType, Instrumenter.HasMethodAdvice { - public SqlClientBaseInstrumentation() { - super("vertx", "vertx-sql-client"); - } - - @Override - public Map contextStore() { - Map contextStores = new HashMap<>(); - contextStores.put("io.vertx.sqlclient.SqlClient", DBInfo.class.getName()); - contextStores.put("io.vertx.sqlclient.Query", "datadog.trace.api.Pair"); - return contextStores; - } - - @Override - public String instrumentedType() { - return "io.vertx.sqlclient.impl.SqlClientBase"; - } - - @Override - public void methodAdvice(MethodTransformer transformer) { - transformer.applyAdvice( - isMethod() - .and(isPublic()) - .and(named("query")) - .and(takesArguments(1)) - .and(takesArgument(0, named("java.lang.String"))), - packageName + ".SqlClientBaseAdvice$NormalQuery"); - transformer.applyAdvice( - isMethod() - .and(isPublic()) - .and(named("preparedQuery")) - .and(takesArguments(1)) - .and(takesArgument(0, named("java.lang.String"))), - packageName + ".SqlClientBaseAdvice$PreparedQuery"); - } -} diff --git a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/SqlConnectionBaseInstrumentation.java b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/SqlConnectionBaseInstrumentation.java deleted file mode 100644 index b2031c5105d..00000000000 --- a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/SqlConnectionBaseInstrumentation.java +++ /dev/null @@ -1,49 +0,0 @@ -package datadog.trace.instrumentation.vertx_pg_client_4_2_0; - -import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; -import static net.bytebuddy.matcher.ElementMatchers.*; - -import com.google.auto.service.AutoService; -import datadog.trace.agent.tooling.Instrumenter; -import datadog.trace.agent.tooling.InstrumenterModule; -import datadog.trace.bootstrap.instrumentation.jdbc.DBInfo; -import java.util.HashMap; -import java.util.Map; - -@AutoService(InstrumenterModule.class) -public class SqlConnectionBaseInstrumentation extends InstrumenterModule.Tracing - implements Instrumenter.ForSingleType, Instrumenter.HasMethodAdvice { - public SqlConnectionBaseInstrumentation() { - super("vertx", "vertx-sql-client"); - } - - @Override - public Map contextStore() { - Map contextStores = new HashMap<>(); - contextStores.put("io.vertx.sqlclient.SqlClient", DBInfo.class.getName()); - contextStores.put("io.vertx.sqlclient.PreparedStatement", "datadog.trace.api.Pair"); - return contextStores; - } - - @Override - public String[] helperClassNames() { - return new String[] {packageName + ".PrepareHandlerWrapper"}; - } - - @Override - public String instrumentedType() { - return "io.vertx.sqlclient.impl.SqlConnectionBase"; - } - - @Override - public void methodAdvice(MethodTransformer transformer) { - transformer.applyAdvice( - isMethod() - .and(isPublic()) - .and(named("prepare")) - .and(takesArguments(2)) - .and(takesArgument(0, named("java.lang.String"))) - .and(takesArgument(1, named("io.vertx.core.Handler"))), - packageName + ".SqlConnectionBasePrepareAdvice"); - } -} diff --git a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/SqlConnectionBasePrepareAdvice.java b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/SqlConnectionBasePrepareAdvice.java deleted file mode 100644 index 5cdf845c226..00000000000 --- a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/SqlConnectionBasePrepareAdvice.java +++ /dev/null @@ -1,29 +0,0 @@ -package datadog.trace.instrumentation.vertx_pg_client_4_2_0; - -import datadog.trace.api.Pair; -import datadog.trace.bootstrap.InstrumentationContext; -import datadog.trace.bootstrap.instrumentation.jdbc.DBInfo; -import datadog.trace.bootstrap.instrumentation.jdbc.DBQueryInfo; -import io.vertx.core.AsyncResult; -import io.vertx.core.Handler; -import io.vertx.sqlclient.PreparedStatement; -import io.vertx.sqlclient.SqlClient; -import net.bytebuddy.asm.Advice; - -public class SqlConnectionBasePrepareAdvice { - @Advice.OnMethodEnter(suppress = Throwable.class) - public static void beforePrepare( - @Advice.This final SqlClient zis, - @Advice.Argument(0) final String sql, - @Advice.Argument(value = 1, readOnly = false) - Handler> handler) { - Pair info = - Pair.of( - InstrumentationContext.get(SqlClient.class, DBInfo.class).get(zis), - DBQueryInfo.ofStatement(sql)); - - handler = - new PrepareHandlerWrapper( - handler, InstrumentationContext.get(PreparedStatement.class, Pair.class), info); - } -} diff --git a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/VertxSqlClientDecorator.java b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/VertxSqlClientDecorator.java deleted file mode 100644 index 785a431b18e..00000000000 --- a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/VertxSqlClientDecorator.java +++ /dev/null @@ -1,114 +0,0 @@ -package datadog.trace.instrumentation.vertx_pg_client_4_2_0; - -import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.startSpan; -import static datadog.trace.bootstrap.instrumentation.api.Tags.DB_OPERATION; - -import datadog.trace.api.Pair; -import datadog.trace.api.naming.SpanNaming; -import datadog.trace.bootstrap.ContextStore; -import datadog.trace.bootstrap.instrumentation.api.AgentSpan; -import datadog.trace.bootstrap.instrumentation.api.InternalSpanTypes; -import datadog.trace.bootstrap.instrumentation.api.Tags; -import datadog.trace.bootstrap.instrumentation.api.UTF8BytesString; -import datadog.trace.bootstrap.instrumentation.decorator.DatabaseClientDecorator; -import datadog.trace.bootstrap.instrumentation.jdbc.DBInfo; -import datadog.trace.bootstrap.instrumentation.jdbc.DBQueryInfo; - -public class VertxSqlClientDecorator extends DatabaseClientDecorator { - - public static final VertxSqlClientDecorator DECORATE = new VertxSqlClientDecorator(); - - private static final CharSequence VERTX_SQL = UTF8BytesString.create("vertx-sql"); - private static final CharSequence DATABASE_QUERY = UTF8BytesString.create("handler"); - private static final UTF8BytesString DB_QUERY = UTF8BytesString.create("DB Query"); - private static final UTF8BytesString VERTX_STATEMENT = - UTF8BytesString.create("vertx-sql-statement"); - private static final UTF8BytesString VERTX_PREPARED_STATEMENT = - UTF8BytesString.create("vertx-sql-prepared_statement"); - private static final String DEFAULT_SERVICE_NAME = - SpanNaming.instance().namingSchema().database().service("postgresql"); - - @Override - protected String[] instrumentationNames() { - return new String[] {"vertx", "vertx-sql-client"}; - } - - @Override - protected String service() { - return DEFAULT_SERVICE_NAME; // Overridden by onConnection - } - - @Override - protected CharSequence component() { - return VERTX_SQL; // Overridden by onStatement and onPreparedStatement - } - - @Override - protected CharSequence spanType() { - return InternalSpanTypes.SQL; - } - - @Override - protected String dbType() { - return "vertx-sql"; - } - - @Override - protected String dbUser(final DBInfo info) { - return info.getUser(); - } - - @Override - protected String dbInstance(final DBInfo info) { - if (info.getInstance() != null) { - return info.getInstance(); - } else { - return info.getDb(); - } - } - - @Override - protected String dbHostname(final DBInfo info) { - return info.getHost(); - } - - public AgentSpan startAndDecorateSpanForStatement( - T query, ContextStore contextStore, boolean prepared) { - CharSequence component = prepared ? VERTX_PREPARED_STATEMENT : VERTX_STATEMENT; - AgentSpan span = startSpan(DATABASE_QUERY); - if (null == span) { - return null; - } - afterStart(span); - - DBInfo dbInfo = null; - DBQueryInfo dbQueryInfo = null; - Pair queryInfo = contextStore.get(query); - if (queryInfo != null) { - dbInfo = queryInfo.getLeft(); - dbQueryInfo = queryInfo.getRight(); - } - - if (dbInfo != null) { - processDatabaseType(span, dbInfo.getType()); - } - super.onConnection(span, dbInfo); - if (null != dbQueryInfo) { - span.setResourceName(dbQueryInfo.getSql()); - span.setTag(DB_OPERATION, dbQueryInfo.getOperation()); - } else { - span.setResourceName(DB_QUERY); - } - span.setTag(Tags.COMPONENT, component); - - return span; - } - - @Override - protected void postProcessServiceAndOperationName(AgentSpan span, NamingEntry namingEntry) { - if (namingEntry.getService() != null) { - span.setServiceName(namingEntry.getService()); - } - span.setOperationName(namingEntry.getOperation()); - } -} diff --git a/dd-java-agent/instrumentation/vertx-sql-common/build.gradle b/dd-java-agent/instrumentation/vertx-sql-common/build.gradle new file mode 100644 index 00000000000..ec8c516a81f --- /dev/null +++ b/dd-java-agent/instrumentation/vertx-sql-common/build.gradle @@ -0,0 +1,36 @@ + +apply from: "$rootDir/gradle/java.gradle" + +muzzle { + pass { + group = 'io.vertx' + module = 'vertx-mysql-client' + versions = '[4.0.0,5.0.0)' + assertInverse = true + } +} + +addTestSuiteForDir('latestDepTest', 'test') +addTestSuiteExtendingForDir('latestDepForkedTest', 'latestDepTest', 'test') + +apply from: "$rootDir/gradle/configure_tests.gradle" + +latestDepTest { + finalizedBy 'latestDepForkedTest' +} + +dependencies { + compileOnly group: 'io.vertx', name: 'vertx-mysql-client', version: '4.0.0' + + testImplementation group: 'io.vertx', name: 'vertx-mysql-client', version: '4.0.0' + + // This is needed for the test container to start + testImplementation group: 'mysql', name: 'mysql-connector-java', version: '8.0.23' + testImplementation group: 'org.testcontainers', name: 'mysql', version: libs.versions.testcontainers.get() + + latestDepTestImplementation group: 'io.vertx', name: 'vertx-mysql-client', version: '4.0.+' +} + +tasks.withType(Test).configureEach { + usesService(testcontainersLimit) +} diff --git a/dd-java-agent/instrumentation/vertx-mysql-client-4.0/src/main/java/datadog/trace/instrumentation/vertx_sql_client_4/CursorImplInstrumentation.java b/dd-java-agent/instrumentation/vertx-sql-common/src/main/java/datadog/trace/instrumentation/vertx_sql_common/CursorImplInstrumentation.java similarity index 96% rename from dd-java-agent/instrumentation/vertx-mysql-client-4.0/src/main/java/datadog/trace/instrumentation/vertx_sql_client_4/CursorImplInstrumentation.java rename to dd-java-agent/instrumentation/vertx-sql-common/src/main/java/datadog/trace/instrumentation/vertx_sql_common/CursorImplInstrumentation.java index 9348c80989b..8e23301bbd5 100644 --- a/dd-java-agent/instrumentation/vertx-mysql-client-4.0/src/main/java/datadog/trace/instrumentation/vertx_sql_client_4/CursorImplInstrumentation.java +++ b/dd-java-agent/instrumentation/vertx-sql-common/src/main/java/datadog/trace/instrumentation/vertx_sql_common/CursorImplInstrumentation.java @@ -1,4 +1,4 @@ -package datadog.trace.instrumentation.vertx_sql_client_4; +package datadog.trace.instrumentation.vertx_sql_common; import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; import static java.util.Collections.singletonMap; diff --git a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/CursorReadAdvice.java b/dd-java-agent/instrumentation/vertx-sql-common/src/main/java/datadog/trace/instrumentation/vertx_sql_common/CursorReadAdvice.java similarity index 84% rename from dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/CursorReadAdvice.java rename to dd-java-agent/instrumentation/vertx-sql-common/src/main/java/datadog/trace/instrumentation/vertx_sql_common/CursorReadAdvice.java index 8dac2262b74..c08613fb2e0 100644 --- a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/CursorReadAdvice.java +++ b/dd-java-agent/instrumentation/vertx-sql-common/src/main/java/datadog/trace/instrumentation/vertx_sql_common/CursorReadAdvice.java @@ -1,7 +1,9 @@ -package datadog.trace.instrumentation.vertx_pg_client_4_2_0; +package datadog.trace.instrumentation.vertx_sql_common; -import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.*; -import static datadog.trace.instrumentation.vertx_pg_client_4_2_0.VertxSqlClientDecorator.DECORATE; +import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.activateSpan; +import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.activeSpan; +import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.captureSpan; +import static datadog.trace.instrumentation.vertx_sql_common.VertxSqlClientDecorator.DECORATE; import datadog.trace.api.Pair; import datadog.trace.bootstrap.InstrumentationContext; diff --git a/dd-java-agent/instrumentation/vertx-mysql-client-4.0/src/main/java/datadog/trace/instrumentation/vertx_sql_client_4/PrepareHandlerWrapper.java b/dd-java-agent/instrumentation/vertx-sql-common/src/main/java/datadog/trace/instrumentation/vertx_sql_common/PrepareHandlerWrapper.java similarity index 94% rename from dd-java-agent/instrumentation/vertx-mysql-client-4.0/src/main/java/datadog/trace/instrumentation/vertx_sql_client_4/PrepareHandlerWrapper.java rename to dd-java-agent/instrumentation/vertx-sql-common/src/main/java/datadog/trace/instrumentation/vertx_sql_common/PrepareHandlerWrapper.java index 202db4fcc66..55b04ab3ed7 100644 --- a/dd-java-agent/instrumentation/vertx-mysql-client-4.0/src/main/java/datadog/trace/instrumentation/vertx_sql_client_4/PrepareHandlerWrapper.java +++ b/dd-java-agent/instrumentation/vertx-sql-common/src/main/java/datadog/trace/instrumentation/vertx_sql_common/PrepareHandlerWrapper.java @@ -1,4 +1,4 @@ -package datadog.trace.instrumentation.vertx_sql_client_4; +package datadog.trace.instrumentation.vertx_sql_common; import datadog.trace.api.Pair; import datadog.trace.bootstrap.ContextStore; diff --git a/dd-java-agent/instrumentation/vertx-mysql-client-4.0/src/main/java/datadog/trace/instrumentation/vertx_sql_client_4/PreparedQueryInstrumentation.java b/dd-java-agent/instrumentation/vertx-sql-common/src/main/java/datadog/trace/instrumentation/vertx_sql_common/PreparedQueryInstrumentation.java similarity index 97% rename from dd-java-agent/instrumentation/vertx-mysql-client-4.0/src/main/java/datadog/trace/instrumentation/vertx_sql_client_4/PreparedQueryInstrumentation.java rename to dd-java-agent/instrumentation/vertx-sql-common/src/main/java/datadog/trace/instrumentation/vertx_sql_common/PreparedQueryInstrumentation.java index b7843ccdf89..148f68936fa 100644 --- a/dd-java-agent/instrumentation/vertx-mysql-client-4.0/src/main/java/datadog/trace/instrumentation/vertx_sql_client_4/PreparedQueryInstrumentation.java +++ b/dd-java-agent/instrumentation/vertx-sql-common/src/main/java/datadog/trace/instrumentation/vertx_sql_common/PreparedQueryInstrumentation.java @@ -1,4 +1,4 @@ -package datadog.trace.instrumentation.vertx_sql_client_4; +package datadog.trace.instrumentation.vertx_sql_common; import static datadog.trace.agent.tooling.bytebuddy.matcher.HierarchyMatchers.implementsInterface; import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; diff --git a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/QueryAdvice.java b/dd-java-agent/instrumentation/vertx-sql-common/src/main/java/datadog/trace/instrumentation/vertx_sql_common/QueryAdvice.java similarity index 88% rename from dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/QueryAdvice.java rename to dd-java-agent/instrumentation/vertx-sql-common/src/main/java/datadog/trace/instrumentation/vertx_sql_common/QueryAdvice.java index db2e3444a52..d1acb91c408 100644 --- a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/src/main/java/datadog/trace/instrumentation/vertx_pg_client_4_2_0/QueryAdvice.java +++ b/dd-java-agent/instrumentation/vertx-sql-common/src/main/java/datadog/trace/instrumentation/vertx_sql_common/QueryAdvice.java @@ -1,7 +1,9 @@ -package datadog.trace.instrumentation.vertx_pg_client_4_2_0; +package datadog.trace.instrumentation.vertx_sql_common; -import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.*; -import static datadog.trace.instrumentation.vertx_pg_client_4_2_0.VertxSqlClientDecorator.DECORATE; +import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.activateSpan; +import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.activeSpan; +import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.captureSpan; +import static datadog.trace.instrumentation.vertx_sql_common.VertxSqlClientDecorator.DECORATE; import datadog.trace.api.Pair; import datadog.trace.bootstrap.ContextStore; diff --git a/dd-java-agent/instrumentation/vertx-mysql-client-4.0/src/main/java/datadog/trace/instrumentation/vertx_sql_client_4/QueryImplInstrumentation.java b/dd-java-agent/instrumentation/vertx-sql-common/src/main/java/datadog/trace/instrumentation/vertx_sql_common/QueryImplInstrumentation.java similarity index 97% rename from dd-java-agent/instrumentation/vertx-mysql-client-4.0/src/main/java/datadog/trace/instrumentation/vertx_sql_client_4/QueryImplInstrumentation.java rename to dd-java-agent/instrumentation/vertx-sql-common/src/main/java/datadog/trace/instrumentation/vertx_sql_common/QueryImplInstrumentation.java index b911e24d68d..796dfa53c89 100644 --- a/dd-java-agent/instrumentation/vertx-mysql-client-4.0/src/main/java/datadog/trace/instrumentation/vertx_sql_client_4/QueryImplInstrumentation.java +++ b/dd-java-agent/instrumentation/vertx-sql-common/src/main/java/datadog/trace/instrumentation/vertx_sql_common/QueryImplInstrumentation.java @@ -1,4 +1,4 @@ -package datadog.trace.instrumentation.vertx_sql_client_4; +package datadog.trace.instrumentation.vertx_sql_common; import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; import static java.util.Collections.singletonMap; diff --git a/dd-java-agent/instrumentation/vertx-mysql-client-4.0/src/main/java/datadog/trace/instrumentation/vertx_sql_client_4/QueryResultHandlerWrapper.java b/dd-java-agent/instrumentation/vertx-sql-common/src/main/java/datadog/trace/instrumentation/vertx_sql_common/QueryResultHandlerWrapper.java similarity index 95% rename from dd-java-agent/instrumentation/vertx-mysql-client-4.0/src/main/java/datadog/trace/instrumentation/vertx_sql_client_4/QueryResultHandlerWrapper.java rename to dd-java-agent/instrumentation/vertx-sql-common/src/main/java/datadog/trace/instrumentation/vertx_sql_common/QueryResultHandlerWrapper.java index e0d77a5a613..b187a1db75b 100644 --- a/dd-java-agent/instrumentation/vertx-mysql-client-4.0/src/main/java/datadog/trace/instrumentation/vertx_sql_client_4/QueryResultHandlerWrapper.java +++ b/dd-java-agent/instrumentation/vertx-sql-common/src/main/java/datadog/trace/instrumentation/vertx_sql_common/QueryResultHandlerWrapper.java @@ -1,4 +1,4 @@ -package datadog.trace.instrumentation.vertx_sql_client_4; +package datadog.trace.instrumentation.vertx_sql_common; import datadog.trace.bootstrap.instrumentation.api.AgentScope; import datadog.trace.bootstrap.instrumentation.api.AgentSpan; diff --git a/dd-java-agent/instrumentation/vertx-mysql-client-4.0/src/main/java/datadog/trace/instrumentation/vertx_sql_client_4/SqlClientBaseAdvice.java b/dd-java-agent/instrumentation/vertx-sql-common/src/main/java/datadog/trace/instrumentation/vertx_sql_common/SqlClientBaseAdvice.java similarity index 96% rename from dd-java-agent/instrumentation/vertx-mysql-client-4.0/src/main/java/datadog/trace/instrumentation/vertx_sql_client_4/SqlClientBaseAdvice.java rename to dd-java-agent/instrumentation/vertx-sql-common/src/main/java/datadog/trace/instrumentation/vertx_sql_common/SqlClientBaseAdvice.java index 354440516fa..bf715c26c52 100644 --- a/dd-java-agent/instrumentation/vertx-mysql-client-4.0/src/main/java/datadog/trace/instrumentation/vertx_sql_client_4/SqlClientBaseAdvice.java +++ b/dd-java-agent/instrumentation/vertx-sql-common/src/main/java/datadog/trace/instrumentation/vertx_sql_common/SqlClientBaseAdvice.java @@ -1,4 +1,4 @@ -package datadog.trace.instrumentation.vertx_sql_client_4; +package datadog.trace.instrumentation.vertx_sql_common; import datadog.trace.api.Pair; import datadog.trace.bootstrap.InstrumentationContext; diff --git a/dd-java-agent/instrumentation/vertx-mysql-client-4.0/src/main/java/datadog/trace/instrumentation/vertx_sql_client_4/SqlClientBaseInstrumentation.java b/dd-java-agent/instrumentation/vertx-sql-common/src/main/java/datadog/trace/instrumentation/vertx_sql_common/SqlClientBaseInstrumentation.java similarity index 97% rename from dd-java-agent/instrumentation/vertx-mysql-client-4.0/src/main/java/datadog/trace/instrumentation/vertx_sql_client_4/SqlClientBaseInstrumentation.java rename to dd-java-agent/instrumentation/vertx-sql-common/src/main/java/datadog/trace/instrumentation/vertx_sql_common/SqlClientBaseInstrumentation.java index 920a8bfe375..f3415958f99 100644 --- a/dd-java-agent/instrumentation/vertx-mysql-client-4.0/src/main/java/datadog/trace/instrumentation/vertx_sql_client_4/SqlClientBaseInstrumentation.java +++ b/dd-java-agent/instrumentation/vertx-sql-common/src/main/java/datadog/trace/instrumentation/vertx_sql_common/SqlClientBaseInstrumentation.java @@ -1,4 +1,4 @@ -package datadog.trace.instrumentation.vertx_sql_client_4; +package datadog.trace.instrumentation.vertx_sql_common; import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; import static net.bytebuddy.matcher.ElementMatchers.isMethod; diff --git a/dd-java-agent/instrumentation/vertx-mysql-client-4.0/src/main/java/datadog/trace/instrumentation/vertx_sql_client_4/SqlConnectionBaseInstrumentation.java b/dd-java-agent/instrumentation/vertx-sql-common/src/main/java/datadog/trace/instrumentation/vertx_sql_common/SqlConnectionBaseInstrumentation.java similarity index 96% rename from dd-java-agent/instrumentation/vertx-mysql-client-4.0/src/main/java/datadog/trace/instrumentation/vertx_sql_client_4/SqlConnectionBaseInstrumentation.java rename to dd-java-agent/instrumentation/vertx-sql-common/src/main/java/datadog/trace/instrumentation/vertx_sql_common/SqlConnectionBaseInstrumentation.java index 86b4f7a4bab..600acf86247 100644 --- a/dd-java-agent/instrumentation/vertx-mysql-client-4.0/src/main/java/datadog/trace/instrumentation/vertx_sql_client_4/SqlConnectionBaseInstrumentation.java +++ b/dd-java-agent/instrumentation/vertx-sql-common/src/main/java/datadog/trace/instrumentation/vertx_sql_common/SqlConnectionBaseInstrumentation.java @@ -1,4 +1,4 @@ -package datadog.trace.instrumentation.vertx_sql_client_4; +package datadog.trace.instrumentation.vertx_sql_common; import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; import static net.bytebuddy.matcher.ElementMatchers.isMethod; diff --git a/dd-java-agent/instrumentation/vertx-mysql-client-4.0/src/main/java/datadog/trace/instrumentation/vertx_sql_client_4/SqlConnectionBasePrepareAdvice.java b/dd-java-agent/instrumentation/vertx-sql-common/src/main/java/datadog/trace/instrumentation/vertx_sql_common/SqlConnectionBasePrepareAdvice.java similarity index 95% rename from dd-java-agent/instrumentation/vertx-mysql-client-4.0/src/main/java/datadog/trace/instrumentation/vertx_sql_client_4/SqlConnectionBasePrepareAdvice.java rename to dd-java-agent/instrumentation/vertx-sql-common/src/main/java/datadog/trace/instrumentation/vertx_sql_common/SqlConnectionBasePrepareAdvice.java index 736084d67a7..c41372f4c79 100644 --- a/dd-java-agent/instrumentation/vertx-mysql-client-4.0/src/main/java/datadog/trace/instrumentation/vertx_sql_client_4/SqlConnectionBasePrepareAdvice.java +++ b/dd-java-agent/instrumentation/vertx-sql-common/src/main/java/datadog/trace/instrumentation/vertx_sql_common/SqlConnectionBasePrepareAdvice.java @@ -1,4 +1,4 @@ -package datadog.trace.instrumentation.vertx_sql_client_4; +package datadog.trace.instrumentation.vertx_sql_common; import datadog.trace.api.Pair; import datadog.trace.bootstrap.InstrumentationContext; diff --git a/dd-java-agent/instrumentation/vertx-mysql-client-4.0/src/main/java/datadog/trace/instrumentation/vertx_sql_client_4/VertxSqlClientDecorator.java b/dd-java-agent/instrumentation/vertx-sql-common/src/main/java/datadog/trace/instrumentation/vertx_sql_common/VertxSqlClientDecorator.java similarity index 98% rename from dd-java-agent/instrumentation/vertx-mysql-client-4.0/src/main/java/datadog/trace/instrumentation/vertx_sql_client_4/VertxSqlClientDecorator.java rename to dd-java-agent/instrumentation/vertx-sql-common/src/main/java/datadog/trace/instrumentation/vertx_sql_common/VertxSqlClientDecorator.java index a1b19c81169..eca8852fd4b 100644 --- a/dd-java-agent/instrumentation/vertx-mysql-client-4.0/src/main/java/datadog/trace/instrumentation/vertx_sql_client_4/VertxSqlClientDecorator.java +++ b/dd-java-agent/instrumentation/vertx-sql-common/src/main/java/datadog/trace/instrumentation/vertx_sql_common/VertxSqlClientDecorator.java @@ -1,4 +1,4 @@ -package datadog.trace.instrumentation.vertx_sql_client_4; +package datadog.trace.instrumentation.vertx_sql_common; import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.startSpan; import static datadog.trace.bootstrap.instrumentation.api.Tags.DB_OPERATION; diff --git a/settings.gradle b/settings.gradle index 4db45c5a4f2..0dd4017dadf 100644 --- a/settings.gradle +++ b/settings.gradle @@ -505,6 +505,7 @@ include ':dd-java-agent:instrumentation:vertx-pg-client-4.2.0' include ':dd-java-agent:instrumentation:vertx-redis-client-3.9' include ':dd-java-agent:instrumentation:vertx-redis-client-3.9:stubs' include ':dd-java-agent:instrumentation:vertx-rx-3.5' +include ':dd-java-agent:instrumentation:vertx-sql-common' include ':dd-java-agent:instrumentation:vertx-web-3.4' include ':dd-java-agent:instrumentation:vertx-web-3.5' include ':dd-java-agent:instrumentation:vertx-web-3.9' From 3b7474ccc223fb38cbaa0e6ea6e835626719d238 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rapha=C3=ABl=20Vandon?= Date: Fri, 28 Feb 2025 11:50:59 +0100 Subject: [PATCH 6/8] clean gradle file and remove muzzle hacks --- .../vertx-sql-common/build.gradle | 33 +------------------ .../vertx_sql_common/SqlClientBaseAdvice.java | 11 ------- .../SqlConnectionBasePrepareAdvice.java | 6 ---- 3 files changed, 1 insertion(+), 49 deletions(-) diff --git a/dd-java-agent/instrumentation/vertx-sql-common/build.gradle b/dd-java-agent/instrumentation/vertx-sql-common/build.gradle index ec8c516a81f..7512f33426b 100644 --- a/dd-java-agent/instrumentation/vertx-sql-common/build.gradle +++ b/dd-java-agent/instrumentation/vertx-sql-common/build.gradle @@ -1,36 +1,5 @@ - apply from: "$rootDir/gradle/java.gradle" -muzzle { - pass { - group = 'io.vertx' - module = 'vertx-mysql-client' - versions = '[4.0.0,5.0.0)' - assertInverse = true - } -} - -addTestSuiteForDir('latestDepTest', 'test') -addTestSuiteExtendingForDir('latestDepForkedTest', 'latestDepTest', 'test') - -apply from: "$rootDir/gradle/configure_tests.gradle" - -latestDepTest { - finalizedBy 'latestDepForkedTest' -} - dependencies { - compileOnly group: 'io.vertx', name: 'vertx-mysql-client', version: '4.0.0' - - testImplementation group: 'io.vertx', name: 'vertx-mysql-client', version: '4.0.0' - - // This is needed for the test container to start - testImplementation group: 'mysql', name: 'mysql-connector-java', version: '8.0.23' - testImplementation group: 'org.testcontainers', name: 'mysql', version: libs.versions.testcontainers.get() - - latestDepTestImplementation group: 'io.vertx', name: 'vertx-mysql-client', version: '4.0.+' -} - -tasks.withType(Test).configureEach { - usesService(testcontainersLimit) + compileOnly group: 'io.vertx', name: 'vertx-sql-client', version: '4.0.0' } diff --git a/dd-java-agent/instrumentation/vertx-sql-common/src/main/java/datadog/trace/instrumentation/vertx_sql_common/SqlClientBaseAdvice.java b/dd-java-agent/instrumentation/vertx-sql-common/src/main/java/datadog/trace/instrumentation/vertx_sql_common/SqlClientBaseAdvice.java index bf715c26c52..bffaf0f1b14 100644 --- a/dd-java-agent/instrumentation/vertx-sql-common/src/main/java/datadog/trace/instrumentation/vertx_sql_common/SqlClientBaseAdvice.java +++ b/dd-java-agent/instrumentation/vertx-sql-common/src/main/java/datadog/trace/instrumentation/vertx_sql_common/SqlClientBaseAdvice.java @@ -4,7 +4,6 @@ import datadog.trace.bootstrap.InstrumentationContext; import datadog.trace.bootstrap.instrumentation.jdbc.DBInfo; import datadog.trace.bootstrap.instrumentation.jdbc.DBQueryInfo; -import io.vertx.mysqlclient.MySQLConnection; import io.vertx.sqlclient.Query; import io.vertx.sqlclient.SqlClient; import net.bytebuddy.asm.Advice; @@ -23,11 +22,6 @@ public static void afterQuery( DBQueryInfo.ofStatement(sql)); InstrumentationContext.get(Query.class, Pair.class).put(query, info); } - - // Limit ourselves to 4.x by checking for the ping() method that was added in 4.x - private static void muzzleCheck(MySQLConnection connection) { - connection.ping(); - } } public static class PreparedQuery { @@ -42,10 +36,5 @@ public static void afterPreparedQuery( DBQueryInfo.ofPreparedStatement(sql)); InstrumentationContext.get(Query.class, Pair.class).put(query, info); } - - // Limit ourselves to 4.x by checking for the ping() method that was added in 4.x - private static void muzzleCheck(MySQLConnection connection) { - connection.ping(); - } } } diff --git a/dd-java-agent/instrumentation/vertx-sql-common/src/main/java/datadog/trace/instrumentation/vertx_sql_common/SqlConnectionBasePrepareAdvice.java b/dd-java-agent/instrumentation/vertx-sql-common/src/main/java/datadog/trace/instrumentation/vertx_sql_common/SqlConnectionBasePrepareAdvice.java index c41372f4c79..176d8016fca 100644 --- a/dd-java-agent/instrumentation/vertx-sql-common/src/main/java/datadog/trace/instrumentation/vertx_sql_common/SqlConnectionBasePrepareAdvice.java +++ b/dd-java-agent/instrumentation/vertx-sql-common/src/main/java/datadog/trace/instrumentation/vertx_sql_common/SqlConnectionBasePrepareAdvice.java @@ -6,7 +6,6 @@ import datadog.trace.bootstrap.instrumentation.jdbc.DBQueryInfo; import io.vertx.core.AsyncResult; import io.vertx.core.Handler; -import io.vertx.mysqlclient.MySQLConnection; import io.vertx.sqlclient.PreparedStatement; import io.vertx.sqlclient.SqlClient; import net.bytebuddy.asm.Advice; @@ -27,9 +26,4 @@ public static void beforePrepare( new PrepareHandlerWrapper( handler, InstrumentationContext.get(PreparedStatement.class, Pair.class), info); } - - // Limit ourselves to 4.x by checking for the ping() method that was added in 4.x - private static void muzzleCheck(MySQLConnection connection) { - connection.ping(); - } } From c6e281c6836c372eb37212a5674c852c998ca05d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rapha=C3=ABl=20Vandon?= Date: Fri, 28 Feb 2025 13:40:57 +0100 Subject: [PATCH 7/8] also unify older instrumentation --- .../CursorImplInstrumentation.java | 47 ------- .../vertx_sql_client/CursorReadAdvice.java | 56 --------- .../PrepareHandlerWrapper.java | 32 ----- .../PreparedQueryInstrumentation.java | 72 ----------- .../vertx_sql_client/QueryAdvice.java | 82 ------------- .../QueryImplInstrumentation.java | 57 --------- .../QueryResultHandlerWrapper.java | 41 ------- .../vertx_sql_client/SqlClientBaseAdvice.java | 50 -------- .../SqlClientBaseInstrumentation.java | 53 -------- .../SqlConnectionBaseInstrumentation.java | 54 -------- .../SqlConnectionBasePrepareAdvice.java | 35 ------ .../VertxSqlClientDecorator.java | 116 ------------------ 12 files changed, 695 deletions(-) delete mode 100644 dd-java-agent/instrumentation/vertx-mysql-client-3.9/src/main/java/datadog/trace/instrumentation/vertx_sql_client/CursorImplInstrumentation.java delete mode 100644 dd-java-agent/instrumentation/vertx-mysql-client-3.9/src/main/java/datadog/trace/instrumentation/vertx_sql_client/CursorReadAdvice.java delete mode 100644 dd-java-agent/instrumentation/vertx-mysql-client-3.9/src/main/java/datadog/trace/instrumentation/vertx_sql_client/PrepareHandlerWrapper.java delete mode 100644 dd-java-agent/instrumentation/vertx-mysql-client-3.9/src/main/java/datadog/trace/instrumentation/vertx_sql_client/PreparedQueryInstrumentation.java delete mode 100644 dd-java-agent/instrumentation/vertx-mysql-client-3.9/src/main/java/datadog/trace/instrumentation/vertx_sql_client/QueryAdvice.java delete mode 100644 dd-java-agent/instrumentation/vertx-mysql-client-3.9/src/main/java/datadog/trace/instrumentation/vertx_sql_client/QueryImplInstrumentation.java delete mode 100644 dd-java-agent/instrumentation/vertx-mysql-client-3.9/src/main/java/datadog/trace/instrumentation/vertx_sql_client/QueryResultHandlerWrapper.java delete mode 100644 dd-java-agent/instrumentation/vertx-mysql-client-3.9/src/main/java/datadog/trace/instrumentation/vertx_sql_client/SqlClientBaseAdvice.java delete mode 100644 dd-java-agent/instrumentation/vertx-mysql-client-3.9/src/main/java/datadog/trace/instrumentation/vertx_sql_client/SqlClientBaseInstrumentation.java delete mode 100644 dd-java-agent/instrumentation/vertx-mysql-client-3.9/src/main/java/datadog/trace/instrumentation/vertx_sql_client/SqlConnectionBaseInstrumentation.java delete mode 100644 dd-java-agent/instrumentation/vertx-mysql-client-3.9/src/main/java/datadog/trace/instrumentation/vertx_sql_client/SqlConnectionBasePrepareAdvice.java delete mode 100644 dd-java-agent/instrumentation/vertx-mysql-client-3.9/src/main/java/datadog/trace/instrumentation/vertx_sql_client/VertxSqlClientDecorator.java diff --git a/dd-java-agent/instrumentation/vertx-mysql-client-3.9/src/main/java/datadog/trace/instrumentation/vertx_sql_client/CursorImplInstrumentation.java b/dd-java-agent/instrumentation/vertx-mysql-client-3.9/src/main/java/datadog/trace/instrumentation/vertx_sql_client/CursorImplInstrumentation.java deleted file mode 100644 index 6afeb290963..00000000000 --- a/dd-java-agent/instrumentation/vertx-mysql-client-3.9/src/main/java/datadog/trace/instrumentation/vertx_sql_client/CursorImplInstrumentation.java +++ /dev/null @@ -1,47 +0,0 @@ -package datadog.trace.instrumentation.vertx_sql_client; - -import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; -import static java.util.Collections.singletonMap; -import static net.bytebuddy.matcher.ElementMatchers.isMethod; -import static net.bytebuddy.matcher.ElementMatchers.isPublic; -import static net.bytebuddy.matcher.ElementMatchers.takesArgument; - -import com.google.auto.service.AutoService; -import datadog.trace.agent.tooling.Instrumenter; -import datadog.trace.agent.tooling.InstrumenterModule; -import java.util.Map; - -@AutoService(InstrumenterModule.class) -public class CursorImplInstrumentation extends InstrumenterModule.Tracing - implements Instrumenter.ForSingleType, Instrumenter.HasMethodAdvice { - public CursorImplInstrumentation() { - super("vertx", "vertx-sql-client"); - } - - @Override - public Map contextStore() { - return singletonMap("io.vertx.sqlclient.PreparedStatement", "datadog.trace.api.Pair"); - } - - @Override - public String[] helperClassNames() { - return new String[] { - packageName + ".QueryResultHandlerWrapper", packageName + ".VertxSqlClientDecorator", - }; - } - - @Override - public String instrumentedType() { - return "io.vertx.sqlclient.impl.CursorImpl"; - } - - @Override - public void methodAdvice(MethodTransformer transformer) { - transformer.applyAdvice( - isMethod() - .and(isPublic()) - .and(named("read")) - .and(takesArgument(1, named("io.vertx.core.Handler"))), - packageName + ".CursorReadAdvice"); - } -} diff --git a/dd-java-agent/instrumentation/vertx-mysql-client-3.9/src/main/java/datadog/trace/instrumentation/vertx_sql_client/CursorReadAdvice.java b/dd-java-agent/instrumentation/vertx-mysql-client-3.9/src/main/java/datadog/trace/instrumentation/vertx_sql_client/CursorReadAdvice.java deleted file mode 100644 index a02e7f8fb3f..00000000000 --- a/dd-java-agent/instrumentation/vertx-mysql-client-3.9/src/main/java/datadog/trace/instrumentation/vertx_sql_client/CursorReadAdvice.java +++ /dev/null @@ -1,56 +0,0 @@ -package datadog.trace.instrumentation.vertx_sql_client; - -import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.activateSpan; -import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.activeSpan; -import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.captureSpan; -import static datadog.trace.instrumentation.vertx_sql_client.VertxSqlClientDecorator.DECORATE; - -import datadog.trace.api.Pair; -import datadog.trace.bootstrap.InstrumentationContext; -import datadog.trace.bootstrap.instrumentation.api.AgentScope; -import datadog.trace.bootstrap.instrumentation.api.AgentSpan; -import io.vertx.core.AsyncResult; -import io.vertx.core.Handler; -import io.vertx.mysqlclient.MySQLConnection; -import io.vertx.sqlclient.PreparedStatement; -import io.vertx.sqlclient.Row; -import io.vertx.sqlclient.RowSet; -import net.bytebuddy.asm.Advice; -import net.bytebuddy.implementation.bytecode.assign.Assigner; - -public class CursorReadAdvice { - @Advice.OnMethodEnter(suppress = Throwable.class) - public static AgentScope beforeRead( - @Advice.Argument(value = 1, readOnly = false) Handler>> handler, - @Advice.FieldValue(value = "ps", typing = Assigner.Typing.DYNAMIC) - final PreparedStatement ps) { - if (handler instanceof QueryResultHandlerWrapper) { - return null; - } - final AgentSpan parentSpan = activeSpan(); - final AgentScope.Continuation parentContinuation = - null == parentSpan ? null : captureSpan(parentSpan); - final AgentSpan clientSpan = - DECORATE.startAndDecorateSpanForStatement( - ps, InstrumentationContext.get(PreparedStatement.class, Pair.class), true); - if (null == clientSpan) { - return null; - } - handler = new QueryResultHandlerWrapper<>(handler, clientSpan, parentContinuation); - - return activateSpan(clientSpan, true); - } - - @Advice.OnMethodExit(onThrowable = Throwable.class, suppress = Throwable.class) - public static void afterRead( - @Advice.Thrown final Throwable throwable, @Advice.Enter final AgentScope clientScope) { - if (null != clientScope) { - clientScope.close(); - } - } - - // Limit ourselves to 3.9.x and MySQL by checking for this method that was removed in 4.x - private static void muzzleCheck(MySQLConnection connection) { - connection.close(); - } -} diff --git a/dd-java-agent/instrumentation/vertx-mysql-client-3.9/src/main/java/datadog/trace/instrumentation/vertx_sql_client/PrepareHandlerWrapper.java b/dd-java-agent/instrumentation/vertx-mysql-client-3.9/src/main/java/datadog/trace/instrumentation/vertx_sql_client/PrepareHandlerWrapper.java deleted file mode 100644 index 4d604798271..00000000000 --- a/dd-java-agent/instrumentation/vertx-mysql-client-3.9/src/main/java/datadog/trace/instrumentation/vertx_sql_client/PrepareHandlerWrapper.java +++ /dev/null @@ -1,32 +0,0 @@ -package datadog.trace.instrumentation.vertx_sql_client; - -import datadog.trace.api.Pair; -import datadog.trace.bootstrap.ContextStore; -import datadog.trace.bootstrap.instrumentation.jdbc.DBInfo; -import datadog.trace.bootstrap.instrumentation.jdbc.DBQueryInfo; -import io.vertx.core.AsyncResult; -import io.vertx.core.Handler; -import io.vertx.sqlclient.PreparedStatement; - -public class PrepareHandlerWrapper implements Handler> { - private final Handler> handler; - private final ContextStore contextStore; - private final Pair queryInfo; - - public PrepareHandlerWrapper( - Handler> handler, - ContextStore contextStore, - Pair queryInfo) { - this.handler = handler; - this.contextStore = contextStore; - this.queryInfo = queryInfo; - } - - @Override - public void handle(AsyncResult event) { - if (event.succeeded()) { - contextStore.put(event.result(), queryInfo); - } - handler.handle(event); - } -} diff --git a/dd-java-agent/instrumentation/vertx-mysql-client-3.9/src/main/java/datadog/trace/instrumentation/vertx_sql_client/PreparedQueryInstrumentation.java b/dd-java-agent/instrumentation/vertx-mysql-client-3.9/src/main/java/datadog/trace/instrumentation/vertx_sql_client/PreparedQueryInstrumentation.java deleted file mode 100644 index ca678b659d2..00000000000 --- a/dd-java-agent/instrumentation/vertx-mysql-client-3.9/src/main/java/datadog/trace/instrumentation/vertx_sql_client/PreparedQueryInstrumentation.java +++ /dev/null @@ -1,72 +0,0 @@ -package datadog.trace.instrumentation.vertx_sql_client; - -import static datadog.trace.agent.tooling.bytebuddy.matcher.HierarchyMatchers.implementsInterface; -import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; -import static java.util.Collections.singletonMap; -import static net.bytebuddy.matcher.ElementMatchers.isMethod; -import static net.bytebuddy.matcher.ElementMatchers.isPublic; -import static net.bytebuddy.matcher.ElementMatchers.isVirtual; -import static net.bytebuddy.matcher.ElementMatchers.returns; -import static net.bytebuddy.matcher.ElementMatchers.takesArgument; -import static net.bytebuddy.matcher.ElementMatchers.takesArguments; - -import com.google.auto.service.AutoService; -import datadog.trace.agent.tooling.Instrumenter; -import datadog.trace.agent.tooling.InstrumenterModule; -import java.util.Map; -import net.bytebuddy.description.type.TypeDescription; -import net.bytebuddy.matcher.ElementMatcher; - -@AutoService(InstrumenterModule.class) -public class PreparedQueryInstrumentation extends InstrumenterModule.Tracing - implements Instrumenter.ForTypeHierarchy, Instrumenter.HasMethodAdvice { - public PreparedQueryInstrumentation() { - super("vertx", "vertx-sql-client"); - } - - @Override - public Map contextStore() { - return singletonMap("io.vertx.sqlclient.Query", "datadog.trace.api.Pair"); - } - - @Override - public String[] helperClassNames() { - return new String[] { - packageName + ".QueryResultHandlerWrapper", packageName + ".VertxSqlClientDecorator", - }; - } - - @Override - public String hierarchyMarkerType() { - return "io.vertx.sqlclient.PreparedQuery"; - } - - @Override - public ElementMatcher hierarchyMatcher() { - return implementsInterface(named(hierarchyMarkerType())); - } - - @Override - public void methodAdvice(MethodTransformer transformer) { - transformer.applyAdvice( - isMethod() - .and(isPublic()) - .and(named("execute")) - .and(takesArguments(2)) - .and(takesArgument(1, named("io.vertx.core.Handler"))), - packageName + ".QueryAdvice$Execute"); - transformer.applyAdvice( - isMethod() - .and(isPublic()) - .and(named("executeBatch")) - .and(takesArguments(2)) - .and(takesArgument(1, named("io.vertx.core.Handler"))), - packageName + ".QueryAdvice$Execute"); - transformer.applyAdvice( - isMethod() - .and(isVirtual()) - .and(named("copy")) - .and(returns(named("io.vertx.sqlclient.impl.QueryBase"))), - packageName + ".QueryAdvice$Copy"); - } -} diff --git a/dd-java-agent/instrumentation/vertx-mysql-client-3.9/src/main/java/datadog/trace/instrumentation/vertx_sql_client/QueryAdvice.java b/dd-java-agent/instrumentation/vertx-mysql-client-3.9/src/main/java/datadog/trace/instrumentation/vertx_sql_client/QueryAdvice.java deleted file mode 100644 index 2edacf9a25d..00000000000 --- a/dd-java-agent/instrumentation/vertx-mysql-client-3.9/src/main/java/datadog/trace/instrumentation/vertx_sql_client/QueryAdvice.java +++ /dev/null @@ -1,82 +0,0 @@ -package datadog.trace.instrumentation.vertx_sql_client; - -import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.activateSpan; -import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.activeSpan; -import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.captureSpan; -import static datadog.trace.instrumentation.vertx_sql_client.VertxSqlClientDecorator.DECORATE; - -import datadog.trace.api.Pair; -import datadog.trace.bootstrap.ContextStore; -import datadog.trace.bootstrap.InstrumentationContext; -import datadog.trace.bootstrap.instrumentation.api.AgentScope; -import datadog.trace.bootstrap.instrumentation.api.AgentSpan; -import io.vertx.core.AsyncResult; -import io.vertx.core.Handler; -import io.vertx.mysqlclient.MySQLConnection; -import io.vertx.sqlclient.Query; -import io.vertx.sqlclient.SqlResult; -import net.bytebuddy.asm.Advice; -import net.bytebuddy.implementation.bytecode.assign.Assigner; - -public class QueryAdvice { - public static class Copy { - @Advice.OnMethodExit(suppress = Throwable.class) - public static void afterCopy( - @Advice.This final Query zis, @Advice.Return final Query ret) { - ContextStore contextStore = InstrumentationContext.get(Query.class, Pair.class); - contextStore.put(ret, contextStore.get(zis)); - } - - // Limit ourselves to 3.9.x and MySQL by checking for this method that was removed in 4.x - private static void muzzleCheck(MySQLConnection connection) { - connection.close(); - } - } - - public static class Execute { - @Advice.OnMethodEnter(suppress = Throwable.class) - public static > AgentScope beforeExecute( - @Advice.This final Query zis, - @Advice.Argument( - value = 0, - readOnly = false, - optional = true, - typing = Assigner.Typing.DYNAMIC) - Object maybeHandler, - @Advice.Argument(value = 1, readOnly = false, optional = true) - Handler> handler) { - final boolean prepared = !(maybeHandler instanceof Handler); - - final AgentSpan parentSpan = activeSpan(); - final AgentScope.Continuation parentContinuation = - null == parentSpan ? null : captureSpan(parentSpan); - final AgentSpan clientSpan = - DECORATE.startAndDecorateSpanForStatement( - zis, InstrumentationContext.get(Query.class, Pair.class), prepared); - if (null == clientSpan) { - return null; - } - if (prepared) { - handler = new QueryResultHandlerWrapper<>(handler, clientSpan, parentContinuation); - } else { - maybeHandler = - new QueryResultHandlerWrapper<>( - (Handler>) maybeHandler, clientSpan, parentContinuation); - } - return activateSpan(clientSpan); - } - - @Advice.OnMethodExit(onThrowable = Throwable.class, suppress = Throwable.class) - public static void afterExecute( - @Advice.Thrown final Throwable throwable, @Advice.Enter final AgentScope clientScope) { - if (null != clientScope) { - clientScope.close(); - } - } - - // Limit ourselves to 3.9.x and MySQL by checking for this method that was removed in 4.x - private static void muzzleCheck(MySQLConnection connection) { - connection.close(); - } - } -} diff --git a/dd-java-agent/instrumentation/vertx-mysql-client-3.9/src/main/java/datadog/trace/instrumentation/vertx_sql_client/QueryImplInstrumentation.java b/dd-java-agent/instrumentation/vertx-mysql-client-3.9/src/main/java/datadog/trace/instrumentation/vertx_sql_client/QueryImplInstrumentation.java deleted file mode 100644 index d04c2afbda2..00000000000 --- a/dd-java-agent/instrumentation/vertx-mysql-client-3.9/src/main/java/datadog/trace/instrumentation/vertx_sql_client/QueryImplInstrumentation.java +++ /dev/null @@ -1,57 +0,0 @@ -package datadog.trace.instrumentation.vertx_sql_client; - -import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; -import static java.util.Collections.singletonMap; -import static net.bytebuddy.matcher.ElementMatchers.isMethod; -import static net.bytebuddy.matcher.ElementMatchers.isPublic; -import static net.bytebuddy.matcher.ElementMatchers.isVirtual; -import static net.bytebuddy.matcher.ElementMatchers.returns; -import static net.bytebuddy.matcher.ElementMatchers.takesArgument; -import static net.bytebuddy.matcher.ElementMatchers.takesArguments; - -import com.google.auto.service.AutoService; -import datadog.trace.agent.tooling.Instrumenter; -import datadog.trace.agent.tooling.InstrumenterModule; -import java.util.Map; - -@AutoService(InstrumenterModule.class) -public class QueryImplInstrumentation extends InstrumenterModule.Tracing - implements Instrumenter.ForSingleType, Instrumenter.HasMethodAdvice { - public QueryImplInstrumentation() { - super("vertx", "vertx-sql-client"); - } - - @Override - public Map contextStore() { - return singletonMap("io.vertx.sqlclient.Query", "datadog.trace.api.Pair"); - } - - @Override - public String[] helperClassNames() { - return new String[] { - packageName + ".QueryResultHandlerWrapper", packageName + ".VertxSqlClientDecorator", - }; - } - - @Override - public String instrumentedType() { - return "io.vertx.sqlclient.impl.SqlClientBase$QueryImpl"; - } - - @Override - public void methodAdvice(MethodTransformer transformer) { - transformer.applyAdvice( - isMethod() - .and(isPublic()) - .and(named("execute")) - .and(takesArguments(1)) - .and(takesArgument(0, named("io.vertx.core.Handler"))), - packageName + ".QueryAdvice$Execute"); - transformer.applyAdvice( - isMethod() - .and(isVirtual()) - .and(named("copy")) - .and(returns(named("io.vertx.sqlclient.impl.QueryBase"))), - packageName + ".QueryAdvice$Copy"); - } -} diff --git a/dd-java-agent/instrumentation/vertx-mysql-client-3.9/src/main/java/datadog/trace/instrumentation/vertx_sql_client/QueryResultHandlerWrapper.java b/dd-java-agent/instrumentation/vertx-mysql-client-3.9/src/main/java/datadog/trace/instrumentation/vertx_sql_client/QueryResultHandlerWrapper.java deleted file mode 100644 index 972dbeacd4e..00000000000 --- a/dd-java-agent/instrumentation/vertx-mysql-client-3.9/src/main/java/datadog/trace/instrumentation/vertx_sql_client/QueryResultHandlerWrapper.java +++ /dev/null @@ -1,41 +0,0 @@ -package datadog.trace.instrumentation.vertx_sql_client; - -import datadog.trace.bootstrap.instrumentation.api.AgentScope; -import datadog.trace.bootstrap.instrumentation.api.AgentSpan; -import io.vertx.core.AsyncResult; -import io.vertx.core.Handler; -import io.vertx.sqlclient.SqlResult; - -public class QueryResultHandlerWrapper> - implements Handler> { - private final Handler> handler; - private final AgentSpan clientSpan; - private final AgentScope.Continuation parentContinuation; - - public QueryResultHandlerWrapper( - final Handler> handler, - final AgentSpan clientSpan, - final AgentScope.Continuation parentContinuation) { - this.handler = handler; - this.clientSpan = clientSpan; - this.parentContinuation = parentContinuation; - } - - @Override - public void handle(final AsyncResult event) { - AgentScope scope = null; - try { - if (null != clientSpan) { - clientSpan.finish(); - } - if (null != parentContinuation) { - scope = parentContinuation.activate(); - } - handler.handle(event); - } finally { - if (null != scope) { - scope.close(); - } - } - } -} diff --git a/dd-java-agent/instrumentation/vertx-mysql-client-3.9/src/main/java/datadog/trace/instrumentation/vertx_sql_client/SqlClientBaseAdvice.java b/dd-java-agent/instrumentation/vertx-mysql-client-3.9/src/main/java/datadog/trace/instrumentation/vertx_sql_client/SqlClientBaseAdvice.java deleted file mode 100644 index 91d9136a189..00000000000 --- a/dd-java-agent/instrumentation/vertx-mysql-client-3.9/src/main/java/datadog/trace/instrumentation/vertx_sql_client/SqlClientBaseAdvice.java +++ /dev/null @@ -1,50 +0,0 @@ -package datadog.trace.instrumentation.vertx_sql_client; - -import datadog.trace.api.Pair; -import datadog.trace.bootstrap.InstrumentationContext; -import datadog.trace.bootstrap.instrumentation.jdbc.DBInfo; -import datadog.trace.bootstrap.instrumentation.jdbc.DBQueryInfo; -import io.vertx.mysqlclient.MySQLConnection; -import io.vertx.sqlclient.Query; -import io.vertx.sqlclient.SqlClient; -import net.bytebuddy.asm.Advice; - -public class SqlClientBaseAdvice { - public static class NormalQuery { - @Advice.OnMethodExit(suppress = Throwable.class) - public static void afterQuery( - @Advice.This final SqlClient zis, - @Advice.Argument(0) final String sql, - @Advice.Return final Query query) { - Pair info = - Pair.of( - InstrumentationContext.get(SqlClient.class, DBInfo.class).get(zis), - DBQueryInfo.ofStatement(sql)); - InstrumentationContext.get(Query.class, Pair.class).put(query, info); - } - - // Limit ourselves to 3.9.x and MySQL by checking for this method that was removed in 4.x - private static void muzzleCheck(MySQLConnection connection) { - connection.close(); - } - } - - public static class PreparedQuery { - @Advice.OnMethodExit(suppress = Throwable.class) - public static void afterPreparedQuery( - @Advice.This final SqlClient zis, - @Advice.Argument(0) final String sql, - @Advice.Return final Query query) { - Pair info = - Pair.of( - InstrumentationContext.get(SqlClient.class, DBInfo.class).get(zis), - DBQueryInfo.ofPreparedStatement(sql)); - InstrumentationContext.get(Query.class, Pair.class).put(query, info); - } - - // Limit ourselves to 3.9.x and MySQL by checking for this method that was removed in 4.x - private static void muzzleCheck(MySQLConnection connection) { - connection.close(); - } - } -} diff --git a/dd-java-agent/instrumentation/vertx-mysql-client-3.9/src/main/java/datadog/trace/instrumentation/vertx_sql_client/SqlClientBaseInstrumentation.java b/dd-java-agent/instrumentation/vertx-mysql-client-3.9/src/main/java/datadog/trace/instrumentation/vertx_sql_client/SqlClientBaseInstrumentation.java deleted file mode 100644 index b60abb64a93..00000000000 --- a/dd-java-agent/instrumentation/vertx-mysql-client-3.9/src/main/java/datadog/trace/instrumentation/vertx_sql_client/SqlClientBaseInstrumentation.java +++ /dev/null @@ -1,53 +0,0 @@ -package datadog.trace.instrumentation.vertx_sql_client; - -import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; -import static net.bytebuddy.matcher.ElementMatchers.isMethod; -import static net.bytebuddy.matcher.ElementMatchers.isPublic; -import static net.bytebuddy.matcher.ElementMatchers.takesArgument; -import static net.bytebuddy.matcher.ElementMatchers.takesArguments; - -import com.google.auto.service.AutoService; -import datadog.trace.agent.tooling.Instrumenter; -import datadog.trace.agent.tooling.InstrumenterModule; -import datadog.trace.bootstrap.instrumentation.jdbc.DBInfo; -import java.util.HashMap; -import java.util.Map; - -@AutoService(InstrumenterModule.class) -public class SqlClientBaseInstrumentation extends InstrumenterModule.Tracing - implements Instrumenter.ForSingleType, Instrumenter.HasMethodAdvice { - public SqlClientBaseInstrumentation() { - super("vertx", "vertx-sql-client"); - } - - @Override - public Map contextStore() { - Map contextStores = new HashMap<>(); - contextStores.put("io.vertx.sqlclient.SqlClient", DBInfo.class.getName()); - contextStores.put("io.vertx.sqlclient.Query", "datadog.trace.api.Pair"); - return contextStores; - } - - @Override - public String instrumentedType() { - return "io.vertx.sqlclient.impl.SqlClientBase"; - } - - @Override - public void methodAdvice(MethodTransformer transformer) { - transformer.applyAdvice( - isMethod() - .and(isPublic()) - .and(named("query")) - .and(takesArguments(1)) - .and(takesArgument(0, named("java.lang.String"))), - packageName + ".SqlClientBaseAdvice$NormalQuery"); - transformer.applyAdvice( - isMethod() - .and(isPublic()) - .and(named("preparedQuery")) - .and(takesArguments(1)) - .and(takesArgument(0, named("java.lang.String"))), - packageName + ".SqlClientBaseAdvice$PreparedQuery"); - } -} diff --git a/dd-java-agent/instrumentation/vertx-mysql-client-3.9/src/main/java/datadog/trace/instrumentation/vertx_sql_client/SqlConnectionBaseInstrumentation.java b/dd-java-agent/instrumentation/vertx-mysql-client-3.9/src/main/java/datadog/trace/instrumentation/vertx_sql_client/SqlConnectionBaseInstrumentation.java deleted file mode 100644 index 1704d06b688..00000000000 --- a/dd-java-agent/instrumentation/vertx-mysql-client-3.9/src/main/java/datadog/trace/instrumentation/vertx_sql_client/SqlConnectionBaseInstrumentation.java +++ /dev/null @@ -1,54 +0,0 @@ -package datadog.trace.instrumentation.vertx_sql_client; - -import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; -import static net.bytebuddy.matcher.ElementMatchers.isMethod; -import static net.bytebuddy.matcher.ElementMatchers.isPublic; -import static net.bytebuddy.matcher.ElementMatchers.takesArgument; -import static net.bytebuddy.matcher.ElementMatchers.takesArguments; - -import com.google.auto.service.AutoService; -import datadog.trace.agent.tooling.Instrumenter; -import datadog.trace.agent.tooling.InstrumenterModule; -import datadog.trace.bootstrap.instrumentation.jdbc.DBInfo; -import java.util.HashMap; -import java.util.Map; - -@AutoService(InstrumenterModule.class) -public class SqlConnectionBaseInstrumentation extends InstrumenterModule.Tracing - implements Instrumenter.ForSingleType, Instrumenter.HasMethodAdvice { - public SqlConnectionBaseInstrumentation() { - super("vertx", "vertx-sql-client"); - } - - @Override - public Map contextStore() { - Map contextStores = new HashMap<>(); - contextStores.put("io.vertx.sqlclient.SqlClient", DBInfo.class.getName()); - contextStores.put("io.vertx.sqlclient.PreparedStatement", "datadog.trace.api.Pair"); - return contextStores; - } - - @Override - public String[] helperClassNames() { - return new String[] { - packageName + ".PrepareHandlerWrapper", - }; - } - - @Override - public String instrumentedType() { - return "io.vertx.sqlclient.impl.SqlConnectionBase"; - } - - @Override - public void methodAdvice(MethodTransformer transformer) { - transformer.applyAdvice( - isMethod() - .and(isPublic()) - .and(named("prepare")) - .and(takesArguments(2)) - .and(takesArgument(0, named("java.lang.String"))) - .and(takesArgument(1, named("io.vertx.core.Handler"))), - packageName + ".SqlConnectionBasePrepareAdvice"); - } -} diff --git a/dd-java-agent/instrumentation/vertx-mysql-client-3.9/src/main/java/datadog/trace/instrumentation/vertx_sql_client/SqlConnectionBasePrepareAdvice.java b/dd-java-agent/instrumentation/vertx-mysql-client-3.9/src/main/java/datadog/trace/instrumentation/vertx_sql_client/SqlConnectionBasePrepareAdvice.java deleted file mode 100644 index 9fdc0cdf7dc..00000000000 --- a/dd-java-agent/instrumentation/vertx-mysql-client-3.9/src/main/java/datadog/trace/instrumentation/vertx_sql_client/SqlConnectionBasePrepareAdvice.java +++ /dev/null @@ -1,35 +0,0 @@ -package datadog.trace.instrumentation.vertx_sql_client; - -import datadog.trace.api.Pair; -import datadog.trace.bootstrap.InstrumentationContext; -import datadog.trace.bootstrap.instrumentation.jdbc.DBInfo; -import datadog.trace.bootstrap.instrumentation.jdbc.DBQueryInfo; -import io.vertx.core.AsyncResult; -import io.vertx.core.Handler; -import io.vertx.mysqlclient.MySQLConnection; -import io.vertx.sqlclient.PreparedStatement; -import io.vertx.sqlclient.SqlClient; -import net.bytebuddy.asm.Advice; - -public class SqlConnectionBasePrepareAdvice { - @Advice.OnMethodEnter(suppress = Throwable.class) - public static void beforePrepare( - @Advice.This final SqlClient zis, - @Advice.Argument(0) final String sql, - @Advice.Argument(value = 1, readOnly = false) - Handler> handler) { - Pair info = - Pair.of( - InstrumentationContext.get(SqlClient.class, DBInfo.class).get(zis), - DBQueryInfo.ofStatement(sql)); - - handler = - new PrepareHandlerWrapper( - handler, InstrumentationContext.get(PreparedStatement.class, Pair.class), info); - } - - // Limit ourselves to 3.9.x and MySQL by checking for this method that was removed in 4.x - private static void muzzleCheck(MySQLConnection connection) { - connection.close(); - } -} diff --git a/dd-java-agent/instrumentation/vertx-mysql-client-3.9/src/main/java/datadog/trace/instrumentation/vertx_sql_client/VertxSqlClientDecorator.java b/dd-java-agent/instrumentation/vertx-mysql-client-3.9/src/main/java/datadog/trace/instrumentation/vertx_sql_client/VertxSqlClientDecorator.java deleted file mode 100644 index d93c9604eaa..00000000000 --- a/dd-java-agent/instrumentation/vertx-mysql-client-3.9/src/main/java/datadog/trace/instrumentation/vertx_sql_client/VertxSqlClientDecorator.java +++ /dev/null @@ -1,116 +0,0 @@ -package datadog.trace.instrumentation.vertx_sql_client; - -import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.startSpan; -import static datadog.trace.bootstrap.instrumentation.api.Tags.DB_OPERATION; - -import datadog.trace.api.Pair; -import datadog.trace.api.naming.SpanNaming; -import datadog.trace.bootstrap.ContextStore; -import datadog.trace.bootstrap.instrumentation.api.AgentSpan; -import datadog.trace.bootstrap.instrumentation.api.InternalSpanTypes; -import datadog.trace.bootstrap.instrumentation.api.Tags; -import datadog.trace.bootstrap.instrumentation.api.UTF8BytesString; -import datadog.trace.bootstrap.instrumentation.decorator.DatabaseClientDecorator; -import datadog.trace.bootstrap.instrumentation.jdbc.DBInfo; -import datadog.trace.bootstrap.instrumentation.jdbc.DBQueryInfo; - -public class VertxSqlClientDecorator extends DatabaseClientDecorator { - - public static final VertxSqlClientDecorator DECORATE = new VertxSqlClientDecorator(); - - private static final CharSequence VERTX_SQL = UTF8BytesString.create("vertx-sql"); - private static final CharSequence DATABASE_QUERY = UTF8BytesString.create("database.query"); - private static final UTF8BytesString DB_QUERY = UTF8BytesString.create("DB Query"); - private static final UTF8BytesString VERTX_STATEMENT = - UTF8BytesString.create("vertx-sql-statement"); - private static final UTF8BytesString VERTX_PREPARED_STATEMENT = - UTF8BytesString.create("vertx-sql-prepared_statement"); - private static final String DEFAULT_SERVICE_NAME = - SpanNaming.instance().namingSchema().database().service("vertx-sql"); - - @Override - protected String[] instrumentationNames() { - return new String[] {"vertx", "vertx-sql-client"}; - } - - @Override - protected String service() { - return DEFAULT_SERVICE_NAME; // Overridden by onConnection - } - - @Override - protected CharSequence component() { - return VERTX_SQL; // Overridden by onStatement and onPreparedStatement - } - - @Override - protected CharSequence spanType() { - return InternalSpanTypes.SQL; - } - - @Override - protected String dbType() { - return "vertx-sql"; - } - - @Override - protected String dbUser(final DBInfo info) { - return info.getUser(); - } - - @Override - protected String dbInstance(final DBInfo info) { - if (info.getInstance() != null) { - return info.getInstance(); - } else { - return info.getDb(); - } - } - - @Override - protected String dbHostname(final DBInfo info) { - return info.getHost(); - } - - public AgentSpan startAndDecorateSpanForStatement( - T query, ContextStore contextStore, boolean prepared) { - CharSequence component = prepared ? VERTX_PREPARED_STATEMENT : VERTX_STATEMENT; - AgentSpan span = startSpan(DATABASE_QUERY); - if (null == span) { - return null; - } - afterStart(span); - - DBInfo dbInfo = null; - DBQueryInfo dbQueryInfo = null; - Pair queryInfo = contextStore.get(query); - if (queryInfo != null) { - dbInfo = queryInfo.getLeft(); - dbQueryInfo = queryInfo.getRight(); - } - - if (dbInfo != null) { - processDatabaseType(span, dbInfo.getType()); - } - super.onConnection(span, dbInfo); - - if (null != dbQueryInfo) { - span.setResourceName(dbQueryInfo.getSql()); - span.setTag(DB_OPERATION, dbQueryInfo.getOperation()); - } else { - span.setResourceName(DB_QUERY); - } - span.setTag(Tags.COMPONENT, component); - - return span; - } - - @Override - protected void postProcessServiceAndOperationName( - AgentSpan span, DatabaseClientDecorator.NamingEntry namingEntry) { - if (namingEntry.getService() != null) { - span.setServiceName(namingEntry.getService()); - } - span.setOperationName(namingEntry.getOperation()); - } -} From 523e10f441602769a9c10bd05e5705ad2ac87c56 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rapha=C3=ABl=20Vandon?= Date: Fri, 28 Feb 2025 13:45:36 +0100 Subject: [PATCH 8/8] add dependency for tests --- .../instrumentation/vertx-mysql-client-3.9/build.gradle | 1 + .../instrumentation/vertx-mysql-client-4.0/build.gradle | 1 + .../instrumentation/vertx-pg-client-4.2.0/build.gradle | 1 + dd-java-agent/instrumentation/vertx-sql-common/build.gradle | 2 +- 4 files changed, 4 insertions(+), 1 deletion(-) diff --git a/dd-java-agent/instrumentation/vertx-mysql-client-3.9/build.gradle b/dd-java-agent/instrumentation/vertx-mysql-client-3.9/build.gradle index 222285d1b8e..e3285676f9f 100644 --- a/dd-java-agent/instrumentation/vertx-mysql-client-3.9/build.gradle +++ b/dd-java-agent/instrumentation/vertx-mysql-client-3.9/build.gradle @@ -28,6 +28,7 @@ dependencies { compileOnly group: 'io.vertx', name: 'vertx-mysql-client', version: '3.9.0' testImplementation group: 'io.vertx', name: 'vertx-mysql-client', version: '3.9.0' + testImplementation project(':dd-java-agent:instrumentation:vertx-sql-common') // This is needed for the test container to start testImplementation group: 'mysql', name: 'mysql-connector-java', version: '8.0.23' diff --git a/dd-java-agent/instrumentation/vertx-mysql-client-4.0/build.gradle b/dd-java-agent/instrumentation/vertx-mysql-client-4.0/build.gradle index ec8c516a81f..937a0ee67a6 100644 --- a/dd-java-agent/instrumentation/vertx-mysql-client-4.0/build.gradle +++ b/dd-java-agent/instrumentation/vertx-mysql-client-4.0/build.gradle @@ -23,6 +23,7 @@ dependencies { compileOnly group: 'io.vertx', name: 'vertx-mysql-client', version: '4.0.0' testImplementation group: 'io.vertx', name: 'vertx-mysql-client', version: '4.0.0' + testImplementation project(':dd-java-agent:instrumentation:vertx-sql-common') // This is needed for the test container to start testImplementation group: 'mysql', name: 'mysql-connector-java', version: '8.0.23' diff --git a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/build.gradle b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/build.gradle index 7fa0eb8d07e..24f0dfaf394 100644 --- a/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/build.gradle +++ b/dd-java-agent/instrumentation/vertx-pg-client-4.2.0/build.gradle @@ -23,6 +23,7 @@ dependencies { compileOnly group: 'io.vertx', name: 'vertx-pg-client', version: '4.2.0' testImplementation group: 'io.vertx', name: 'vertx-pg-client', version: '4.2.0' + testImplementation project(':dd-java-agent:instrumentation:vertx-sql-common') // This is needed for the test container to start testImplementation group: 'com.ongres.scram', name: 'client', version: '2.1' diff --git a/dd-java-agent/instrumentation/vertx-sql-common/build.gradle b/dd-java-agent/instrumentation/vertx-sql-common/build.gradle index 7512f33426b..35cd14a7ebf 100644 --- a/dd-java-agent/instrumentation/vertx-sql-common/build.gradle +++ b/dd-java-agent/instrumentation/vertx-sql-common/build.gradle @@ -1,5 +1,5 @@ apply from: "$rootDir/gradle/java.gradle" dependencies { - compileOnly group: 'io.vertx', name: 'vertx-sql-client', version: '4.0.0' + compileOnly group: 'io.vertx', name: 'vertx-sql-client', version: '3.9.0' }