Skip to content

Commit 297dee3

Browse files
VPolkaVPolka
authored
Add ok and error request metrics (#12738)
1 parent 60c4deb commit 297dee3

29 files changed

+347
-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::TEvGone());
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: 126 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,
@@ -702,6 +703,130 @@ public:
702703
COUNTER_DEF(ResponsesWithDiskSpaceLightYellowMove);
703704
};
704705

706+
///////////////////////////////////////////////////////////////////////////////////
707+
// THandleClassGroup
708+
///////////////////////////////////////////////////////////////////////////////////
709+
class THandleClassGroup : public TBase {
710+
public:
711+
GROUP_CONSTRUCTOR(THandleClassGroup)
712+
{
713+
COUNTER_INIT_IF_EXTENDED(Undefined, true);
714+
COUNTER_INIT_IF_EXTENDED(GetDiscover, true);
715+
COUNTER_INIT_IF_EXTENDED(GetFast, true);
716+
COUNTER_INIT_IF_EXTENDED(GetAsync, true);
717+
COUNTER_INIT_IF_EXTENDED(GetLow, true);
718+
COUNTER_INIT_IF_EXTENDED(PutTabletLog, true);
719+
COUNTER_INIT_IF_EXTENDED(PutUserData, true);
720+
COUNTER_INIT_IF_EXTENDED(PutAsyncBlob, true);
721+
}
722+
723+
COUNTER_DEF(Undefined);
724+
COUNTER_DEF(GetDiscover);
725+
COUNTER_DEF(GetFast);
726+
COUNTER_DEF(GetAsync);
727+
COUNTER_DEF(GetLow);
728+
COUNTER_DEF(PutTabletLog);
729+
COUNTER_DEF(PutUserData);
730+
COUNTER_DEF(PutAsyncBlob);
731+
732+
::NMonitoring::TDeprecatedCounter &GetCounter(const std::optional<NKikimrBlobStorage::EGetHandleClass>& handleClass) {
733+
if (!handleClass) {
734+
return Undefined();
735+
}
736+
switch (*handleClass) {
737+
case NKikimrBlobStorage::AsyncRead:
738+
return GetAsync();
739+
case NKikimrBlobStorage::FastRead:
740+
return GetFast();
741+
case NKikimrBlobStorage::Discover:
742+
return GetDiscover();
743+
case NKikimrBlobStorage::LowRead:
744+
return GetLow();
745+
default:
746+
return Undefined();
747+
}
748+
}
749+
::NMonitoring::TDeprecatedCounter &GetCounter(const std::optional<NKikimrBlobStorage::EPutHandleClass>& handleClass) {
750+
if (!handleClass) {
751+
return Undefined();
752+
}
753+
switch (*handleClass) {
754+
case NKikimrBlobStorage::TabletLog:
755+
return PutTabletLog();
756+
case NKikimrBlobStorage::AsyncBlob:
757+
return PutAsyncBlob();
758+
case NKikimrBlobStorage::UserData:
759+
return PutUserData();
760+
default:
761+
return Undefined();
762+
}
763+
}
764+
765+
::NMonitoring::TDeprecatedCounter &GetCounter() {
766+
return Undefined();
767+
}
768+
};
769+
770+
///////////////////////////////////////////////////////////////////////////////////
771+
// TResponseStatusGroup
772+
///////////////////////////////////////////////////////////////////////////////////
773+
class TResponseStatusGroup {
774+
public:
775+
TIntrusivePtr<::NMonitoring::TDynamicCounters> Group;
776+
777+
THandleClassGroup Undefined;
778+
THandleClassGroup ResponsesWithStatusError;
779+
THandleClassGroup ResponsesWithStatusRace;
780+
THandleClassGroup ResponsesWithStatusBlocked;
781+
THandleClassGroup ResponsesWithStatusOutOfSpace;
782+
THandleClassGroup ResponsesWithStatusDeadline;
783+
THandleClassGroup ResponsesWithStatusNotReady;
784+
THandleClassGroup ResponsesWithStatusVdiskErrorState;
785+
786+
TResponseStatusGroup(const TIntrusivePtr<::NMonitoring::TDynamicCounters>& counters)
787+
: Group(counters->GetSubgroup("subsystem", "statuses"))
788+
, Undefined(Group, "status", "UNDEFINED")
789+
, ResponsesWithStatusError(Group, "status", "ERROR")
790+
, ResponsesWithStatusRace(Group, "status", "RACE")
791+
, ResponsesWithStatusBlocked(Group, "status", "BLOCKED")
792+
, ResponsesWithStatusOutOfSpace(Group, "status", "OUT_OF_SPACE")
793+
, ResponsesWithStatusDeadline(Group, "status", "DEADLINE")
794+
, ResponsesWithStatusNotReady(Group, "status", "NOT_READY")
795+
, ResponsesWithStatusVdiskErrorState(Group, "status", "VDISK_STATUS_ERROR")
796+
{}
797+
798+
template <typename THandleClassType>
799+
::NMonitoring::TDeprecatedCounter &GetCounterByHandleClass(NKikimrProto::EReplyStatus status, const std::optional<THandleClassType>& handleClass = std::nullopt) {
800+
switch (status) {
801+
case NKikimrProto::ERROR:
802+
return ResponsesWithStatusError.GetCounter(handleClass);
803+
case NKikimrProto::RACE:
804+
return ResponsesWithStatusRace.GetCounter(handleClass);
805+
case NKikimrProto::BLOCKED:
806+
return ResponsesWithStatusBlocked.GetCounter(handleClass);
807+
case NKikimrProto::OUT_OF_SPACE:
808+
return ResponsesWithStatusOutOfSpace.GetCounter(handleClass);
809+
case NKikimrProto::DEADLINE:
810+
return ResponsesWithStatusDeadline.GetCounter(handleClass);
811+
case NKikimrProto::NOTREADY:
812+
return ResponsesWithStatusNotReady.GetCounter(handleClass);
813+
case NKikimrProto::VDISK_ERROR_STATE:
814+
return ResponsesWithStatusVdiskErrorState.GetCounter(handleClass);
815+
default: return Undefined.GetCounter(handleClass);
816+
}
817+
}
818+
819+
::NMonitoring::TDeprecatedCounter &GetCounter(NKikimrProto::EReplyStatus status) {
820+
return GetCounterByHandleClass(status, std::optional<NKikimrBlobStorage::EPutHandleClass>{});
821+
}
822+
::NMonitoring::TDeprecatedCounter &GetCounter(NKikimrProto::EReplyStatus status, const std::optional<NKikimrBlobStorage::EPutHandleClass>& handleClass) {
823+
return GetCounterByHandleClass(status, handleClass);
824+
}
825+
::NMonitoring::TDeprecatedCounter &GetCounter(NKikimrProto::EReplyStatus status, const std::optional<NKikimrBlobStorage::EGetHandleClass>& handleClass) {
826+
return GetCounterByHandleClass(status, handleClass);
827+
}
828+
};
829+
705830
///////////////////////////////////////////////////////////////////////////////////
706831
// TCostTrackerGroup
707832
///////////////////////////////////////////////////////////////////////////////////

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

