Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

test: test_topology_ops: adapt to tablets #18707

Draft
wants to merge 1 commit into
base: master
Choose a base branch
from

Conversation

tchaikov
Copy link
Contributor

@tchaikov tchaikov commented May 16, 2024

in e7d4e08, we reenabled the background writes in this test, but when running with tablets enabled, background writes are still disabled because of #17025, which was fixed last week. so we can enable background writes with tablets.

in this change,

  • background writes are enabled with tablets.
  • increase the number of nodes by 1 so that we have enough nodes to fulfill the needs of tablets, which enforces that the number of replicas should always satisfy RF.
  • pass rf to start_writes() explicitly, so we have less magic numbers in the test, and make the data dependencies more obvious.

Fixes #17589
Signed-off-by: Kefu Chai [email protected]

  • tablets related fix. no need to backport

@tchaikov tchaikov added area/test Issues related to the testing system code and environment area/tablets backport/none Backport is not required labels May 16, 2024
@tchaikov tchaikov requested review from kbr-scylla and removed request for kbr-scylla May 16, 2024 11:57
@tchaikov tchaikov marked this pull request as draft May 17, 2024 14:26
@tchaikov
Copy link
Contributor Author

the test passes locally. but it is failing on jenkins.. looking..

@tchaikov tchaikov marked this pull request as ready for review May 20, 2024 12:55
in e7d4e08, we reenabled the background writes in this test, but
when running with tablets enabled, background writes are still
disabled because of scylladb#17025, which was fixed last week. so we can
enable background writes with tablets.

in this change,

* background writes are enabled with tablets.
* increase the number of nodes by 1 so that we have enough nodes
  to fulfill the needs of tablets, which enforces that the number
  of replicas should always satisfy RF.
* pass rf to `start_writes()` explicitly, so we have less
  magic numbers in the test, and make the data dependencies
  more obvious.

Fixes scylladb#17589
Signed-off-by: Kefu Chai <[email protected]>
@scylladb-promoter
Copy link
Contributor

🔴 CI State: FAILURE

❌ - Build

Build Details:

  • Duration: 4 hr 5 min
  • Builder: i-0fd8badd51d4a5531 (m5d.12xlarge)

@kbr-scylla kbr-scylla requested a review from patjed41 May 21, 2024 13:06
@kbr-scylla
Copy link
Contributor

Restarted CI build

Copy link
Contributor

@patjed41 patjed41 left a comment

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Looks good if the test passes in CI

@scylladb-promoter
Copy link
Contributor

🔴 CI State: ABORTED

✅ - Build
❌ - Unit Tests Custom
The following new/updated tests ran 100 times for each mode:
🔹 topology_experimental_raft/test_topology_ops

Failed Tests (212/298):

Build Details:

  • Duration: 15 hr
  • Builder: i-0e31f0ab3f4e2b3e0 (i4i.8xlarge)

@tchaikov tchaikov marked this pull request as draft May 22, 2024 04:47
@tchaikov tchaikov self-assigned this May 22, 2024
@tchaikov
Copy link
Contributor Author

the test is failing. looking..

@kbr-scylla
Copy link
Contributor

But also for the case tablets_enabled=false, apparently.

But for tablets_enabled=false your change should be transparent, if I understand it correctly (please review and confirm that it is)

