Capacity metrics

ydb/core/blobstorage/nodewarden/blobstorage_node_warden_ut.cpp

@@ -1014,14 +1014,16 @@ Y_UNIT_TEST_SUITE(TBlobStorageWardenTest) {
     void CheckInferredPDiskSettings(TTestBasicRuntime& runtime, TActorId fakeWhiteboard, TActorId fakeNodeWarden,
             ui32 pdiskId, ui32 expectedSlotCount, ui32 expectedSlotSizeInUnits,
             TDuration simTimeout = TDuration::Seconds(10)) {
-        for (int attempt=0; attempt<10; ++attempt) {
+        const int maxAttempts = 10;
+        for (int attempt = 1; attempt <= maxAttempts; ++attempt) {
             // Check EvPDiskStateUpdate sent from PDiskActor to Whiteboard
             const auto ev = runtime.GrabEdgeEventRethrow<NNodeWhiteboard::TEvWhiteboard::TEvPDiskStateUpdate>(fakeWhiteboard, simTimeout);
             VERBOSE_COUT(" Got TEvPDiskStateUpdate# " << ev->ToString());
 
             NKikimrWhiteboard::TPDiskStateInfo pdiskInfo = ev->Get()->Record;
             UNIT_ASSERT_VALUES_EQUAL(pdiskInfo.GetPDiskId(), pdiskId);
             if (pdiskInfo.GetState() != NKikimrBlobStorage::TPDiskState::Normal) {
+                UNIT_ASSERT_LT_C(attempt, maxAttempts, "last attempt failed");
                 continue;
             }
             UNIT_ASSERT(pdiskInfo.HasExpectedSlotCount());
@@ -1030,10 +1032,12 @@ Y_UNIT_TEST_SUITE(TBlobStorageWardenTest) {
             UNIT_ASSERT(pdiskInfo.HasTotalSize());
             UNIT_ASSERT_VALUES_EQUAL(pdiskInfo.GetExpectedSlotCount(), expectedSlotCount);
             UNIT_ASSERT_VALUES_EQUAL(pdiskInfo.GetSlotSizeInUnits(), expectedSlotSizeInUnits);
+            UNIT_ASSERT(pdiskInfo.HasPDiskUsage());
+            UNIT_ASSERT_VALUES_EQUAL(pdiskInfo.GetPDiskUsage(), 0.0);
             break;
         }
 
-        {
+        for (int attempt = 1; attempt <= maxAttempts; ++attempt) {
             // Check EvControllerUpdateDiskStatus sent from PDiskActor to NodeWarden
             const auto ev = runtime.GrabEdgeEventRethrow<TEvBlobStorage::TEvControllerUpdateDiskStatus>(fakeNodeWarden, simTimeout);
             VERBOSE_COUT(" Got TEvControllerUpdateDiskStatus# " << ev->ToString());
@@ -1043,10 +1047,17 @@ Y_UNIT_TEST_SUITE(TBlobStorageWardenTest) {
 
             const NKikimrBlobStorage::TPDiskMetrics &metrics = diskStatus.GetPDisksMetrics(0);
             UNIT_ASSERT_VALUES_EQUAL(metrics.GetPDiskId(), pdiskId);
+            if (metrics.GetState() != NKikimrBlobStorage::TPDiskState::Normal) {
+                UNIT_ASSERT_LT_C(attempt, maxAttempts, "last attempt failed");
+                continue;
+            }
             UNIT_ASSERT(metrics.HasSlotCount());
             UNIT_ASSERT(metrics.HasSlotSizeInUnits());
             UNIT_ASSERT_VALUES_EQUAL(metrics.GetSlotCount(), expectedSlotCount);
             UNIT_ASSERT_VALUES_EQUAL(metrics.GetSlotSizeInUnits(), expectedSlotSizeInUnits);
+            UNIT_ASSERT(metrics.HasPDiskUsage());
+            UNIT_ASSERT_VALUES_EQUAL(metrics.GetPDiskUsage(), 0.0);
+            break;
         }
     }
 

ydb/core/blobstorage/pdisk/blobstorage_pdisk.h

@@ -1427,7 +1427,10 @@ struct TEvCheckSpaceResult : TEventLocal<TEvCheckSpaceResult, TEvBlobStorage::Ev
     ui32 UsedChunks; // equals OwnerQuota.Used(owner) - a number of chunks allocated by requesting owner
     ui32 NumSlots; // number of VDisks over PDisk, not their weight
     ui32 NumActiveSlots; // sum of VDisks weights - $ \sum_i{ceil(VSlot[i].SlotSizeInUnits / PDisk.SlotSizeInUnits)} $
-    double Occupancy = 0;
+    double NormalizedOccupancy = 0;
+    double VDiskSlotUsage = 0;  // 100.0 * Owner.Used / Owner.LightYellowLimit
+    double VDiskRawUsage = 0;  // 100.0 * Owner.Used / Owner.HardLimit
+    double PDiskUsage = 0;  // 100.0 * SharedQuota.Used / SharedQuota.HardLimit
     TString ErrorReason;
     TStatusFlags LogStatusFlags;
 

ydb/core/blobstorage/pdisk/blobstorage_pdisk_chunk_tracker.h

@@ -590,7 +590,7 @@ using TColor = NKikimrBlobStorage::TPDiskSpaceColor;
         OwnerQuota->PrintHTML(str, SharedQuota.Get(), &ColorBorder, &ColorBorderOccupancy);
     }
 
-    ui32 ColorFlagLimit(TOwner owner, NKikimrBlobStorage::TPDiskSpaceColor::E color) {
+    ui32 ColorFlagLimit(TOwner owner, NKikimrBlobStorage::TPDiskSpaceColor::E color) const {
         if (IsOwnerUser(owner)) {
             return OwnerQuota->ColorFlagLimit(owner, color);
         } else {

ydb/core/blobstorage/pdisk/blobstorage_pdisk_impl.cpp

@@ -1589,7 +1589,7 @@ void TPDisk::WhiteboardReport(TWhiteboardReport &whiteboardReport) {
         pdiskState.SetSerialNumber(Cfg->ExpectedSerial);
         const auto& state = static_cast<NKikimrBlobStorage::TPDiskState::E>(Mon.PDiskState->Val());
         pdiskState.SetState(state);
-        
+
         // Only report size information when PDisk is not in error state
         if (*Mon.PDiskBriefState != TPDiskMon::TPDisk::Error) {
             pdiskState.SetAvailableSize(availableSize);
@@ -1624,8 +1624,21 @@ void TPDisk::WhiteboardReport(TWhiteboardReport &whiteboardReport) {
             vdiskMetrics->SetAvailableSize(ownerFree);
             vdiskMetrics->SetAllocatedSize(ownerAllocated);
             double occupancy;
-            vdiskMetrics->SetStatusFlags(Keeper.GetSpaceStatusFlags(owner, &occupancy));
-            vdiskMetrics->SetOccupancy(occupancy);
+            NPDisk::TStatusFlags statusFlags = Keeper.GetSpaceStatusFlags(owner, &occupancy);
+            NKikimrBlobStorage::TPDiskSpaceColor::E spaceColor = StatusFlagToSpaceColor(statusFlags);
+            double vdiskSlotUsage = Keeper.GetVDiskSlotUsage(owner);
+            double vdiskRawUsage = Keeper.GetVDiskRawUsage(owner);
+            vdiskMetrics->SetStatusFlags(statusFlags);
+            vdiskMetrics->SetNormalizedOccupancy(occupancy);
+            vdiskMetrics->SetVDiskSlotUsage(vdiskSlotUsage);
+            vdiskMetrics->SetVDiskRawUsage(vdiskRawUsage);
+            vdiskMetrics->SetCapacityAlert(spaceColor);
+
+            vdiskInfo.SetNormalizedOccupancy(occupancy);
+            vdiskInfo.SetVDiskSlotUsage(vdiskSlotUsage);
+            vdiskInfo.SetVDiskRawUsage(vdiskRawUsage);
+            vdiskInfo.SetCapacityAlert(spaceColor);
+
             auto *vslotId = vdiskMetrics->MutableVSlotId();
             vslotId->SetNodeId(PCtx->ActorSystem->NodeId);
             vslotId->SetPDiskId(PCtx->PDiskId);
@@ -1655,6 +1668,10 @@ void TPDisk::WhiteboardReport(TWhiteboardReport &whiteboardReport) {
         if (ExpectedSlotCount) {
             pDiskMetrics.SetSlotCount(ExpectedSlotCount);
         }
+
+        double pdiskUsage = Keeper.GetPDiskUsage();
+        pDiskMetrics.SetPDiskUsage(pdiskUsage);
+        pdiskState.SetPDiskUsage(pdiskUsage);
     }
 
     PCtx->ActorSystem->Send(whiteboardReport.Sender, reportResult);
@@ -2182,7 +2199,10 @@ void TPDisk::CheckSpace(TCheckSpace &evCheckSpace) {
                 GetNumActiveSlots(),
                 TString(),
                 GetStatusFlags(OwnerSystem, evCheckSpace.OwnerGroupType));
-    result->Occupancy = occupancy;
+    result->NormalizedOccupancy = occupancy;
+    result->VDiskSlotUsage = Keeper.GetVDiskSlotUsage(evCheckSpace.Owner);
+    result->VDiskRawUsage = Keeper.GetVDiskRawUsage(evCheckSpace.Owner);
+    result->PDiskUsage = Keeper.GetPDiskUsage();
     PCtx->ActorSystem->Send(evCheckSpace.Sender, result.release());
     Mon.CheckSpace.CountResponse();
     return;

ydb/core/blobstorage/pdisk/blobstorage_pdisk_keeper.h

@@ -150,6 +150,24 @@ class TKeeper {
         return ChunkTracker.EstimateSpaceColor(owner, allocationSize, occupancy);
     }
 
+    double GetPDiskUsage() const {
+        i64 totalUsed = ChunkTracker.GetTotalUsed();
+        i64 totalHardLimit = ChunkTracker.GetTotalHardLimit();
+        return 100.0 * (totalHardLimit ? (double)totalUsed / totalHardLimit : 1.0);
+    }
+
+    double GetVDiskSlotUsage(TOwner owner) const {
+        i64 used = ChunkTracker.GetOwnerUsed(owner);
+        ui32 lightYellowLimit = ChunkTracker.ColorFlagLimit(owner, NKikimrBlobStorage::TPDiskSpaceColor::LIGHT_YELLOW);
+        return 100.0 * (lightYellowLimit ? (double)used / lightYellowLimit : 1.0);
+    }
+
+    double GetVDiskRawUsage(TOwner owner) const {
+        i64 used = ChunkTracker.GetOwnerUsed(owner);
+        i64 hardLimit = ChunkTracker.GetOwnerHardLimit(owner);
+        return 100.0 * (hardLimit ? (double)used / hardLimit : 1.0);
+    }
+
     //
     // Trimming
     //