Skip to content

Commit f11d065

Browse files
VPolkaVPolka
authored
Merge 7084292 into 1f43830 
2 parents 1f43830 + 7084292 commit f11d065

29 files changed

+332
-88
lines changed

‎ydb/core/blobstorage/vdisk/common/blobstorage_status.cpp‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -37,7 +37,7 @@ namespace NKikimr {
3737
SetRacingGroupInfo(record, Result->Record, GroupInfo);
3838
LOG_DEBUG(ctx, BS_VDISK_OTHER, VDISKP(VCtx->VDiskLogPrefix, "TEvVStatusResult Request# {%s} Response# {%s}",
3939
SingleLineProto(record).data(), SingleLineProto(Result->Record).data()));
40-
SendVDiskResponse(ctx, Ev->Sender, Result.release(), Ev->Cookie, Ev->GetChannel(), VCtx);
40+
SendVDiskResponse(ctx, Ev->Sender, Result.release(), Ev->Cookie, Ev->GetChannel(), VCtx, {});
4141
Die(ctx);
4242
return;
4343
}
@@ -73,7 +73,7 @@ namespace NKikimr {
7373
ctx.Send(NotifyId, new TEvents::TEvActorDied());
7474
LOG_DEBUG(ctx, BS_VDISK_GET,
7575
VDISKP(VCtx->VDiskLogPrefix, "TEvVStatusResult"));
76-
SendVDiskResponse(ctx, Ev->Sender, Result.release(), Ev->Cookie, Ev->GetChannel(), VCtx);
76+
SendVDiskResponse(ctx, Ev->Sender, Result.release(), Ev->Cookie, Ev->GetChannel(), VCtx, {});
7777
Die(ctx);
7878
}
7979
}

