diff --git a/pom.xml b/pom.xml
index fe85bf3f41..faf8915b3a 100644
--- a/pom.xml
+++ b/pom.xml
@@ -95,12 +95,12 @@
   <org.apache.httpcomponents.version>4.5.14</org.apache.httpcomponents.version>
   <io.fabric8.client.version>6.7.2</io.fabric8.client.version>
   <io.netty.version>4.1.101.Final</io.netty.version>
-  <io.vertx.version>4.4.4</io.vertx.version>
+  <io.vertx.version>4.4.6</io.vertx.version>
   <!--
     FIXME this needs to be synced with the vertx version - is there a BOM to use or something?
     https://github.com/vert-x3/vertx-web/blob/${io.vertx.version}/vertx-web-graphql/pom.xml#L35
   -->
-  <com.graphql.java.extended.scalars.version>20.2</com.graphql.java.extended.scalars.version>
+  <com.graphql.java.extended.scalars.version>20.4</com.graphql.java.extended.scalars.version>
   <com.nimbusds.jose.jwt.version>9.31</com.nimbusds.jose.jwt.version>
   <org.bouncycastle.version>1.75</org.bouncycastle.version>
   <org.jasypt.version>1.9.3</org.jasypt.version>
diff --git a/src/main/java/io/cryostat/net/web/http/api/v2/RuleDeleteHandler.java b/src/main/java/io/cryostat/net/web/http/api/v2/RuleDeleteHandler.java
index 2bfa9fad18..ca358347a7 100644
--- a/src/main/java/io/cryostat/net/web/http/api/v2/RuleDeleteHandler.java
+++ b/src/main/java/io/cryostat/net/web/http/api/v2/RuleDeleteHandler.java
@@ -127,13 +127,13 @@ public IntermediateResponse<Void> handle(RequestParameters params) throws ApiExc
                 .send();
         if (Boolean.valueOf(params.getQueryParams().get(CLEAN_PARAM))) {
             vertx.executeBlocking(
-                    promise -> {
+                    () -> {
                         try {
                             cleanup(params, rule);
-                            promise.complete();
                         } catch (Exception e) {
-                            promise.fail(e);
+                            logger.error(e);
                         }
+                        return null;
                     });
         }
         return new IntermediateResponse<Void>().body(null);
@@ -144,7 +144,7 @@ private void cleanup(RequestParameters params, Rule rule) {
                 .forEach(
                         (ServiceRef ref) -> {
                             vertx.executeBlocking(
-                                    promise -> {
+                                    () -> {
                                         try {
                                             if (ruleRegistry.applies(rule, ref)) {
                                                 String targetId = ref.getServiceUri().toString();
@@ -157,11 +157,10 @@ private void cleanup(RequestParameters params, Rule rule) {
                                                 recordings.stopRecording(
                                                         cd, rule.getRecordingName(), true);
                                             }
-                                            promise.complete();
                                         } catch (Exception e) {
                                             logger.error(e);
-                                            promise.fail(e);
                                         }
+                                        return null;
                                     });
                         });
     }
diff --git a/src/main/java/io/cryostat/net/web/http/api/v2/RulePatchHandler.java b/src/main/java/io/cryostat/net/web/http/api/v2/RulePatchHandler.java
index 2ee969d820..e8f2250dc3 100644
--- a/src/main/java/io/cryostat/net/web/http/api/v2/RulePatchHandler.java
+++ b/src/main/java/io/cryostat/net/web/http/api/v2/RulePatchHandler.java
@@ -140,13 +140,13 @@ public IntermediateResponse<Void> handle(RequestParameters params) throws ApiExc
 
         if (!enabled && Boolean.valueOf(params.getQueryParams().get(CLEAN_PARAM))) {
             vertx.executeBlocking(
-                    promise -> {
+                    () -> {
                         try {
                             cleanup(params, rule);
-                            promise.complete();
                         } catch (Exception e) {
-                            promise.fail(e);
+                            logger.error(e);
                         }
+                        return null;
                     });
         }
 
@@ -158,7 +158,7 @@ private void cleanup(RequestParameters params, Rule rule) {
                 .forEach(
                         (ServiceRef ref) -> {
                             vertx.executeBlocking(
-                                    promise -> {
+                                    () -> {
                                         try {
                                             if (ruleRegistry.applies(rule, ref)) {
                                                 String targetId = ref.getServiceUri().toString();
@@ -171,11 +171,10 @@ private void cleanup(RequestParameters params, Rule rule) {
                                                 recordings.stopRecording(
                                                         cd, rule.getRecordingName(), true);
                                             }
-                                            promise.complete();
                                         } catch (Exception e) {
                                             logger.error(e);
-                                            promise.fail(e);
                                         }
+                                        return null;
                                     });
                         });
     }
diff --git a/src/test/java/io/cryostat/MockVertx.java b/src/test/java/io/cryostat/MockVertx.java
index ab69a1d601..0bce2adfe0 100644
--- a/src/test/java/io/cryostat/MockVertx.java
+++ b/src/test/java/io/cryostat/MockVertx.java
@@ -15,6 +15,8 @@
  */
 package io.cryostat;
 
+import java.util.concurrent.Callable;
+
 import io.vertx.core.AsyncResult;
 import io.vertx.core.Handler;
 import io.vertx.core.Promise;
@@ -114,7 +116,7 @@ public boolean failed() {
                 .executeBlocking(Mockito.any(), Mockito.any());
 
         Mockito.lenient()
-                .when(vertx.executeBlocking(Mockito.any()))
+                .when(vertx.executeBlocking(Mockito.any(Handler.class)))
                 .thenAnswer(
                         new Answer() {
                             @Override
@@ -128,6 +130,17 @@ public Object answer(InvocationOnMock invocation) throws Throwable {
                             }
                         });
 
+        Mockito.lenient()
+                .when(vertx.executeBlocking(Mockito.any(Callable.class)))
+                .thenAnswer(
+                        new Answer() {
+                            @Override
+                            public Object answer(InvocationOnMock invocation) throws Throwable {
+                                Callable callable = invocation.getArgument(0);
+                                return callable.call();
+                            }
+                        });
+
         Mockito.lenient()
                 .doAnswer(
                         new Answer() {
diff --git a/src/test/java/io/cryostat/net/web/http/api/v2/RuleDeleteHandlerTest.java b/src/test/java/io/cryostat/net/web/http/api/v2/RuleDeleteHandlerTest.java
index 72307e892c..14cd5e8bb7 100644
--- a/src/test/java/io/cryostat/net/web/http/api/v2/RuleDeleteHandlerTest.java
+++ b/src/test/java/io/cryostat/net/web/http/api/v2/RuleDeleteHandlerTest.java
@@ -20,6 +20,7 @@
 import java.util.Map;
 import java.util.Optional;
 import java.util.Set;
+import java.util.concurrent.Callable;
 
 import io.cryostat.MainModule;
 import io.cryostat.MockVertx;
@@ -181,7 +182,7 @@ void shouldRespondWith404ForNonexistentRule() throws Exception {
                     Assertions.assertThrows(ApiException.class, () -> handler.handle(params));
             MatcherAssert.assertThat(ex.getStatusCode(), Matchers.equalTo(404));
 
-            Mockito.verify(vertx, Mockito.never()).executeBlocking(Mockito.any());
+            Mockito.verify(vertx, Mockito.never()).executeBlocking(Mockito.any(Callable.class));
             Mockito.verify(registry, Mockito.never()).deleteRule(Mockito.any(Rule.class));
             Mockito.verify(registry, Mockito.never()).deleteRule(Mockito.anyString());
             Mockito.verify(registry, Mockito.never()).applies(Mockito.any(), Mockito.any());
@@ -223,7 +224,7 @@ void shouldRespondWith200ForCleanupFailures() throws Exception {
             IntermediateResponse<Void> response = handler.handle(params);
             MatcherAssert.assertThat(response.getStatusCode(), Matchers.equalTo(200));
 
-            Mockito.verify(vertx, Mockito.times(2)).executeBlocking(Mockito.any());
+            Mockito.verify(vertx, Mockito.times(2)).executeBlocking(Mockito.any(Callable.class));
             Mockito.verify(registry).deleteRule(rule);
             Mockito.verify(registry).applies(rule, serviceRef);
             Mockito.verify(recordingTargetHelper)
@@ -253,7 +254,7 @@ void shouldRespondWith200AfterCleanupNoop() throws Exception {
             IntermediateResponse<Void> response = handler.handle(params);
             MatcherAssert.assertThat(response.getStatusCode(), Matchers.equalTo(200));
 
-            Mockito.verify(vertx, Mockito.times(1)).executeBlocking(Mockito.any());
+            Mockito.verify(vertx, Mockito.times(1)).executeBlocking(Mockito.any(Callable.class));
             Mockito.verify(registry).deleteRule(rule);
             Mockito.verify(registry, Mockito.never()).applies(Mockito.any(), Mockito.any());
             Mockito.verify(recordingTargetHelper, Mockito.never())
@@ -288,7 +289,7 @@ void shouldRespondWith200AfterSuccessfulCleanup() throws Exception {
             IntermediateResponse<Void> response = handler.handle(params);
             MatcherAssert.assertThat(response.getStatusCode(), Matchers.equalTo(200));
 
-            Mockito.verify(vertx, Mockito.times(2)).executeBlocking(Mockito.any());
+            Mockito.verify(vertx, Mockito.times(2)).executeBlocking(Mockito.any(Callable.class));
             Mockito.verify(registry).deleteRule(rule);
             Mockito.verify(registry).applies(Mockito.any(), Mockito.any());
             Mockito.verify(recordingTargetHelper)
diff --git a/src/test/java/io/cryostat/net/web/http/api/v2/RulePatchHandlerTest.java b/src/test/java/io/cryostat/net/web/http/api/v2/RulePatchHandlerTest.java
index afb680163b..1019868f06 100644
--- a/src/test/java/io/cryostat/net/web/http/api/v2/RulePatchHandlerTest.java
+++ b/src/test/java/io/cryostat/net/web/http/api/v2/RulePatchHandlerTest.java
@@ -20,6 +20,7 @@
 import java.util.Map;
 import java.util.Optional;
 import java.util.Set;
+import java.util.concurrent.Callable;
 
 import io.cryostat.MainModule;
 import io.cryostat.MockVertx;
@@ -220,7 +221,7 @@ void shouldDisableRuleAndCleanup() throws Exception {
             Mockito.verify(notificationBuilder).build();
             Mockito.verify(notification).send();
 
-            Mockito.verify(vertx, Mockito.times(2)).executeBlocking(Mockito.any());
+            Mockito.verify(vertx, Mockito.times(2)).executeBlocking(Mockito.any(Callable.class));
             Mockito.verify(registry)
                     .applies(Mockito.any(Rule.class), Mockito.any(ServiceRef.class));
             Mockito.verify(recordingTargetHelper)