Lines changed: 110 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,82 @@ void SendVDiskResponse(const TActorContext &ctx, const TActorId &recipient, IEve
6970
}
7071
}
7172

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

114-
}//NKikimr
191+
void UpdateMonResponseStatus(NKikimrProto::EReplyStatus status, const TCommonHandleClass& handleClass, const std::shared_ptr<NMonGroup::TResponseStatusGroup>& monGroup) {
192+
if (!monGroup) {
193+
return;
194+
}
195+
196+
if (std::holds_alternative<NKikimrBlobStorage::EPutHandleClass>(handleClass.HandleClass)) {
197+
monGroup->GetCounter(status, std::get<NKikimrBlobStorage::EPutHandleClass>(handleClass.HandleClass)).Inc();
198+
} else if (std::holds_alternative<NKikimrBlobStorage::EGetHandleClass>(handleClass.HandleClass)) {
199+
monGroup->GetCounter(status, std::get<NKikimrBlobStorage::EGetHandleClass>(handleClass.HandleClass)).Inc();
200+
} else {
201+
monGroup->GetCounter(status).Inc();
202+
}
203+
}
204+
205+
} //NKikimr

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

Lines changed: 33 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -5,8 +5,39 @@
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+
HandleClass = ev.Record.GetHandleClass();
25+
} else if constexpr (THasGetHandleClass<TEv>::value) {
26+
HandleClass = ev.GetHandleClass();
27+
}
28+
}
29+
30+
TCommonHandleClass(const NKikimrBlobStorage::EPutHandleClass& putHandleClass) {
31+
HandleClass = putHandleClass;
32+
}
33+
TCommonHandleClass(const NKikimrBlobStorage::EGetHandleClass& getHandleClass) {
34+
HandleClass = getHandleClass;
35+
}
36+
37+
std::variant<std::monostate, NKikimrBlobStorage::EPutHandleClass, NKikimrBlobStorage::EGetHandleClass> HandleClass;
38+
};
39+
40+
void SendVDiskResponse(const TActorContext &ctx, const TActorId &recipient, IEventBase *ev, ui64 cookie, const TIntrusivePtr<TVDiskContext>& vCtx, const TCommonHandleClass& handleClass);
41+
void SendVDiskResponse(const TActorContext &ctx, const TActorId &recipient, IEventBase *ev, ui64 cookie, ui32 channel, const TIntrusivePtr<TVDiskContext>& vCtx, const TCommonHandleClass& handleClass);
1142

1243
}//NKikimr

0 commit comments

Comments
 (0)