From bf9b64b466cbc913fc7651d06a22a9d85e955f08 Mon Sep 17 00:00:00 2001 From: Tilly Oswell Wheeler Date: Tue, 15 Oct 2024 14:57:02 +0100 Subject: [PATCH 01/19] Added CassandraTException --- .../cassandra/CassandraClientFactory.java | 19 ++++-- .../CassandraKeyValueServiceImpl.java | 65 ++++++++++++------- .../cassandra/CassandraNamespaceDeleter.java | 2 +- .../CassandraNamespaceDeleterFactory.java | 3 +- .../cassandra/CassandraTExceptions.java | 49 ++++++++++++++ .../cassandra/CassandraTableTruncator.java | 3 +- .../cassandra/CassandraTimedOutException.java | 42 ++++++++++++ .../CassandraTimestampBackupRunner.java | 3 +- .../keyvalue/cassandra/CassandraVerifier.java | 3 +- .../keyvalue/cassandra/CqlExecutorImpl.java | 4 +- .../cassandra/TracingQueryRunner.java | 4 +- .../cassandra/WrappingQueryRunner.java | 20 ++++-- .../keyvalue/cassandra/paging/RowGetter.java | 5 +- 13 files changed, 169 insertions(+), 53 deletions(-) create mode 100644 atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraTExceptions.java create mode 100644 atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraTimedOutException.java diff --git a/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraClientFactory.java b/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraClientFactory.java index df5d31da551..ccc5a4f9f8d 100644 --- a/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraClientFactory.java +++ b/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraClientFactory.java @@ -119,8 +119,14 @@ private CassandraClient instrumentClient(Client rawClient) { return client; } - private Cassandra.Client getRawClientWithKeyspaceSet() throws TException { - Client ret = getRawClientWithTimedCreation(); + private Cassandra.Client getRawClientWithKeyspaceSet() { + Client ret; + try { + ret = getRawClientWithTimedCreation(); + } catch (TException e) { + throw CassandraTExceptions.mapToUncheckedException(e); + } + try { ret.set_keyspace(clientConfig.keyspace()); if (log.isDebugEnabled()) { @@ -136,7 +142,10 @@ private Cassandra.Client getRawClientWithKeyspaceSet() throws TException { return ret; } catch (TException e) { ret.getOutputProtocol().getTransport().close(); - throw e; + throw CassandraTExceptions.mapToUncheckedException( + "Failed to create new client for: {}", + e, + SafeArg.of("address", CassandraLogHelper.host(cassandraServer.proxy()))); } } @@ -210,8 +219,8 @@ private static Cassandra.Client getRawClient( addr); } catch (TException e) { client.getOutputProtocol().getTransport().close(); - log.error("Exception thrown attempting to authenticate with config provided credentials", e); - throw e; + throw CassandraTExceptions.mapToUncheckedException( + "Exception thrown attempting to authenticate with config provided credentials", e); } return client; diff --git a/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraKeyValueServiceImpl.java b/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraKeyValueServiceImpl.java index d0c224c108e..9e56bdcad60 100644 --- a/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraKeyValueServiceImpl.java +++ b/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraKeyValueServiceImpl.java @@ -151,6 +151,7 @@ import org.apache.cassandra.thrift.KsDef; import org.apache.cassandra.thrift.Mutation; import org.apache.cassandra.thrift.SlicePredicate; +import org.apache.cassandra.thrift.TimedOutException; import org.apache.thrift.TException; /** @@ -717,14 +718,18 @@ public Map> apply(CassandraClient client) SafeArg.of("startTs", startTs), SafeArg.of("host", host)); } + Map>> results = Collections.emptyMap(); + try { + results = wrappingQueryRunner.multiget_multislice( + "getRows", + client, + tableRef, + query, + readConsistencyProvider.getConsistency(tableRef)); - Map>> results = - wrappingQueryRunner.multiget_multislice( - "getRows", - client, - tableRef, - query, - readConsistencyProvider.getConsistency(tableRef)); + } catch (TException e) { + throw CassandraTExceptions.mapToUncheckedException(e, SafeArg.of("tableRef", tableRef)); + } return Maps.transformValues(results, CellLoader::flattenReadOnlyLists); } @@ -966,14 +971,18 @@ public RowColumnRangeResult apply(CassandraClient client) throws Exception { startTs); Limit limit = Limit.of(batchColumnRangeSelection.getBatchHint()); SlicePredicate pred = SlicePredicates.create(range, limit); - - Map> results = wrappingQueryRunner.multiget( - "getRowsColumnRange", - client, - tableRef, - wrap(rows), - pred, - readConsistencyProvider.getConsistency(tableRef)); + Map> results = Collections.emptyMap(); + try { + results = wrappingQueryRunner.multiget( + "getRowsColumnRange", + client, + tableRef, + wrap(rows), + pred, + readConsistencyProvider.getConsistency(tableRef)); + } catch (TException e) { + throw new TimedOutException(); + } return RowColumnRangeExtractor.extract(rows, results, startTs, metricsManager); } @@ -985,6 +994,8 @@ public String toString() { + " max columns)"; } }); + } catch (TimedOutException e) { + throw CassandraTExceptions.mapToUncheckedException(e, SafeArg.of("tableRef", tableRef)); } catch (Exception e) { throw Throwables.unwrapAndThrowAtlasDbDependencyException(e); } @@ -1029,15 +1040,19 @@ public TokenBackedBasicResultsPage, byte[]> apply( ByteBuffer rowByteBuffer = ByteBuffer.wrap(row); - Map> results = - wrappingQueryRunner.multiget( - "getRowsColumnRange", - client, - tableRef, - ImmutableList.of(rowByteBuffer), - pred, - readConsistencyProvider.getConsistency(tableRef)); - + Map> results = Collections.emptyMap(); + try { + results = wrappingQueryRunner.multiget( + "getRowsColumnRange", + client, + tableRef, + ImmutableList.of(rowByteBuffer), + pred, + readConsistencyProvider.getConsistency(tableRef)); + } catch (TException e) { + throw CassandraTExceptions.mapToUncheckedException( + e, SafeArg.of("tableRef", tableRef)); + } if (results.isEmpty()) { return SimpleTokenBackedResultsPage.create( startCol, ImmutableList.of(), false); @@ -1715,7 +1730,7 @@ public void deleteRange(final TableReference tableRef, final RangeRequest range) } catch (RetryLimitReachedException e) { throw CassandraUtils.wrapInIceForDeleteOrRethrow(e); } catch (TException e) { - throw Throwables.unwrapAndThrowAtlasDbDependencyException(e); + throw CassandraTExceptions.mapToUncheckedException(e); } } else { super.deleteRange(tableRef, range); diff --git a/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraNamespaceDeleter.java b/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraNamespaceDeleter.java index 96a118810f8..0b4723b0171 100644 --- a/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraNamespaceDeleter.java +++ b/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraNamespaceDeleter.java @@ -59,7 +59,7 @@ public boolean isNamespaceDeletedSuccessfully() { } catch (NotFoundException e) { return true; } catch (TException e) { - throw Throwables.throwUncheckedException(e); + throw CassandraTExceptions.mapToUncheckedException(e); } } diff --git a/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraNamespaceDeleterFactory.java b/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraNamespaceDeleterFactory.java index 150d8adbacf..c88ebea3ecf 100644 --- a/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraNamespaceDeleterFactory.java +++ b/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraNamespaceDeleterFactory.java @@ -27,7 +27,6 @@ import com.palantir.atlasdb.namespacedeleter.NamespaceDeleterFactory; import com.palantir.atlasdb.spi.KeyValueServiceConfig; import com.palantir.atlasdb.spi.KeyValueServiceRuntimeConfig; -import com.palantir.common.base.Throwables; import com.palantir.refreshable.Refreshable; import java.net.InetSocketAddress; import java.util.Optional; @@ -66,7 +65,7 @@ private static CassandraClient createClient( .orElseThrow(); return CassandraClientFactory.getClientInternal(CassandraServer.of(host), CassandraClientConfig.of(config)); } catch (TException e) { - throw Throwables.rewrapAndThrowUncheckedException(e); + throw CassandraTExceptions.mapToUncheckedException(e); } } } diff --git a/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraTExceptions.java b/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraTExceptions.java new file mode 100644 index 00000000000..f8ef54c64b1 --- /dev/null +++ b/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraTExceptions.java @@ -0,0 +1,49 @@ +/* + * (c) Copyright 2024 Palantir Technologies Inc. All rights reserved. + * + * 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.palantir.atlasdb.keyvalue.cassandra; + +import com.google.errorprone.annotations.CompileTimeConstant; +import com.palantir.atlasdb.keyvalue.api.InsufficientConsistencyException; +import com.palantir.common.exception.AtlasDbDependencyException; +import com.palantir.logsafe.Arg; +import org.apache.cassandra.thrift.TimedOutException; +import org.apache.cassandra.thrift.UnavailableException; + +public final class CassandraTExceptions { + private CassandraTExceptions() {} + + public static AtlasDbDependencyException mapToUncheckedException( + @CompileTimeConstant final String logMessage, Throwable throwable, Arg... args) { + if (throwable instanceof TimedOutException) { + return new CassandraTimedOutException(throwable, args); + } + if (throwable instanceof UnavailableException) { + return new InsufficientConsistencyException(logMessage, throwable); + } + return new AtlasDbDependencyException(throwable); + } + + public static AtlasDbDependencyException mapToUncheckedException(Throwable throwable, Arg... args) { + if (throwable instanceof TimedOutException) { + return new CassandraTimedOutException(throwable, args); + } + if (throwable instanceof UnavailableException) { + return new InsufficientConsistencyException(throwable); + } + return new AtlasDbDependencyException(throwable); + } +} diff --git a/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraTableTruncator.java b/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraTableTruncator.java index 2a724a261df..02f6aa3a986 100644 --- a/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraTableTruncator.java +++ b/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraTableTruncator.java @@ -18,7 +18,6 @@ import com.palantir.atlasdb.keyvalue.api.TableReference; import com.palantir.common.base.FunctionCheckedException; -import com.palantir.common.base.Throwables; import java.util.Collection; import org.apache.thrift.TException; @@ -36,7 +35,7 @@ void truncateTables(Collection tablesToTruncate) { try { runTruncateInternal(tablesToTruncate); } catch (TException e) { - throw Throwables.unwrapAndThrowAtlasDbDependencyException(e); + throw CassandraTExceptions.mapToUncheckedException(e); } } } diff --git a/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraTimedOutException.java b/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraTimedOutException.java new file mode 100644 index 00000000000..ee19eb90592 --- /dev/null +++ b/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraTimedOutException.java @@ -0,0 +1,42 @@ +/* + * (c) Copyright 2024 Palantir Technologies Inc. All rights reserved. + * + * 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.palantir.atlasdb.keyvalue.cassandra; + +import com.google.errorprone.annotations.CompileTimeConstant; +import com.palantir.common.exception.AtlasDbDependencyException; +import com.palantir.logsafe.Arg; +import com.palantir.logsafe.exceptions.SafeExceptions; + +public class CassandraTimedOutException extends AtlasDbDependencyException { + private static final long serialVersionUID = 1L; + + @CompileTimeConstant + private static final String LOG_MESSAGE = + "Cassandra query threw a TimedOut exception. Possible reasons and actions to resolve include:\n" + + "1. Reason: AtlasDB clients are requesting too much data from Cassandra.\n" + + " Resolution: Change the query to request less data.\n" + + "2. Reason: Data that has been deleted is being read in the query (e.g. A large amount of" + + " tombstones).\n" + + " Resolution: Run a compaction on your Cassandra server.\n" + + "3. Reason: Cassandra is struggling, possibly due to another large query, server health issues, or a" + + " network outage.\n" + + " Resolution: Ask your CassandraOps to check the state of the Cassandra server."; + + public CassandraTimedOutException(Throwable throwable, Arg... args) { + super(SafeExceptions.renderMessage(LOG_MESSAGE, args), throwable); + } +} diff --git a/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraTimestampBackupRunner.java b/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraTimestampBackupRunner.java index 85e0e82e94a..166f299ebe8 100644 --- a/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraTimestampBackupRunner.java +++ b/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraTimestampBackupRunner.java @@ -20,7 +20,6 @@ import com.palantir.atlasdb.AtlasDbConstants; import com.palantir.atlasdb.encoding.PtBytes; import com.palantir.common.annotation.Idempotent; -import com.palantir.common.base.Throwables; import com.palantir.logsafe.Preconditions; import com.palantir.logsafe.SafeArg; import com.palantir.logsafe.logger.SafeLogger; @@ -185,7 +184,7 @@ private CqlResult executeQueryUnchecked(CassandraClient client, CqlQuery query) AtlasDbConstants.TIMESTAMP_TABLE, () -> client.execute_cql3_query(query, Compression.NONE, ConsistencyLevel.QUORUM)); } catch (TException e) { - throw Throwables.rewrapAndThrowUncheckedException(e); + throw CassandraTExceptions.mapToUncheckedException(e); } } diff --git a/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraVerifier.java b/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraVerifier.java index 3c90ae8173f..7373351428d 100644 --- a/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraVerifier.java +++ b/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraVerifier.java @@ -35,7 +35,6 @@ import com.palantir.atlasdb.keyvalue.cassandra.CassandraClientFactory.CassandraClientConfig; import com.palantir.atlasdb.keyvalue.cassandra.pool.CassandraServer; import com.palantir.common.base.FunctionCheckedException; -import com.palantir.common.base.Throwables; import com.palantir.logsafe.DoNotLog; import com.palantir.logsafe.Preconditions; import com.palantir.logsafe.SafeArg; @@ -90,7 +89,7 @@ static Set sanityCheckDatacenters(CassandraClient client, CassandraVerif return sanityCheckDatacentersInternal( client, verifierConfig.replicationFactor(), verifierConfig.ignoreNodeTopologyChecks()); } catch (TException e) { - throw Throwables.throwUncheckedException(e); + throw CassandraTExceptions.mapToUncheckedException(e); } }); } diff --git a/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CqlExecutorImpl.java b/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CqlExecutorImpl.java index da7162be76f..3438cfa3878 100644 --- a/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CqlExecutorImpl.java +++ b/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CqlExecutorImpl.java @@ -270,7 +270,7 @@ public CqlPreparedResult prepare(ByteBuffer query, byte[] rowHintForHostSelectio hostsPerPreparedQuery.put(preparedResult.getItemId(), hostForRow); return preparedResult; } catch (TException e) { - throw Throwables.throwUncheckedException(e); + throw CassandraTExceptions.mapToUncheckedException(e); } } @@ -304,7 +304,7 @@ private CqlResult executeFunctionOnHost( } throw e; } catch (TException e) { - throw Throwables.throwUncheckedException(e); + throw CassandraTExceptions.mapToUncheckedException(e, SafeArg.of("server", cassandraServer)); } } diff --git a/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/TracingQueryRunner.java b/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/TracingQueryRunner.java index eccb9734f7b..a6db28b8783 100644 --- a/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/TracingQueryRunner.java +++ b/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/TracingQueryRunner.java @@ -53,7 +53,7 @@ public V run(CassandraClient client, Set tableRefs, Action V trace(Action action, CassandraClient client, Set } catch (TException e) { failed = true; logFailedCall(tableRefs); - throw e; + throw CassandraTExceptions.mapToUncheckedException(e); } finally { long duration = stopwatch.elapsed(TimeUnit.MILLISECONDS); logTraceResults(duration, tableRefs, traceId, failed); diff --git a/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/WrappingQueryRunner.java b/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/WrappingQueryRunner.java index 1d77ae8aedf..f89812823f3 100644 --- a/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/WrappingQueryRunner.java +++ b/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/WrappingQueryRunner.java @@ -18,6 +18,7 @@ import com.palantir.atlasdb.keyvalue.api.InsufficientConsistencyException; import com.palantir.atlasdb.keyvalue.api.TableReference; import com.palantir.atlasdb.keyvalue.cassandra.thrift.MutationMap; +import com.palantir.logsafe.SafeArg; import java.nio.ByteBuffer; import java.util.List; import java.util.Map; @@ -53,9 +54,10 @@ Void batchMutate( return null; }); } catch (UnavailableException e) { - throw new InsufficientConsistencyException( - "This batch mutate operation requires " + consistency + " Cassandra nodes to be up and available.", - e); + throw CassandraTExceptions.mapToUncheckedException( + "Batch mutate operation requires Cassandra nodes to be up and available. Check these nodes: ", + e, + SafeArg.of("consistency", consistency)); } } @@ -73,8 +75,10 @@ Map> multiget( tableRef, () -> client.multiget_slice(kvsMethodName, tableRef, rowNames, pred, consistency)); } catch (UnavailableException e) { - throw new InsufficientConsistencyException( - "This get operation requires " + consistency + " Cassandra nodes to be up and available.", e); + throw CassandraTExceptions.mapToUncheckedException( + "This get operation requires Cassandra nodes to be up and available. Check these nodes: ", + e, + SafeArg.of("consistency", consistency)); } } @@ -89,8 +93,10 @@ Map>> multiget_multislice( return queryRunner.run( client, tableRef, () -> client.multiget_multislice(kvsMethodName, tableRef, request, consistency)); } catch (UnavailableException e) { - throw new InsufficientConsistencyException( - "This get operation requires " + consistency + " Cassandra nodes to be up and available.", e); + throw CassandraTExceptions.mapToUncheckedException( + "This get operation requires Cassandra nodes to be up and available. Check these nodes: ", + e, + SafeArg.of("consistency", consistency)); } } } diff --git a/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/paging/RowGetter.java b/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/paging/RowGetter.java index 33832a349c5..354acb66b38 100644 --- a/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/paging/RowGetter.java +++ b/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/paging/RowGetter.java @@ -15,10 +15,10 @@ */ package com.palantir.atlasdb.keyvalue.cassandra.paging; -import com.palantir.atlasdb.keyvalue.api.InsufficientConsistencyException; import com.palantir.atlasdb.keyvalue.api.TableReference; import com.palantir.atlasdb.keyvalue.cassandra.CassandraClient; import com.palantir.atlasdb.keyvalue.cassandra.CassandraClientPool; +import com.palantir.atlasdb.keyvalue.cassandra.CassandraTExceptions; import com.palantir.atlasdb.keyvalue.cassandra.TracingQueryRunner; import com.palantir.atlasdb.keyvalue.cassandra.pool.CassandraServer; import com.palantir.atlasdb.keyvalue.cassandra.thrift.SlicePredicates; @@ -61,8 +61,7 @@ public List apply(CassandraClient client) { () -> client.get_range_slices( kvsMethodName, tableRef, slicePredicate, keyRange, consistency)); } catch (UnavailableException e) { - throw new InsufficientConsistencyException( - "get_range_slices requires " + consistency + " Cassandra nodes to be up and available.", e); + throw CassandraTExceptions.mapToUncheckedException("get_range_slices requires Cassandra nodes to be up and available. Check Cassandra nodes: ", e, SafeArg.of("consistency", consistency)); } catch (Exception e) { throw Throwables.unwrapAndThrowAtlasDbDependencyException(e); } From fcfcdd4a3c12098d52493537a5e115c402da6ebf Mon Sep 17 00:00:00 2001 From: Tilly Oswell Wheeler Date: Tue, 15 Oct 2024 15:49:35 +0100 Subject: [PATCH 02/19] Adding missedTExceptions --- .../keyvalue/cassandra/CassandraKeyValueServiceImpl.java | 4 ++-- .../atlasdb/keyvalue/cassandra/CassandraVerifier.java | 4 ++-- .../atlasdb/keyvalue/cassandra/paging/RowGetter.java | 5 ++++- 3 files changed, 8 insertions(+), 5 deletions(-) diff --git a/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraKeyValueServiceImpl.java b/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraKeyValueServiceImpl.java index 9e56bdcad60..42eb895106b 100644 --- a/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraKeyValueServiceImpl.java +++ b/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraKeyValueServiceImpl.java @@ -1768,7 +1768,7 @@ public void deleteRows(TableReference tableRef, Iterable rows) { } catch (RetryLimitReachedException e) { throw CassandraUtils.wrapInIceForDeleteOrRethrow(e); } catch (TException e) { - throw Throwables.unwrapAndThrowAtlasDbDependencyException(e); + throw CassandraTExceptions.mapToUncheckedException(e); } } @@ -1906,7 +1906,7 @@ public void deleteFromAtomicTable(TableReference tableRef, Set cells) { try { atomicTableCellDeleter.deleteFromAtomicTable(client, tableRef, cell); } catch (TException e) { - throw Throwables.unwrapAndThrowAtlasDbDependencyException(e); + throw CassandraTExceptions.mapToUncheckedException(e); } } return null; diff --git a/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraVerifier.java b/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraVerifier.java index 7373351428d..a52fe706f93 100644 --- a/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraVerifier.java +++ b/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraVerifier.java @@ -390,8 +390,8 @@ private static void checkRfsMatchConfig( if (isValidMigrationReplicationFactorState(replicationFactorVerifierConfig, strategyOptions)) { log.info( "Your current Cassandra keyspace had two datacenters with different replication factors, where" - + " the higher replication factor matched expected. This is a valid migration state, hence" - + " allowing it.", + + " the higher replication factor matched expected. This is a valid migration state, hence" + + " allowing it.", SafeArg.of("keyspace", ks.getName())); } else { logErrorOrThrow( diff --git a/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/paging/RowGetter.java b/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/paging/RowGetter.java index 354acb66b38..62bd93d8737 100644 --- a/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/paging/RowGetter.java +++ b/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/paging/RowGetter.java @@ -61,7 +61,10 @@ public List apply(CassandraClient client) { () -> client.get_range_slices( kvsMethodName, tableRef, slicePredicate, keyRange, consistency)); } catch (UnavailableException e) { - throw CassandraTExceptions.mapToUncheckedException("get_range_slices requires Cassandra nodes to be up and available. Check Cassandra nodes: ", e, SafeArg.of("consistency", consistency)); + throw CassandraTExceptions.mapToUncheckedException( + "get_range_slices requires Cassandra nodes to be up and available. Check Cassandra nodes: ", + e, + SafeArg.of("consistency", consistency)); } catch (Exception e) { throw Throwables.unwrapAndThrowAtlasDbDependencyException(e); } From 73922f58f6e0b964c6ef16d16e5088826e9d86d1 Mon Sep 17 00:00:00 2001 From: Tilly Oswell Wheeler Date: Tue, 15 Oct 2024 15:50:37 +0100 Subject: [PATCH 03/19] spotlessApply --- .../cassandra/CassandraTimedOutException.java | 16 ++++++++-------- .../keyvalue/cassandra/CassandraVerifier.java | 4 ++-- 2 files changed, 10 insertions(+), 10 deletions(-) diff --git a/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraTimedOutException.java b/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraTimedOutException.java index ee19eb90592..b47b5f8ffe0 100644 --- a/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraTimedOutException.java +++ b/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraTimedOutException.java @@ -27,14 +27,14 @@ public class CassandraTimedOutException extends AtlasDbDependencyException { @CompileTimeConstant private static final String LOG_MESSAGE = "Cassandra query threw a TimedOut exception. Possible reasons and actions to resolve include:\n" - + "1. Reason: AtlasDB clients are requesting too much data from Cassandra.\n" - + " Resolution: Change the query to request less data.\n" - + "2. Reason: Data that has been deleted is being read in the query (e.g. A large amount of" - + " tombstones).\n" - + " Resolution: Run a compaction on your Cassandra server.\n" - + "3. Reason: Cassandra is struggling, possibly due to another large query, server health issues, or a" - + " network outage.\n" - + " Resolution: Ask your CassandraOps to check the state of the Cassandra server."; + + "1. Reason: AtlasDB clients are requesting too much data from Cassandra.\n" + + " Resolution: Change the query to request less data.\n" + + "2. Reason: Data that has been deleted is being read in the query (e.g. A large amount of" + + " tombstones).\n" + + " Resolution: Run a compaction on your Cassandra server.\n" + + "3. Reason: Cassandra is struggling, possibly due to another large query, server health issues, or a" + + " network outage.\n" + + " Resolution: Ask your CassandraOps to check the state of the Cassandra server."; public CassandraTimedOutException(Throwable throwable, Arg... args) { super(SafeExceptions.renderMessage(LOG_MESSAGE, args), throwable); diff --git a/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraVerifier.java b/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraVerifier.java index a52fe706f93..7373351428d 100644 --- a/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraVerifier.java +++ b/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraVerifier.java @@ -390,8 +390,8 @@ private static void checkRfsMatchConfig( if (isValidMigrationReplicationFactorState(replicationFactorVerifierConfig, strategyOptions)) { log.info( "Your current Cassandra keyspace had two datacenters with different replication factors, where" - + " the higher replication factor matched expected. This is a valid migration state, hence" - + " allowing it.", + + " the higher replication factor matched expected. This is a valid migration state, hence" + + " allowing it.", SafeArg.of("keyspace", ks.getName())); } else { logErrorOrThrow( From 5ca86f77418c73c4a5255247198c79df2a2da254 Mon Sep 17 00:00:00 2001 From: Tilly Oswell Wheeler Date: Tue, 15 Oct 2024 16:02:20 +0100 Subject: [PATCH 04/19] Added UnavailableException catches --- .../atlasdb/keyvalue/cassandra/CassandraUtils.java | 2 +- .../keyvalue/cassandra/cas/CheckAndSetRunner.java | 9 ++++++--- .../atlasdb/keyvalue/cassandra/paging/RowGetter.java | 1 + 3 files changed, 8 insertions(+), 4 deletions(-) diff --git a/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraUtils.java b/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraUtils.java index 9d553ffc1ea..daab4b262cc 100644 --- a/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraUtils.java +++ b/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraUtils.java @@ -42,7 +42,7 @@ public static FunctionCheckedException, Except public static AtlasDbDependencyException wrapInIceForDeleteOrRethrow(RetryLimitReachedException ex) { if (ex.suppressed(UnavailableException.class) || ex.suppressed(InsufficientConsistencyException.class)) { - throw new InsufficientConsistencyException("Deleting requires all Cassandra nodes to be available.", ex); + throw CassandraTExceptions.mapToUncheckedException("Deleting requires all Cassandra nodes to be available.", ex); } throw ex; } diff --git a/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/cas/CheckAndSetRunner.java b/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/cas/CheckAndSetRunner.java index 5b23304e762..8206503b3b7 100644 --- a/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/cas/CheckAndSetRunner.java +++ b/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/cas/CheckAndSetRunner.java @@ -17,11 +17,12 @@ import com.google.protobuf.ByteString; import com.palantir.atlasdb.keyvalue.api.CheckAndSetRequest; -import com.palantir.atlasdb.keyvalue.api.InsufficientConsistencyException; import com.palantir.atlasdb.keyvalue.api.TableReference; import com.palantir.atlasdb.keyvalue.cassandra.CassandraClient; +import com.palantir.atlasdb.keyvalue.cassandra.CassandraTExceptions; import com.palantir.atlasdb.keyvalue.cassandra.TracingQueryRunner; import com.palantir.atlasdb.keyvalue.impl.CheckAndSetResult; +import com.palantir.logsafe.SafeArg; import org.apache.cassandra.thrift.Compression; import org.apache.cassandra.thrift.ConsistencyLevel; import org.apache.cassandra.thrift.CqlResult; @@ -47,8 +48,10 @@ public CheckAndSetResult executeCheckAndSet(CassandraClient client, CheckAndSetQueries.getQueryForRequest(request), Compression.NONE, writeConsistency)); return CheckAndSetResponseDecoder.decodeCqlResult(result); } catch (UnavailableException e) { - throw new InsufficientConsistencyException( - "Check-and-set requires " + writeConsistency + " Cassandra nodes to be up and available.", e); + throw CassandraTExceptions.mapToUncheckedException( + "Check-and-set requires Cassandra nodes to be up and available. Check these nodes: ", + e, + SafeArg.of("writeConsistency", writeConsistency)); } } } diff --git a/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/paging/RowGetter.java b/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/paging/RowGetter.java index 62bd93d8737..8e1eb5f19ba 100644 --- a/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/paging/RowGetter.java +++ b/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/paging/RowGetter.java @@ -24,6 +24,7 @@ import com.palantir.atlasdb.keyvalue.cassandra.thrift.SlicePredicates; import com.palantir.common.base.FunctionCheckedException; import com.palantir.common.base.Throwables; +import com.palantir.logsafe.SafeArg; import java.util.List; import java.util.stream.Collectors; import org.apache.cassandra.thrift.ConsistencyLevel; From e49373c69645e48358b4a29d584fbff3a29f0e94 Mon Sep 17 00:00:00 2001 From: svc-changelog Date: Tue, 15 Oct 2024 15:05:19 +0000 Subject: [PATCH 05/19] Add generated changelog entries --- changelog/@unreleased/pr-7353.v2.yml | 10 ++++++++++ 1 file changed, 10 insertions(+) create mode 100644 changelog/@unreleased/pr-7353.v2.yml diff --git a/changelog/@unreleased/pr-7353.v2.yml b/changelog/@unreleased/pr-7353.v2.yml new file mode 100644 index 00000000000..8ff2acd70fb --- /dev/null +++ b/changelog/@unreleased/pr-7353.v2.yml @@ -0,0 +1,10 @@ +type: improvement +improvement: + description: |- + New Exception classes: + - CassandraTExceptions() + - CassandraTimedOutException() + + Amended how UnavailableException TSwift Cassandra native Exceptions are caught, and they now get mapped to InsufficientConsistencyException() via CassandraTExceptions(). + links: + - https://github.com/palantir/atlasdb/pull/7353 From a64466caf1f00ad28d97cc1ff94eadedfa8f4aaa Mon Sep 17 00:00:00 2001 From: Tilly Oswell Wheeler Date: Tue, 15 Oct 2024 16:24:43 +0100 Subject: [PATCH 06/19] Ammended the CassadraException to include args as the other PR will implement --- .../keyvalue/api/InsufficientConsistencyException.java | 5 +++++ .../atlasdb/keyvalue/cassandra/CassandraTExceptions.java | 4 ++-- .../palantir/atlasdb/keyvalue/cassandra/CassandraUtils.java | 3 ++- 3 files changed, 9 insertions(+), 3 deletions(-) diff --git a/atlasdb-api/src/main/java/com/palantir/atlasdb/keyvalue/api/InsufficientConsistencyException.java b/atlasdb-api/src/main/java/com/palantir/atlasdb/keyvalue/api/InsufficientConsistencyException.java index 75471acf822..233fd19a30c 100644 --- a/atlasdb-api/src/main/java/com/palantir/atlasdb/keyvalue/api/InsufficientConsistencyException.java +++ b/atlasdb-api/src/main/java/com/palantir/atlasdb/keyvalue/api/InsufficientConsistencyException.java @@ -16,6 +16,7 @@ package com.palantir.atlasdb.keyvalue.api; import com.palantir.common.exception.AtlasDbDependencyException; +import com.palantir.logsafe.Arg; /** * Thrown by a key value service when an operation could not be performed @@ -31,4 +32,8 @@ public InsufficientConsistencyException(String msg) { public InsufficientConsistencyException(String msg, Throwable ex) { super(msg, ex); } + + public InsufficientConsistencyException(Throwable ex, Arg... args) { + super(ex, args); + } } diff --git a/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraTExceptions.java b/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraTExceptions.java index f8ef54c64b1..d30fa4c1826 100644 --- a/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraTExceptions.java +++ b/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraTExceptions.java @@ -42,8 +42,8 @@ public static AtlasDbDependencyException mapToUncheckedException(Throwable throw return new CassandraTimedOutException(throwable, args); } if (throwable instanceof UnavailableException) { - return new InsufficientConsistencyException(throwable); + return new InsufficientConsistencyException(throwable, args); } - return new AtlasDbDependencyException(throwable); + return new AtlasDbDependencyException(throwable, args); } } diff --git a/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraUtils.java b/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraUtils.java index daab4b262cc..e2d0f125be1 100644 --- a/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraUtils.java +++ b/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraUtils.java @@ -42,7 +42,8 @@ public static FunctionCheckedException, Except public static AtlasDbDependencyException wrapInIceForDeleteOrRethrow(RetryLimitReachedException ex) { if (ex.suppressed(UnavailableException.class) || ex.suppressed(InsufficientConsistencyException.class)) { - throw CassandraTExceptions.mapToUncheckedException("Deleting requires all Cassandra nodes to be available.", ex); + throw CassandraTExceptions.mapToUncheckedException( + "Deleting requires all Cassandra nodes to be available.", ex); } throw ex; } From 4ece4094879f1ee6ac18258e57236baabf193e10 Mon Sep 17 00:00:00 2001 From: Tilly Oswell Wheeler Date: Fri, 18 Oct 2024 12:35:19 +0100 Subject: [PATCH 07/19] Amended compileTime --- .../api/InsufficientConsistencyException.java | 9 +++-- .../cassandra/CassandraClientFactory.java | 20 +++++++--- .../cassandra/CassandraTimedOutException.java | 3 +- .../exception/AtlasDbDependencyException.java | 39 +++++++++++++++---- 4 files changed, 52 insertions(+), 19 deletions(-) diff --git a/atlasdb-api/src/main/java/com/palantir/atlasdb/keyvalue/api/InsufficientConsistencyException.java b/atlasdb-api/src/main/java/com/palantir/atlasdb/keyvalue/api/InsufficientConsistencyException.java index 233fd19a30c..3d6139e3490 100644 --- a/atlasdb-api/src/main/java/com/palantir/atlasdb/keyvalue/api/InsufficientConsistencyException.java +++ b/atlasdb-api/src/main/java/com/palantir/atlasdb/keyvalue/api/InsufficientConsistencyException.java @@ -15,6 +15,7 @@ */ package com.palantir.atlasdb.keyvalue.api; +import com.google.errorprone.annotations.CompileTimeConstant; import com.palantir.common.exception.AtlasDbDependencyException; import com.palantir.logsafe.Arg; @@ -25,12 +26,12 @@ public class InsufficientConsistencyException extends AtlasDbDependencyException { private static final long serialVersionUID = 1L; - public InsufficientConsistencyException(String msg) { - super(msg); + public InsufficientConsistencyException(@CompileTimeConstant String msg, Arg... args) { + super(msg, args); } - public InsufficientConsistencyException(String msg, Throwable ex) { - super(msg, ex); + public InsufficientConsistencyException(@CompileTimeConstant String msg, Throwable ex, Arg... args) { + super(msg, ex, args); } public InsufficientConsistencyException(Throwable ex, Arg... args) { diff --git a/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraClientFactory.java b/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraClientFactory.java index ccc5a4f9f8d..c9f992cf450 100644 --- a/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraClientFactory.java +++ b/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraClientFactory.java @@ -20,6 +20,7 @@ import com.github.benmanes.caffeine.cache.LoadingCache; import com.google.common.annotations.VisibleForTesting; import com.google.common.collect.ImmutableSet; +import com.google.errorprone.annotations.CompileTimeConstant; import com.palantir.atlasdb.cassandra.CassandraCredentialsConfig; import com.palantir.atlasdb.cassandra.CassandraKeyValueServiceConfig; import com.palantir.atlasdb.keyvalue.cassandra.ImmutableCassandraClientConfig.SocketTimeoutMillisBuildStage; @@ -31,6 +32,7 @@ import com.palantir.conjure.java.api.config.ssl.SslConfiguration; import com.palantir.conjure.java.config.ssl.SslSocketFactories; import com.palantir.exception.SafeSSLPeerUnverifiedException; +import com.palantir.logsafe.Arg; import com.palantir.logsafe.DoNotLog; import com.palantir.logsafe.SafeArg; import com.palantir.logsafe.UnsafeArg; @@ -102,9 +104,17 @@ public CassandraClient create() { String message = String.format( "Failed to construct client for %s/%s", cassandraServer.proxy(), clientConfig.keyspace()); if (clientConfig.usingSsl()) { - message += " over SSL"; + throw new ClientCreationFailedException( + "Failed to construct client for {}/{} over SSL", + e, + SafeArg.of("proxy", CassandraLogHelper.host(cassandraServer.proxy())), + SafeArg.of("keyspace", clientConfig.keyspace())); } - throw new ClientCreationFailedException(message, e); + throw new ClientCreationFailedException( + "Failed to construct client for {}/{}", + e, + SafeArg.of("proxy", CassandraLogHelper.host(cassandraServer.proxy())), + SafeArg.of("keyspace", clientConfig.keyspace())); } } @@ -133,7 +143,7 @@ private Cassandra.Client getRawClientWithKeyspaceSet() { log.debug( "Created new client for {}/{}{}{}", SafeArg.of("address", CassandraLogHelper.host(cassandraServer.proxy())), - UnsafeArg.of("keyspace", clientConfig.keyspace()), + SafeArg.of("keyspace", clientConfig.keyspace()), SafeArg.of("usingSsl", clientConfig.usingSsl() ? " over SSL" : ""), UnsafeArg.of( "usernameConfig", @@ -321,8 +331,8 @@ public void destroyObject(PooledObject client) { static final class ClientCreationFailedException extends AtlasDbDependencyException { private static final long serialVersionUID = 1L; - ClientCreationFailedException(String message, Exception cause) { - super(message, cause); + ClientCreationFailedException(@CompileTimeConstant String message, Exception cause, Arg... args) { + super(message, cause, args); } } diff --git a/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraTimedOutException.java b/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraTimedOutException.java index b47b5f8ffe0..1631c298f64 100644 --- a/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraTimedOutException.java +++ b/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraTimedOutException.java @@ -16,15 +16,14 @@ package com.palantir.atlasdb.keyvalue.cassandra; -import com.google.errorprone.annotations.CompileTimeConstant; import com.palantir.common.exception.AtlasDbDependencyException; import com.palantir.logsafe.Arg; import com.palantir.logsafe.exceptions.SafeExceptions; +@SuppressWarnings("CompileTimeConstant") public class CassandraTimedOutException extends AtlasDbDependencyException { private static final long serialVersionUID = 1L; - @CompileTimeConstant private static final String LOG_MESSAGE = "Cassandra query threw a TimedOut exception. Possible reasons and actions to resolve include:\n" + "1. Reason: AtlasDB clients are requesting too much data from Cassandra.\n" diff --git a/atlasdb-commons/src/main/java/com/palantir/common/exception/AtlasDbDependencyException.java b/atlasdb-commons/src/main/java/com/palantir/common/exception/AtlasDbDependencyException.java index b52f38247ba..b5bf53b3b5d 100644 --- a/atlasdb-commons/src/main/java/com/palantir/common/exception/AtlasDbDependencyException.java +++ b/atlasdb-commons/src/main/java/com/palantir/common/exception/AtlasDbDependencyException.java @@ -15,18 +15,41 @@ */ package com.palantir.common.exception; -public class AtlasDbDependencyException extends RuntimeException { - private static final String EXCEPTION_MESSAGE = "AtlasDB dependency threw an exception."; +import com.google.errorprone.annotations.CompileTimeConstant; +import com.palantir.logsafe.Arg; +import com.palantir.logsafe.Safe; +import com.palantir.logsafe.SafeLoggable; +import com.palantir.logsafe.exceptions.SafeExceptions; +import java.util.Arrays; +import java.util.List; +import javax.annotation.Nullable; - public AtlasDbDependencyException(String msg) { - super(msg); +public class AtlasDbDependencyException extends RuntimeException implements SafeLoggable { + private final List> args; + private final String logMessage; + + public AtlasDbDependencyException(@CompileTimeConstant String logMessage, Arg... args) { + this(logMessage, null, args); + } + + public AtlasDbDependencyException(Throwable throwable, Arg... args) { + this("AtlasDB dependency threw an exception.", throwable, args); + } + + public AtlasDbDependencyException( + @Safe @CompileTimeConstant String logMessage, @Nullable Throwable cause, Arg... args) { + super(SafeExceptions.renderMessage(logMessage, args), cause); + this.args = Arrays.asList(args); + this.logMessage = logMessage; } - public AtlasDbDependencyException(String msg, Throwable throwable) { - super(msg, throwable); + @Override + public @Safe String getLogMessage() { + return logMessage; } - public AtlasDbDependencyException(Throwable throwable) { - super(EXCEPTION_MESSAGE, throwable); + @Override + public List> getArgs() { + return args; } } From d0d672f45b091b9e8f5a95dc175221ff651b00ee Mon Sep 17 00:00:00 2001 From: Tilly Oswell Wheeler Date: Fri, 18 Oct 2024 12:35:58 +0100 Subject: [PATCH 08/19] explainer for compile time suppression --- .../cassandra/CassandraTimedOutException.java | 18 ++++++++++-------- 1 file changed, 10 insertions(+), 8 deletions(-) diff --git a/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraTimedOutException.java b/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraTimedOutException.java index 1631c298f64..2994eec9aa8 100644 --- a/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraTimedOutException.java +++ b/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraTimedOutException.java @@ -20,20 +20,22 @@ import com.palantir.logsafe.Arg; import com.palantir.logsafe.exceptions.SafeExceptions; +// Added the below suppression because the Runtime class compileTime string check sees the + in the static final as +// non compile time safe. But no other way to achieve as we are using a java version that does not have text blocks. @SuppressWarnings("CompileTimeConstant") public class CassandraTimedOutException extends AtlasDbDependencyException { private static final long serialVersionUID = 1L; private static final String LOG_MESSAGE = "Cassandra query threw a TimedOut exception. Possible reasons and actions to resolve include:\n" - + "1. Reason: AtlasDB clients are requesting too much data from Cassandra.\n" - + " Resolution: Change the query to request less data.\n" - + "2. Reason: Data that has been deleted is being read in the query (e.g. A large amount of" - + " tombstones).\n" - + " Resolution: Run a compaction on your Cassandra server.\n" - + "3. Reason: Cassandra is struggling, possibly due to another large query, server health issues, or a" - + " network outage.\n" - + " Resolution: Ask your CassandraOps to check the state of the Cassandra server."; + + "1. Reason: AtlasDB clients are requesting too much data from Cassandra.\n" + + " Resolution: Change the query to request less data.\n" + + "2. Reason: Data that has been deleted is being read in the query (e.g. A large amount of" + + " tombstones).\n" + + " Resolution: Run a compaction on your Cassandra server.\n" + + "3. Reason: Cassandra is struggling, possibly due to another large query, server health issues, or a" + + " network outage.\n" + + " Resolution: Ask your CassandraOps to check the state of the Cassandra server."; public CassandraTimedOutException(Throwable throwable, Arg... args) { super(SafeExceptions.renderMessage(LOG_MESSAGE, args), throwable); From a7cc4617779d30d81d7fc26bc569301eb7909732 Mon Sep 17 00:00:00 2001 From: Tilly Oswell Wheeler Date: Fri, 18 Oct 2024 13:04:24 +0100 Subject: [PATCH 09/19] typo --- .../atlasdb/keyvalue/api/InsufficientConsistencyException.java | 1 + 1 file changed, 1 insertion(+) diff --git a/atlasdb-api/src/main/java/com/palantir/atlasdb/keyvalue/api/InsufficientConsistencyException.java b/atlasdb-api/src/main/java/com/palantir/atlasdb/keyvalue/api/InsufficientConsistencyException.java index 948b6121a30..3d6139e3490 100644 --- a/atlasdb-api/src/main/java/com/palantir/atlasdb/keyvalue/api/InsufficientConsistencyException.java +++ b/atlasdb-api/src/main/java/com/palantir/atlasdb/keyvalue/api/InsufficientConsistencyException.java @@ -32,6 +32,7 @@ public InsufficientConsistencyException(@CompileTimeConstant String msg, Arg. public InsufficientConsistencyException(@CompileTimeConstant String msg, Throwable ex, Arg... args) { super(msg, ex, args); + } public InsufficientConsistencyException(Throwable ex, Arg... args) { super(ex, args); From d269d60c1f00d9a4c76c7494dd5f6dde734fca47 Mon Sep 17 00:00:00 2001 From: Tilly Oswell Wheeler Date: Fri, 18 Oct 2024 13:19:57 +0100 Subject: [PATCH 10/19] Api break confirmation not a break as break has been fixed via same PR --- .palantir/revapi.yml | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/.palantir/revapi.yml b/.palantir/revapi.yml index cd44a79b8fd..cf167609357 100644 --- a/.palantir/revapi.yml +++ b/.palantir/revapi.yml @@ -423,6 +423,22 @@ acceptedBreaks: new: "method void com.palantir.atlasdb.keyvalue.api.InsufficientConsistencyException::(java.lang.String,\ \ java.lang.Throwable, com.palantir.logsafe.Arg[])" justification: "I have fixed all the implementations and it is not used externally" + "0.1169.0": + com.palantir.atlasdb:atlasdb-api: + - code: "java.method.parameterTypeChanged" + old: "parameter void com.palantir.atlasdb.keyvalue.api.InsufficientConsistencyException::(===java.lang.String===,\ + \ java.lang.Throwable)" + new: "parameter void com.palantir.atlasdb.keyvalue.api.InsufficientConsistencyException::(===java.lang.Throwable===,\ + \ com.palantir.logsafe.Arg[])" + justification: "Not a break as I have handle the implementation in the same\ + \ PR" + - code: "java.method.parameterTypeChanged" + old: "parameter void com.palantir.atlasdb.keyvalue.api.InsufficientConsistencyException::(java.lang.String,\ + \ ===java.lang.Throwable===)" + new: "parameter void com.palantir.atlasdb.keyvalue.api.InsufficientConsistencyException::(java.lang.Throwable,\ + \ ===com.palantir.logsafe.Arg[]===)" + justification: "Not a break as I have handle the implementation in the same\ + \ PR" "0.770.0": com.palantir.atlasdb:atlasdb-api: - code: "java.class.removed" From b0ee926fdbe034f68424cac7868022d4e05f162a Mon Sep 17 00:00:00 2001 From: Tilly Oswell Wheeler Date: Fri, 18 Oct 2024 13:36:24 +0100 Subject: [PATCH 11/19] spoteless --- .../cassandra/CassandraTimedOutException.java | 16 ++++++++-------- .../keyvalue/cassandra/paging/RowGetter.java | 3 ++- 2 files changed, 10 insertions(+), 9 deletions(-) diff --git a/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraTimedOutException.java b/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraTimedOutException.java index 2994eec9aa8..775d8b2fb02 100644 --- a/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraTimedOutException.java +++ b/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraTimedOutException.java @@ -28,14 +28,14 @@ public class CassandraTimedOutException extends AtlasDbDependencyException { private static final String LOG_MESSAGE = "Cassandra query threw a TimedOut exception. Possible reasons and actions to resolve include:\n" - + "1. Reason: AtlasDB clients are requesting too much data from Cassandra.\n" - + " Resolution: Change the query to request less data.\n" - + "2. Reason: Data that has been deleted is being read in the query (e.g. A large amount of" - + " tombstones).\n" - + " Resolution: Run a compaction on your Cassandra server.\n" - + "3. Reason: Cassandra is struggling, possibly due to another large query, server health issues, or a" - + " network outage.\n" - + " Resolution: Ask your CassandraOps to check the state of the Cassandra server."; + + "1. Reason: AtlasDB clients are requesting too much data from Cassandra.\n" + + " Resolution: Change the query to request less data.\n" + + "2. Reason: Data that has been deleted is being read in the query (e.g. A large amount of" + + " tombstones).\n" + + " Resolution: Run a compaction on your Cassandra server.\n" + + "3. Reason: Cassandra is struggling, possibly due to another large query, server health issues, or a" + + " network outage.\n" + + " Resolution: Ask your CassandraOps to check the state of the Cassandra server."; public CassandraTimedOutException(Throwable throwable, Arg... args) { super(SafeExceptions.renderMessage(LOG_MESSAGE, args), throwable); diff --git a/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/paging/RowGetter.java b/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/paging/RowGetter.java index 808d99dd6e8..8e1eb5f19ba 100644 --- a/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/paging/RowGetter.java +++ b/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/paging/RowGetter.java @@ -63,7 +63,8 @@ public List apply(CassandraClient client) { kvsMethodName, tableRef, slicePredicate, keyRange, consistency)); } catch (UnavailableException e) { throw CassandraTExceptions.mapToUncheckedException( - "get_range_slices requires Cassandra nodes to be up and available. Check Cassandra nodes: ", e, + "get_range_slices requires Cassandra nodes to be up and available. Check Cassandra nodes: ", + e, SafeArg.of("consistency", consistency)); } catch (Exception e) { throw Throwables.unwrapAndThrowAtlasDbDependencyException(e); From 86d55f3f9695c904a0bad5426e890228e3e7220a Mon Sep 17 00:00:00 2001 From: Tilly Oswell Wheeler Date: Mon, 21 Oct 2024 15:27:31 +0100 Subject: [PATCH 12/19] Added a catch for a TEXception --- .../atlasdb/keyvalue/cassandra/CassandraTExceptions.java | 3 +++ .../palantir/atlasdb/keyvalue/cassandra/CellRangeDeleter.java | 2 ++ 2 files changed, 5 insertions(+) diff --git a/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraTExceptions.java b/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraTExceptions.java index d30fa4c1826..b3df3f7a5ec 100644 --- a/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraTExceptions.java +++ b/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraTExceptions.java @@ -34,6 +34,9 @@ public static AtlasDbDependencyException mapToUncheckedException( if (throwable instanceof UnavailableException) { return new InsufficientConsistencyException(logMessage, throwable); } + if (throwable instanceof InsufficientConsistencyException) { + return new InsufficientConsistencyException(logMessage, throwable); + } return new AtlasDbDependencyException(throwable); } diff --git a/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CellRangeDeleter.java b/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CellRangeDeleter.java index 1788a56e922..676285f2bd7 100644 --- a/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CellRangeDeleter.java +++ b/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CellRangeDeleter.java @@ -97,6 +97,8 @@ public String toString() { }); } catch (RetryLimitReachedException e) { throw CassandraUtils.wrapInIceForDeleteOrRethrow(e); + } catch (TException e) { + throw CassandraTExceptions.mapToUncheckedException(e); } catch (Exception e) { throw Throwables.unwrapAndThrowAtlasDbDependencyException(e); } From fda40b59e815de025d87b0b4a94ff30557a6c596 Mon Sep 17 00:00:00 2001 From: Tilly Oswell Wheeler Date: Wed, 23 Oct 2024 14:19:35 +0100 Subject: [PATCH 13/19] change exception caught --- .../cassandra/multinode/AbstractDegradedClusterTest.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/atlasdb-cassandra-multinode-tests/src/test/java/com/palantir/cassandra/multinode/AbstractDegradedClusterTest.java b/atlasdb-cassandra-multinode-tests/src/test/java/com/palantir/cassandra/multinode/AbstractDegradedClusterTest.java index 2b4b6a6834d..d32389ec93d 100644 --- a/atlasdb-cassandra-multinode-tests/src/test/java/com/palantir/cassandra/multinode/AbstractDegradedClusterTest.java +++ b/atlasdb-cassandra-multinode-tests/src/test/java/com/palantir/cassandra/multinode/AbstractDegradedClusterTest.java @@ -24,13 +24,13 @@ import com.palantir.atlasdb.AtlasDbConstants; import com.palantir.atlasdb.encoding.PtBytes; import com.palantir.atlasdb.keyvalue.api.Cell; -import com.palantir.atlasdb.keyvalue.api.InsufficientConsistencyException; import com.palantir.atlasdb.keyvalue.api.KeyValueService; import com.palantir.atlasdb.keyvalue.api.TableReference; import com.palantir.atlasdb.keyvalue.api.Value; import com.palantir.atlasdb.keyvalue.cassandra.CassandraClient; import com.palantir.atlasdb.keyvalue.cassandra.CassandraKeyValueService; import com.palantir.atlasdb.keyvalue.cassandra.CassandraKeyValueServices; +import com.palantir.atlasdb.keyvalue.cassandra.CassandraTExceptions; import com.palantir.common.base.RunnableCheckedException; import com.palantir.common.exception.AtlasDbDependencyException; import java.util.HashMap; @@ -107,7 +107,7 @@ void assertThrowsAtlasDbDependencyExceptionAndDoesNotChangeCassandraSchema(Runna } void assertThrowsInsufficientConsistencyExceptionAndDoesNotChangeCassandraSchema(RunnableCheckedException task) { - assertThatThrownBy(task::run).isInstanceOf(InsufficientConsistencyException.class); + assertThatThrownBy(task::run).isInstanceOf(CassandraTExceptions.class); assertCassandraSchemaUnchanged(); } From 49fb7e113977d94bcfab5ab8163cccc513d135fa Mon Sep 17 00:00:00 2001 From: Tilly Oswell Wheeler Date: Wed, 23 Oct 2024 15:22:38 +0100 Subject: [PATCH 14/19] Change to catch AtlasDbDependency excpetion --- .../cassandra/multinode/AbstractDegradedClusterTest.java | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/atlasdb-cassandra-multinode-tests/src/test/java/com/palantir/cassandra/multinode/AbstractDegradedClusterTest.java b/atlasdb-cassandra-multinode-tests/src/test/java/com/palantir/cassandra/multinode/AbstractDegradedClusterTest.java index d32389ec93d..a200b3a31a2 100644 --- a/atlasdb-cassandra-multinode-tests/src/test/java/com/palantir/cassandra/multinode/AbstractDegradedClusterTest.java +++ b/atlasdb-cassandra-multinode-tests/src/test/java/com/palantir/cassandra/multinode/AbstractDegradedClusterTest.java @@ -30,7 +30,6 @@ import com.palantir.atlasdb.keyvalue.cassandra.CassandraClient; import com.palantir.atlasdb.keyvalue.cassandra.CassandraKeyValueService; import com.palantir.atlasdb.keyvalue.cassandra.CassandraKeyValueServices; -import com.palantir.atlasdb.keyvalue.cassandra.CassandraTExceptions; import com.palantir.common.base.RunnableCheckedException; import com.palantir.common.exception.AtlasDbDependencyException; import java.util.HashMap; @@ -107,7 +106,7 @@ void assertThrowsAtlasDbDependencyExceptionAndDoesNotChangeCassandraSchema(Runna } void assertThrowsInsufficientConsistencyExceptionAndDoesNotChangeCassandraSchema(RunnableCheckedException task) { - assertThatThrownBy(task::run).isInstanceOf(CassandraTExceptions.class); + assertThatThrownBy(task::run).isInstanceOf(AtlasDbDependencyException.class); assertCassandraSchemaUnchanged(); } From bebe35e40b513d7a00d4956658d863dce213c78d Mon Sep 17 00:00:00 2001 From: Tilly Oswell Wheeler Date: Wed, 23 Oct 2024 16:48:32 +0100 Subject: [PATCH 15/19] Exception now throws AtlasDbException so adapting the integration test --- .../cassandra/multinode/AbstractDegradedClusterTest.java | 3 ++- .../palantir/cassandra/multinode/OneNodeDownDeleteTest.java | 2 +- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/atlasdb-cassandra-multinode-tests/src/test/java/com/palantir/cassandra/multinode/AbstractDegradedClusterTest.java b/atlasdb-cassandra-multinode-tests/src/test/java/com/palantir/cassandra/multinode/AbstractDegradedClusterTest.java index a200b3a31a2..2b4b6a6834d 100644 --- a/atlasdb-cassandra-multinode-tests/src/test/java/com/palantir/cassandra/multinode/AbstractDegradedClusterTest.java +++ b/atlasdb-cassandra-multinode-tests/src/test/java/com/palantir/cassandra/multinode/AbstractDegradedClusterTest.java @@ -24,6 +24,7 @@ import com.palantir.atlasdb.AtlasDbConstants; import com.palantir.atlasdb.encoding.PtBytes; import com.palantir.atlasdb.keyvalue.api.Cell; +import com.palantir.atlasdb.keyvalue.api.InsufficientConsistencyException; import com.palantir.atlasdb.keyvalue.api.KeyValueService; import com.palantir.atlasdb.keyvalue.api.TableReference; import com.palantir.atlasdb.keyvalue.api.Value; @@ -106,7 +107,7 @@ void assertThrowsAtlasDbDependencyExceptionAndDoesNotChangeCassandraSchema(Runna } void assertThrowsInsufficientConsistencyExceptionAndDoesNotChangeCassandraSchema(RunnableCheckedException task) { - assertThatThrownBy(task::run).isInstanceOf(AtlasDbDependencyException.class); + assertThatThrownBy(task::run).isInstanceOf(InsufficientConsistencyException.class); assertCassandraSchemaUnchanged(); } diff --git a/atlasdb-cassandra-multinode-tests/src/test/java/com/palantir/cassandra/multinode/OneNodeDownDeleteTest.java b/atlasdb-cassandra-multinode-tests/src/test/java/com/palantir/cassandra/multinode/OneNodeDownDeleteTest.java index 8e0b16e946d..d1f0ec2c204 100644 --- a/atlasdb-cassandra-multinode-tests/src/test/java/com/palantir/cassandra/multinode/OneNodeDownDeleteTest.java +++ b/atlasdb-cassandra-multinode-tests/src/test/java/com/palantir/cassandra/multinode/OneNodeDownDeleteTest.java @@ -42,7 +42,7 @@ public void deletingThrows() { @Test public void deleteAllTimestampsThrows() { - assertThrowsInsufficientConsistencyExceptionAndDoesNotChangeCassandraSchema(() -> getTestKvs() + assertThrowsAtlasDbDependencyExceptionAndDoesNotChangeCassandraSchema(() -> getTestKvs() .deleteAllTimestamps( TEST_TABLE, ImmutableMap.of( From 2245e01af8635ff55e34f368c1f952730722b881 Mon Sep 17 00:00:00 2001 From: Tilly Oswell Wheeler Date: Thu, 24 Oct 2024 13:39:28 +0100 Subject: [PATCH 16/19] test changed for new exception thrown --- .../com/palantir/cassandra/multinode/OneNodeDownDeleteTest.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/atlasdb-cassandra-multinode-tests/src/test/java/com/palantir/cassandra/multinode/OneNodeDownDeleteTest.java b/atlasdb-cassandra-multinode-tests/src/test/java/com/palantir/cassandra/multinode/OneNodeDownDeleteTest.java index d1f0ec2c204..1eeb0c88cf6 100644 --- a/atlasdb-cassandra-multinode-tests/src/test/java/com/palantir/cassandra/multinode/OneNodeDownDeleteTest.java +++ b/atlasdb-cassandra-multinode-tests/src/test/java/com/palantir/cassandra/multinode/OneNodeDownDeleteTest.java @@ -36,7 +36,7 @@ void testSetup(CassandraKeyValueService kvs) { @Test public void deletingThrows() { - assertThrowsInsufficientConsistencyExceptionAndDoesNotChangeCassandraSchema( + assertThrowsAtlasDbDependencyExceptionAndDoesNotChangeCassandraSchema( () -> getTestKvs().delete(TEST_TABLE, ImmutableMultimap.of(CELL_1_1, TIMESTAMP))); } From 87149e647ef7bfb0f5c19b03f49222d133b8c3b7 Mon Sep 17 00:00:00 2001 From: Tilly Oswell Wheeler Date: Fri, 25 Oct 2024 11:56:25 +0100 Subject: [PATCH 17/19] added requested changes: --- .../atlasdb/keyvalue/cassandra/WrappingQueryRunner.java | 6 +++--- changelog/@unreleased/pr-7353.v2.yml | 2 +- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/WrappingQueryRunner.java b/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/WrappingQueryRunner.java index f89812823f3..a064a23fa1f 100644 --- a/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/WrappingQueryRunner.java +++ b/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/WrappingQueryRunner.java @@ -55,7 +55,7 @@ Void batchMutate( }); } catch (UnavailableException e) { throw CassandraTExceptions.mapToUncheckedException( - "Batch mutate operation requires Cassandra nodes to be up and available. Check these nodes: ", + "Batch mutate operation requires a sufficient number of nodes to be up. Check that the consistency level of {} is adequate.", e, SafeArg.of("consistency", consistency)); } @@ -76,7 +76,7 @@ Map> multiget( () -> client.multiget_slice(kvsMethodName, tableRef, rowNames, pred, consistency)); } catch (UnavailableException e) { throw CassandraTExceptions.mapToUncheckedException( - "This get operation requires Cassandra nodes to be up and available. Check these nodes: ", + "This get operation requires a sufficient number of nodes to be up. Check that the consistency level of {} is adequate.", e, SafeArg.of("consistency", consistency)); } @@ -94,7 +94,7 @@ Map>> multiget_multislice( client, tableRef, () -> client.multiget_multislice(kvsMethodName, tableRef, request, consistency)); } catch (UnavailableException e) { throw CassandraTExceptions.mapToUncheckedException( - "This get operation requires Cassandra nodes to be up and available. Check these nodes: ", + "This get operation requires a sufficient number of nodes to be up. Check that the consistency level of {} is adequate.", e, SafeArg.of("consistency", consistency)); } diff --git a/changelog/@unreleased/pr-7353.v2.yml b/changelog/@unreleased/pr-7353.v2.yml index 8ff2acd70fb..3e8570f9b0f 100644 --- a/changelog/@unreleased/pr-7353.v2.yml +++ b/changelog/@unreleased/pr-7353.v2.yml @@ -5,6 +5,6 @@ improvement: - CassandraTExceptions() - CassandraTimedOutException() - Amended how UnavailableException TSwift Cassandra native Exceptions are caught, and they now get mapped to InsufficientConsistencyException() via CassandraTExceptions(). + Amended how UnavailableException Thrift Cassandra native Exceptions are caught, and they now get mapped to InsufficientConsistencyException() via CassandraTExceptions(). links: - https://github.com/palantir/atlasdb/pull/7353 From 185f04e372074cc87a670d352c7bb1cccd6e1ff0 Mon Sep 17 00:00:00 2001 From: Tilly Oswell Wheeler Date: Fri, 25 Oct 2024 11:57:57 +0100 Subject: [PATCH 18/19] Change the compaction wording --- .../atlasdb/keyvalue/cassandra/CassandraTimedOutException.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraTimedOutException.java b/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraTimedOutException.java index 775d8b2fb02..8af364c823d 100644 --- a/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraTimedOutException.java +++ b/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraTimedOutException.java @@ -32,7 +32,7 @@ public class CassandraTimedOutException extends AtlasDbDependencyException { + " Resolution: Change the query to request less data.\n" + "2. Reason: Data that has been deleted is being read in the query (e.g. A large amount of" + " tombstones).\n" - + " Resolution: Run a compaction on your Cassandra server.\n" + + " Resolution: Check the status of sweep for your client, and if required run a compaction on your Cassandra server.\n" + "3. Reason: Cassandra is struggling, possibly due to another large query, server health issues, or a" + " network outage.\n" + " Resolution: Ask your CassandraOps to check the state of the Cassandra server."; From cd6fbfaf5ebb0798c3ab7134d9f7c17eb8285928 Mon Sep 17 00:00:00 2001 From: Tilly Oswell Wheeler Date: Fri, 25 Oct 2024 12:20:46 +0100 Subject: [PATCH 19/19] spotlessApply --- .../keyvalue/cassandra/CassandraTimedOutException.java | 3 ++- .../atlasdb/keyvalue/cassandra/WrappingQueryRunner.java | 9 ++++++--- 2 files changed, 8 insertions(+), 4 deletions(-) diff --git a/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraTimedOutException.java b/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraTimedOutException.java index 8af364c823d..3fbb496d2cc 100644 --- a/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraTimedOutException.java +++ b/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/CassandraTimedOutException.java @@ -32,7 +32,8 @@ public class CassandraTimedOutException extends AtlasDbDependencyException { + " Resolution: Change the query to request less data.\n" + "2. Reason: Data that has been deleted is being read in the query (e.g. A large amount of" + " tombstones).\n" - + " Resolution: Check the status of sweep for your client, and if required run a compaction on your Cassandra server.\n" + + " Resolution: Check the status of sweep for your client, and if required run a compaction on your" + + " Cassandra server.\n" + "3. Reason: Cassandra is struggling, possibly due to another large query, server health issues, or a" + " network outage.\n" + " Resolution: Ask your CassandraOps to check the state of the Cassandra server."; diff --git a/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/WrappingQueryRunner.java b/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/WrappingQueryRunner.java index a064a23fa1f..803dbf366ec 100644 --- a/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/WrappingQueryRunner.java +++ b/atlasdb-cassandra/src/main/java/com/palantir/atlasdb/keyvalue/cassandra/WrappingQueryRunner.java @@ -55,7 +55,8 @@ Void batchMutate( }); } catch (UnavailableException e) { throw CassandraTExceptions.mapToUncheckedException( - "Batch mutate operation requires a sufficient number of nodes to be up. Check that the consistency level of {} is adequate.", + "Batch mutate operation requires a sufficient number of nodes to be up. Check that the consistency" + + " level of {} is adequate.", e, SafeArg.of("consistency", consistency)); } @@ -76,7 +77,8 @@ Map> multiget( () -> client.multiget_slice(kvsMethodName, tableRef, rowNames, pred, consistency)); } catch (UnavailableException e) { throw CassandraTExceptions.mapToUncheckedException( - "This get operation requires a sufficient number of nodes to be up. Check that the consistency level of {} is adequate.", + "This get operation requires a sufficient number of nodes to be up. Check that the consistency" + + " level of {} is adequate.", e, SafeArg.of("consistency", consistency)); } @@ -94,7 +96,8 @@ Map>> multiget_multislice( client, tableRef, () -> client.multiget_multislice(kvsMethodName, tableRef, request, consistency)); } catch (UnavailableException e) { throw CassandraTExceptions.mapToUncheckedException( - "This get operation requires a sufficient number of nodes to be up. Check that the consistency level of {} is adequate.", + "This get operation requires a sufficient number of nodes to be up. Check that the consistency" + + " level of {} is adequate.", e, SafeArg.of("consistency", consistency)); }