From fa2a8d37e4ccae0196ab850d6b33a6669d2db4cb Mon Sep 17 00:00:00 2001 From: Dmitry Razumov Date: Tue, 14 Jan 2025 22:36:17 +0100 Subject: [PATCH] Implement EHistogramCounterOptions for THistogram class in storage (#2503) * Implement EHistogramCounterOptions for THistogram class in storage * fix tests * review fixes * review fixes * fix * Trigger Build * review fixes * review fixes * fix tests * review fixes * fix test * fix indent --------- Co-authored-by: Dmitry Razumov --- .../libs/storage/core/disk_counters.cpp | 12 +- .../libs/storage/core/disk_counters.h | 125 ++++--- .../libs/storage/core/disk_counters_ut.cpp | 4 +- .../blockstore/libs/storage/core/histogram.h | 64 +++- .../libs/storage/core/histogram_ut.cpp | 306 ++++++++++++++++++ .../storage/core/storage_request_counters.h | 16 +- .../libs/storage/partition/part_actor.cpp | 4 +- .../storage/partition/part_actor_stats.cpp | 4 +- .../libs/storage/partition2/part2_actor.cpp | 4 +- .../storage/partition2/part2_actor_stats.cpp | 4 +- .../storage/partition_nonrepl/part_mirror.cpp | 2 + .../storage/partition_nonrepl/part_mirror.h | 1 + .../partition_nonrepl/part_mirror_actor.cpp | 4 + .../partition_nonrepl/part_mirror_actor.h | 3 + .../part_mirror_actor_stats.cpp | 5 +- .../partition_nonrepl/part_mirror_resync.cpp | 2 + .../partition_nonrepl/part_mirror_resync.h | 2 + .../part_mirror_resync_actor.cpp | 4 + .../part_mirror_resync_actor.h | 3 + .../part_mirror_resync_actor_stats.cpp | 5 +- .../part_mirror_resync_ut.cpp | 4 + .../partition_nonrepl/part_mirror_ut.cpp | 3 + .../partition_nonrepl/part_nonrepl.cpp | 3 + .../storage/partition_nonrepl/part_nonrepl.h | 2 + .../partition_nonrepl/part_nonrepl_actor.cpp | 7 +- .../partition_nonrepl/part_nonrepl_actor.h | 3 + .../part_nonrepl_actor_stats.cpp | 5 +- .../part_nonrepl_migration.cpp | 2 + .../part_nonrepl_migration.h | 1 + .../part_nonrepl_migration_actor.cpp | 19 +- .../part_nonrepl_migration_actor.h | 2 +- .../part_nonrepl_migration_common_actor.cpp | 2 + .../part_nonrepl_migration_common_actor.h | 10 +- ...nrepl_migration_common_actor_migration.cpp | 12 + ...t_nonrepl_migration_common_actor_stats.cpp | 10 +- .../part_nonrepl_migration_ut.cpp | 2 + .../partition_nonrepl/part_nonrepl_rdma.cpp | 2 + .../partition_nonrepl/part_nonrepl_rdma.h | 2 + .../part_nonrepl_rdma_actor.cpp | 7 +- .../part_nonrepl_rdma_actor.h | 3 + .../part_nonrepl_rdma_actor_stats.cpp | 5 +- .../part_nonrepl_rdma_ut.cpp | 2 + .../partition_nonrepl/part_nonrepl_ut.cpp | 2 + .../partition_nonrepl/resync_range_ut.cpp | 2 + .../libs/storage/partition_nonrepl/ut_env.h | 4 +- .../stats_service/stats_service_actor.cpp | 2 +- .../stats_service_actor_solomon.cpp | 9 +- .../stats_service/stats_service_state.cpp | 2 +- .../stats_service/stats_service_state.h | 75 +++-- .../stats_service/stats_service_ut.cpp | 70 ++-- .../libs/storage/testlib/counters_printer.cpp | 65 ++++ .../libs/storage/testlib/counters_printer.h | 40 +++ .../libs/storage/testlib/diagnostics.cpp | 14 + .../libs/storage/testlib/diagnostics.h | 10 + cloud/blockstore/libs/storage/testlib/ya.make | 2 + .../volume/actors/shadow_disk_actor.cpp | 14 +- .../storage/volume/actors/shadow_disk_actor.h | 2 +- .../libs/storage/volume/volume_actor.cpp | 4 +- .../storage/volume/volume_actor_loadstate.cpp | 1 + .../storage/volume/volume_actor_startstop.cpp | 5 + .../storage/volume/volume_actor_stats.cpp | 18 +- .../volume/volume_actor_updateconfig.cpp | 1 + .../libs/storage/volume/volume_state.cpp | 9 +- .../libs/storage/volume/volume_state.h | 8 +- .../libs/storage/volume/volume_state_ut.cpp | 5 + 65 files changed, 887 insertions(+), 159 deletions(-) create mode 100644 cloud/blockstore/libs/storage/core/histogram_ut.cpp create mode 100644 cloud/blockstore/libs/storage/testlib/counters_printer.cpp create mode 100644 cloud/blockstore/libs/storage/testlib/counters_printer.h create mode 100644 cloud/blockstore/libs/storage/testlib/diagnostics.cpp create mode 100644 cloud/blockstore/libs/storage/testlib/diagnostics.h diff --git a/cloud/blockstore/libs/storage/core/disk_counters.cpp b/cloud/blockstore/libs/storage/core/disk_counters.cpp index a058b87b85d..ae556dc9564 100644 --- a/cloud/blockstore/libs/storage/core/disk_counters.cpp +++ b/cloud/blockstore/libs/storage/core/disk_counters.cpp @@ -421,14 +421,18 @@ void TVolumeSelfCounters::Publish(TInstant now) //////////////////////////////////////////////////////////////////////////////// -TVolumeSelfCountersPtr CreateVolumeSelfCounters(EPublishingPolicy policy) +TVolumeSelfCountersPtr CreateVolumeSelfCounters( + EPublishingPolicy policy, + EHistogramCounterOptions histCounterOptions) { - return std::make_unique(policy); + return std::make_unique(policy, histCounterOptions); } -TPartitionDiskCountersPtr CreatePartitionDiskCounters(EPublishingPolicy policy) +TPartitionDiskCountersPtr CreatePartitionDiskCounters( + EPublishingPolicy policy, + EHistogramCounterOptions histCounterOptions) { - return std::make_unique(policy); + return std::make_unique(policy, histCounterOptions); } } // namespace NCloud::NBlockStore::NStorage diff --git a/cloud/blockstore/libs/storage/core/disk_counters.h b/cloud/blockstore/libs/storage/core/disk_counters.h index 92ccf993e39..718e470bf25 100644 --- a/cloud/blockstore/libs/storage/core/disk_counters.h +++ b/cloud/blockstore/libs/storage/core/disk_counters.h @@ -32,10 +32,12 @@ struct TMemberWithMeta: public TBase , PublishingPolicy(publishingPolicy) {} + template TMemberWithMeta( EPublishingPolicy publishingPolicy, - ERequestCounterOption counterOption) - : TBase() + ERequestCounterOption counterOption, + TArgs&&... args) + : TBase(std::forward(args)...) , PublishingPolicy(publishingPolicy) , CounterOption(counterOption) {} @@ -373,28 +375,42 @@ struct THistogramRequestCounters using THighResMeta = TMemberMeta; + explicit THistogramRequestCounters( + EHistogramCounterOptions histCounterOptions) + : HistCounterOptions(histCounterOptions) + {} + + EHistogramCounterOptions HistCounterOptions; + // BlobStorage based - TLowResCounter Flush{EPublishingPolicy::Repl}; - TLowResCounter AddBlobs{EPublishingPolicy::Repl}; - TLowResCounter Compaction{EPublishingPolicy::Repl}; - TLowResCounter Cleanup{EPublishingPolicy::Repl}; - TLowResCounter CollectGarbage{EPublishingPolicy::Repl}; - TLowResCounter DeleteGarbage{EPublishingPolicy::Repl}; - TLowResCounter TrimFreshLog{EPublishingPolicy::Repl}; - TLowResCounter AddConfirmedBlobs{EPublishingPolicy::Repl}; - TLowResCounter AddUnconfirmedBlobs{EPublishingPolicy::Repl}; - TLowResCounter ConfirmBlobs{EPublishingPolicy::Repl}; + TLowResCounter Flush{EPublishingPolicy::Repl, HistCounterOptions}; + TLowResCounter AddBlobs{EPublishingPolicy::Repl, HistCounterOptions}; + TLowResCounter Compaction{EPublishingPolicy::Repl, HistCounterOptions}; + TLowResCounter Cleanup{EPublishingPolicy::Repl, HistCounterOptions}; + TLowResCounter CollectGarbage{EPublishingPolicy::Repl, HistCounterOptions}; + TLowResCounter DeleteGarbage{EPublishingPolicy::Repl, HistCounterOptions}; + TLowResCounter TrimFreshLog{EPublishingPolicy::Repl, HistCounterOptions}; + TLowResCounter AddConfirmedBlobs{ + EPublishingPolicy::Repl, + HistCounterOptions}; + TLowResCounter AddUnconfirmedBlobs{ + EPublishingPolicy::Repl, + HistCounterOptions}; + TLowResCounter ConfirmBlobs{EPublishingPolicy::Repl, HistCounterOptions}; // BlobStorage based with kind and size TLowResCounter WriteBlob{ EPublishingPolicy::Repl, - ERequestCounterOption::HasKind}; + ERequestCounterOption::HasKind, + HistCounterOptions}; TLowResCounter ReadBlob{ EPublishingPolicy::Repl, - ERequestCounterOption::HasKind}; + ERequestCounterOption::HasKind, + HistCounterOptions}; TLowResCounter PatchBlob{ EPublishingPolicy::Repl, - ERequestCounterOption::HasKind}; + ERequestCounterOption::HasKind, + HistCounterOptions}; static constexpr TLowResMeta AllLowResCounters[] = { MakeMeta<&THistogramRequestCounters::Flush>(), @@ -415,12 +431,15 @@ struct THistogramRequestCounters THighResCounter ReadBlocks{ EPublishingPolicy::All, - ERequestCounterOption::HasVoidBytes}; - THighResCounter WriteBlocks{EPublishingPolicy::All}; - THighResCounter ZeroBlocks{EPublishingPolicy::All}; - THighResCounter DescribeBlocks{EPublishingPolicy::All}; - THighResCounter ChecksumBlocks{EPublishingPolicy::All}; - THighResCounter CopyBlocks{EPublishingPolicy::DiskRegistryBased}; + ERequestCounterOption::HasVoidBytes, + HistCounterOptions}; + THighResCounter WriteBlocks{EPublishingPolicy::All, HistCounterOptions}; + THighResCounter ZeroBlocks{EPublishingPolicy::All, HistCounterOptions}; + THighResCounter DescribeBlocks{EPublishingPolicy::All, HistCounterOptions}; + THighResCounter ChecksumBlocks{EPublishingPolicy::All, HistCounterOptions}; + THighResCounter CopyBlocks{ + EPublishingPolicy::DiskRegistryBased, + HistCounterOptions}; static constexpr THighResMeta AllHighResCounters[] = { MakeMeta<&THistogramRequestCounters::ReadBlocks>(), @@ -434,7 +453,9 @@ struct THistogramRequestCounters static_assert( sizeof(THistogramRequestCounters) == - (sizeof(THistogramRequestCounters::TLowResCounter) * + // cannot use sizeof(EHistogramCounterOptions) because of alignment + (offsetof(THistogramRequestCounters, Flush) + + sizeof(THistogramRequestCounters::TLowResCounter) * std::size(THistogramRequestCounters::AllLowResCounters) + sizeof(THistogramRequestCounters::THighResCounter) * std::size(THistogramRequestCounters::AllHighResCounters))); @@ -444,9 +465,15 @@ struct THistogramCounters using TCounter = TMemberWithMeta>; using TMeta = TMemberMeta; + EHistogramCounterOptions HistCounterOptions; + // BlobStorage based - TCounter ActorQueue{EPublishingPolicy::Repl}; - TCounter MailboxQueue{EPublishingPolicy::Repl}; + TCounter ActorQueue{EPublishingPolicy::Repl, HistCounterOptions}; + TCounter MailboxQueue{EPublishingPolicy::Repl, HistCounterOptions}; + + explicit THistogramCounters(EHistogramCounterOptions histCounterOptions) + : HistCounterOptions(histCounterOptions) + {} static constexpr TMeta AllCounters[] = { MakeMeta<&THistogramCounters::ActorQueue>(), @@ -456,8 +483,10 @@ struct THistogramCounters static_assert( sizeof(THistogramCounters) == - sizeof(THistogramCounters::TCounter) * - std::size(THistogramCounters::AllCounters)); + // cannot use sizeof(EHistogramCounterOptions) because of alignment + (offsetof(THistogramCounters, ActorQueue) + + sizeof(THistogramCounters::TCounter) * + std::size(THistogramCounters::AllCounters))); //////////////////////////////////////////////////////////////////////////////// @@ -637,11 +666,18 @@ struct TVolumeSelfRequestCounters using TCounter = TMemberWithMeta>; using TMeta = TMemberMeta; + EHistogramCounterOptions HistCounterOptions; + // Common - TCounter ReadBlocks{EPublishingPolicy::All}; - TCounter WriteBlocks{EPublishingPolicy::All}; - TCounter ZeroBlocks{EPublishingPolicy::All}; - TCounter DescribeBlocks{EPublishingPolicy::All}; + TCounter ReadBlocks{EPublishingPolicy::All, HistCounterOptions}; + TCounter WriteBlocks{EPublishingPolicy::All, HistCounterOptions}; + TCounter ZeroBlocks{EPublishingPolicy::All, HistCounterOptions}; + TCounter DescribeBlocks{EPublishingPolicy::All, HistCounterOptions}; + + explicit TVolumeSelfRequestCounters( + EHistogramCounterOptions histCounterOptions) + : HistCounterOptions(histCounterOptions) + {} static constexpr TMeta AllCounters[] = { MakeMeta<&TVolumeSelfRequestCounters::ReadBlocks>(), @@ -652,8 +688,10 @@ struct TVolumeSelfRequestCounters }; static_assert( sizeof(TVolumeSelfRequestCounters) == - sizeof(TVolumeSelfRequestCounters::TCounter) * - std::size(TVolumeSelfRequestCounters::AllCounters)); + // cannot use sizeof(EHistogramCounterOptions) because of alignment + (offsetof(TVolumeSelfRequestCounters, ReadBlocks) + + sizeof(TVolumeSelfRequestCounters::TCounter) * + std::size(TVolumeSelfRequestCounters::AllCounters))); struct TTransportCounters { @@ -699,8 +737,12 @@ struct TPartitionDiskCounters EPublishingPolicy Policy; - explicit TPartitionDiskCounters(EPublishingPolicy policy) - : Policy(policy) + TPartitionDiskCounters( + EPublishingPolicy policy, + EHistogramCounterOptions histCounterOptions) + : RequestCounters(histCounterOptions) + , Histogram(histCounterOptions) + , Policy(policy) {} void Add(const TPartitionDiskCounters& source); @@ -720,8 +762,11 @@ struct TVolumeSelfCounters EPublishingPolicy Policy; - explicit TVolumeSelfCounters(EPublishingPolicy policy) - : Policy(policy) + TVolumeSelfCounters( + EPublishingPolicy policy, + EHistogramCounterOptions histCounterOptions) + : RequestCounters(histCounterOptions) + , Policy(policy) {} void Add(const TVolumeSelfCounters& source); @@ -738,7 +783,11 @@ using TVolumeSelfCountersPtr = std::unique_ptr; //////////////////////////////////////////////////////////////////////////////// -TPartitionDiskCountersPtr CreatePartitionDiskCounters(EPublishingPolicy policy); -TVolumeSelfCountersPtr CreateVolumeSelfCounters(EPublishingPolicy policy); +TPartitionDiskCountersPtr CreatePartitionDiskCounters( + EPublishingPolicy policy, + EHistogramCounterOptions histCounterOptions); +TVolumeSelfCountersPtr CreateVolumeSelfCounters( + EPublishingPolicy policy, + EHistogramCounterOptions histCounterOptions); } // namespace NCloud::NBlockStore::NStorage diff --git a/cloud/blockstore/libs/storage/core/disk_counters_ut.cpp b/cloud/blockstore/libs/storage/core/disk_counters_ut.cpp index eb5028061a5..38ce95d7c83 100644 --- a/cloud/blockstore/libs/storage/core/disk_counters_ut.cpp +++ b/cloud/blockstore/libs/storage/core/disk_counters_ut.cpp @@ -12,7 +12,9 @@ Y_UNIT_TEST_SUITE(TDiskCountersTests) { Y_UNIT_TEST(ShouldResetAfterPublish) { - TVolumeSelfCounters counters(EPublishingPolicy::All); + TVolumeSelfCounters counters( + EPublishingPolicy::All, + EHistogramCounterOption::ReportMultipleCounters); NMonitoring::TDynamicCountersPtr dynCounters = new NMonitoring::TDynamicCounters(); counters.Register(dynCounters, false); diff --git a/cloud/blockstore/libs/storage/core/histogram.h b/cloud/blockstore/libs/storage/core/histogram.h index 56b3920fae6..40c7dd3edb9 100644 --- a/cloud/blockstore/libs/storage/core/histogram.h +++ b/cloud/blockstore/libs/storage/core/histogram.h @@ -5,6 +5,8 @@ #include #include +#include +#include #include #include @@ -24,12 +26,15 @@ struct THistogram std::array Buckets; + EHistogramCounterOptions CounterOptions; + std::optional Hist; std::optional HistSolomonCounters; std::optional PercSolomonCounters; TString GroupName; - THistogram() + explicit THistogram(EHistogramCounterOptions counterOptions) + : CounterOptions(counterOptions) { Fill(Buckets.begin(), Buckets.end(), 0); } @@ -49,6 +54,9 @@ struct THistogram auto idx = std::distance(TBuckets::Buckets.begin(), it); Buckets[idx] += count; + if (Hist) { + Hist.value()->Collect(static_cast(value), count); + } if (HistSolomonCounters) { *HistSolomonCounters.value()[idx] += count; } @@ -57,7 +65,7 @@ struct THistogram } } - const TVector GetBuckets() const + TVector GetBuckets() const { TVector result(Reserve(Buckets.size())); for (size_t i = 0; i < Buckets.size(); ++i) { @@ -69,21 +77,20 @@ struct THistogram return result; } - const TVector GetBucketNames(bool histogram) const + TVector GetBucketNames(bool histogram) const { if (histogram) { return TBuckets::MakeNames(); - } else { - return GetDefaultPercentileNames(); } + return GetDefaultPercentileNames(); } - const TVector CalculatePercentiles() const + TVector CalculatePercentiles() const { return CalculatePercentiles(GetDefaultPercentiles()); } - const TVector CalculatePercentiles( + TVector CalculatePercentiles( const TVector& percentiles) const { auto buckets = GetBuckets(); @@ -124,7 +131,7 @@ struct THistogram return buckets; } - const TVector GetSolomonHistogram() const + TVector GetSolomonHistogram() const { TVector r(Reserve(Buckets.size())); for (ui32 i = 0; i < Buckets.size(); ++i) { @@ -160,8 +167,14 @@ struct THistogram GroupName, visibleHistogram); - auto histBuckets = GetBucketNames(true); + const auto bounds = ConvertToHistBounds(TBuckets::Buckets); + Hist = histGroup.GetHistogram( + GroupName, + NMonitoring::ExplicitHistogram(bounds), + true, + visibleHistogram); + const auto histBuckets = GetBucketNames(true); HistSolomonCounters = std::make_optional(); for (size_t i = 0; i < histBuckets.size(); ++i) { HistSolomonCounters->push_back( @@ -183,11 +196,23 @@ struct THistogram reportHistogram ? "histogram" : "percentiles", GroupName); - auto buckets = GetBucketNames(reportHistogram); + const auto buckets = GetBucketNames(reportHistogram); if (reportHistogram) { - HistSolomonCounters = std::make_optional(); - for (size_t i = 0; i < buckets.size(); ++i) { - HistSolomonCounters->push_back(group->GetCounter(buckets[i], true)); + if (CounterOptions & EHistogramCounterOption::ReportSingleCounter) { + const auto bounds = ConvertToHistBounds(TBuckets::Buckets); + Hist = group->GetHistogram( + GroupName, + NMonitoring::ExplicitHistogram(bounds), + true); + } + if (CounterOptions & + EHistogramCounterOption::ReportMultipleCounters) + { + HistSolomonCounters = std::make_optional(); + for (size_t i = 0; i < buckets.size(); ++i) { + HistSolomonCounters->push_back( + group->GetCounter(buckets[i], true)); + } } } else { PercSolomonCounters = std::make_optional(); @@ -199,13 +224,20 @@ struct THistogram void Publish() { - if (!HistSolomonCounters && !PercSolomonCounters) { + if (!Hist && !HistSolomonCounters && !PercSolomonCounters) { Y_DEBUG_ABORT_UNLESS(0); return; } + if (Hist) { + const auto hist = GetSolomonHistogram(); + for (size_t i = 0; i < hist.size(); ++i) { + Hist.value()->Collect(static_cast(Buckets[i]), hist[i]); + } + } + if (HistSolomonCounters) { - auto hist = GetSolomonHistogram(); + const auto hist = GetSolomonHistogram(); Y_ABORT_UNLESS(HistSolomonCounters->size() == hist.size()); @@ -215,7 +247,7 @@ struct THistogram } if (PercSolomonCounters) { - auto percentiles = CalculatePercentiles(); + const auto percentiles = CalculatePercentiles(); Y_ABORT_UNLESS(PercSolomonCounters->size() == percentiles.size()); for (ui32 i = 0; i < percentiles.size(); ++i) { diff --git a/cloud/blockstore/libs/storage/core/histogram_ut.cpp b/cloud/blockstore/libs/storage/core/histogram_ut.cpp new file mode 100644 index 00000000000..0b110518410 --- /dev/null +++ b/cloud/blockstore/libs/storage/core/histogram_ut.cpp @@ -0,0 +1,306 @@ +#include "histogram.h" + +#include +#include + +#include + +namespace NCloud::NBlockStore::NStorage { + +using TDynamicCounterPtr = NMonitoring::TDynamicCounterPtr; +using TDynamicCounters = NMonitoring::TDynamicCounters; + +namespace { + +//////////////////////////////////////////////////////////////////////////////// + +auto CreateTestHistogram1( + const TDynamicCounterPtr& group, + EHistogramCounterOptions histCounterOptions) +{ + THistogram histogram(histCounterOptions); + histogram.Register(group, true); + + histogram.Increment(1); + histogram.Increment(2, 1); + histogram.Increment(4, 3); // 4KB: 5 + histogram.Increment(6, 1); + histogram.Increment(7, 3); // 8KB: 4 + histogram.Increment(10, 1); + histogram.Increment(16, 2); // 16KB: 3 + histogram.Increment(20, 1); + histogram.Increment(30, 1); // 32KB: 2 + histogram.Increment(40, 1); // 64KB: 1 + return histogram; +} + +auto CreateTestHistogram2( + const TDynamicCounterPtr& group, + EHistogramCounterOptions histCounterOptions) +{ + THistogram histogram(histCounterOptions); + histogram.Register(group, true); + + histogram.Increment(1024, 1); + histogram.Increment(2000, 2); + histogram.Increment(3000, 2); + histogram.Increment(4096, 1); + histogram.Increment(4097, 1); + histogram.Increment(10000, 1); + histogram.Increment(100500, 1); + histogram.Increment(1000000000, 1); + return histogram; +} + +} // namespace + +//////////////////////////////////////////////////////////////////////////////// + +Y_UNIT_TEST_SUITE(THistogramTest) +{ + Y_UNIT_TEST(TestGetSolomonHistogram) + { + TDynamicCounterPtr group{new TDynamicCounters()}; + + { + const auto histogram = CreateTestHistogram1( + group, + EHistogramCounterOption::ReportMultipleCounters); + const auto buckets = histogram.GetSolomonHistogram(); + + UNIT_ASSERT_VALUES_EQUAL(buckets.size(), 12); + + const TVector expected = {5, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0}; + for (size_t i = 0; i < buckets.size(); ++i) { + UNIT_ASSERT_VALUES_EQUAL_C( + buckets[i], + expected[i], + "index=" + ToString(i)); + } + } + + { + const auto histogram = CreateTestHistogram2( + group, + EHistogramCounterOption::ReportMultipleCounters); + const auto buckets = histogram.GetSolomonHistogram(); + + const TVector expected = {0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4}; + for (size_t i = 0; i < buckets.size(); ++i) { + UNIT_ASSERT_VALUES_EQUAL_C( + buckets[i], + expected[i], + "index=" + ToString(i)); + } + } + } + + Y_UNIT_TEST(TestGetPercentileBuckets) + { + TDynamicCounterPtr group{new TDynamicCounters()}; + + { + const auto histogram = CreateTestHistogram1( + group, + EHistogramCounterOption::ReportMultipleCounters); + const auto buckets = histogram.GetPercentileBuckets(); + + UNIT_ASSERT_VALUES_EQUAL( + buckets.size(), + TKbSizeBuckets::BUCKETS_COUNT); + UNIT_ASSERT_DOUBLES_EQUAL(buckets[0].first, 4, Min()); + UNIT_ASSERT_DOUBLES_EQUAL(buckets[1].first, 8, Min()); + UNIT_ASSERT_DOUBLES_EQUAL(buckets[2].first, 16, Min()); + UNIT_ASSERT_DOUBLES_EQUAL(buckets[3].first, 32, Min()); + UNIT_ASSERT_DOUBLES_EQUAL(buckets[4].first, 64, Min()); + UNIT_ASSERT_VALUES_EQUAL(buckets[0].second, 5); + UNIT_ASSERT_VALUES_EQUAL(buckets[1].second, 4); + UNIT_ASSERT_VALUES_EQUAL(buckets[2].second, 3); + UNIT_ASSERT_VALUES_EQUAL(buckets[3].second, 2); + UNIT_ASSERT_VALUES_EQUAL(buckets[4].second, 1); + } + + { + const auto histogram = CreateTestHistogram2( + group, + EHistogramCounterOption::ReportMultipleCounters); + const auto buckets = histogram.GetPercentileBuckets(); + + UNIT_ASSERT_VALUES_EQUAL( + buckets.size(), + TKbSizeBuckets::BUCKETS_COUNT); + UNIT_ASSERT_DOUBLES_EQUAL(buckets[8].first, 1024, Min()); + UNIT_ASSERT_DOUBLES_EQUAL(buckets[9].first, 2048, Min()); + UNIT_ASSERT_DOUBLES_EQUAL(buckets[10].first, 4096, Min()); + UNIT_ASSERT_DOUBLES_EQUAL( + buckets[11].first, + Max(), + Min()); + UNIT_ASSERT_VALUES_EQUAL(buckets[8].second, 1); + UNIT_ASSERT_VALUES_EQUAL(buckets[9].second, 2); + UNIT_ASSERT_VALUES_EQUAL(buckets[10].second, 3); + UNIT_ASSERT_VALUES_EQUAL(buckets[11].second, 4); + } + } + + Y_UNIT_TEST(TestCalculatePercentiles) + { + TDynamicCounterPtr group{new TDynamicCounters()}; + auto histogram = CreateTestHistogram1( + group, + EHistogramCounterOption::ReportMultipleCounters); + + TVector percentiles = histogram.CalculatePercentiles(); + UNIT_ASSERT_VALUES_EQUAL(percentiles.size(), 5); + UNIT_ASSERT_DOUBLES_EQUAL(percentiles[0], 6.5, 0.1); // p50 + UNIT_ASSERT_VALUES_EQUAL(percentiles[4], 64); // p100 + } + + Y_UNIT_TEST(TestReset) + { + TDynamicCounterPtr group{new TDynamicCounters()}; + auto histogram = CreateTestHistogram1( + group, + EHistogramCounterOption::ReportMultipleCounters); + + histogram.Reset(); + + const auto buckets = histogram.GetSolomonHistogram(); + for (auto value: buckets) { + UNIT_ASSERT_VALUES_EQUAL(value, 0); + } + } + + Y_UNIT_TEST(TestAdd) + { + TDynamicCounterPtr group{new TDynamicCounters()}; + auto histogram1 = CreateTestHistogram1( + group, + EHistogramCounterOption::ReportMultipleCounters); + auto histogram2 = CreateTestHistogram2( + group, + EHistogramCounterOption::ReportMultipleCounters); + auto histogram3 = CreateTestHistogram1( + group, + EHistogramCounterOption::ReportMultipleCounters); + + { + const TVector expected = {5, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0}; + const auto buckets = histogram1.GetSolomonHistogram(); + for (size_t i = 0; i < buckets.size(); ++i) { + UNIT_ASSERT_VALUES_EQUAL_C( + buckets[i], + expected[i], + "index=" + ToString(i)); + } + } + + histogram1.Add(histogram2); + { + const TVector expected = {5, 4, 3, 2, 1, 0, 0, 0, 1, 2, 3, 4}; + const auto buckets = histogram1.GetSolomonHistogram(); + for (size_t i = 0; i < buckets.size(); ++i) { + UNIT_ASSERT_VALUES_EQUAL_C( + buckets[i], + expected[i], + "index=" + ToString(i)); + } + } + + histogram1.Add(histogram3); + { + const TVector expected = + {10, 8, 6, 4, 2, 0, 0, 0, 1, 2, 3, 4}; + const auto buckets = histogram1.GetSolomonHistogram(); + for (size_t i = 0; i < buckets.size(); ++i) { + UNIT_ASSERT_VALUES_EQUAL_C( + buckets[i], + expected[i], + "index=" + ToString(i)); + } + } + } + + Y_UNIT_TEST(ShouldReportHistogramSingleCounter) + { + TDynamicCounterPtr group(new TDynamicCounters()); + auto histogram1 = CreateTestHistogram1( + group, + EHistogramCounterOption::ReportSingleCounter); + TStringStream ss; + TCountersPrinter printer(&ss); + group->Accept("root", "counters", printer); + + TString expected = R"(root:counters { + histogram:Time { + sensor:Time = {4: 5, 8: 4, 16: 3, 32: 2, 64: 1, 128: 0, 256: 0, 512: 0, 1024: 0, 2048: 0, 4096: 0, inf: 0} + } +} +)"; + UNIT_ASSERT_STRINGS_EQUAL(ss.Str(), expected); + } + + Y_UNIT_TEST(ShouldReportHistogramMultipleCounters) + { + TDynamicCounterPtr group(new TDynamicCounters()); + auto histogram1 = CreateTestHistogram1( + group, + EHistogramCounterOption::ReportMultipleCounters); + TStringStream ss; + TCountersPrinter printer(&ss); + group->Accept("root", "counters", printer); + + TString expected = R"(root:counters { + histogram:Time { + sensor:1024KB = 0 + sensor:128KB = 0 + sensor:16KB = 3 + sensor:2048KB = 0 + sensor:256KB = 0 + sensor:32KB = 2 + sensor:4096KB = 0 + sensor:4KB = 5 + sensor:512KB = 0 + sensor:64KB = 1 + sensor:8KB = 4 + sensor:Inf = 0 + } +} +)"; + UNIT_ASSERT_STRINGS_EQUAL(ss.Str(), expected); + } + + Y_UNIT_TEST(ShouldReportHistogramBothSingleAndMultipleCounters) + { + TDynamicCounterPtr group(new TDynamicCounters()); + auto histogram1 = CreateTestHistogram1( + group, + EHistogramCounterOption::ReportSingleCounter | + EHistogramCounterOption::ReportMultipleCounters); + TStringStream ss; + TCountersPrinter printer(&ss); + group->Accept("root", "counters", printer); + + TString expected = R"(root:counters { + histogram:Time { + sensor:1024KB = 0 + sensor:128KB = 0 + sensor:16KB = 3 + sensor:2048KB = 0 + sensor:256KB = 0 + sensor:32KB = 2 + sensor:4096KB = 0 + sensor:4KB = 5 + sensor:512KB = 0 + sensor:64KB = 1 + sensor:8KB = 4 + sensor:Inf = 0 + sensor:Time = {4: 5, 8: 4, 16: 3, 32: 2, 64: 1, 128: 0, 256: 0, 512: 0, 1024: 0, 2048: 0, 4096: 0, inf: 0} + } +} +)"; + UNIT_ASSERT_STRINGS_EQUAL(ss.Str(), expected); + } +} + +} // namespace NCloud::NBlockStore::NStorage diff --git a/cloud/blockstore/libs/storage/core/storage_request_counters.h b/cloud/blockstore/libs/storage/core/storage_request_counters.h index 0604a3968f9..0505c4be30a 100644 --- a/cloud/blockstore/libs/storage/core/storage_request_counters.h +++ b/cloud/blockstore/libs/storage/core/storage_request_counters.h @@ -46,12 +46,14 @@ struct TRequestCounters ui64 ExternalCount = 0; ui64 ExternalRequestBytes = 0; - THistogram Total; + EHistogramCounterOptions HistCounterOptions; - THistogram Fresh; - THistogram Mixed; - THistogram Merged; - THistogram External; + THistogram Total{HistCounterOptions}; + + THistogram Fresh{HistCounterOptions}; + THistogram Mixed{HistCounterOptions}; + THistogram Merged{HistCounterOptions}; + THistogram External{HistCounterOptions}; NMonitoring::TDynamicCounters::TCounterPtr SolomonCount; NMonitoring::TDynamicCounters::TCounterPtr SolomonRequestBytes; @@ -69,6 +71,10 @@ struct TRequestCounters ERequestCounterOptions Options; + explicit TRequestCounters(EHistogramCounterOptions histCounterOptions) + : HistCounterOptions(histCounterOptions) + {} + void AddRequest( ui64 time, ui64 size = 0, diff --git a/cloud/blockstore/libs/storage/partition/part_actor.cpp b/cloud/blockstore/libs/storage/partition/part_actor.cpp index f956f4eeb04..e728a9b0f3f 100644 --- a/cloud/blockstore/libs/storage/partition/part_actor.cpp +++ b/cloud/blockstore/libs/storage/partition/part_actor.cpp @@ -171,7 +171,9 @@ void TPartitionActor::RegisterCounters(const TActorContext& ctx) } if (!PartCounters) { - PartCounters = CreatePartitionDiskCounters(EPublishingPolicy::Repl); + PartCounters = CreatePartitionDiskCounters( + EPublishingPolicy::Repl, + DiagnosticsConfig->GetHistogramCounterOptions()); } } diff --git a/cloud/blockstore/libs/storage/partition/part_actor_stats.cpp b/cloud/blockstore/libs/storage/partition/part_actor_stats.cpp index 9ffc4ca1809..1870d19cef6 100644 --- a/cloud/blockstore/libs/storage/partition/part_actor_stats.cpp +++ b/cloud/blockstore/libs/storage/partition/part_actor_stats.cpp @@ -147,7 +147,9 @@ void TPartitionActor::SendStatsToService(const TActorContext& ctx) UserCPUConsumption = 0; SysCPUConsumption = sysCpuConsumption; - PartCounters = CreatePartitionDiskCounters(EPublishingPolicy::Repl); + PartCounters = CreatePartitionDiskCounters( + EPublishingPolicy::Repl, + DiagnosticsConfig->GetHistogramCounterOptions()); NCloud::Send(ctx, VolumeActorId, std::move(request)); } diff --git a/cloud/blockstore/libs/storage/partition2/part2_actor.cpp b/cloud/blockstore/libs/storage/partition2/part2_actor.cpp index 7b5eacf3d5a..705759771d3 100644 --- a/cloud/blockstore/libs/storage/partition2/part2_actor.cpp +++ b/cloud/blockstore/libs/storage/partition2/part2_actor.cpp @@ -135,7 +135,9 @@ void TPartitionActor::RegisterCounters(const TActorContext& ctx) } if (!PartCounters) { - PartCounters = CreatePartitionDiskCounters(EPublishingPolicy::Repl); + PartCounters = CreatePartitionDiskCounters( + EPublishingPolicy::Repl, + DiagnosticsConfig->GetHistogramCounterOptions()); } } diff --git a/cloud/blockstore/libs/storage/partition2/part2_actor_stats.cpp b/cloud/blockstore/libs/storage/partition2/part2_actor_stats.cpp index 8e390331f4d..593d0370f06 100644 --- a/cloud/blockstore/libs/storage/partition2/part2_actor_stats.cpp +++ b/cloud/blockstore/libs/storage/partition2/part2_actor_stats.cpp @@ -124,7 +124,9 @@ void TPartitionActor::SendStatsToService(const TActorContext& ctx) UserCPUConsumption = 0; SysCPUConsumption = sysCpuConsumption; - PartCounters = CreatePartitionDiskCounters(EPublishingPolicy::Repl); + PartCounters = CreatePartitionDiskCounters( + EPublishingPolicy::Repl, + DiagnosticsConfig->GetHistogramCounterOptions()); NCloud::Send(ctx, VolumeActorId, std::move(request)); } diff --git a/cloud/blockstore/libs/storage/partition_nonrepl/part_mirror.cpp b/cloud/blockstore/libs/storage/partition_nonrepl/part_mirror.cpp index a3343d4fbf8..1b29c21019c 100644 --- a/cloud/blockstore/libs/storage/partition_nonrepl/part_mirror.cpp +++ b/cloud/blockstore/libs/storage/partition_nonrepl/part_mirror.cpp @@ -10,6 +10,7 @@ using namespace NActors; IActorPtr CreateMirrorPartition( TStorageConfigPtr config, + TDiagnosticsConfigPtr diagnosticsConfig, IProfileLogPtr profileLog, IBlockDigestGeneratorPtr digestGenerator, TString rwClientId, @@ -22,6 +23,7 @@ IActorPtr CreateMirrorPartition( { return std::make_unique( std::move(config), + std::move(diagnosticsConfig), std::move(profileLog), std::move(digestGenerator), std::move(rwClientId), diff --git a/cloud/blockstore/libs/storage/partition_nonrepl/part_mirror.h b/cloud/blockstore/libs/storage/partition_nonrepl/part_mirror.h index 7ddfae66565..b9c9076b26a 100644 --- a/cloud/blockstore/libs/storage/partition_nonrepl/part_mirror.h +++ b/cloud/blockstore/libs/storage/partition_nonrepl/part_mirror.h @@ -15,6 +15,7 @@ namespace NCloud::NBlockStore::NStorage { NActors::IActorPtr CreateMirrorPartition( TStorageConfigPtr config, + TDiagnosticsConfigPtr diagnosticsConfig, IProfileLogPtr profileLog, IBlockDigestGeneratorPtr digestGenerator, TString rwClientId, diff --git a/cloud/blockstore/libs/storage/partition_nonrepl/part_mirror_actor.cpp b/cloud/blockstore/libs/storage/partition_nonrepl/part_mirror_actor.cpp index 144a89a2a20..f120d037ae4 100644 --- a/cloud/blockstore/libs/storage/partition_nonrepl/part_mirror_actor.cpp +++ b/cloud/blockstore/libs/storage/partition_nonrepl/part_mirror_actor.cpp @@ -45,6 +45,7 @@ TDuration CalculateScrubbingInterval( TMirrorPartitionActor::TMirrorPartitionActor( TStorageConfigPtr config, + TDiagnosticsConfigPtr diagnosticsConfig, IProfileLogPtr profileLog, IBlockDigestGeneratorPtr digestGenerator, TString rwClientId, @@ -55,6 +56,7 @@ TMirrorPartitionActor::TMirrorPartitionActor( TActorId statActorId, TActorId resyncActorId) : Config(std::move(config)) + , DiagnosticsConfig(std::move(diagnosticsConfig)) , ProfileLog(std::move(profileLog)) , BlockDigestGenerator(std::move(digestGenerator)) , RdmaClient(std::move(rdmaClient)) @@ -110,6 +112,7 @@ void TMirrorPartitionActor::SetupPartitions(const TActorContext& ctx) if (replicaInfo.Migrations.size()) { actor = CreateNonreplicatedPartitionMigration( Config, + DiagnosticsConfig, ProfileLog, BlockDigestGenerator, 0, // initialMigrationIndex @@ -121,6 +124,7 @@ void TMirrorPartitionActor::SetupPartitions(const TActorContext& ctx) } else { actor = CreateNonreplicatedPartition( Config, + DiagnosticsConfig, replicaInfo.Config, SelfId(), RdmaClient); diff --git a/cloud/blockstore/libs/storage/partition_nonrepl/part_mirror_actor.h b/cloud/blockstore/libs/storage/partition_nonrepl/part_mirror_actor.h index 7a769b49e01..60106832fcd 100644 --- a/cloud/blockstore/libs/storage/partition_nonrepl/part_mirror_actor.h +++ b/cloud/blockstore/libs/storage/partition_nonrepl/part_mirror_actor.h @@ -7,6 +7,7 @@ #include "part_mirror_state.h" #include "part_nonrepl_events_private.h" +#include #include #include #include @@ -45,6 +46,7 @@ class TMirrorPartitionActor final { private: const TStorageConfigPtr Config; + const TDiagnosticsConfigPtr DiagnosticsConfig; const IProfileLogPtr ProfileLog; const IBlockDigestGeneratorPtr BlockDigestGenerator; NRdma::IClientPtr RdmaClient; @@ -86,6 +88,7 @@ class TMirrorPartitionActor final public: TMirrorPartitionActor( TStorageConfigPtr config, + TDiagnosticsConfigPtr diagnosticsConfig, IProfileLogPtr profileLog, IBlockDigestGeneratorPtr digestGenerator, TString rwClientId, diff --git a/cloud/blockstore/libs/storage/partition_nonrepl/part_mirror_actor_stats.cpp b/cloud/blockstore/libs/storage/partition_nonrepl/part_mirror_actor_stats.cpp index 857aab0e138..a2b585f3dd4 100644 --- a/cloud/blockstore/libs/storage/partition_nonrepl/part_mirror_actor_stats.cpp +++ b/cloud/blockstore/libs/storage/partition_nonrepl/part_mirror_actor_stats.cpp @@ -38,8 +38,9 @@ void TMirrorPartitionActor::SendStats(const TActorContext& ctx) return; } - auto stats = - CreatePartitionDiskCounters(EPublishingPolicy::DiskRegistryBased); + auto stats = CreatePartitionDiskCounters( + EPublishingPolicy::DiskRegistryBased, + DiagnosticsConfig->GetHistogramCounterOptions()); for (const auto& counters: ReplicaCounters) { if (counters) { diff --git a/cloud/blockstore/libs/storage/partition_nonrepl/part_mirror_resync.cpp b/cloud/blockstore/libs/storage/partition_nonrepl/part_mirror_resync.cpp index 49f0966ffad..0e60717a810 100644 --- a/cloud/blockstore/libs/storage/partition_nonrepl/part_mirror_resync.cpp +++ b/cloud/blockstore/libs/storage/partition_nonrepl/part_mirror_resync.cpp @@ -10,6 +10,7 @@ using namespace NActors; IActorPtr CreateMirrorPartitionResync( TStorageConfigPtr config, + TDiagnosticsConfigPtr diagnosticsConfig, IProfileLogPtr profileLog, IBlockDigestGeneratorPtr digestGenerator, TString rwClientId, @@ -22,6 +23,7 @@ IActorPtr CreateMirrorPartitionResync( { return std::make_unique( std::move(config), + std::move(diagnosticsConfig), std::move(profileLog), std::move(digestGenerator), std::move(rwClientId), diff --git a/cloud/blockstore/libs/storage/partition_nonrepl/part_mirror_resync.h b/cloud/blockstore/libs/storage/partition_nonrepl/part_mirror_resync.h index 1ec6e02928a..718a7c08083 100644 --- a/cloud/blockstore/libs/storage/partition_nonrepl/part_mirror_resync.h +++ b/cloud/blockstore/libs/storage/partition_nonrepl/part_mirror_resync.h @@ -4,6 +4,7 @@ #include "config.h" +#include #include #include #include @@ -15,6 +16,7 @@ namespace NCloud::NBlockStore::NStorage { NActors::IActorPtr CreateMirrorPartitionResync( TStorageConfigPtr config, + TDiagnosticsConfigPtr diagnosticsConfig, IProfileLogPtr profileLog, IBlockDigestGeneratorPtr digestGenerator, TString rwClientId, diff --git a/cloud/blockstore/libs/storage/partition_nonrepl/part_mirror_resync_actor.cpp b/cloud/blockstore/libs/storage/partition_nonrepl/part_mirror_resync_actor.cpp index 5b020ac5572..d01aa5f5e51 100644 --- a/cloud/blockstore/libs/storage/partition_nonrepl/part_mirror_resync_actor.cpp +++ b/cloud/blockstore/libs/storage/partition_nonrepl/part_mirror_resync_actor.cpp @@ -25,6 +25,7 @@ LWTRACE_USING(BLOCKSTORE_STORAGE_PROVIDER); TMirrorPartitionResyncActor::TMirrorPartitionResyncActor( TStorageConfigPtr config, + TDiagnosticsConfigPtr diagnosticsConfig, IProfileLogPtr profileLog, IBlockDigestGeneratorPtr digestGenerator, TString rwClientId, @@ -35,6 +36,7 @@ TMirrorPartitionResyncActor::TMirrorPartitionResyncActor( NActors::TActorId statActorId, ui64 initialResyncIndex) : Config(std::move(config)) + , DiagnosticsConfig(std::move(diagnosticsConfig)) , ProfileLog(std::move(profileLog)) , BlockDigestGenerator(std::move(digestGenerator)) , RWClientId(std::move(rwClientId)) @@ -100,6 +102,7 @@ void TMirrorPartitionResyncActor::SetupPartitions(const TActorContext& ctx) ctx, CreateMirrorPartition( Config, + DiagnosticsConfig, ProfileLog, BlockDigestGenerator, RWClientId, @@ -116,6 +119,7 @@ void TMirrorPartitionResyncActor::SetupPartitions(const TActorContext& ctx) for (ui32 i = 0; i < replicaInfos.size(); i++) { IActorPtr actor = CreateNonreplicatedPartition( Config, + DiagnosticsConfig, replicaInfos[i].Config, TActorId(), // do not send stats RdmaClient); diff --git a/cloud/blockstore/libs/storage/partition_nonrepl/part_mirror_resync_actor.h b/cloud/blockstore/libs/storage/partition_nonrepl/part_mirror_resync_actor.h index 7307dd565d1..e1bb8da062c 100644 --- a/cloud/blockstore/libs/storage/partition_nonrepl/part_mirror_resync_actor.h +++ b/cloud/blockstore/libs/storage/partition_nonrepl/part_mirror_resync_actor.h @@ -7,6 +7,7 @@ #include "part_nonrepl_events_private.h" #include "resync_range.h" +#include #include #include #include @@ -37,6 +38,7 @@ class TMirrorPartitionResyncActor final { private: const TStorageConfigPtr Config; + const TDiagnosticsConfigPtr DiagnosticsConfig; const IProfileLogPtr ProfileLog; const IBlockDigestGeneratorPtr BlockDigestGenerator; TString RWClientId; @@ -88,6 +90,7 @@ class TMirrorPartitionResyncActor final public: TMirrorPartitionResyncActor( TStorageConfigPtr config, + TDiagnosticsConfigPtr diagnosticsConfig, IProfileLogPtr profileLog, IBlockDigestGeneratorPtr digestGenerator, TString rwClientId, diff --git a/cloud/blockstore/libs/storage/partition_nonrepl/part_mirror_resync_actor_stats.cpp b/cloud/blockstore/libs/storage/partition_nonrepl/part_mirror_resync_actor_stats.cpp index d2163fbed6d..0e177b4c104 100644 --- a/cloud/blockstore/libs/storage/partition_nonrepl/part_mirror_resync_actor_stats.cpp +++ b/cloud/blockstore/libs/storage/partition_nonrepl/part_mirror_resync_actor_stats.cpp @@ -32,8 +32,9 @@ void TMirrorPartitionResyncActor::HandlePartCounters( void TMirrorPartitionResyncActor::SendStats(const TActorContext& ctx) { - auto stats = - CreatePartitionDiskCounters(EPublishingPolicy::DiskRegistryBased); + auto stats = CreatePartitionDiskCounters( + EPublishingPolicy::DiskRegistryBased, + DiagnosticsConfig->GetHistogramCounterOptions()); if (MirrorCounters) { stats->AggregateWith(*MirrorCounters); diff --git a/cloud/blockstore/libs/storage/partition_nonrepl/part_mirror_resync_ut.cpp b/cloud/blockstore/libs/storage/partition_nonrepl/part_mirror_resync_ut.cpp index 94426befa8b..7c2e0d2561c 100644 --- a/cloud/blockstore/libs/storage/partition_nonrepl/part_mirror_resync_ut.cpp +++ b/cloud/blockstore/libs/storage/partition_nonrepl/part_mirror_resync_ut.cpp @@ -12,6 +12,7 @@ #include #include #include +#include #include #include @@ -279,6 +280,7 @@ struct TTestEnv auto mirror = std::make_unique( Config, + CreateDiagnosticsConfig(), CreateProfileLogStub(), CreateBlockDigestGeneratorStub(), "", // rwClientId @@ -347,6 +349,7 @@ struct TTestEnv { auto actor = std::make_unique( Config, + CreateDiagnosticsConfig(), CreateProfileLogStub(), CreateBlockDigestGeneratorStub(), "", // rwClientId @@ -422,6 +425,7 @@ struct TTestEnv { auto part = std::make_unique( Config, + CreateDiagnosticsConfig(), partConfig, TActorId() // do not send stats ); diff --git a/cloud/blockstore/libs/storage/partition_nonrepl/part_mirror_ut.cpp b/cloud/blockstore/libs/storage/partition_nonrepl/part_mirror_ut.cpp index 76d6ce716c0..ad9e6c31f5f 100644 --- a/cloud/blockstore/libs/storage/partition_nonrepl/part_mirror_ut.cpp +++ b/cloud/blockstore/libs/storage/partition_nonrepl/part_mirror_ut.cpp @@ -11,6 +11,7 @@ #include #include #include +#include #include #include @@ -213,6 +214,7 @@ struct TTestEnv auto part = std::make_unique( Config, + CreateDiagnosticsConfig(), CreateProfileLogStub(), CreateBlockDigestGeneratorStub(), "", // rwClientId @@ -266,6 +268,7 @@ struct TTestEnv { auto part = std::make_unique( Config, + CreateDiagnosticsConfig(), partConfig, TActorId() // do not send stats ); diff --git a/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl.cpp b/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl.cpp index 6ed85057da5..6d2180069f4 100644 --- a/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl.cpp +++ b/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl.cpp @@ -11,6 +11,7 @@ using namespace NActors; IActorPtr CreateNonreplicatedPartition( TStorageConfigPtr config, + TDiagnosticsConfigPtr diagnosticsConfig, TNonreplicatedPartitionConfigPtr partConfig, TActorId statActorId, NRdma::IClientPtr rdmaClient) @@ -18,6 +19,7 @@ IActorPtr CreateNonreplicatedPartition( if (rdmaClient) { return std::make_unique( std::move(config), + std::move(diagnosticsConfig), std::move(partConfig), std::move(rdmaClient), statActorId); @@ -25,6 +27,7 @@ IActorPtr CreateNonreplicatedPartition( return std::make_unique( std::move(config), + std::move(diagnosticsConfig), std::move(partConfig), statActorId); } diff --git a/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl.h b/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl.h index 5cb39e7a4eb..b459ec03c5b 100644 --- a/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl.h +++ b/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl.h @@ -2,6 +2,7 @@ #include "public.h" +#include #include #include #include @@ -14,6 +15,7 @@ namespace NCloud::NBlockStore::NStorage { NActors::IActorPtr CreateNonreplicatedPartition( TStorageConfigPtr config, + TDiagnosticsConfigPtr diagnosticsConfig, TNonreplicatedPartitionConfigPtr partConfig, NActors::TActorId statActorId, NRdma::IClientPtr rdmaClient = nullptr); diff --git a/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_actor.cpp b/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_actor.cpp index db34d6ec703..5adec4da8fe 100644 --- a/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_actor.cpp +++ b/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_actor.cpp @@ -56,14 +56,17 @@ bool TNonreplicatedPartitionActor::TDeviceStat::CooldownPassed( TNonreplicatedPartitionActor::TNonreplicatedPartitionActor( TStorageConfigPtr config, + TDiagnosticsConfigPtr diagnosticsConfig, TNonreplicatedPartitionConfigPtr partConfig, TActorId statActorId) : Config(std::move(config)) + , DiagnosticsConfig(std::move(diagnosticsConfig)) , PartConfig(std::move(partConfig)) , StatActorId(statActorId) , DeviceStats(PartConfig->GetDevices().size()) - , PartCounters( - CreatePartitionDiskCounters(EPublishingPolicy::DiskRegistryBased)) + , PartCounters(CreatePartitionDiskCounters( + EPublishingPolicy::DiskRegistryBased, + DiagnosticsConfig->GetHistogramCounterOptions())) {} TNonreplicatedPartitionActor::~TNonreplicatedPartitionActor() = default; diff --git a/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_actor.h b/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_actor.h index c46a7d679ba..c4ef1576699 100644 --- a/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_actor.h +++ b/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_actor.h @@ -5,6 +5,7 @@ #include "config.h" #include "part_nonrepl_events_private.h" +#include #include #include #include @@ -48,6 +49,7 @@ class TNonreplicatedPartitionActor final { private: const TStorageConfigPtr Config; + const TDiagnosticsConfigPtr DiagnosticsConfig; const TNonreplicatedPartitionConfigPtr PartConfig; const NActors::TActorId StatActorId; @@ -103,6 +105,7 @@ class TNonreplicatedPartitionActor final public: TNonreplicatedPartitionActor( TStorageConfigPtr config, + TDiagnosticsConfigPtr diagnosticsConfig, TNonreplicatedPartitionConfigPtr partConfig, NActors::TActorId statActorId); diff --git a/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_actor_stats.cpp b/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_actor_stats.cpp index 625142cb8e1..aecc53df0bc 100644 --- a/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_actor_stats.cpp +++ b/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_actor_stats.cpp @@ -50,8 +50,9 @@ void TNonreplicatedPartitionActor::SendStats(const TActorContext& ctx) NetworkBytes = 0; CpuUsage = {}; - PartCounters = - CreatePartitionDiskCounters(EPublishingPolicy::DiskRegistryBased); + PartCounters = CreatePartitionDiskCounters( + EPublishingPolicy::DiskRegistryBased, + DiagnosticsConfig->GetHistogramCounterOptions()); NCloud::Send(ctx, StatActorId, std::move(request)); } diff --git a/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_migration.cpp b/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_migration.cpp index e2ed414db8b..8ebec373d78 100644 --- a/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_migration.cpp +++ b/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_migration.cpp @@ -10,6 +10,7 @@ using namespace NActors; IActorPtr CreateNonreplicatedPartitionMigration( TStorageConfigPtr config, + TDiagnosticsConfigPtr diagnosticsConfig, IProfileLogPtr profileLog, IBlockDigestGeneratorPtr digestGenerator, ui64 initialMigrationIndex, @@ -21,6 +22,7 @@ IActorPtr CreateNonreplicatedPartitionMigration( { return std::make_unique( std::move(config), + std::move(diagnosticsConfig), std::move(profileLog), std::move(digestGenerator), initialMigrationIndex, diff --git a/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_migration.h b/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_migration.h index 9e89b21ca02..b86ddfa9627 100644 --- a/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_migration.h +++ b/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_migration.h @@ -16,6 +16,7 @@ namespace NCloud::NBlockStore::NStorage { NActors::IActorPtr CreateNonreplicatedPartitionMigration( TStorageConfigPtr config, + TDiagnosticsConfigPtr diagnosticsConfig, IProfileLogPtr profileLog, IBlockDigestGeneratorPtr digestGenerator, ui64 initialMigrationIndex, diff --git a/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_migration_actor.cpp b/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_migration_actor.cpp index 0a036ff9769..6af6879563a 100644 --- a/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_migration_actor.cpp +++ b/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_migration_actor.cpp @@ -17,6 +17,7 @@ constexpr TDuration PrepareMigrationInterval = TDuration::Seconds(5); TNonreplicatedPartitionMigrationActor::TNonreplicatedPartitionMigrationActor( TStorageConfigPtr config, + TDiagnosticsConfigPtr diagnosticsConfig, IProfileLogPtr profileLog, IBlockDigestGeneratorPtr digestGenerator, ui64 initialMigrationIndex, @@ -28,6 +29,7 @@ TNonreplicatedPartitionMigrationActor::TNonreplicatedPartitionMigrationActor( : TNonreplicatedPartitionMigrationCommonActor( static_cast(this), config, + std::move(diagnosticsConfig), srcConfig->GetName(), srcConfig->GetBlockCount(), srcConfig->GetBlockSize(), @@ -37,7 +39,6 @@ TNonreplicatedPartitionMigrationActor::TNonreplicatedPartitionMigrationActor( std::move(rwClientId), statActorId, config->GetMaxMigrationIoDepth()) - , Config(std::move(config)) , SrcConfig(std::move(srcConfig)) , Migrations(std::move(migrations)) , RdmaClient(std::move(rdmaClient)) @@ -51,8 +52,8 @@ void TNonreplicatedPartitionMigrationActor::OnBootstrap( CreateSrcActor(ctx), CreateDstActor(ctx), std::make_unique( - Config->GetMaxMigrationBandwidth(), - Config->GetExpectedDiskAgentSize(), + GetConfig()->GetMaxMigrationBandwidth(), + GetConfig()->GetExpectedDiskAgentSize(), SrcConfig)); PrepareForMigration(ctx); @@ -161,7 +162,12 @@ NActors::TActorId TNonreplicatedPartitionMigrationActor::CreateSrcActor( { return NCloud::Register( ctx, - CreateNonreplicatedPartition(Config, SrcConfig, SelfId(), RdmaClient)); + CreateNonreplicatedPartition( + GetConfig(), + GetDiagnosticsConfig(), + SrcConfig, + SelfId(), + RdmaClient)); } NActors::TActorId TNonreplicatedPartitionMigrationActor::CreateDstActor( @@ -169,7 +175,7 @@ NActors::TActorId TNonreplicatedPartitionMigrationActor::CreateDstActor( { Y_ABORT_UNLESS(!Migrations.empty()); - if (Config->GetNonReplicatedVolumeMigrationDisabled()) { + if (GetConfig()->GetNonReplicatedVolumeMigrationDisabled()) { LOG_WARN( ctx, TBlockStoreComponents::PARTITION, @@ -219,7 +225,8 @@ NActors::TActorId TNonreplicatedPartitionMigrationActor::CreateDstActor( return NCloud::Register( ctx, CreateNonreplicatedPartition( - Config, + GetConfig(), + GetDiagnosticsConfig(), SrcConfig->Fork(std::move(devices)), SelfId(), RdmaClient)); diff --git a/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_migration_actor.h b/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_migration_actor.h index 847937aae4e..ad3e946af95 100644 --- a/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_migration_actor.h +++ b/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_migration_actor.h @@ -13,7 +13,6 @@ class TNonreplicatedPartitionMigrationActor final , public IMigrationOwner { private: - const TStorageConfigPtr Config; TNonreplicatedPartitionConfigPtr SrcConfig; google::protobuf::RepeatedPtrField Migrations; NRdma::IClientPtr RdmaClient; @@ -24,6 +23,7 @@ class TNonreplicatedPartitionMigrationActor final public: TNonreplicatedPartitionMigrationActor( TStorageConfigPtr config, + TDiagnosticsConfigPtr diagnosticsConfig, IProfileLogPtr profileLog, IBlockDigestGeneratorPtr digestGenerator, ui64 initialMigrationIndex, diff --git a/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_migration_common_actor.cpp b/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_migration_common_actor.cpp index d04b33bbb86..eaad9b8b87c 100644 --- a/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_migration_common_actor.cpp +++ b/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_migration_common_actor.cpp @@ -20,6 +20,7 @@ TNonreplicatedPartitionMigrationCommonActor:: TNonreplicatedPartitionMigrationCommonActor( IMigrationOwner* migrationOwner, TStorageConfigPtr config, + TDiagnosticsConfigPtr diagnosticsConfig, TString diskId, ui64 blockCount, ui64 blockSize, @@ -31,6 +32,7 @@ TNonreplicatedPartitionMigrationCommonActor:: ui32 maxIoDepth) : MigrationOwner(migrationOwner) , Config(std::move(config)) + , DiagnosticsConfig(std::move(diagnosticsConfig)) , ProfileLog(std::move(profileLog)) , DiskId(std::move(diskId)) , BlockSize(blockSize) diff --git a/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_migration_common_actor.h b/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_migration_common_actor.h index 38a1f1ba633..0580a670f2b 100644 --- a/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_migration_common_actor.h +++ b/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_migration_common_actor.h @@ -4,6 +4,7 @@ #include "config.h" +#include #include #include #include @@ -86,6 +87,7 @@ class TNonreplicatedPartitionMigrationCommonActor IMigrationOwner* const MigrationOwner = nullptr; const TStorageConfigPtr Config; + const TDiagnosticsConfigPtr DiagnosticsConfig; const IProfileLogPtr ProfileLog; const TString DiskId; const ui64 BlockSize; @@ -128,8 +130,9 @@ class TNonreplicatedPartitionMigrationCommonActor bool UpdateCountersScheduled = false; TPartitionDiskCountersPtr SrcCounters; TPartitionDiskCountersPtr DstCounters; - TPartitionDiskCountersPtr MigrationCounters = - CreatePartitionDiskCounters(EPublishingPolicy::DiskRegistryBased); + TPartitionDiskCountersPtr MigrationCounters = CreatePartitionDiskCounters( + EPublishingPolicy::DiskRegistryBased, + DiagnosticsConfig->GetHistogramCounterOptions()); // Usage statistics ui64 NetworkBytes = 0; @@ -152,6 +155,7 @@ class TNonreplicatedPartitionMigrationCommonActor TNonreplicatedPartitionMigrationCommonActor( IMigrationOwner* migrationOwner, TStorageConfigPtr config, + TDiagnosticsConfigPtr diagnosticsConfig, TString diskId, ui64 blockCount, ui64 blockSize, @@ -192,6 +196,8 @@ class TNonreplicatedPartitionMigrationCommonActor protected: [[nodiscard]] TString GetChangedBlocks(TBlockRange64 range) const; + const TStorageConfigPtr& GetConfig() const; + const TDiagnosticsConfigPtr& GetDiagnosticsConfig() const; private: bool IsMigrationAllowed() const; diff --git a/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_migration_common_actor_migration.cpp b/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_migration_common_actor_migration.cpp index b822237561f..0ed8b62cd4e 100644 --- a/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_migration_common_actor_migration.cpp +++ b/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_migration_common_actor_migration.cpp @@ -368,6 +368,18 @@ TString TNonreplicatedPartitionMigrationCommonActor::GetChangedBlocks( return ChangedRangesMap.GetChangedBlocks(range); } +const TStorageConfigPtr& +TNonreplicatedPartitionMigrationCommonActor::GetConfig() const +{ + return Config; +} + +const TDiagnosticsConfigPtr& +TNonreplicatedPartitionMigrationCommonActor::GetDiagnosticsConfig() const +{ + return DiagnosticsConfig; +} + TDuration TNonreplicatedPartitionMigrationCommonActor::CalculateMigrationTimeout( TBlockRange64 range) const diff --git a/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_migration_common_actor_stats.cpp b/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_migration_common_actor_stats.cpp index fa8db90c144..6896381b14a 100644 --- a/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_migration_common_actor_stats.cpp +++ b/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_migration_common_actor_stats.cpp @@ -35,8 +35,9 @@ void TNonreplicatedPartitionMigrationCommonActor::HandlePartCounters( void TNonreplicatedPartitionMigrationCommonActor::SendStats( const TActorContext& ctx) { - auto stats = - CreatePartitionDiskCounters(EPublishingPolicy::DiskRegistryBased); + auto stats = CreatePartitionDiskCounters( + EPublishingPolicy::DiskRegistryBased, + DiagnosticsConfig->GetHistogramCounterOptions()); if (SrcCounters) { stats->AggregateWith(*SrcCounters); @@ -58,8 +59,9 @@ void TNonreplicatedPartitionMigrationCommonActor::SendStats( } stats->AggregateWith(*MigrationCounters); - MigrationCounters = - CreatePartitionDiskCounters(EPublishingPolicy::DiskRegistryBased); + MigrationCounters = CreatePartitionDiskCounters( + EPublishingPolicy::DiskRegistryBased, + DiagnosticsConfig->GetHistogramCounterOptions()); auto request = std::make_unique( diff --git a/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_migration_ut.cpp b/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_migration_ut.cpp index 6a1d109c8d8..ea9a7f9d7cc 100644 --- a/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_migration_ut.cpp +++ b/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_migration_ut.cpp @@ -9,6 +9,7 @@ #include #include #include +#include #include #include @@ -211,6 +212,7 @@ struct TTestEnv auto part = std::make_unique( std::move(config), + CreateDiagnosticsConfig(), CreateProfileLogStub(), CreateBlockDigestGeneratorStub(), 0, diff --git a/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_rdma.cpp b/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_rdma.cpp index d2746c033ab..ac00a1512af 100644 --- a/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_rdma.cpp +++ b/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_rdma.cpp @@ -10,12 +10,14 @@ using namespace NActors; IActorPtr CreateNonreplicatedPartitionRdma( TStorageConfigPtr config, + TDiagnosticsConfigPtr diagnosticsConfig, TNonreplicatedPartitionConfigPtr partConfig, NRdma::IClientPtr rdmaClient, TActorId statActorId) { return std::make_unique( std::move(config), + std::move(diagnosticsConfig), std::move(partConfig), std::move(rdmaClient), statActorId); diff --git a/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_rdma.h b/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_rdma.h index c99b65c8308..24480975d54 100644 --- a/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_rdma.h +++ b/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_rdma.h @@ -2,6 +2,7 @@ #include "public.h" +#include #include #include #include @@ -14,6 +15,7 @@ namespace NCloud::NBlockStore::NStorage { NActors::IActorPtr CreateNonreplicatedPartitionRdma( TStorageConfigPtr config, + TDiagnosticsConfigPtr diagnosticsConfig, TNonreplicatedPartitionConfigPtr partConfig, NRdma::IClientPtr rdmaClient, NActors::TActorId statActorId); diff --git a/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_rdma_actor.cpp b/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_rdma_actor.cpp index eaca90c2900..0bb61a15bb2 100644 --- a/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_rdma_actor.cpp +++ b/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_rdma_actor.cpp @@ -24,15 +24,18 @@ LWTRACE_USING(BLOCKSTORE_STORAGE_PROVIDER); TNonreplicatedPartitionRdmaActor::TNonreplicatedPartitionRdmaActor( TStorageConfigPtr config, + TDiagnosticsConfigPtr diagnosticsConfig, TNonreplicatedPartitionConfigPtr partConfig, NRdma::IClientPtr rdmaClient, TActorId statActorId) : Config(std::move(config)) + , DiagnosticsConfig(std::move(diagnosticsConfig)) , PartConfig(std::move(partConfig)) , RdmaClient(std::move(rdmaClient)) , StatActorId(statActorId) - , PartCounters( - CreatePartitionDiskCounters(EPublishingPolicy::DiskRegistryBased)) + , PartCounters(CreatePartitionDiskCounters( + EPublishingPolicy::DiskRegistryBased, + DiagnosticsConfig->GetHistogramCounterOptions())) {} TNonreplicatedPartitionRdmaActor::~TNonreplicatedPartitionRdmaActor() diff --git a/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_rdma_actor.h b/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_rdma_actor.h index a6cb516ccb3..1731dd19930 100644 --- a/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_rdma_actor.h +++ b/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_rdma_actor.h @@ -5,6 +5,7 @@ #include "config.h" #include "part_nonrepl_events_private.h" +#include #include #include #include @@ -39,6 +40,7 @@ class TNonreplicatedPartitionRdmaActor final { private: const TStorageConfigPtr Config; + const TDiagnosticsConfigPtr DiagnosticsConfig; const TNonreplicatedPartitionConfigPtr PartConfig; const NRdma::IClientPtr RdmaClient; const NActors::TActorId StatActorId; @@ -73,6 +75,7 @@ class TNonreplicatedPartitionRdmaActor final public: TNonreplicatedPartitionRdmaActor( TStorageConfigPtr config, + TDiagnosticsConfigPtr diagnosticsConfig, TNonreplicatedPartitionConfigPtr partConfig, NRdma::IClientPtr rdmaClient, NActors::TActorId statActorId); diff --git a/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_rdma_actor_stats.cpp b/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_rdma_actor_stats.cpp index f06d72a9d72..610348d0838 100644 --- a/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_rdma_actor_stats.cpp +++ b/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_rdma_actor_stats.cpp @@ -40,8 +40,9 @@ void TNonreplicatedPartitionRdmaActor::SendStats(const TActorContext& ctx) NetworkBytes = 0; CpuUsage = {}; - PartCounters = - CreatePartitionDiskCounters(EPublishingPolicy::DiskRegistryBased); + PartCounters = CreatePartitionDiskCounters( + EPublishingPolicy::DiskRegistryBased, + DiagnosticsConfig->GetHistogramCounterOptions()); NCloud::Send(ctx, StatActorId, std::move(request)); } diff --git a/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_rdma_ut.cpp b/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_rdma_ut.cpp index 5d37661830c..12b1d3a8d9f 100644 --- a/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_rdma_ut.cpp +++ b/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_rdma_ut.cpp @@ -10,6 +10,7 @@ #include #include #include +#include #include #include @@ -138,6 +139,7 @@ struct TTestEnv auto part = std::make_unique( std::move(config), + CreateDiagnosticsConfig(), std::move(partConfig), RdmaClient, VolumeActorId diff --git a/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_ut.cpp b/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_ut.cpp index c4480cc86fe..fe7af8eadba 100644 --- a/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_ut.cpp +++ b/cloud/blockstore/libs/storage/partition_nonrepl/part_nonrepl_ut.cpp @@ -10,6 +10,7 @@ #include #include #include +#include #include #include @@ -139,6 +140,7 @@ struct TTestEnv auto part = std::make_unique( std::move(config), + CreateDiagnosticsConfig(), std::move(partConfig), VolumeActorId ); diff --git a/cloud/blockstore/libs/storage/partition_nonrepl/resync_range_ut.cpp b/cloud/blockstore/libs/storage/partition_nonrepl/resync_range_ut.cpp index dd7e415b76e..9b144ccfd21 100644 --- a/cloud/blockstore/libs/storage/partition_nonrepl/resync_range_ut.cpp +++ b/cloud/blockstore/libs/storage/partition_nonrepl/resync_range_ut.cpp @@ -12,6 +12,7 @@ #include #include #include +#include #include #include @@ -143,6 +144,7 @@ struct TTestEnv auto part = std::make_unique( config, + CreateDiagnosticsConfig(), std::move(partConfig), VolumeActorId ); diff --git a/cloud/blockstore/libs/storage/partition_nonrepl/ut_env.h b/cloud/blockstore/libs/storage/partition_nonrepl/ut_env.h index fde71b6c403..1994bf4e812 100644 --- a/cloud/blockstore/libs/storage/partition_nonrepl/ut_env.h +++ b/cloud/blockstore/libs/storage/partition_nonrepl/ut_env.h @@ -31,7 +31,9 @@ const ui64 DefaultDeviceBlockSize = 512; struct TStorageStatsServiceState : TAtomicRefCount { - TPartitionDiskCounters Counters{EPublishingPolicy::DiskRegistryBased}; + TPartitionDiskCounters Counters{ + EPublishingPolicy::DiskRegistryBased, + EHistogramCounterOption::ReportMultipleCounters}; }; using TStorageStatsServiceStatePtr = TIntrusivePtr; diff --git a/cloud/blockstore/libs/storage/stats_service/stats_service_actor.cpp b/cloud/blockstore/libs/storage/stats_service/stats_service_actor.cpp index c44b4329217..7e04c57452f 100644 --- a/cloud/blockstore/libs/storage/stats_service/stats_service_actor.cpp +++ b/cloud/blockstore/libs/storage/stats_service/stats_service_actor.cpp @@ -26,7 +26,7 @@ TStatsServiceActor::TStatsServiceActor( , DiagnosticsConfig(std::move(diagnosticsConfig)) , StatsUploader(std::move(uploader)) , ClientStatsAggregator(std::move(clientStatsAggregator)) - , State(*Config) + , State(*Config, *DiagnosticsConfig) , UserCounters(CreateUserCounterSupplier()) {} diff --git a/cloud/blockstore/libs/storage/stats_service/stats_service_actor_solomon.cpp b/cloud/blockstore/libs/storage/stats_service/stats_service_actor_solomon.cpp index c3e236075cd..57d4d83d0c7 100644 --- a/cloud/blockstore/libs/storage/stats_service/stats_service_actor_solomon.cpp +++ b/cloud/blockstore/libs/storage/stats_service/stats_service_actor_solomon.cpp @@ -223,10 +223,13 @@ void TStatsServiceActor::HandleRegisterVolume( auto volume = State.GetOrAddVolume(msg->DiskId, msg->Config); if (volume->IsDiskRegistryBased()) { - volume->PerfCounters = - TDiskPerfData(EPublishingPolicy::DiskRegistryBased); + volume->PerfCounters = TDiskPerfData( + EPublishingPolicy::DiskRegistryBased, + DiagnosticsConfig->GetHistogramCounterOptions()); } else { - volume->PerfCounters = TDiskPerfData(EPublishingPolicy::Repl); + volume->PerfCounters = TDiskPerfData( + EPublishingPolicy::Repl, + DiagnosticsConfig->GetHistogramCounterOptions()); } } diff --git a/cloud/blockstore/libs/storage/stats_service/stats_service_state.cpp b/cloud/blockstore/libs/storage/stats_service/stats_service_state.cpp index 6d5f5b8d5cb..ea62aa167f7 100644 --- a/cloud/blockstore/libs/storage/stats_service/stats_service_state.cpp +++ b/cloud/blockstore/libs/storage/stats_service/stats_service_state.cpp @@ -206,7 +206,7 @@ TVolumeStatsInfo* TStatsServiceState::GetOrAddVolume( it = VolumesById.emplace_direct( ctx, diskId, - TVolumeStatsInfo(std::move(config))); + TVolumeStatsInfo(std::move(config), HistCounterOptions)); auto rit = RecentVolumesById.find(diskId); if (rit != RecentVolumesById.end()) { diff --git a/cloud/blockstore/libs/storage/stats_service/stats_service_state.h b/cloud/blockstore/libs/storage/stats_service/stats_service_state.h index b2b5ae3f9d7..7cf83666506 100644 --- a/cloud/blockstore/libs/storage/stats_service/stats_service_state.h +++ b/cloud/blockstore/libs/storage/stats_service/stats_service_state.h @@ -1,5 +1,6 @@ #pragma once +#include #include #include #include @@ -36,11 +37,13 @@ struct TDiskPerfData ui64 VolumeSystemCpu = 0; ui64 VolumeUserCpu = 0; - TDiskPerfData(EPublishingPolicy policy) - : DiskCounters(policy) - , VolumeSelfCounters(policy) - , YdbDiskCounters(policy) - , YdbVolumeSelfCounters(policy) + TDiskPerfData( + EPublishingPolicy policy, + EHistogramCounterOptions histCounterOptions) + : DiskCounters(policy, histCounterOptions) + , VolumeSelfCounters(policy, histCounterOptions) + , YdbDiskCounters(policy, histCounterOptions) + , YdbVolumeSelfCounters(policy, histCounterOptions) {} }; @@ -61,10 +64,12 @@ struct TTotalCounters TSimpleCounter VolumeStartTime1To5Sec; TSimpleCounter VolumeStartTimeOver5Sec; - TTotalCounters(EPublishingPolicy policy) - : PartAcc(policy) - , VolumeAcc(policy) - {}; + TTotalCounters( + EPublishingPolicy policy, + EHistogramCounterOptions histCounterOptions) + : PartAcc(policy, histCounterOptions) + , VolumeAcc(policy, histCounterOptions) + {} void Register(NMonitoring::TDynamicCountersPtr counters); void Reset(); @@ -128,9 +133,11 @@ struct TVolumeStatsInfo TInstant ApproximateStartTs; TDuration ApproximateBootstrapTime; - TVolumeStatsInfo(NProto::TVolume config) + TVolumeStatsInfo( + NProto::TVolume config, + EHistogramCounterOptions histCounterOptions) : VolumeInfo(std::move(config)) - , PerfCounters(EPublishingPolicy::All) + , PerfCounters(EPublishingPolicy::All, histCounterOptions) {} bool IsDiskRegistryBased() const @@ -181,6 +188,7 @@ class TStatsServiceState TBlobLoadCounters HddBlobLoadCounters; bool StatsUploadingCompleted = true; + EHistogramCounterOptions HistCounterOptions; public: void RemoveVolume(TInstant now, const TString& diskId); @@ -189,18 +197,36 @@ class TStatsServiceState const TString& diskId, NProto::TVolume config); - TStatsServiceState(const TStorageConfig& config) - : Total(EPublishingPolicy::All) - , Hdd(EPublishingPolicy::Repl) - , Ssd(EPublishingPolicy::Repl) - , SsdNonrepl(EPublishingPolicy::DiskRegistryBased) - , HddNonrepl(EPublishingPolicy::DiskRegistryBased) - , SsdMirror2(EPublishingPolicy::DiskRegistryBased) - , SsdMirror3(EPublishingPolicy::DiskRegistryBased) - , SsdLocal(EPublishingPolicy::DiskRegistryBased) - , HddLocal(EPublishingPolicy::DiskRegistryBased) - , SsdSystem(EPublishingPolicy::Repl) - , HddSystem(EPublishingPolicy::Repl) + TStatsServiceState( + const TStorageConfig& config, + const TDiagnosticsConfig& diagConfig) + : Total(EPublishingPolicy::All, diagConfig.GetHistogramCounterOptions()) + , Hdd(EPublishingPolicy::Repl, diagConfig.GetHistogramCounterOptions()) + , Ssd(EPublishingPolicy::Repl, diagConfig.GetHistogramCounterOptions()) + , SsdNonrepl( + EPublishingPolicy::DiskRegistryBased, + diagConfig.GetHistogramCounterOptions()) + , HddNonrepl( + EPublishingPolicy::DiskRegistryBased, + diagConfig.GetHistogramCounterOptions()) + , SsdMirror2( + EPublishingPolicy::DiskRegistryBased, + diagConfig.GetHistogramCounterOptions()) + , SsdMirror3( + EPublishingPolicy::DiskRegistryBased, + diagConfig.GetHistogramCounterOptions()) + , SsdLocal( + EPublishingPolicy::DiskRegistryBased, + diagConfig.GetHistogramCounterOptions()) + , HddLocal( + EPublishingPolicy::DiskRegistryBased, + diagConfig.GetHistogramCounterOptions()) + , SsdSystem( + EPublishingPolicy::Repl, + diagConfig.GetHistogramCounterOptions()) + , HddSystem( + EPublishingPolicy::Repl, + diagConfig.GetHistogramCounterOptions()) , SsdBlobLoadCounters( config.GetCommonSSDPoolKind(), config.GetMaxSSDGroupReadIops(), @@ -213,7 +239,8 @@ class TStatsServiceState config.GetMaxHDDGroupWriteIops(), config.GetMaxHDDGroupReadBandwidth(), config.GetMaxHDDGroupWriteBandwidth()) - {}; + , HistCounterOptions(diagConfig.GetHistogramCounterOptions()) + {} const TVolumesMap& GetVolumes() const { diff --git a/cloud/blockstore/libs/storage/stats_service/stats_service_ut.cpp b/cloud/blockstore/libs/storage/stats_service/stats_service_ut.cpp index 9f647670130..134e17840c7 100644 --- a/cloud/blockstore/libs/storage/stats_service/stats_service_ut.cpp +++ b/cloud/blockstore/libs/storage/stats_service/stats_service_ut.cpp @@ -207,8 +207,12 @@ TVector BroadcastVolumeCounters( TDispatchOptions options; for (ui32 i = 0; i < nodes.size(); ++i) { - auto counters = CreatePartitionDiskCounters(EPublishingPolicy::Repl); - auto volume = CreateVolumeSelfCounters(EPublishingPolicy::Repl); + auto counters = CreatePartitionDiskCounters( + EPublishingPolicy::Repl, + EHistogramCounterOption::ReportMultipleCounters); + auto volume = CreateVolumeSelfCounters( + EPublishingPolicy::Repl, + EHistogramCounterOption::ReportMultipleCounters); counters->Simple.MixedBytesCount.Set(1); SendDiskStats( @@ -253,8 +257,12 @@ void ForceYdbStatsUpdate( TDispatchOptions options; for (ui32 i = 0; i < volumes.size(); ++i) { - auto counters = CreatePartitionDiskCounters(EPublishingPolicy::Repl); - auto volume = CreateVolumeSelfCounters(EPublishingPolicy::Repl); + auto counters = CreatePartitionDiskCounters( + EPublishingPolicy::Repl, + EHistogramCounterOption::ReportMultipleCounters); + auto volume = CreateVolumeSelfCounters( + EPublishingPolicy::Repl, + EHistogramCounterOption::ReportMultipleCounters); counters->Simple.MixedBytesCount.Set(1); SendDiskStats( @@ -480,8 +488,12 @@ Y_UNIT_TEST_SUITE(TServiceVolumeStatsTest) UnregisterVolume(runtime, DefaultDiskId); - auto counters = CreatePartitionDiskCounters(EPublishingPolicy::Repl); - auto volume = CreateVolumeSelfCounters(EPublishingPolicy::Repl); + auto counters = CreatePartitionDiskCounters( + EPublishingPolicy::Repl, + EHistogramCounterOption::ReportMultipleCounters); + auto volume = CreateVolumeSelfCounters( + EPublishingPolicy::Repl, + EHistogramCounterOption::ReportMultipleCounters); counters->Simple.MixedBytesCount.Set(1); SendDiskStats( @@ -529,23 +541,31 @@ Y_UNIT_TEST_SUITE(TServiceVolumeStatsTest) RegisterVolume(runtime, "vol0"); RegisterVolume(runtime, "vol1"); - auto counters1 = CreatePartitionDiskCounters(EPublishingPolicy::Repl); + auto counters1 = CreatePartitionDiskCounters( + EPublishingPolicy::Repl, + EHistogramCounterOption::ReportMultipleCounters); counters1->Simple.CompactionScore.Set(1); SendDiskStats( runtime, "vol0", std::move(counters1), - CreateVolumeSelfCounters(EPublishingPolicy::Repl), + CreateVolumeSelfCounters( + EPublishingPolicy::Repl, + EHistogramCounterOption::ReportMultipleCounters), EVolumeTestOptions::VOLUME_HASCLIENTS, 0); - auto counters2 = CreatePartitionDiskCounters(EPublishingPolicy::Repl); + auto counters2 = CreatePartitionDiskCounters( + EPublishingPolicy::Repl, + EHistogramCounterOption::ReportMultipleCounters); counters2->Simple.CompactionScore.Set(3); SendDiskStats( runtime, "vol1", std::move(counters2), - CreateVolumeSelfCounters(EPublishingPolicy::Repl), + CreateVolumeSelfCounters( + EPublishingPolicy::Repl, + EHistogramCounterOption::ReportMultipleCounters), EVolumeTestOptions::VOLUME_HASCLIENTS, 0); @@ -582,13 +602,17 @@ Y_UNIT_TEST_SUITE(TServiceVolumeStatsTest) RegisterVolume(runtime, DefaultDiskId, mediaKind, isSystem); - auto counters = CreatePartitionDiskCounters(policy); + auto counters = CreatePartitionDiskCounters( + policy, + EHistogramCounterOption::ReportMultipleCounters); counters->Simple.BytesCount.Set(100500); SendDiskStats( runtime, DefaultDiskId, std::move(counters), - CreateVolumeSelfCounters(policy), + CreateVolumeSelfCounters( + policy, + EHistogramCounterOption::ReportMultipleCounters), EVolumeTestOptions::VOLUME_HASCLIENTS, 0); auto updateMsg = std::make_unique(); @@ -779,8 +803,11 @@ Y_UNIT_TEST_SUITE(TServiceVolumeStatsTest) totalCounters->GetCounter("VolumeStartTimeOver5Sec")->Val()); \ // CHECK_STATS - auto makeVolumeCounters = [=] (ui64 lt, ui64 st) { - auto counters = CreateVolumeSelfCounters(EPublishingPolicy::Repl); + auto makeVolumeCounters = [=](ui64 lt, ui64 st) + { + auto counters = CreateVolumeSelfCounters( + EPublishingPolicy::Repl, + EHistogramCounterOption::ReportMultipleCounters); counters->Simple.LastVolumeLoadTime.Set(lt); counters->Simple.LastVolumeStartTime.Set(st); return counters; @@ -799,11 +826,14 @@ Y_UNIT_TEST_SUITE(TServiceVolumeStatsTest) {"disk-3", 5'500'000, 3'000'000}, }; - auto sendDiskStats = [&] (const TDiskInfo& diskInfo) { + auto sendDiskStats = [&](const TDiskInfo& diskInfo) + { SendDiskStats( runtime, diskInfo.DiskId, - CreatePartitionDiskCounters(EPublishingPolicy::Repl), + CreatePartitionDiskCounters( + EPublishingPolicy::Repl, + EHistogramCounterOption::ReportMultipleCounters), makeVolumeCounters(diskInfo.LoadTime, diskInfo.StartTime), EVolumeTestOptions::VOLUME_HASCLIENTS, 0); @@ -1057,14 +1087,18 @@ Y_UNIT_TEST_SUITE(TServiceVolumeStatsTest) RegisterVolume(runtime, "vol0", mediaKind, true); - auto counters = CreatePartitionDiskCounters(publishingPolicy); + auto counters = CreatePartitionDiskCounters( + publishingPolicy, + EHistogramCounterOption::ReportMultipleCounters); counters->RequestCounters.ReadBlocks.Count = 42; counters->RequestCounters.ReadBlocks.RequestBytes = 100500; SendDiskStats( runtime, "vol0", std::move(counters), - CreateVolumeSelfCounters(publishingPolicy), + CreateVolumeSelfCounters( + publishingPolicy, + EHistogramCounterOption::ReportMultipleCounters), EVolumeTestOptions::VOLUME_HASCLIENTS, 0); auto updateMsg = std::make_unique(); diff --git a/cloud/blockstore/libs/storage/testlib/counters_printer.cpp b/cloud/blockstore/libs/storage/testlib/counters_printer.cpp new file mode 100644 index 00000000000..5a43ec43318 --- /dev/null +++ b/cloud/blockstore/libs/storage/testlib/counters_printer.cpp @@ -0,0 +1,65 @@ +#include "counters_printer.h" + +namespace NCloud::NBlockStore::NStorage { + +//////////////////////////////////////////////////////////////////////////////// + +namespace { + +IOutputStream& Indent(IOutputStream* out, int level) +{ + for (int i = 0; i < level; i++) { + out->Write(" "); + } + return *out; +} + +} // namespace + +//////////////////////////////////////////////////////////////////////////////// + +TCountersPrinter::TCountersPrinter(IOutputStream* out) + : Out(out) +{} + +void TCountersPrinter::OnCounter( + const TString& labelName, + const TString& labelValue, + const NMonitoring::TCounterForPtr* counter) +{ + Indent(Out, Level) << labelName << ':' << labelValue << " = " + << counter->Val() << '\n'; +} + +void TCountersPrinter::OnHistogram( + const TString& labelName, + const TString& labelValue, + NMonitoring::IHistogramSnapshotPtr snapshot, + bool derivative) +{ + Y_UNUSED(derivative); + Indent(Out, Level) << labelName << ':' << labelValue << " = " << *snapshot + << '\n'; +} + +void TCountersPrinter::OnGroupBegin( + const TString& labelName, + const TString& labelValue, + const NMonitoring::TDynamicCounters* snapshot) +{ + Y_UNUSED(snapshot); + Indent(Out, Level++) << labelName << ':' << labelValue << " {\n"; +} + +void TCountersPrinter::OnGroupEnd( + const TString& labelName, + const TString& labelValue, + const NMonitoring::TDynamicCounters* snapshot) +{ + Y_UNUSED(labelName); + Y_UNUSED(labelValue); + Y_UNUSED(snapshot); + Indent(Out, --Level) << "}\n"; +} + +} // namespace NCloud::NBlockStore::NStorage diff --git a/cloud/blockstore/libs/storage/testlib/counters_printer.h b/cloud/blockstore/libs/storage/testlib/counters_printer.h new file mode 100644 index 00000000000..f8f140bdf3a --- /dev/null +++ b/cloud/blockstore/libs/storage/testlib/counters_printer.h @@ -0,0 +1,40 @@ +#pragma once + +#include +#include +#include + +namespace NCloud::NBlockStore::NStorage { + +class TCountersPrinter: public NMonitoring::ICountableConsumer +{ +private: + IOutputStream* Out; + int Level = 0; + +public: + explicit TCountersPrinter(IOutputStream* out); + + void OnCounter( + const TString& labelName, + const TString& labelValue, + const NMonitoring::TCounterForPtr* counter) override; + + void OnHistogram( + const TString& labelName, + const TString& labelValue, + NMonitoring::IHistogramSnapshotPtr snapshot, + bool derivative) override; + + void OnGroupBegin( + const TString& labelName, + const TString& labelValue, + const NMonitoring::TDynamicCounters* snapshot) override; + + void OnGroupEnd( + const TString& labelName, + const TString& labelValue, + const NMonitoring::TDynamicCounters* snapshot) override; +}; + +} // namespace NCloud::NBlockStore::NStorage diff --git a/cloud/blockstore/libs/storage/testlib/diagnostics.cpp b/cloud/blockstore/libs/storage/testlib/diagnostics.cpp new file mode 100644 index 00000000000..1183a259de1 --- /dev/null +++ b/cloud/blockstore/libs/storage/testlib/diagnostics.cpp @@ -0,0 +1,14 @@ + +#include "diagnostics.h" + +namespace NCloud::NBlockStore { + +TDiagnosticsConfigPtr CreateDiagnosticsConfig() +{ + NProto::TDiagnosticsConfig diagnosticsConfig; + diagnosticsConfig.SetReportHistogramAsMultipleCounters(true); + diagnosticsConfig.SetReportHistogramAsSingleCounter(false); + return std::make_shared(diagnosticsConfig); +} + +} // namespace NCloud::NBlockStore diff --git a/cloud/blockstore/libs/storage/testlib/diagnostics.h b/cloud/blockstore/libs/storage/testlib/diagnostics.h new file mode 100644 index 00000000000..91b6024c4b8 --- /dev/null +++ b/cloud/blockstore/libs/storage/testlib/diagnostics.h @@ -0,0 +1,10 @@ + +#pragma once + +#include + +namespace NCloud::NBlockStore { + +TDiagnosticsConfigPtr CreateDiagnosticsConfig(); + +} // namespace NCloud::NBlockStore diff --git a/cloud/blockstore/libs/storage/testlib/ya.make b/cloud/blockstore/libs/storage/testlib/ya.make index cb6b2a6bc2c..aa145fcdb8c 100644 --- a/cloud/blockstore/libs/storage/testlib/ya.make +++ b/cloud/blockstore/libs/storage/testlib/ya.make @@ -1,6 +1,8 @@ LIBRARY(blockstore-libs-storage-testlib) SRCS( + counters_printer.cpp + diagnostics.cpp disk_agent_mock.cpp disk_registry_proxy_mock.cpp service_client.cpp diff --git a/cloud/blockstore/libs/storage/volume/actors/shadow_disk_actor.cpp b/cloud/blockstore/libs/storage/volume/actors/shadow_disk_actor.cpp index 78f28ef9dfa..c546e44e47f 100644 --- a/cloud/blockstore/libs/storage/volume/actors/shadow_disk_actor.cpp +++ b/cloud/blockstore/libs/storage/volume/actors/shadow_disk_actor.cpp @@ -526,6 +526,7 @@ void TAcquireShadowDiskActor::MaybeReady(const NActors::TActorContext& ctx) TShadowDiskActor::TShadowDiskActor( TStorageConfigPtr config, + TDiagnosticsConfigPtr diagnosticConfig, NRdma::IClientPtr rdmaClient, IProfileLogPtr profileLog, IBlockDigestGeneratorPtr digestGenerator, @@ -539,6 +540,7 @@ TShadowDiskActor::TShadowDiskActor( : TNonreplicatedPartitionMigrationCommonActor( static_cast(this), config, + std::move(diagnosticConfig), srcConfig->GetName(), srcConfig->GetBlockCount(), srcConfig->GetBlockSize(), @@ -550,7 +552,6 @@ TShadowDiskActor::TShadowDiskActor( checkpointInfo.ShadowDiskState == EShadowDiskState::Ready), volumeActorId, config->GetMaxShadowDiskFillIoDepth()) - , Config(std::move(config)) , RdmaClient(std::move(rdmaClient)) , SrcConfig(std::move(srcConfig)) , CheckpointId(checkpointInfo.CheckpointId) @@ -744,7 +745,7 @@ void TShadowDiskActor::AcquireShadowDisk( AcquireActorId = NCloud::Register( ctx, std::make_unique( - Config, + GetConfig(), ShadowDiskId, ShadowDiskDevices, acquireReason, @@ -825,7 +826,8 @@ void TShadowDiskActor::CreateShadowDiskPartitionActor( DstActorId = NCloud::Register( ctx, CreateNonreplicatedPartition( - Config, + GetConfig(), + GetDiagnosticsConfig(), DstConfig, VolumeActorId, // send stat to volume directly. RdmaClient)); @@ -846,8 +848,8 @@ void TShadowDiskActor::CreateShadowDiskPartitionActor( SrcActorId, DstActorId, std::make_unique( - Config->GetMaxShadowDiskFillBandwidth(), - Config->GetExpectedDiskAgentSize(), + GetConfig()->GetMaxShadowDiskFillBandwidth(), + GetConfig()->GetExpectedDiskAgentSize(), DstConfig)); StartWork(ctx); @@ -868,7 +870,7 @@ void TShadowDiskActor::CreateShadowDiskPartitionActor( void TShadowDiskActor::SchedulePeriodicalReAcquire(const TActorContext& ctx) { ctx.Schedule( - Config->GetClientRemountPeriod(), + GetConfig()->GetClientRemountPeriod(), new TEvents::TEvWakeup(EShadowDiskWakeupReason::SDWR_REACQUIRE)); } diff --git a/cloud/blockstore/libs/storage/volume/actors/shadow_disk_actor.h b/cloud/blockstore/libs/storage/volume/actors/shadow_disk_actor.h index 46d872e065d..5c19ed4fc5a 100644 --- a/cloud/blockstore/libs/storage/volume/actors/shadow_disk_actor.h +++ b/cloud/blockstore/libs/storage/volume/actors/shadow_disk_actor.h @@ -81,7 +81,6 @@ class TShadowDiskActor final Error, }; - const TStorageConfigPtr Config; const NRdma::IClientPtr RdmaClient; const TNonreplicatedPartitionConfigPtr SrcConfig; const TString CheckpointId; @@ -110,6 +109,7 @@ class TShadowDiskActor final public: TShadowDiskActor( TStorageConfigPtr config, + TDiagnosticsConfigPtr diagnosticConfig, NRdma::IClientPtr rdmaClient, IProfileLogPtr profileLog, IBlockDigestGeneratorPtr digestGenerator, diff --git a/cloud/blockstore/libs/storage/volume/volume_actor.cpp b/cloud/blockstore/libs/storage/volume/volume_actor.cpp index ac4c911e4fd..8f3323322e2 100644 --- a/cloud/blockstore/libs/storage/volume/volume_actor.cpp +++ b/cloud/blockstore/libs/storage/volume/volume_actor.cpp @@ -171,7 +171,9 @@ void TVolumeActor::RegisterCounters(const TActorContext& ctx) } if (!VolumeSelfCounters) { - VolumeSelfCounters = CreateVolumeSelfCounters(State->CountersPolicy()); + VolumeSelfCounters = CreateVolumeSelfCounters( + State->CountersPolicy(), + DiagnosticsConfig->GetHistogramCounterOptions()); } } diff --git a/cloud/blockstore/libs/storage/volume/volume_actor_loadstate.cpp b/cloud/blockstore/libs/storage/volume/volume_actor_loadstate.cpp index a965e084d50..5981768cd37 100644 --- a/cloud/blockstore/libs/storage/volume/volume_actor_loadstate.cpp +++ b/cloud/blockstore/libs/storage/volume/volume_actor_loadstate.cpp @@ -124,6 +124,7 @@ void TVolumeActor::CompleteLoadState( State = std::make_unique( Config, + DiagnosticsConfig, std::move(*args.Meta), std::move(args.MetaHistory), std::move(args.VolumeParams), diff --git a/cloud/blockstore/libs/storage/volume/volume_actor_startstop.cpp b/cloud/blockstore/libs/storage/volume/volume_actor_startstop.cpp index 207fe346279..002fe1e9033 100644 --- a/cloud/blockstore/libs/storage/volume/volume_actor_startstop.cpp +++ b/cloud/blockstore/libs/storage/volume/volume_actor_startstop.cpp @@ -194,6 +194,7 @@ void TVolumeActor::SetupDiskRegistryBasedPartitions(const TActorContext& ctx) ctx, CreateNonreplicatedPartition( Config, + DiagnosticsConfig, nonreplicatedConfig, SelfId(), GetRdmaClient())); @@ -203,6 +204,7 @@ void TVolumeActor::SetupDiskRegistryBasedPartitions(const TActorContext& ctx) ctx, CreateNonreplicatedPartitionMigration( Config, + DiagnosticsConfig, ProfileLog, BlockDigestGenerator, State->GetMeta().GetMigrationIndex(), @@ -226,6 +228,7 @@ void TVolumeActor::SetupDiskRegistryBasedPartitions(const TActorContext& ctx) ctx, CreateMirrorPartitionResync( Config, + DiagnosticsConfig, ProfileLog, BlockDigestGenerator, State->GetReadWriteAccessClientId(), @@ -241,6 +244,7 @@ void TVolumeActor::SetupDiskRegistryBasedPartitions(const TActorContext& ctx) ctx, CreateMirrorPartition( Config, + DiagnosticsConfig, ProfileLog, BlockDigestGenerator, State->GetReadWriteAccessClientId(), @@ -274,6 +278,7 @@ NActors::TActorId TVolumeActor::WrapNonreplActorIfNeeded( nonreplicatedActorId = NCloud::Register( ctx, Config, + DiagnosticsConfig, GetRdmaClient(), ProfileLog, BlockDigestGenerator, diff --git a/cloud/blockstore/libs/storage/volume/volume_actor_stats.cpp b/cloud/blockstore/libs/storage/volume/volume_actor_stats.cpp index 11c7823f768..158d51f5b35 100644 --- a/cloud/blockstore/libs/storage/volume/volume_actor_stats.cpp +++ b/cloud/blockstore/libs/storage/volume/volume_actor_stats.cpp @@ -145,8 +145,9 @@ void TVolumeActor::HandleDiskRegistryBasedPartCounters( } if (!statInfo->LastCounters) { - statInfo->LastCounters = - CreatePartitionDiskCounters(State->CountersPolicy()); + statInfo->LastCounters = CreatePartitionDiskCounters( + State->CountersPolicy(), + DiagnosticsConfig->GetHistogramCounterOptions()); } statInfo->LastCounters->Add(*msg->DiskCounters); @@ -193,8 +194,9 @@ void TVolumeActor::HandlePartCounters( } if (!statInfo->LastCounters) { - statInfo->LastCounters = - CreatePartitionDiskCounters(State->CountersPolicy()); + statInfo->LastCounters = CreatePartitionDiskCounters( + State->CountersPolicy(), + DiagnosticsConfig->GetHistogramCounterOptions()); statInfo->LastMetrics = std::move(msg->BlobLoadMetrics); } @@ -284,7 +286,9 @@ void TVolumeActor::DoSendPartStatsToService( const NActors::TActorContext& ctx, const TString& diskId) { - auto stats = CreatePartitionDiskCounters(State->CountersPolicy()); + auto stats = CreatePartitionDiskCounters( + State->CountersPolicy(), + DiagnosticsConfig->GetHistogramCounterOptions()); ui64 systemCpu = 0; ui64 userCpu = 0; // XXX - we need to "manually" calculate total channel history @@ -415,7 +419,9 @@ void TVolumeActor::SendSelfStatsToService(const TActorContext& ctx) State->GetMeta().GetMigrations().size() == 0); SendVolumeSelfCounters(ctx); - VolumeSelfCounters = CreateVolumeSelfCounters(State->CountersPolicy()); + VolumeSelfCounters = CreateVolumeSelfCounters( + State->CountersPolicy(), + DiagnosticsConfig->GetHistogramCounterOptions()); } void TVolumeActor::HandleGetVolumeLoadInfo( diff --git a/cloud/blockstore/libs/storage/volume/volume_actor_updateconfig.cpp b/cloud/blockstore/libs/storage/volume/volume_actor_updateconfig.cpp index f4af107741b..88be65b7538 100644 --- a/cloud/blockstore/libs/storage/volume/volume_actor_updateconfig.cpp +++ b/cloud/blockstore/libs/storage/volume/volume_actor_updateconfig.cpp @@ -337,6 +337,7 @@ void TVolumeActor::CompleteUpdateConfig( State.reset(new TVolumeState( Config, + DiagnosticsConfig, args.Meta, {args.MetaHistoryItem}, // TODO: will it get updated later? diff --git a/cloud/blockstore/libs/storage/volume/volume_state.cpp b/cloud/blockstore/libs/storage/volume/volume_state.cpp index a655665b38b..2a8fbd0d8ec 100644 --- a/cloud/blockstore/libs/storage/volume/volume_state.cpp +++ b/cloud/blockstore/libs/storage/volume/volume_state.cpp @@ -138,6 +138,7 @@ void TCachedVolumeMountHistory::CleanupHistoryIfNeeded(TInstant oldest) TVolumeState::TVolumeState( TStorageConfigPtr storageConfig, + TDiagnosticsConfigPtr diagnosticsConfig, NProto::TVolumeMeta meta, TVector metaHistory, TVector volumeParams, @@ -147,6 +148,7 @@ TVolumeState::TVolumeState( TVector checkpointRequests, bool startPartitionsNeeded) : StorageConfig(std::move(storageConfig)) + , DiagnosticsConfig(std::move(diagnosticsConfig)) , Meta(std::move(meta)) , MetaHistory(std::move(metaHistory)) , Config(&Meta.GetConfig()) @@ -903,8 +905,11 @@ TPartitionStatInfo& TVolumeState::CreatePartitionStatInfo( const TString& diskId, ui64 tabletId) { - PartitionStatInfos.push_back( - TPartitionStatInfo(diskId, tabletId, CountersPolicy())); + PartitionStatInfos.push_back(TPartitionStatInfo( + diskId, + tabletId, + CountersPolicy(), + DiagnosticsConfig->GetHistogramCounterOptions())); return PartitionStatInfos.back(); } diff --git a/cloud/blockstore/libs/storage/volume/volume_state.h b/cloud/blockstore/libs/storage/volume/volume_state.h index e2c4c0a3201..7b92e555392 100644 --- a/cloud/blockstore/libs/storage/volume/volume_state.h +++ b/cloud/blockstore/libs/storage/volume/volume_state.h @@ -3,6 +3,7 @@ #include "partition_info.h" #include "public.h" +#include #include #include #include @@ -97,10 +98,11 @@ struct TPartitionStatInfo TPartitionStatInfo( const TString& diskId, const ui64 tabletId, - EPublishingPolicy countersPolicy) + EPublishingPolicy countersPolicy, + EHistogramCounterOptions histCounterOptions) : DiskId(diskId) , TabletId(tabletId) - , CachedCounters(countersPolicy) + , CachedCounters(countersPolicy, histCounterOptions) {} }; @@ -182,6 +184,7 @@ class TVolumeState { private: TStorageConfigPtr StorageConfig; + const TDiagnosticsConfigPtr DiagnosticsConfig; NProto::TVolumeMeta Meta; TVector MetaHistory; const NProto::TPartitionConfig* Config; @@ -241,6 +244,7 @@ class TVolumeState public: TVolumeState( TStorageConfigPtr storageConfig, + TDiagnosticsConfigPtr diagnosticsConfig, NProto::TVolumeMeta meta, TVector metaHistory, TVector volumeParams, diff --git a/cloud/blockstore/libs/storage/volume/volume_state_ut.cpp b/cloud/blockstore/libs/storage/volume/volume_state_ut.cpp index 9734b85c262..5c3e28333b2 100644 --- a/cloud/blockstore/libs/storage/volume/volume_state_ut.cpp +++ b/cloud/blockstore/libs/storage/volume/volume_state_ut.cpp @@ -3,6 +3,7 @@ #include #include #include +#include #include #include @@ -85,6 +86,7 @@ TVolumeState CreateVolumeState( { return TVolumeState( MakeConfig(inactiveClientsTimeout, {}), + CreateDiagnosticsConfig(), CreateVolumeMeta(pp), {{TInstant::Seconds(100), CreateVolumeMeta(pp)}}, // metaHistory {}, @@ -103,6 +105,7 @@ TVolumeState CreateVolumeState( { return TVolumeState( MakeConfig(inactiveClientsTimeout, {}), + CreateDiagnosticsConfig(), CreateVolumeMeta(pp), {{TInstant::Seconds(100), CreateVolumeMeta(pp)}}, // metaHistory {}, @@ -121,6 +124,7 @@ TVolumeState CreateVolumeState( std::make_shared( config, std::make_shared()), + CreateDiagnosticsConfig(), CreateVolumeMeta({}), {}, // metaHistory {}, @@ -1890,6 +1894,7 @@ Y_UNIT_TEST_SUITE(TVolumeStateTest) return TVolumeState{ MakeConfig(10s, 0s), + CreateDiagnosticsConfig(), std::move(meta), {}, // metaHistory {}, // volumeParams