Value-type: {@link String} + */ + BACKOFF_RETRY_POLICY_CLASS("advanced.backoff-retry-policy.class"), + + BACKOFF_RETRY_MAX_BACKOFF_MS("advanced.backoff-retry-policy.max-backoff-ms"), + BACKOFF_RETRY_BASE_BACKOFF_MS("advanced.backoff-retry-policy.base-backoff-ms"), + BACKOFF_RETRY_JITTER_RATIO("advanced.backoff-retry-policy.jitter-ratio"), + // SPECULATIVE_EXECUTION_POLICY is a collection of sub-properties SPECULATIVE_EXECUTION_POLICY("advanced.speculative-execution-policy"), /** @@ -537,7 +551,6 @@ public enum DefaultDriverOption implements DriverOption { *
Value-type: {@link java.time.Duration Duration}
*/
METRICS_NODE_CQL_MESSAGES_INTERVAL("advanced.metrics.node.cql-messages.refresh-interval"),
-
/**
* Whether or not to disable the Nagle algorithm.
*
diff --git a/core/src/main/java/com/datastax/oss/driver/api/core/config/OptionsMap.java b/core/src/main/java/com/datastax/oss/driver/api/core/config/OptionsMap.java
index 64665709028..7953154509d 100644
--- a/core/src/main/java/com/datastax/oss/driver/api/core/config/OptionsMap.java
+++ b/core/src/main/java/com/datastax/oss/driver/api/core/config/OptionsMap.java
@@ -281,6 +281,10 @@ protected static void fillWithDriverDefaults(OptionsMap map) {
map.put(TypedDriverOption.RECONNECTION_BASE_DELAY, Duration.ofSeconds(1));
map.put(TypedDriverOption.RECONNECTION_MAX_DELAY, Duration.ofSeconds(60));
map.put(TypedDriverOption.RETRY_POLICY_CLASS, "DefaultRetryPolicy");
+ map.put(TypedDriverOption.BACKOFF_RETRY_POLICY_CLASS, "NoBackoffPolicy");
+ map.put(TypedDriverOption.BACKOFF_RETRY_BASE_BACKOFF_MS, 100);
+ map.put(TypedDriverOption.BACKOFF_RETRY_MAX_BACKOFF_MS, 10000);
+ map.put(TypedDriverOption.BACKOFF_RETRY_JITTER_RATIO, 0.1);
map.put(TypedDriverOption.SPECULATIVE_EXECUTION_POLICY_CLASS, "NoSpeculativeExecutionPolicy");
map.put(TypedDriverOption.TIMESTAMP_GENERATOR_CLASS, "AtomicTimestampGenerator");
map.put(TypedDriverOption.TIMESTAMP_GENERATOR_DRIFT_WARNING_THRESHOLD, Duration.ofSeconds(1));
diff --git a/core/src/main/java/com/datastax/oss/driver/api/core/config/TypedDriverOption.java b/core/src/main/java/com/datastax/oss/driver/api/core/config/TypedDriverOption.java
index b6051749c71..c2e9c12cb6f 100644
--- a/core/src/main/java/com/datastax/oss/driver/api/core/config/TypedDriverOption.java
+++ b/core/src/main/java/com/datastax/oss/driver/api/core/config/TypedDriverOption.java
@@ -199,6 +199,20 @@ public String toString() {
/** The class of the retry policy. */
public static final TypedDriverOption For each request, the driver gets a "query plan" (a list of coordinators to try) from the
+ * {@link LoadBalancingPolicy}, and tries each node in sequence. This policy is invoked if the
+ * request to that node fails.
+ *
+ * The methods of this interface are invoked on I/O threads, therefore implementations should
+ * never block. In particular, don't call {@link Thread#sleep(long)} to retry after a delay:
+ * this would prevent asynchronous processing of other requests, and very negatively impact
+ * throughput. If the application needs to back off and retry later, this should be implemented in
+ * client code, not in this policy.
+ */
+public interface BackoffRetryPolicy extends AutoCloseable {
+ /**
+ * Whether to retry when the server replied with a {@code READ_TIMEOUT} error; this indicates a
+ * server-side timeout during a read query, i.e. some replicas did not reply to the
+ * coordinator in time.
+ *
+ * @param request the request that timed out.
+ * @param cl the requested consistency level.
+ * @param blockFor the minimum number of replica acknowledgements/responses that were required to
+ * fulfill the operation.
+ * @param received the number of replica that had acknowledged/responded to the operation before
+ * it failed.
+ * @param dataPresent whether the actual data was amongst the received replica responses. See
+ * {@link ReadTimeoutException#wasDataPresent()}.
+ * @param retryCount how many times the retry policy has been invoked already for this request
+ * (not counting the current invocation).
+ */
+ int onReadTimeoutBackoffMs(
+ @NonNull Request request,
+ @NonNull ConsistencyLevel cl,
+ int blockFor,
+ int received,
+ boolean dataPresent,
+ int retryCount,
+ RetryVerdict verdict);
+
+ /**
+ * Whether to retry when the server replied with a {@code WRITE_TIMEOUT} error; this indicates a
+ * server-side timeout during a write query, i.e. some replicas did not reply to the
+ * coordinator in time.
+ *
+ * Note that this method will only be invoked for {@link Request#isIdempotent()} idempotent}
+ * requests: when a write times out, it is impossible to determine with 100% certainty whether the
+ * mutation was applied or not, so the write is never safe to retry; the driver will rethrow the
+ * error directly, without invoking the retry policy.
+ *
+ * @param request the request that timed out.
+ * @param cl the requested consistency level.
+ * @param writeType the type of the write for which the timeout was raised.
+ * @param blockFor the minimum number of replica acknowledgements/responses that were required to
+ * fulfill the operation.
+ * @param received the number of replica that had acknowledged/responded to the operation before
+ * it failed.
+ * @param retryCount how many times the retry policy has been invoked already for this request
+ * (not counting the current invocation).
+ */
+ int onWriteTimeoutBackoffMs(
+ @NonNull Request request,
+ @NonNull ConsistencyLevel cl,
+ @NonNull WriteType writeType,
+ int blockFor,
+ int received,
+ int retryCount,
+ RetryVerdict verdict);
+
+ /**
+ * Whether to retry when the server replied with an {@code UNAVAILABLE} error; this indicates that
+ * the coordinator determined that there were not enough replicas alive to perform a query with
+ * the requested consistency level.
+ *
+ * @param request the request that timed out.
+ * @param cl the requested consistency level.
+ * @param required the number of replica acknowledgements/responses required to perform the
+ * operation (with its required consistency level).
+ * @param alive the number of replicas that were known to be alive by the coordinator node when it
+ * tried to execute the operation.
+ * @param retryCount how many times the retry policy has been invoked already for this request
+ * (not counting the current invocation).
+ */
+ int onUnavailableBackoffMs(
+ @NonNull Request request,
+ @NonNull ConsistencyLevel cl,
+ int required,
+ int alive,
+ int retryCount,
+ RetryVerdict verdict);
+
+ /**
+ * Whether to retry when a request was aborted before we could get a response from the server.
+ *
+ * This can happen in two cases: if the connection was closed due to an external event (this
+ * will manifest as a {@link ClosedConnectionException}, or {@link HeartbeatException} for a
+ * heartbeat failure); or if there was an unexpected error while decoding the response (this can
+ * only be a driver bug).
+ *
+ * Note that this method will only be invoked for {@linkplain Request#isIdempotent()
+ * idempotent} requests: when execution was aborted before getting a response, it is impossible to
+ * determine with 100% certainty whether a mutation was applied or not, so a write is never safe
+ * to retry; the driver will rethrow the error directly, without invoking the retry policy.
+ *
+ * @param request the request that was aborted.
+ * @param error the error.
+ * @param retryCount how many times the retry policy has been invoked already for this request
+ * (not counting the current invocation).
+ */
+ int onRequestAbortedBackoffMs(
+ @NonNull Request request, @NonNull Throwable error, int retryCount, RetryVerdict verdict);
+
+ /**
+ * Whether to retry when the server replied with a recoverable error (other than {@code
+ * READ_TIMEOUT}, {@code WRITE_TIMEOUT} or {@code UNAVAILABLE}).
+ *
+ * This can happen for the following errors: {@link OverloadedException}, {@link ServerError},
+ * {@link TruncateException}, {@link ReadFailureException}, {@link WriteFailureException}.
+ *
+ * The following errors are handled internally by the driver, and therefore will never
+ * be encountered in this method:
+ *
+ * Note that this method will only be invoked for {@link Request#isIdempotent()} idempotent}
+ * requests: when execution was aborted before getting a response, it is impossible to determine
+ * with 100% certainty whether a mutation was applied or not, so a write is never safe to retry;
+ * the driver will rethrow the error directly, without invoking the retry policy.
+ *
+ * @param request the request that failed.
+ * @param error the error.
+ * @param retryCount how many times the retry policy has been invoked already for this request
+ * (not counting the current invocation).
+ */
+ int onErrorResponseBackoff(
+ @NonNull Request request,
+ @NonNull CoordinatorException error,
+ int retryCount,
+ RetryVerdict verdict);
+
+ /** Called when the cluster that this policy is associated with closes. */
+ @Override
+ void close();
+}
diff --git a/core/src/main/java/com/datastax/oss/driver/api/core/retry/BackoffRetryVerdict.java b/core/src/main/java/com/datastax/oss/driver/api/core/retry/BackoffRetryVerdict.java
new file mode 100644
index 00000000000..f95688d0319
--- /dev/null
+++ b/core/src/main/java/com/datastax/oss/driver/api/core/retry/BackoffRetryVerdict.java
@@ -0,0 +1,32 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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.oss.driver.api.core.retry;
+
+import java.time.Duration;
+
+/**
+ * The verdict returned by a {@link RetryPolicy} determining what to do when a request failed. A
+ * verdict contains a {@link RetryDecision} indicating if a retry should be attempted at all and
+ * where, with what delay, and a method that allows the original request to be modified before the
+ * retry.
+ */
+public interface BackoffRetryVerdict extends RetryVerdict {
+
+ /** @return a delay that request needs to take before retrying. */
+ Duration getRetryBackoff();
+}
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/context/DefaultDriverContext.java b/core/src/main/java/com/datastax/oss/driver/internal/core/context/DefaultDriverContext.java
index dd59a76f7d8..53d49b228e9 100644
--- a/core/src/main/java/com/datastax/oss/driver/internal/core/context/DefaultDriverContext.java
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/context/DefaultDriverContext.java
@@ -38,6 +38,7 @@
import com.datastax.oss.driver.api.core.metadata.Node;
import com.datastax.oss.driver.api.core.metadata.NodeStateListener;
import com.datastax.oss.driver.api.core.metadata.schema.SchemaChangeListener;
+import com.datastax.oss.driver.api.core.retry.BackoffRetryPolicy;
import com.datastax.oss.driver.api.core.retry.RetryPolicy;
import com.datastax.oss.driver.api.core.session.ProgrammaticArguments;
import com.datastax.oss.driver.api.core.session.throttling.RequestThrottler;
@@ -150,6 +151,8 @@ public class DefaultDriverContext implements InternalDriverContext {
new LazyReference<>("reconnectionPolicy", this::buildReconnectionPolicy, cycleDetector);
private final LazyReference This is a very conservative implementation: it triggers a maximum of one retry per request,
+ * and only in cases that have a high chance of success (see the method javadocs for detailed
+ * explanations of each case).
+ *
+ * To activate this policy, modify the {@code advanced.retry-policy} section in the driver
+ * configuration, for example:
+ *
+ * See {@code reference.conf} (in the manual or core driver JAR) for more details.
+ */
+@ThreadSafe
+public class ExponentialBackoffPolicy implements BackoffRetryPolicy {
+ private static final SplittableRandom random = new SplittableRandom();
+
+ private static final Logger LOG = LoggerFactory.getLogger(ExponentialBackoffPolicy.class);
+
+ @VisibleForTesting
+ public static final String BACKOFF_ON_READ_TIMEOUT =
+ "[{}] Delaying retry on read timeout for {}ms (consistency: {}, required responses: {}, "
+ + "received responses: {}, data retrieved: {}, retries: {})";
+
+ @VisibleForTesting
+ public static final String BACKOFF_ON_WRITE_TIMEOUT =
+ "[{}] Delaying retry on write timeout for {}ms (consistency: {}, write type: {}, "
+ + "required acknowledgments: {}, received acknowledgments: {}, retries: {})";
+
+ @VisibleForTesting
+ public static final String BACKOFF_ON_UNAVAILABLE =
+ "[{}] Delaying retry on unavailable exception for {}ms (consistency: {}, "
+ + "required replica: {}, alive replica: {}, retries: {})";
+
+ @VisibleForTesting
+ public static final String BACKOFF_ON_ABORTED =
+ "[{}] Delaying retry on aborted request for {}ms (retries: {})";
+
+ @VisibleForTesting
+ public static final String BACKOFF_ON_ERROR =
+ "[{}] Delaying on node error for {}ms (retries: {})";
+
+ private final String logPrefix;
+ private final int baseDelayMs;
+ private final int maxDelayMs;
+ private final double jitterRatio;
+
+ public ExponentialBackoffPolicy(DriverContext context, String profileName) {
+ DriverExecutionProfile profile = context.getConfig().getProfile(profileName);
+ this.logPrefix = context.getSessionName() + "|" + profileName;
+ this.baseDelayMs = profile.getInt(DefaultDriverOption.BACKOFF_RETRY_BASE_BACKOFF_MS);
+ this.maxDelayMs = profile.getInt(DefaultDriverOption.BACKOFF_RETRY_MAX_BACKOFF_MS);
+ this.jitterRatio = profile.getDouble(DefaultDriverOption.BACKOFF_RETRY_JITTER_RATIO);
+ }
+
+ public ExponentialBackoffPolicy(
+ String logPrefix, int baseDelayMs, int maxDelayMs, double jitterRatio) {
+ this.logPrefix = logPrefix;
+ this.baseDelayMs = baseDelayMs;
+ this.maxDelayMs = maxDelayMs;
+ this.jitterRatio = jitterRatio;
+ }
+
+ @Override
+ public int onReadTimeoutBackoffMs(
+ @NonNull Request request,
+ @NonNull ConsistencyLevel cl,
+ int blockFor,
+ int received,
+ boolean dataPresent,
+ int retryCount,
+ RetryVerdict verdict) {
+ int backoffMs = calculateBackoffMs(retryCount);
+ if (LOG.isTraceEnabled() && backoffMs != 0) {
+ LOG.trace(
+ BACKOFF_ON_READ_TIMEOUT, logPrefix, backoffMs, cl, blockFor, received, false, retryCount);
+ }
+ return backoffMs;
+ }
+
+ @Override
+ public int onWriteTimeoutBackoffMs(
+ @NonNull Request request,
+ @NonNull ConsistencyLevel cl,
+ @NonNull WriteType writeType,
+ int blockFor,
+ int received,
+ int retryCount,
+ RetryVerdict verdict) {
+ int backoffMs = calculateBackoffMs(retryCount);
+ if (LOG.isTraceEnabled() && backoffMs != 0) {
+ LOG.trace(
+ BACKOFF_ON_WRITE_TIMEOUT,
+ logPrefix,
+ backoffMs,
+ cl,
+ blockFor,
+ received,
+ false,
+ retryCount);
+ }
+ return backoffMs;
+ }
+
+ @Override
+ public int onUnavailableBackoffMs(
+ @NonNull Request request,
+ @NonNull ConsistencyLevel cl,
+ int required,
+ int alive,
+ int retryCount,
+ RetryVerdict verdict) {
+ int backoffMs = calculateBackoffMs(retryCount);
+ if (LOG.isTraceEnabled() && backoffMs != 0) {
+ LOG.trace(BACKOFF_ON_UNAVAILABLE, logPrefix, backoffMs, cl, required, alive, retryCount);
+ }
+ return backoffMs;
+ }
+
+ @Override
+ public int onRequestAbortedBackoffMs(
+ @NonNull Request request, @NonNull Throwable error, int retryCount, RetryVerdict verdict) {
+ int backoffMs = calculateBackoffMs(retryCount);
+ if (LOG.isTraceEnabled() && backoffMs != 0) {
+ LOG.trace(BACKOFF_ON_ABORTED, logPrefix, backoffMs, retryCount, error);
+ }
+ return backoffMs;
+ }
+
+ @Override
+ public int onErrorResponseBackoff(
+ @NonNull Request request,
+ @NonNull CoordinatorException error,
+ int retryCount,
+ RetryVerdict verdict) {
+ int backoffMs = calculateBackoffMs(retryCount);
+ if (LOG.isTraceEnabled() && backoffMs != 0) {
+ LOG.trace(BACKOFF_ON_ERROR, logPrefix, backoffMs, retryCount, error);
+ }
+ return backoffMs;
+ }
+
+ private int calculateBackoffMs(int attempt) {
+ int expDelay = (int) (baseDelayMs * Math.pow(2, attempt - 1));
+ int jitter = random.nextInt((int) (jitterRatio * expDelay));
+ return Math.min(expDelay + jitter, maxDelayMs);
+ }
+
+ @Override
+ public void close() {}
+}
diff --git a/core/src/main/java/com/datastax/oss/driver/internal/core/retry/NoBackoffPolicy.java b/core/src/main/java/com/datastax/oss/driver/internal/core/retry/NoBackoffPolicy.java
new file mode 100644
index 00000000000..d6e18ec3032
--- /dev/null
+++ b/core/src/main/java/com/datastax/oss/driver/internal/core/retry/NoBackoffPolicy.java
@@ -0,0 +1,109 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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.oss.driver.internal.core.retry;
+
+import com.datastax.oss.driver.api.core.ConsistencyLevel;
+import com.datastax.oss.driver.api.core.context.DriverContext;
+import com.datastax.oss.driver.api.core.retry.BackoffRetryPolicy;
+import com.datastax.oss.driver.api.core.retry.RetryVerdict;
+import com.datastax.oss.driver.api.core.servererrors.CoordinatorException;
+import com.datastax.oss.driver.api.core.servererrors.WriteType;
+import com.datastax.oss.driver.api.core.session.Request;
+import edu.umd.cs.findbugs.annotations.NonNull;
+import net.jcip.annotations.ThreadSafe;
+
+/**
+ * The default retry policy.
+ *
+ * This is a very conservative implementation: it triggers a maximum of one retry per request,
+ * and only in cases that have a high chance of success (see the method javadocs for detailed
+ * explanations of each case).
+ *
+ * To activate this policy, modify the {@code advanced.retry-policy} section in the driver
+ * configuration, for example:
+ *
+ *
+ *
+ *
+ *
+ * datastax-java-driver {
+ * advanced.retry-policy {
+ * class = DefaultRetryPolicy
+ * }
+ * }
+ *
+ *
+ *
+ * datastax-java-driver {
+ * advanced.retry-policy {
+ * class = DefaultRetryPolicy
+ * }
+ * }
+ *
+ *
+ * See {@code reference.conf} (in the manual or core driver JAR) for more details.
+ */
+@ThreadSafe
+public class NoBackoffPolicy implements BackoffRetryPolicy {
+
+ public NoBackoffPolicy(DriverContext context, String profileName) {}
+
+ public NoBackoffPolicy() {}
+
+ @Override
+ public int onReadTimeoutBackoffMs(
+ @NonNull Request request,
+ @NonNull ConsistencyLevel cl,
+ int blockFor,
+ int received,
+ boolean dataPresent,
+ int retryCount,
+ RetryVerdict verdict) {
+ return 0;
+ }
+
+ @Override
+ public int onWriteTimeoutBackoffMs(
+ @NonNull Request request,
+ @NonNull ConsistencyLevel cl,
+ @NonNull WriteType writeType,
+ int blockFor,
+ int received,
+ int retryCount,
+ RetryVerdict verdict) {
+ return 0;
+ }
+
+ @Override
+ public int onUnavailableBackoffMs(
+ @NonNull Request request,
+ @NonNull ConsistencyLevel cl,
+ int required,
+ int alive,
+ int retryCount,
+ RetryVerdict verdict) {
+ return 0;
+ }
+
+ @Override
+ public int onRequestAbortedBackoffMs(
+ @NonNull Request request, @NonNull Throwable error, int retryCount, RetryVerdict verdict) {
+ return 0;
+ }
+
+ @Override
+ public int onErrorResponseBackoff(
+ @NonNull Request request,
+ @NonNull CoordinatorException error,
+ int retryCount,
+ RetryVerdict verdict) {
+ return 0;
+ }
+
+ @Override
+ public void close() {}
+}
diff --git a/core/src/main/resources/reference.conf b/core/src/main/resources/reference.conf
index 1ac37d14132..84c44e3240c 100644
--- a/core/src/main/resources/reference.conf
+++ b/core/src/main/resources/reference.conf
@@ -649,6 +649,27 @@ datastax-java-driver {
class = DefaultRetryPolicy
}
+ advanced.backoff-retry-policy {
+ # The class of the policy. If it is not qualified, the driver assumes that it resides in the
+ # package com.datastax.oss.driver.internal.core.retry.
+ #
+ # The driver provides two implementations out of the box:
+ #
+ # - DefaultRetryPolicy: the default policy, should almost always be the right choice.
+ # - ConsistencyDowngradingRetryPolicy: an alternative policy that weakens consistency guarantees
+ # as a trade-off to maximize the chance of success when retrying. Use with caution.
+ #
+ # Refer to the manual to understand how these policies work.
+ #
+ # You can also specify a custom class that implements RetryPolicy and has a public constructor
+ # with two arguments: the DriverContext and a String representing the profile name.
+ class = NoBackoffPolicy
+
+ max-backoff-ms = 10000
+ base-backoff-ms = 100
+ jitter-ratio = 0.1
+ }
+
# The policy that controls if the driver pre-emptively tries other nodes if a node takes too long
# to respond.
#
diff --git a/core/src/test/java/com/datastax/oss/driver/api/core/config/TypedDriverOptionTest.java b/core/src/test/java/com/datastax/oss/driver/api/core/config/TypedDriverOptionTest.java
index eee4000a459..9e5a1a24f51 100644
--- a/core/src/test/java/com/datastax/oss/driver/api/core/config/TypedDriverOptionTest.java
+++ b/core/src/test/java/com/datastax/oss/driver/api/core/config/TypedDriverOptionTest.java
@@ -44,6 +44,7 @@ public void should_have_equivalents_for_all_builtin_untyped_options() {
ImmutableSet.of(
DefaultDriverOption.LOAD_BALANCING_POLICY,
DefaultDriverOption.RETRY_POLICY,
+ DefaultDriverOption.BACKOFF_RETRY_POLICY,
DefaultDriverOption.SPECULATIVE_EXECUTION_POLICY);
for (DriverOption option :
diff --git a/core/src/test/java/com/datastax/oss/driver/internal/core/config/map/MapBasedDriverConfigLoaderTest.java b/core/src/test/java/com/datastax/oss/driver/internal/core/config/map/MapBasedDriverConfigLoaderTest.java
index 93f6b274826..76966b9eefe 100644
--- a/core/src/test/java/com/datastax/oss/driver/internal/core/config/map/MapBasedDriverConfigLoaderTest.java
+++ b/core/src/test/java/com/datastax/oss/driver/internal/core/config/map/MapBasedDriverConfigLoaderTest.java
@@ -103,6 +103,8 @@ private Optional