-- and if so, this would mean that the test was already flaky for tablets_enabled=false case :( (cc @patjed41)

@patjed41
Copy link
Contributor

I see:

ERROR 2024-05-22 01:46:10,462 [shard 1:stmt] storage_proxy - No mapping for :: in the passed effective replication map

It's one of the "no ip mapping" issues or a new one. The similar issues are #18676 and #18843. This test fails with tablets disabled and no disrupted topology operations, so I guess it's a new one.

@kbr-scylla
Copy link
Contributor

It's one of the "no ip mapping" issues or a new one. The similar issues are #18676 and #18843. This test fails with tablets disabled and no disrupted topology operations, so I guess it's a new one.

Damn it :(
cc @gleb-cloudius

@kbr-scylla
Copy link
Contributor

It could be the same root cause as #18843 -- that LEFT nodes are still inserted into locator::topology (but without IP mappings, which we don't have for LEFT nodes), IIUC this logic is generic for raft-topology (not only when tablets are enabled)

@gleb-cloudius explained here #18843 (comment)

@gleb-cloudius
Copy link
Contributor

It could be the same root cause as #18843 -- that LEFT nodes are still inserted into locator::topology (but without IP mappings, which we don't have for LEFT nodes), IIUC this logic is generic for raft-topology (not only when tablets are enabled)

No, without tablets the code is disabled. But I do not see any evidence yet that the failure here with and without tablets are the same. Logs without fail on timeout and with on something else. I will probably take 10 more years for me to download logs, so I cannot check better.

@kbr-scylla
Copy link
Contributor

@tchaikov you aborted twice: once to cancel test run, second time in the middle of artifacts collection phase, so we're missing a lot of logs unfortunately

patjed41 added a commit to patjed41/scylladb that referenced this pull request May 23, 2024
`test_topology_ops` is flaky, which has been uncovered by gating
in scylladb#18707. However, debugging it is harder than it
should be because write workers can flood the logs. They may send
a lot of failed writes before the test fails. Then, the log file
can become huge, even up to 20 GB.

Fix this issue by stopping a write worker after the first error.
patjed41 added a commit to patjed41/scylladb that referenced this pull request May 23, 2024
`test_topology_ops` is flaky, which has been uncovered by gating
in scylladb#18707. However, debugging it is harder than it
should be because write workers can flood the logs. They may send
a lot of failed writes before the test fails. Then, the log file
can become huge, even up to 20 GB.

Fix this issue by stopping a write worker after the first error.

This test is important for 6.0, so we can backport this change.
@@ -24,7 +24,13 @@
@pytest.mark.parametrize("tablets_enabled", ["true", "false"])
async def test_topology_ops(request, manager: ManagerClient, tablets_enabled: bool):
"""Test basic topology operations using the topology coordinator."""
cfg = {'experimental_features' : ['tablets']} if tablets_enabled else {}
rf = 3
if tablets_enabled:
Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Isn't tablets_enabled is a non empty string here which is always True?

Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Yes, and we have multiple (5 if I'm not wrong) tests broken in the same way. The first bug served as a bad example that caused the other bugs. We need to fix these tests and check if they pass.

The bigger problem with this particular test is that before this PR we didn't send writes if tablets were enabled. But they were always enabled, so we never sent writes. The test was basically disabled. This is very bad for such a basic and important test.

Hopefully, the situation is not that bad. IIRC, I verified that this test was not flaky before incorrectly parameterizing it with tablets around 3 month ago. So, I hope that "missing IP mapping" is the only regression.

@kbr-scylla

Copy link
Contributor

@patjed41 patjed41 May 27, 2024

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Yes, and we have multiple (5 if I'm not wrong) tests broken in the same way. The first bug served as a bad example that caused the other bugs. We need to fix these tests and check if they pass.

Only one test was broken -- test_default_tombstone_gc. I opened #18888.

I'll be investigating failures in this test after re-enabling writes. This PR will have to wait until all detected bugs are fixed.

Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

The failures are because the test is always running with tablets (#18707 (comment)) and it is a known problem with tablets #18843

Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Then, I'll only check if it passes without tablets and write workers re-enabled. We were running the test with write workers always disabled (because tablets were always enabled) for 3 months.

Copy link
Contributor Author

@tchaikov tchaikov May 28, 2024

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

but my observation is quite the opposite , it fails with write load enabled and with tablets disabled. see #18932 . EDIT, please wait. i just rebased it.

Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

You need to move the test from topology_experimental_raft since this suit enables tablets by default. See #18707 (comment).

Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I fixed it in #18900 by changing the config.

@gleb-cloudius
Copy link
Contributor

The test is in topology_experimental_raft suit which has tablets enabled by default since 6defcb7 (forever). So all tests are running with tablets enabled.

kbr-scylla pushed a commit that referenced this pull request May 27, 2024
`test_topology_ops` is flaky, which has been uncovered by gating
in #18707. However, debugging it is harder than it
should be because write workers can flood the logs. They may send
a lot of failed writes before the test fails. Then, the log file
can become huge, even up to 20 GB.

Fix this issue by stopping a write worker after the first error.

This test is important for 6.0, so we can backport this change.

Closes #18851
mergify bot pushed a commit that referenced this pull request May 27, 2024
`test_topology_ops` is flaky, which has been uncovered by gating
in #18707. However, debugging it is harder than it
should be because write workers can flood the logs. They may send
a lot of failed writes before the test fails. Then, the log file
can become huge, even up to 20 GB.

Fix this issue by stopping a write worker after the first error.

This test is important for 6.0, so we can backport this change.

(cherry picked from commit 4dd2b7a)
@tchaikov
Copy link
Contributor Author

tchaikov commented May 28, 2024

@tchaikov you aborted twice: once to cancel test run, second time in the middle of artifacts collection phase, so we're missing a lot of logs unfortunately

if i didn't abort the test, the test node would be full of log files and running out of space. i spotted this the other time.

@patjed41
Copy link
Contributor

@tchaikov you aborted twice: once to cancel test run, second time in the middle of artifacts collection phase, so we're missing a lot of logs unfortunately

if i didn't abort the test, the test node would be full of log file and running out of space. i spotted this the other time.

#18851 fixed the huge log file issue.

Anyway, we now know that the test is flaky only with tablets enabled because of #18843. This PR is blocked by that issue.

@tchaikov tchaikov removed their assignment May 28, 2024
@tchaikov
Copy link
Contributor Author

tchaikov commented May 28, 2024

@patjed41 thanks Patryk. so at least we can bring the write load back. i just created #18932 to implement it. but it fails locally with the same symptom of #18843

INFO  2024-05-28 19:57:32,327 [shard 0:strm] token_metadata - Added node 719a9d36-1760-46f3-9660-af357b3cbef5 as pending replacing endpoint which replaces existing no
de b2c66a37-c4f9-42bd-85ee-b2461c94c00d
DEBUG 2024-05-28 19:57:32,328 [shard 0:strm] raft_topology - topology_state_load: the last committed CDC generation ID: (2024/05/28 11:57:14, 6cac4ce4-1ce9-11ef-1eae-
e5592d00318e)
INFO  2024-05-28 19:57:32,328 [shard 0:strm] raft_topology - removing node b2c66a37-c4f9-42bd-85ee-b2461c94c00d from group 0 configuration...
INFO  2024-05-28 19:57:32,331 [shard 0:strm] raft_topology - node b2c66a37-c4f9-42bd-85ee-b2461c94c00d removed from group 0 configuration
INFO  2024-05-28 19:57:32,331 [shard 0:strm] raft_topology - updating topology state: replace: read fence completed
DEBUG 2024-05-28 19:57:32,332 [shard 0:strm] raft_topology - reload raft topology state
INFO  2024-05-28 19:57:32,333 [shard 0:strm] gossip - Removed endpoint 127.3.143.2
INFO  2024-05-28 19:57:32,333 [shard 0:strm] gossip - Finished to force remove node 127.3.143.2
ERROR 2024-05-28 19:57:32,334 [shard 0:stmt] storage_proxy - No mapping for :: in the passed effective replication map, at: 0x537be71 0x5045ca6 0x404891b 0x4049766 0x
41375bf 0x41369c1 0x4136231 0x40566ea 0x403ee12 0x4119770 0x411968e 0x412ef68 0x4130145 0x412f852 0x412ef68 0x412e66f 0x412df39 0x4ffef62 0x50aea23 0x50b28f7 0x50af498 0x4ff2d35 0x4ff0e89 0x117dd4f 0x117bbba /lib64/libc.so.6+0x2a087 /lib64/libc.so.6+0x2a14a 0x1177e74
   --------
   seastar::lambda_task<seastar::execution_stage::flush()::$_0>
Aborting on shard 0, in scheduling group statement.
2024-05-28 19:57:32,334 [shard 0:stmt] storage_proxy - No mapping for :: in the passed effective replication map, at:
[Backtrace #0]
seastar::current_backtrace() at ./build/./seastar/include/seastar/util/backtrace.hh:68
seastar::on_internal_error(seastar::logger&, std::basic_string_view<char, std::char_traits<char> >) at ./build/./build/./seastar/src/core/on_internal_error.cc:51
service::storage_proxy::create_write_response_handler_helper(seastar::lw_shared_ptr<schema const>, dht::token const&, std::unique_ptr<service::mutation_holder, std::default_delete<service::mutation_holder> >, db::consistency_level, db::write_type, tracing::trace_state_ptr, service_permit, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::bool_class<service::cancellable_tag>) at ./build/./build/./service/storage_proxy.cc:3168
service::storage_proxy::create_write_response_handler(mutation const&, db::consistency_level, db::write_type, tracing::trace_state_ptr, service_permit, seastar::bool_class<db::allow_per_partition_rate_limit_tag>) at ./build/./build/./service/storage_proxy.cc:3220
service::storage_proxy::mutate_prepare<boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&>(boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&, db::consistency_level, db::write_type, tracing::trace_state_ptr, service_permit, seastar::bool_class<db::allow_per_partition_rate_limit_tag>)::{lambda(mutation const&, db::consistency_level, db::write_type, service_permit)#1}::operator()(mutation const&, db::consistency_level, db::write_type, service_permit) at ./build/./build/./service/storage_proxy.cc:3314
service::storage_proxy::mutate_prepare<boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&, service::storage_proxy::mutate_prepare<boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&>(boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&, db::consistency_level, db::write_type, tracing::trace_state_ptr, service_permit, seastar::bool_class<db::allow_per_partition_rate_limit_tag>)::{lambda(mutation const&, db::consistency_level, db::write_type, service_permit)#1}>(boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&, db::consistency_level, db::write_type, service_permit, service::storage_proxy::mutate_prepare<boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&>(boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&, db::consistency_level, db::write_type, tracing::trace_state_ptr, service_permit, seastar::bool_class<db::allow_per_partition_rate_limit_tag>)::{lambda(mutation const&, db::consistency_level, db::write_type, service_permit)#1})::{lambda(boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&, db::consistency_level, db::write_type, service_permit, service::storage_proxy::mutate_prepare<boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&>(auto:1&&, db::consistency_level, db::write_type, tracing::trace_state_ptr, service_permit, seastar::bool_class<db::allow_per_partition_rate_limit_tag>)::{lambda(mutation const&, db::consistency_level, db::write_type, service_permit)#1})#1}::operator()(boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&, db::consistency_level, db::write_type, service_permit, service::storage_proxy::mutate_prepare<boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&>(boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&, db::consistency_level, db::write_type, tracing::trace_state_ptr, service_permit, seastar::bool_class<db::allow_per_partition_rate_limit_tag>)::{lambda(mutation const&, db::consistency_level, db::write_type, service_permit)#1}) const at ./build/./build/./service/storage_proxy.cc:3301
seastar::future<boost::outcome_v2::basic_result<utils::small_vector<service::storage_proxy::unique_response_handler, 1ul>, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> > seastar::futurize<seastar::future<boost::outcome_v2::basic_result<utils::small_vector<service::storage_proxy::unique_response_handler, 1ul>, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> > >::invoke<service::storage_proxy::mutate_prepare<boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&, service::storage_proxy::mutate_prepare<boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&>(boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&, db::consistency_level, db::write_type, tracing::trace_state_ptr, service_permit, seastar::bool_class<db::allow_per_partition_rate_limit_tag>)::{lambda(mutation const&, db::consistency_level, db::write_type, service_permit)#1}>(boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&, db::consistency_level, db::write_type, service_permit, service::storage_proxy::mutate_prepare<boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&>(boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&, db::consistency_level, db::write_type, tracing::trace_state_ptr, service_permit, seastar::bool_class<db::allow_per_partition_rate_limit_tag>)::{lambda(mutation const&, db::consistency_level, db::write_type, service_permit)#1})::{lambda(boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&, db::consistency_level, db::write_type, service_permit, service::storage_proxy::mutate_prepare<boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&>(auto:1&&, db::consistency_level, db::write_type, tracing::trace_state_ptr, service_permit, seastar::bool_class<db::allow_per_partition_rate_limit_tag>)::{lambda(mutation const&, db::consistency_level, db::write_type, service_permit)#1})#1}, boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&, db::consistency_level&, db::write_type&, service_permit, service::storage_proxy::mutate_prepare<boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&>(boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&, db::consistency_level, db::write_type, tracing::trace_state_ptr, service_permit, seastar::bool_class<db::allow_per_partition_rate_limit_tag>)::{lambda(mutation const&, db::consistency_level, db::write_type, service_permit)#1}>(boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&, boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&, db::consistency_level&, db::write_type&, service_permit&&, service::storage_proxy::mutate_prepare<boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&>(boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&, db::consistency_level, db::write_type, tracing::trace_state_ptr, service_permit, seastar::bool_class<db::allow_per_partition_rate_limit_tag>)::{lambda(mutation const&, db::consistency_level, db::write_type, service_permit)#1}&&) at ./build/./seastar/include/seastar/core/future.hh:2032
auto seastar::futurize_invoke<service::storage_proxy::mutate_prepare<boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&, service::storage_proxy::mutate_prepare<boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&>(boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&, db::consistency_level, db::write_type, tracing::trace_state_ptr, service_permit, seastar::bool_class<db::allow_per_partition_rate_limit_tag>)::{lambda(mutation const&, db::consistency_level, db::write_type, service_permit)#1}>(boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&, db::consistency_level, db::write_type, service_permit, service::storage_proxy::mutate_prepare<boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&>(boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&, db::consistency_level, db::write_type, tracing::trace_state_ptr, service_permit, seastar::bool_class<db::allow_per_partition_rate_limit_tag>)::{lambda(mutation const&, db::consistency_level, db::write_type, service_permit)#1})::{lambda(boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&, db::consistency_level, db::write_type, service_permit, service::storage_proxy::mutate_prepare<boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&>(auto:1&&, db::consistency_level, db::write_type, tracing::trace_state_ptr, service_permit, seastar::bool_class<db::allow_per_partition_rate_limit_tag>)::{lambda(mutation const&, db::consistency_level, db::write_type, service_permit)#1})#1}, boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&, db::consistency_level&, db::write_type&, service_permit, service::storage_proxy::mutate_prepare<boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&>(boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&, db::consistency_level, db::write_type, tracing::trace_state_ptr, service_permit, seastar::bool_class<db::allow_per_partition_rate_limit_tag>)::{lambda(mutation const&, db::consistency_level, db::write_type, service_permit)#1}>(boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&, boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&, db::consistency_level&, db::write_type&, service_permit&&, service::storage_proxy::mutate_prepare<boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&>(boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&, db::consistency_level, db::write_type, tracing::trace_state_ptr, service_permit, seastar::bool_class<db::allow_per_partition_rate_limit_tag>)::{lambda(mutation const&, db::consistency_level, db::write_type, service_permit)#1}&&) at ./build/./seastar/include/seastar/core/future.hh:2063
 (inlined by) seastar::future<boost::outcome_v2::basic_result<utils::small_vector<service::storage_proxy::unique_response_handler, 1ul>, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> > service::storage_proxy::mutate_prepare<boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&, service::storage_proxy::mutate_prepare<boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&>(boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&, db::consistency_level, db::write_type, tracing::trace_state_ptr, service_permit, seastar::bool_class<db::allow_per_partition_rate_limit_tag>)::{lambda(mutation const&, db::consistency_level, db::write_type, service_permit)#1}>(boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&, db::consistency_level, db::write_type, service_permit, service::storage_proxy::mutate_prepare<boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&>(boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&, db::consistency_level, db::write_type, tracing::trace_state_ptr, service_permit, seastar::bool_class<db::allow_per_partition_rate_limit_tag>)::{lambda(mutation const&, db::consistency_level, db::write_type, service_permit)#1}) at ./build/./build/./service/storage_proxy.cc:3297
 (inlined by) seastar::future<boost::outcome_v2::basic_result<utils::small_vector<service::storage_proxy::unique_response_handler, 1ul>, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> > service::storage_proxy::mutate_prepare<boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&>(boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&, db::consistency_level, db::write_type, tracing::trace_state_ptr, service_permit, seastar::bool_class<db::allow_per_partition_rate_limit_tag>) at ./build/./build/./service/storage_proxy.cc:3313
 (inlined by) seastar::future<boost::outcome_v2::basic_result<void, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> > service::storage_proxy::mutate_internal<boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > > >(boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >, db::consistency_level, bool, tracing::trace_state_ptr, service_permit, std::optional<std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > > >, seastar::lw_shared_ptr<cdc::operation_result_tracker>, seastar::bool_class<db::allow_per_partition_rate_limit_tag>) at ./build/./build/./service/storage_proxy.cc:3640
service::storage_proxy::do_mutate(std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker>) at ./build/./build/./service/storage_proxy.cc:3600
seastar::future<boost::outcome_v2::basic_result<void, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> > std::__invoke_impl<seastar::future<boost::outcome_v2::basic_result<void, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> >, seastar::future<boost::outcome_v2::basic_result<void, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> > (service::storage_proxy::* const&)(std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker>), service::storage_proxy*, std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker> >(std::__invoke_memfun_deref, seastar::future<boost::outcome_v2::basic_result<void, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> > (service::storage_proxy::* const&)(std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker>), service::storage_proxy*&&, std::vector<mutation, std::allocator<mutation> >&&, db::consistency_level&&, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >&&, tracing::trace_state_ptr&&, service_permit&&, bool&&, seastar::bool_class<db::allow_per_partition_rate_limit_tag>&&, seastar::lw_shared_ptr<cdc::operation_result_tracker>&&) at /usr/lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/invoke.h:74
std::__invoke_result<seastar::future<boost::outcome_v2::basic_result<void, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> > (service::storage_proxy::* const&)(std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker>), service::storage_proxy*, std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker> >::type std::__invoke<seastar::future<boost::outcome_v2::basic_result<void, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> > (service::storage_proxy::* const&)(std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker>), service::storage_proxy*, std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker> >(seastar::future<boost::outcome_v2::basic_result<void, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> > (service::storage_proxy::* const&)(std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker>), service::storage_proxy*&&, std::vector<mutation, std::allocator<mutation> >&&, db::consistency_level&&, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >&&, tracing::trace_state_ptr&&, service_permit&&, bool&&, seastar::bool_class<db::allow_per_partition_rate_limit_tag>&&, seastar::lw_shared_ptr<cdc::operation_result_tracker>&&) at /usr/lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/invoke.h:96
 (inlined by) decltype (std::__invoke((*this)._M_pmf, (std::forward<service::storage_proxy*>)({parm#1}), (std::forward<std::vector<mutation, std::allocator<mutation> > >)({parm#1}), (std::forward<db::consistency_level>)({parm#1}), (std::forward<std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > > >)({parm#1}), (std::forward<tracing::trace_state_ptr>)({parm#1}), (std::forward<service_permit>)({parm#1}), (std::forward<bool>)({parm#1}), (std::forward<seastar::bool_class<db::allow_per_partition_rate_limit_tag> >)({parm#1}), (std::forward<seastar::lw_shared_ptr<cdc::operation_result_tracker> >)({parm#1}))) std::_Mem_fn_base<seastar::future<boost::outcome_v2::basic_result<void, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> > (service::storage_proxy::*)(std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker>), true>::operator()<service::storage_proxy*, std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker> >(service::storage_proxy*&&, std::vector<mutation, std::allocator<mutation> >&&, db::consistency_level&&, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >&&, tracing::trace_state_ptr&&, service_permit&&, bool&&, seastar::bool_class<db::allow_per_partition_rate_limit_tag>&&, seastar::lw_shared_ptr<cdc::operation_result_tracker>&&) const at /usr/lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/functional:177
 (inlined by) seastar::noncopyable_function<seastar::future<boost::outcome_v2::basic_result<void, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> > (service::storage_proxy*, std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker>)>::direct_vtable_for<std::_Mem_fn<seastar::future<boost::outcome_v2::basic_result<void, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> > (service::storage_proxy::*)(std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker>)> >::call(seastar::noncopyable_function<seastar::future<boost::outcome_v2::basic_result<void, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> > (service::storage_proxy*, std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker>)> const*, service::storage_proxy*, std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker>) at ./build/./seastar/include/seastar/util/noncopyable_function.hh:129
seastar::noncopyable_function<seastar::future<boost::outcome_v2::basic_result<void, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> > (service::storage_proxy*, std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker>)>::operator()(service::storage_proxy*, std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker>) const at ./build/./seastar/include/seastar/util/noncopyable_function.hh:215
seastar::inheriting_concrete_execution_stage<seastar::future<boost::outcome_v2::basic_result<void, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> >, service::storage_proxy*, std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker> >::make_stage_for_group(seastar::scheduling_group)::{lambda(service::storage_proxy*, std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker>)#1}::operator()(service::storage_proxy*, std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker>) const at ./build/./seastar/include/seastar/core/execution_stage.hh:340
seastar::noncopyable_function<seastar::future<boost::outcome_v2::basic_result<void, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> > (service::storage_proxy*, std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker>)>::direct_vtable_for<seastar::inheriting_concrete_execution_stage<seastar::future<boost::outcome_v2::basic_result<void, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> >, service::storage_proxy*, std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker> >::make_stage_for_group(seastar::scheduling_group)::{lambda(service::storage_proxy*, std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker>)#1}>::call(seastar::noncopyable_function<seastar::future<boost::outcome_v2::basic_result<void, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> > (service::storage_proxy*, std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker>)> const*, service::storage_proxy*, std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker>) at ./build/./seastar/include/seastar/util/noncopyable_function.hh:129
seastar::noncopyable_function<seastar::future<boost::outcome_v2::basic_result<void, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> > (service::storage_proxy*, std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker>)>::operator()(service::storage_proxy*, std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker>) const at ./build/./seastar/include/seastar/util/noncopyable_function.hh:215
seastar::future<boost::outcome_v2::basic_result<void, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> > std::__invoke_impl<seastar::future<boost::outcome_v2::basic_result<void, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> >, seastar::noncopyable_function<seastar::future<boost::outcome_v2::basic_result<void, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> > (service::storage_proxy*, std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker>)>&, service::storage_proxy*, std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker> >(std::__invoke_other, seastar::noncopyable_function<seastar::future<boost::outcome_v2::basic_result<void, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> > (service::storage_proxy*, std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker>)>&, service::storage_proxy*&&, std::vector<mutation, std::allocator<mutation> >&&, db::consistency_level&&, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >&&, tracing::trace_state_ptr&&, service_permit&&, bool&&, seastar::bool_class<db::allow_per_partition_rate_limit_tag>&&, seastar::lw_shared_ptr<cdc::operation_result_tracker>&&) at /usr/lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/invoke.h:61
std::__invoke_result<seastar::noncopyable_function<seastar::future<boost::outcome_v2::basic_result<void, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> > (service::storage_proxy*, std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker>)>&, service::storage_proxy*, std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker> >::type std::__invoke<seastar::noncopyable_function<seastar::future<boost::outcome_v2::basic_result<void, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> > (service::storage_proxy*, std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker>)>&, service::storage_proxy*, std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker> >(seastar::noncopyable_function<seastar::future<boost::outcome_v2::basic_result<void, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> > (service::storage_proxy*, std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker>)>&, service::storage_proxy*&&, std::vector<mutation, std::allocator<mutation> >&&, db::consistency_level&&, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >&&, tracing::trace_state_ptr&&, service_permit&&, bool&&, seastar::bool_class<db::allow_per_partition_rate_limit_tag>&&, seastar::lw_shared_ptr<cdc::operation_result_tracker>&&) at /usr/lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/invoke.h:96
 (inlined by) decltype(auto) std::__apply_impl<seastar::noncopyable_function<seastar::future<boost::outcome_v2::basic_result<void, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> > (service::storage_proxy*, std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker>)>&, std::tuple<service::storage_proxy*, std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker> >, 0ul, 1ul, 2ul, 3ul, 4ul, 5ul, 6ul, 7ul, 8ul>(seastar::noncopyable_function<seastar::future<boost::outcome_v2::basic_result<void, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> > (service::storage_proxy*, std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker>)>&, std::tuple<service::storage_proxy*, std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker> >&&, std::integer_sequence<unsigned long, 0ul, 1ul, 2ul, 3ul, 4ul, 5ul, 6ul, 7ul, 8ul>) at /usr/lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tuple:2921
 (inlined by) decltype(auto) std::apply<seastar::noncopyable_function<seastar::future<boost::outcome_v2::basic_result<void, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> > (service::storage_proxy*, std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker>)>&, std::tuple<service::storage_proxy*, std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker> > >(seastar::noncopyable_function<seastar::future<boost::outcome_v2::basic_result<void, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> > (service::storage_proxy*, std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker>)>&, std::tuple<service::storage_proxy*, std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker> >&&) at /usr/lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tuple:2936
 (inlined by) seastar::future<boost::outcome_v2::basic_result<void, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> > seastar::futurize<seastar::future<boost::outcome_v2::basic_result<void, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> > >::apply<seastar::noncopyable_function<seastar::future<boost::outcome_v2::basic_result<void, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> > (service::storage_proxy*, std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker>)>&, service::storage_proxy*, std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker> >(seastar::noncopyable_function<seastar::future<boost::outcome_v2::basic_result<void, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> > (service::storage_proxy*, std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker>)>&, std::tuple<service::storage_proxy*, std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker> >&&) at ./build/./seastar/include/seastar/core/future.hh:2000
 (inlined by) seastar::concrete_execution_stage<seastar::future<boost::outcome_v2::basic_result<void, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> >, service::storage_proxy*, std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker> >::do_flush() at ./build/./seastar/include/seastar/core/execution_stage.hh:249
seastar::execution_stage::flush()::$_0::operator()() const at ./build/./build/./seastar/src/core/execution_stage.cc:149
 (inlined by) seastar::future<void> seastar::futurize<void>::invoke<seastar::execution_stage::flush()::$_0&>(seastar::execution_stage::flush()::$_0&) at ./build/./seastar/include/seastar/core/future.hh:2029
 (inlined by) seastar::lambda_task<seastar::execution_stage::flush()::$_0>::run_and_dispose() at ./build/./seastar/include/seastar/core/make_task.hh:44
seastar::reactor::run_tasks(seastar::reactor::task_queue&) at ./build/./build/./seastar/src/core/reactor.cc:2694
 (inlined by) seastar::reactor::run_some_tasks() at ./build/./build/./seastar/src/core/reactor.cc:3157
seastar::reactor::do_run() at ./build/./build/./seastar/src/core/reactor.cc:3325
seastar::reactor::run() at ./build/./build/./seastar/src/core/reactor.cc:3215
seastar::app_template::run_deprecated(int, char**, std::function<void ()>&&) at ./build/./build/./seastar/src/core/app-template.cc:276
seastar::app_template::run(int, char**, std::function<seastar::future<int> ()>&&) at ./build/./build/./seastar/src/core/app-template.cc:167
scylla_main(int, char**) at ./build/./build/./main.cc:681
main at /usr/lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/std_function.h:591
/lib64/libc.so.6: ELF 64-bit LSB shared object, x86-64, version 1 (GNU/Linux), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, BuildID[sha1]=4a92fcedbba6d6d2629ce066a2970017faa9995e, for GNU/Linux 3.2.0, not stripped

__libc_start_call_main at ??:?
__libc_start_main_alias_2 at :?
_start at ??:?

@patjed41
Copy link
Contributor

patjed41 commented May 28, 2024

@tchaikov #18900 should solve all problems in this test. So, if I'm not wrong, this PR is ready and is only waiting for a fix for #18843. Then, we can run CI again and see if it passes. If it does, we can merge this PR.

You are probably confused because I touched this test even though you are assigned to this issue. But because of the blunders fixed by #18900, we were running this test only with tablets and with write workers disabled for 3 months. We wanted to verify raft-topology ASAP.

@tchaikov
Copy link
Contributor Author

tchaikov commented May 28, 2024

@patjed41 so, may i assign this ticket back to you? since you've done the heavy lifting.

EDIT, oh, wait. so it's just a step away. i am fine either way.

@patjed41
Copy link
Contributor

This issue is about ensuring that this test passes with tablets and write workers enabled. If the test fails again after fixing #18843, it should be investigated by someone with tablets knowledge (I don't really have it). Maybe we shouldn't change the assignment.

denesb pushed a commit that referenced this pull request May 29, 2024
`test_topology_ops` is flaky, which has been uncovered by gating
in #18707. However, debugging it is harder than it
should be because write workers can flood the logs. They may send
a lot of failed writes before the test fails. Then, the log file
can become huge, even up to 20 GB.

Fix this issue by stopping a write worker after the first error.

This test is important for 6.0, so we can backport this change.

(cherry picked from commit 7c1e6ba)

Closes #18914
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Labels
area/tablets area/test Issues related to the testing system code and environment area/topology changes backport/none Backport is not required backport/6.0
Projects
None yet
Development

Successfully merging this pull request may close these issues.

test: test_topology_ops: reenable background writes in tablets mode
5 participants