Restore CommandSchedulerInstrumentation for v5.0

Restores context propagation through the Vert.x SQL client pool command dispatch
pipeline. This is needed for JDBCPool which bypasses Pool.pool() factory: the
null-connectOptions check correctly suppresses the vertx-sql-client span, but
downstream JDBC instrumentation needs the correct parent context to create its
own span. CommandSchedulerInstrumentation stores the context on the first
schedule() call and restores it when the pool dispatches to a connection,
ensuring executeBlocking on worker threads sees the right parent.

With the PoolInstrumentation typeMatcher now fixed, this is safe for non-JDBC
pools: the vertx-sql-client CLIENT span is already created before
CommandScheduler fires, so the context propagation is harmless.

Author: trask

instrumentation/vertx/vertx-sql-client/vertx-sql-client-5.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/vertx/v5_0/sql/CommandSchedulerInstrumentation.java

@@ -0,0 +1,81 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.javaagent.instrumentation.vertx.v5_0.sql;
+
+import static io.opentelemetry.javaagent.extension.matcher.AgentElementMatchers.implementsInterface;
+import static net.bytebuddy.matcher.ElementMatchers.named;
+import static net.bytebuddy.matcher.ElementMatchers.takesArgument;
+
+import io.opentelemetry.context.Context;
+import io.opentelemetry.context.Scope;
+import io.opentelemetry.instrumentation.api.util.VirtualField;
+import io.opentelemetry.javaagent.extension.instrumentation.TypeInstrumentation;
+import io.opentelemetry.javaagent.extension.instrumentation.TypeTransformer;
+import io.vertx.sqlclient.internal.command.CommandBase;
+import javax.annotation.Nullable;
+import net.bytebuddy.asm.Advice;
+import net.bytebuddy.description.type.TypeDescription;
+import net.bytebuddy.matcher.ElementMatcher;
+
+/**
+ * Propagates OpenTelemetry context through the Vert.x SQL client connection pool.
+ *
+ * <p>When a query is initiated (e.g. {@code pool.query("SELECT ...").execute()}), the correct
+ * OpenTelemetry context is active on the event loop thread. The pool may queue the request and
+ * dispatch it later when a connection becomes available — by which time the event loop may be
+ * handling a different request with a different context.
+ *
+ * <p>This instrumentation captures the context on the first {@code CommandScheduler.schedule()}
+ * call (from the query executor, with the correct context) and restores it on subsequent calls
+ * (from the pool to the connection, where the context may be stale). This ensures that downstream
+ * instrumentation (e.g. JDBC) on worker threads sees the correct parent context.
+ */
+public class CommandSchedulerInstrumentation implements TypeInstrumentation {
+
+  @Override
+  public ElementMatcher<TypeDescription> typeMatcher() {
+    return implementsInterface(named("io.vertx.sqlclient.internal.command.CommandScheduler"));
+  }
+
+  @Override
+  public void transform(TypeTransformer transformer) {
+    transformer.applyAdviceToMethod(
+        named("schedule")
+            .and(takesArgument(0, named("io.vertx.sqlclient.internal.command.CommandBase")))
+            .and(takesArgument(1, named("io.vertx.core.Completable"))),
+        CommandSchedulerInstrumentation.class.getName() + "$ScheduleAdvice");
+  }
+
+  // VirtualField.find requires the raw type; CommandBase is invoked reflectively by ByteBuddy
+  @SuppressWarnings({"unused", "rawtypes"})
+  public static class ScheduleAdvice {
+
+    @Advice.OnMethodEnter(suppress = Throwable.class)
+    @Nullable
+    public static Scope onEnter(@Advice.Argument(0) CommandBase<?> command) {
+      VirtualField<CommandBase, Context> contextField =
+          VirtualField.find(CommandBase.class, Context.class);
+      Context stored = contextField.get(command);
+      if (stored == null) {
+        // First schedule call (query executor → pool or direct connection).
+        // The current OpenTelemetry context is correct — store it on the command.
+        contextField.set(command, Context.current());
+        return null;
+      }
+      // Subsequent schedule call (pool → connection).
+      // Restore the stored context so that executeBlocking dispatches with
+      // the correct parent for downstream instrumentation (e.g. JDBC).
+      return stored.makeCurrent();
+    }
+
+    @Advice.OnMethodExit(onThrowable = Throwable.class, suppress = Throwable.class)
+    public static void onExit(@Advice.Enter @Nullable Scope scope) {
+      if (scope != null) {
+        scope.close();
+      }
+    }
+  }
+}

instrumentation/vertx/vertx-sql-client/vertx-sql-client-5.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/vertx/v5_0/sql/VertxSqlClientInstrumentationModule.java

@@ -43,6 +43,7 @@ public List<String> injectedClassNames() {
   @Override
   public List<TypeInstrumentation> typeInstrumentations() {
     return asList(
+        new CommandSchedulerInstrumentation(),
         new DriverInstrumentation(),
         new PoolInstrumentation(),
         new SqlClientBaseInstrumentation(),