JAVA-1682: Provide a way to record latencies for cancelled speculative executions

olim7t · olim7t · commit 13ac1762dfda · 2018-01-11T17:26:45.000-08:00
Those latencies are emitted with a
CancelledSpeculativeExecutionException, which allows LatencyTracker
implementations to choose whether to include them or not. For example, a
tracker that wants to detect "slowness" of a node might want to record
them (otherwise a node that always hits the speculative execution
threshold would appear to have no measurement), whereas a tracker that
monitors latencies of successful executions should ignore them.
diff --git a/changelog/README.md b/changelog/README.md
@@ -11,6 +11,7 @@
 - [new feature] JAVA-1651: Add NO_COMPACT startup option.
 - [improvement] JAVA-1683: Add metrics to track writes to nodes.
 - [new feature] JAVA-1229: Allow specifying the keyspace for individual queries.
+- [improvement] JAVA-1682: Provide a way to record latencies for cancelled speculative executions.
 
 Merged from 3.3.x:
 
diff --git a/driver-core/src/main/java/com/datastax/driver/core/CancelledSpeculativeExecutionException.java b/driver-core/src/main/java/com/datastax/driver/core/CancelledSpeculativeExecutionException.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2012-2017 DataStax Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.datastax.driver.core;
+
+/**
+ * Special exception that gets emitted to {@link LatencyTracker}s with the latencies of cancelled speculative
+ * executions. This allows those trackers to choose whether to ignore those latencies or not.
+ */
+class CancelledSpeculativeExecutionException extends Exception {
+
+    static CancelledSpeculativeExecutionException INSTANCE = new CancelledSpeculativeExecutionException();
+
+    private CancelledSpeculativeExecutionException() {
+        super();
+    }
+}
diff --git a/driver-core/src/main/java/com/datastax/driver/core/PercentileTracker.java b/driver-core/src/main/java/com/datastax/driver/core/PercentileTracker.java
@@ -255,7 +255,8 @@ protected boolean include(Host host, Statement statement, Exception exception) {
             OverloadedException.class,
             BootstrappingException.class,
             UnpreparedException.class,
-            QueryValidationException.class // query validation also happens at early stages in the coordinator
+            QueryValidationException.class, // query validation also happens at early stages in the coordinator
+            CancelledSpeculativeExecutionException.class
     );
 
     /**
diff --git a/driver-core/src/main/java/com/datastax/driver/core/RequestHandler.java b/driver-core/src/main/java/com/datastax/driver/core/RequestHandler.java
@@ -274,6 +274,7 @@ class SpeculativeExecution implements Connection.ResponseCallback {
         private volatile ConsistencyLevel retryConsistencyLevel;
         private final AtomicReference<QueryState> queryStateRef;
         private final AtomicBoolean nextExecutionScheduled = new AtomicBoolean();
+        private final long startTime = System.nanoTime();
 
         // This represents the number of times a retry has been triggered by the RetryPolicy (this is different from
         // queryStateRef.get().retryCount, because some retries don't involve the policy, for example after an
@@ -511,10 +512,18 @@ void cancel() {
                     // If it's still null, this will be handled by re-checking queryStateRef at the end of write().
                     if (connectionHandler != null && connectionHandler.cancelHandler())
                         connectionHandler.connection.release();
+                    Host queriedHost = current;
+                    if (queriedHost != null && statement != Statement.DEFAULT) {
+                        manager.cluster.manager.reportQuery(queriedHost, statement, CancelledSpeculativeExecutionException.INSTANCE, System.nanoTime() - startTime);
+                    }
                     return;
                 } else if (!previous.inProgress && queryStateRef.compareAndSet(previous, QueryState.CANCELLED_WHILE_COMPLETE)) {
                     if (logger.isTraceEnabled())
                         logger.trace("[{}] Cancelled while complete", id);
+                    Host queriedHost = current;
+                    if (queriedHost != null && statement != Statement.DEFAULT) {
+                        manager.cluster.manager.reportQuery(queriedHost, statement, CancelledSpeculativeExecutionException.INSTANCE, System.nanoTime() - startTime);
+                    }
                     return;
                 }
             }