‎ydb/core/blobstorage/vdisk/common/vdisk_context.cpp‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -61,6 +61,7 @@ namespace NKikimr {
6161
, ReplNodeResponseQuoter(std::move(replNodeResponseQuoter))
6262
, CostTracker()
6363
, OOSMonGroup(std::make_shared<NMonGroup::TOutOfSpaceGroup>(VDiskCounters, "subsystem", "oos"))
64+
, ResponseStatusMonGroup(std::make_shared<NMonGroup::TResponseStatusGroup>(VDiskCounters))
6465
, OutOfSpaceState(Top->GetTotalVDisksNum(), Top->GetOrderNumber(ShortSelfVDisk))
6566
, CostMonGroup(vdiskCounters, "subsystem", "cost")
6667
, Logger(as ? ActorSystemLogger(as) : DevNullLogger())

‎ydb/core/blobstorage/vdisk/common/vdisk_context.h‎

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -77,6 +77,9 @@ namespace NKikimr {
7777
std::atomic<ui32> CurrentOOSStatusFlag = NKikimrBlobStorage::StatusIsValid;
7878
std::shared_ptr<NMonGroup::TOutOfSpaceGroup> OOSMonGroup;
7979

80+
// response status
81+
std::shared_ptr<NMonGroup::TResponseStatusGroup> ResponseStatusMonGroup;
82+
8083
private:
8184
// Managing disk space
8285
TOutOfSpaceState OutOfSpaceState;

‎ydb/core/blobstorage/vdisk/common/vdisk_mongroups.h‎

Lines changed: 112 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -3,12 +3,13 @@
33
#include "defs.h"
44

55
#include <ydb/core/base/appdata_fwd.h>
6+
#include <ydb/core/protos/base.pb.h>
7+
#include <ydb/core/protos/blobstorage_base.pb.h>
68
#include <ydb/core/protos/node_whiteboard.pb.h>
79
#include <ydb/core/protos/whiteboard_disk_states.pb.h>
810

911
namespace NKikimr {
1012
namespace NMonGroup {
11-
1213
class TBase {
1314
public:
1415
TBase(const TIntrusivePtr<::NMonitoring::TDynamicCounters>& counters,
@@ -676,6 +677,116 @@ public:
676677
COUNTER_DEF(ResponsesWithDiskSpaceLightYellowMove);
677678
};
678679

680+
///////////////////////////////////////////////////////////////////////////////////
681+
// THandleClassGroup
682+
///////////////////////////////////////////////////////////////////////////////////
683+
class THandleClassGroup : public TBase {
684+
public:
685+
GROUP_CONSTRUCTOR(THandleClassGroup)
686+
{
687+
COUNTER_INIT(Undefined, true);
688+
COUNTER_INIT(GetDiscover, true);
689+
COUNTER_INIT(GetFast, true);
690+
COUNTER_INIT(GetAsync, true);
691+
COUNTER_INIT(GetLow, true);
692+
COUNTER_INIT(PutTabletLog, true);
693+
COUNTER_INIT(PutUserData, true);
694+
COUNTER_INIT(PutAsyncBlob, true);
695+
}
696+
697+
COUNTER_DEF(Undefined);
698+
COUNTER_DEF(GetDiscover);
699+
COUNTER_DEF(GetFast);
700+
COUNTER_DEF(GetAsync);
701+
COUNTER_DEF(GetLow);
702+
COUNTER_DEF(PutTabletLog);
703+
COUNTER_DEF(PutUserData);
704+
COUNTER_DEF(PutAsyncBlob);
705+
706+
::NMonitoring::TDeprecatedCounter &GetCounter(const std::optional<NKikimrBlobStorage::EGetHandleClass>& handleClass = std::nullopt) {
707+
if (!handleClass) {
708+
return Undefined();
709+
}
710+
switch (*handleClass) {
711+
case NKikimrBlobStorage::AsyncRead:
712+
return GetAsync();
713+
case NKikimrBlobStorage::FastRead:
714+
return GetFast();
715+
case NKikimrBlobStorage::Discover:
716+
return GetDiscover();
717+
case NKikimrBlobStorage::LowRead:
718+
return GetLow();
719+
}
720+
}
721+
::NMonitoring::TDeprecatedCounter &GetCounter(const std::optional<NKikimrBlobStorage::EPutHandleClass>& handleClass = std::nullopt) {
722+
if (!handleClass) {
723+
return Undefined();
724+
}
725+
switch (*handleClass) {
726+
case NKikimrBlobStorage::TabletLog:
727+
return PutTabletLog();
728+
case NKikimrBlobStorage::AsyncBlob:
729+
return PutAsyncBlob();
730+
case NKikimrBlobStorage::UserData:
731+
return PutUserData();
732+
}
733+
}
734+
};
735+
736+
///////////////////////////////////////////////////////////////////////////////////
737+
// TResponseStatusGroup
738+
///////////////////////////////////////////////////////////////////////////////////
739+
class TResponseStatusGroup {
740+
public:
741+
TIntrusivePtr<::NMonitoring::TDynamicCounters> Group;
742+
743+
THandleClassGroup Undefined;
744+
THandleClassGroup ResponsesWithStatusError;
745+
THandleClassGroup ResponsesWithStatusRace;
746+
THandleClassGroup ResponsesWithStatusBlocked;
747+
THandleClassGroup ResponsesWithStatusOutOfSpace;
748+
THandleClassGroup ResponsesWithStatusDeadline;
749+
THandleClassGroup ResponsesWithStatusNotReady;
750+
THandleClassGroup ResponsesWithStatusVdiskErrorState;
751+
752+
TResponseStatusGroup(const TIntrusivePtr<::NMonitoring::TDynamicCounters>& counters)
753+
: Group(counters->GetSubgroup("subsystem", "statuses"))
754+
, Undefined(Group, "status", "UNDEFINED")
755+
, ResponsesWithStatusError(Group, "status", "ERROR")
756+
, ResponsesWithStatusRace(Group, "status", "RACE")
757+
, ResponsesWithStatusBlocked(Group, "status", "BLOCKED")
758+
, ResponsesWithStatusOutOfSpace(Group, "status", "OUT_OF_SPACE")
759+
, ResponsesWithStatusDeadline(Group, "status", "DEADLINE")
760+
, ResponsesWithStatusNotReady(Group, "status", "NOT_READY")
761+
, ResponsesWithStatusVdiskErrorState(Group, "status", "VDISK_STATUS_ERROR")
762+
{}
763+
764+
template <typename THandleClassType>
765+
::NMonitoring::TDeprecatedCounter &GetCounter(NKikimrProto::EReplyStatus status, const std::optional<THandleClassType>& handleClass = std::nullopt) {
766+
switch (status) {
767+
case NKikimrProto::ERROR:
768+
return ResponsesWithStatusError.GetCounter(handleClass);
769+
case NKikimrProto::RACE:
770+
return ResponsesWithStatusRace.GetCounter(handleClass);
771+
case NKikimrProto::BLOCKED:
772+
return ResponsesWithStatusBlocked.GetCounter(handleClass);
773+
case NKikimrProto::OUT_OF_SPACE:
774+
return ResponsesWithStatusOutOfSpace.GetCounter(handleClass);
775+
case NKikimrProto::DEADLINE:
776+
return ResponsesWithStatusDeadline.GetCounter(handleClass);
777+
case NKikimrProto::NOTREADY:
778+
return ResponsesWithStatusNotReady.GetCounter(handleClass);
779+
case NKikimrProto::VDISK_ERROR_STATE:
780+
return ResponsesWithStatusVdiskErrorState.GetCounter(handleClass);
781+
default: return Undefined.GetCounter(handleClass);
782+
}
783+
}
784+
785+
::NMonitoring::TDeprecatedCounter &GetCounter(NKikimrProto::EReplyStatus status) {
786+
return GetCounter(status, std::optional<NKikimrBlobStorage::EPutHandleClass>{});
787+
}
788+
};
789+
679790
///////////////////////////////////////////////////////////////////////////////////
680791
// TCostTrackerGroup
681792
///////////////////////////////////////////////////////////////////////////////////

‎ydb/core/blobstorage/vdisk/common/vdisk_response.cpp‎

Lines changed: 105 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -6,35 +6,36 @@
66

77
namespace NKikimr {
88

9+
template <class TRecord>
10+
void ReportResponse(const TRecord& record, const TCommonHandleClass& handleClass, const TIntrusivePtr<TVDiskContext>& vCtx);
911
void LogOOSStatus(ui32 flags, const TLogoBlobID& blobId, const TString& vDiskLogPrefix, std::atomic<ui32>& curFlags);
1012
void UpdateMonOOSStatus(ui32 flags, const std::shared_ptr<NMonGroup::TOutOfSpaceGroup>& monGroup);
13+
void UpdateMonResponseStatus(NKikimrProto::EReplyStatus status, const TCommonHandleClass& handleClass, const std::shared_ptr<NMonGroup::TResponseStatusGroup>& monGroup);
1114

12-
void SendVDiskResponse(const TActorContext &ctx, const TActorId &recipient, IEventBase *ev, ui64 cookie, const TIntrusivePtr<TVDiskContext>& vCtx) {
15+
void SendVDiskResponse(const TActorContext &ctx, const TActorId &recipient, IEventBase *ev, ui64 cookie, const TIntrusivePtr<TVDiskContext>& vCtx, const TCommonHandleClass& handleClass) {
1316
ui32 channel = TInterconnectChannels::IC_BLOBSTORAGE;
1417
if (TEvVResultBase *base = dynamic_cast<TEvVResultBase *>(ev)) {
1518
channel = base->GetChannelToSend();
1619
}
17-
SendVDiskResponse(ctx, recipient, ev, cookie, channel, vCtx);
20+
SendVDiskResponse(ctx, recipient, ev, cookie, channel, vCtx, handleClass);
1821
}
1922

20-
void SendVDiskResponse(const TActorContext &ctx, const TActorId &recipient, IEventBase *ev, ui64 cookie, ui32 channel, const TIntrusivePtr<TVDiskContext>& vCtx) {
23+
void SendVDiskResponse(const TActorContext &ctx, const TActorId &recipient, IEventBase *ev, ui64 cookie, ui32 channel, const TIntrusivePtr<TVDiskContext>& vCtx, const TCommonHandleClass& handleClass) {
2124
if (vCtx) {
22-
switch(ev->Type()) {
23-
case TEvBlobStorage::TEvVPutResult::EventType: {
24-
TEvBlobStorage::TEvVPutResult* event = static_cast<TEvBlobStorage::TEvVPutResult *>(ev);
25-
LogOOSStatus(event->Record.GetStatusFlags(), LogoBlobIDFromLogoBlobID(event->Record.GetBlobID()), vCtx->VDiskLogPrefix, vCtx->CurrentOOSStatusFlag);
26-
UpdateMonOOSStatus(event->Record.GetStatusFlags(), vCtx->OOSMonGroup);
27-
break;
28-
}
29-
case TEvBlobStorage::TEvVMultiPutResult::EventType: {
30-
TEvBlobStorage::TEvVMultiPutResult *event = static_cast<TEvBlobStorage::TEvVMultiPutResult *>(ev);
31-
if (event->Record.ItemsSize() > 0) {
32-
const auto& item = event->Record.GetItems(0);
33-
LogOOSStatus(event->Record.GetStatusFlags(), LogoBlobIDFromLogoBlobID(item.GetBlobID()), vCtx->VDiskLogPrefix, vCtx->CurrentOOSStatusFlag);
34-
UpdateMonOOSStatus(event->Record.GetStatusFlags(), vCtx->OOSMonGroup);
35-
}
36-
break;
25+
switch (ev->Type()) {
26+
#define HANDLE_EVENT(T) \
27+
case T::EventType: { \
28+
T *event = static_cast<T *>(ev); \
29+
ReportResponse(event->Record, handleClass, vCtx); \
30+
break; \
3731
}
32+
33+
HANDLE_EVENT(TEvBlobStorage::TEvVPutResult)
34+
HANDLE_EVENT(TEvBlobStorage::TEvVMultiPutResult)
35+
HANDLE_EVENT(TEvBlobStorage::TEvVGetResult)
36+
HANDLE_EVENT(TEvBlobStorage::TEvVGetBlockResult)
37+
HANDLE_EVENT(TEvBlobStorage::TEvVCollectGarbageResult)
38+
#undef HANDLE_EVENT
3839
}
3940
}
4041

@@ -69,6 +70,77 @@ void SendVDiskResponse(const TActorContext &ctx, const TActorId &recipient, IEve
6970
}
7071
}
7172

73+
template <typename T, typename Tuple>
74+
struct IsInTypes;
75+
76+
template <typename T, typename... Types>
77+
struct IsInTypes<T, std::tuple<Types...>> {
78+
static constexpr bool value = (std::is_same_v<T, Types> || ...);
79+
};
80+
81+
struct TReportingOSStatus {
82+
using EnableFor = std::tuple<
83+
NKikimrBlobStorage::TEvVPutResult,
84+
NKikimrBlobStorage::TEvVMultiPutResult>;
85+
86+
template <typename TRecord>
87+
static void Report(const TRecord& record, const TCommonHandleClass&, const TIntrusivePtr<TVDiskContext>& vCtx) {
88+
LogOOSStatus(record.GetStatusFlags(), LogoBlobIDFromLogoBlobID(record.GetBlobID()), vCtx->VDiskLogPrefix, vCtx->CurrentOOSStatusFlag);
89+
UpdateMonOOSStatus(record.GetStatusFlags(), vCtx->OOSMonGroup);
90+
}
91+
92+
template<>
93+
void Report(const NKikimrBlobStorage::TEvVMultiPutResult& record, const TCommonHandleClass&, const TIntrusivePtr<TVDiskContext>& vCtx) {
94+
if (record.ItemsSize() > 0) {
95+
const auto& item = record.GetItems(0);
96+
LogOOSStatus(record.GetStatusFlags(), LogoBlobIDFromLogoBlobID(item.GetBlobID()), vCtx->VDiskLogPrefix, vCtx->CurrentOOSStatusFlag);
97+
UpdateMonOOSStatus(record.GetStatusFlags(), vCtx->OOSMonGroup);
98+
}
99+
}
100+
};
101+
102+
struct TReportingResponseStatus {
103+
using EnableFor = std::tuple<
104+
NKikimrBlobStorage::TEvVPutResult,
105+
NKikimrBlobStorage::TEvVMultiPutResult,
106+
NKikimrBlobStorage::TEvVGetResult,
107+
NKikimrBlobStorage::TEvVGetBlockResult,
108+
NKikimrBlobStorage::TEvVCollectGarbageResult>;
109+
110+
template <typename TRecord>
111+
static void Report(const TRecord& record, const TCommonHandleClass& handleClass, const TIntrusivePtr<TVDiskContext>& vCtx) {
112+
UpdateMonResponseStatus(record.GetStatus(), handleClass, vCtx->ResponseStatusMonGroup);
113+
}
114+
115+
template<>
116+
void Report(const NKikimrBlobStorage::TEvVMultiPutResult& record, const TCommonHandleClass& handleClass, const TIntrusivePtr<TVDiskContext>& vCtx) {
117+
for (const auto& item : record.GetItems()) {
118+
UpdateMonResponseStatus(item.GetStatus(), handleClass, vCtx->ResponseStatusMonGroup);
119+
}
120+
}
121+
};
122+
123+
#define DEFUNE_REPORT(NAME) \
124+
template <typename TRecord> \
125+
typename std::enable_if<IsInTypes<TRecord, TReporting##NAME::EnableFor>::value>::type Report##NAME( \
126+
const TRecord& record, const TCommonHandleClass& handleClass, const TIntrusivePtr<TVDiskContext>& vCtx) { \
127+
TReporting##NAME::Report(record, handleClass, vCtx); \
128+
} \
129+
\
130+
template <typename TRecord> \
131+
typename std::enable_if<!IsInTypes<TRecord, TReporting##NAME::EnableFor>::value>::type Report##NAME( \
132+
const TRecord& record, const TCommonHandleClass& handleClass, const TIntrusivePtr<TVDiskContext>& vCtx) {}
133+
134+
DEFUNE_REPORT(OSStatus)
135+
DEFUNE_REPORT(ResponseStatus)
136+
#undef DEFUNE_REPORT
137+
138+
template <class TRecord>
139+
void ReportResponse(const TRecord& record, const TCommonHandleClass& handleClass, const TIntrusivePtr<TVDiskContext>& vCtx) {
140+
ReportOSStatus(record, handleClass, vCtx);
141+
ReportResponseStatus(record, handleClass, vCtx);
142+
}
143+
72144
void LogOOSStatus(ui32 flags, const TLogoBlobID& blobId, const TString& vDiskLogPrefix, std::atomic<ui32>& curFlags) {
73145
if (!TlsActivationContext) {
74146
return;
@@ -111,4 +183,18 @@ void UpdateMonOOSStatus(ui32 flags, const std::shared_ptr<NMonGroup::TOutOfSpace
111183
}
112184
}
113185

114-
}//NKikimr
186+
void UpdateMonResponseStatus(NKikimrProto::EReplyStatus status, const TCommonHandleClass& handleClass, const std::shared_ptr<NMonGroup::TResponseStatusGroup>& monGroup) {
187+
if (!monGroup) {
188+
return;
189+
}
190+
191+
if (handleClass.PutHandleClass) {
192+
monGroup->GetCounter(status, handleClass.PutHandleClass).Inc();
193+
} else if (handleClass.GetHandleClass) {
194+
monGroup->GetCounter(status, handleClass.GetHandleClass).Inc();
195+
} else {
196+
monGroup->GetCounter(status).Inc();
197+
}
198+
}
199+
200+
} //NKikimr

‎ydb/core/blobstorage/vdisk/common/vdisk_response.h‎

Lines changed: 37 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -5,8 +5,43 @@
55

66
namespace NKikimr {
77

8-
void SendVDiskResponse(const TActorContext &ctx, const TActorId &recipient, IEventBase *ev, ui64 cookie, const TIntrusivePtr<TVDiskContext>& vCtx);
8+
template <typename TEv, typename = void>
9+
struct THasGetHandleClass : std::false_type {};
10+
template <typename TEv>
11+
struct THasGetHandleClass<TEv, std::void_t<decltype(std::declval<TEv>().GetHandleClass())>> : std::true_type {};
912

10-
void SendVDiskResponse(const TActorContext &ctx, const TActorId &recipient, IEventBase *ev, ui64 cookie, ui32 channel, const TIntrusivePtr<TVDiskContext>& vCtx);
13+
template <typename TEv, typename = void>
14+
struct THasRecordWithGetHandleClass : std::false_type {};
15+
template <typename TEv>
16+
struct THasRecordWithGetHandleClass<TEv, std::void_t<decltype(std::declval<TEv>().Record.GetHandleClass())>> : std::true_type {};
17+
18+
struct TCommonHandleClass {
19+
TCommonHandleClass() = default;
20+
21+
template <typename TEv>
22+
TCommonHandleClass(const TEv& ev) {
23+
if constexpr (THasRecordWithGetHandleClass<TEv>::value) {
24+
TCommonHandleClass(ev.Record.GetHandleClass());
25+
} else if constexpr (THasGetHandleClass<TEv>::value) {
26+
TCommonHandleClass(ev.GetHandleClass());
27+
}
28+
}
29+
template <>
30+
TCommonHandleClass(const NKikimrBlobStorage::EPutHandleClass& putHandleClass) {
31+
PutHandleClass = putHandleClass;
32+
}
33+
template <>
34+
TCommonHandleClass(const NKikimrBlobStorage::EGetHandleClass& getHandleClass) {
35+
GetHandleClass = getHandleClass;
36+
}
37+
38+
39+
std::optional<NKikimrBlobStorage::EPutHandleClass> PutHandleClass;
40+
std::optional<NKikimrBlobStorage::EGetHandleClass> GetHandleClass;
41+
};
42+
43+
void SendVDiskResponse(const TActorContext &ctx, const TActorId &recipient, IEventBase *ev, ui64 cookie, const TIntrusivePtr<TVDiskContext>& vCtx, const TCommonHandleClass& handleClass);
44+
45+
void SendVDiskResponse(const TActorContext &ctx, const TActorId &recipient, IEventBase *ev, ui64 cookie, ui32 channel, const TIntrusivePtr<TVDiskContext>& vCtx, const TCommonHandleClass& handleClass);
1146

1247
}//NKikimr

‎ydb/core/blobstorage/vdisk/huge/blobstorage_hullhuge.cpp‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -231,7 +231,7 @@ LWTRACE_USING(BLOBSTORAGE_PROVIDER);
231231
CHECK_PDISK_RESPONSE(HugeKeeperCtx->VCtx, ev, ctx);
232232
ctx.Send(NotifyID, new TEvHullHugeWritten(HugeSlot));
233233
ctx.Send(HugeKeeperCtx->SkeletonId, new TEvHullLogHugeBlob(WriteId, Item->LogoBlobId, Item->Ingress, DiskAddr,
234-
Item->IgnoreBlock, Item->SenderId, Item->Cookie, std::move(Item->Result), &Item->ExtraBlockChecks), 0, 0,
234+
Item->IgnoreBlock, Item->SenderId, Item->Cookie, Item->HandleClass, std::move(Item->Result), &Item->ExtraBlockChecks), 0, 0,
235235
Span.GetTraceId());
236236
LOG_DEBUG(ctx, BS_HULLHUGE,
237237
VDISKP(HugeKeeperCtx->VCtx->VDiskLogPrefix,

0 commit comments

Comments
 (0)