Skip to content

Commit 9b834dc

Browse files
VPolkaVPolka
committed
add process defferent handle classes
1 parent 084221b commit 9b834dc

File tree

3 files changed

+176
-69
lines changed

3 files changed

+176
-69
lines changed

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

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -61,7 +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, "subsystem", "status"))
64+
, ResponseStatusMonGroup(std::make_shared<NMonGroup::TResponseStatusGroup>(VDiskCounters))
6565
, OutOfSpaceState(Top->GetTotalVDisksNum(), Top->GetOrderNumber(ShortSelfVDisk))
6666
, CostMonGroup(vdiskCounters, "subsystem", "cost")
6767
, Logger(as ? ActorSystemLogger(as) : DevNullLogger())

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

Lines changed: 90 additions & 18 deletions
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,
@@ -665,28 +666,99 @@ public:
665666
};
666667

667668
///////////////////////////////////////////////////////////////////////////////////
668-
// TResponseStatusGroup
669+
// THandleClassGroup
669670
///////////////////////////////////////////////////////////////////////////////////
670-
class TResponseStatusGroup : public TBase {
671+
class THandleClassGroup : public TBase {
671672
public:
672-
GROUP_CONSTRUCTOR(TResponseStatusGroup)
673+
GROUP_CONSTRUCTOR(THandleClassGroup)
673674
{
674-
COUNTER_INIT(ResponsesWithStatusError, true);
675-
COUNTER_INIT(ResponsesWithStatusRace, true);
676-
COUNTER_INIT(ResponsesWithStatusBlocked, true);
677-
COUNTER_INIT(ResponsesWithStatusOutOfSpace, true);
678-
COUNTER_INIT(ResponsesWithStatusDeadline, true);
679-
COUNTER_INIT(ResponsesWithStatusNotReady, true);
680-
COUNTER_INIT(ResponsesWithStatusVdiskErrorState, true);
675+
COUNTER_INIT(VGetDiscover, true);
676+
COUNTER_INIT(VGetFast, true);
677+
COUNTER_INIT(VGetAsync, true);
678+
COUNTER_INIT(VGetLow, true);
679+
COUNTER_INIT(VPutTabletLog, true);
680+
COUNTER_INIT(VPutUserData, true);
681+
COUNTER_INIT(VPutAsyncBlob, true);
682+
}
683+
684+
COUNTER_DEF(VGetDiscover);
685+
COUNTER_DEF(VGetFast);
686+
COUNTER_DEF(VGetAsync);
687+
COUNTER_DEF(VGetLow);
688+
COUNTER_DEF(VPutTabletLog);
689+
COUNTER_DEF(VPutUserData);
690+
COUNTER_DEF(VPutAsyncBlob);
691+
692+
const ::NMonitoring::TDeprecatedCounter &GetCounter(NKikimrBlobStorage::EGetHandleClass handleClass) const {
693+
switch (handleClass) {
694+
case NKikimrBlobStorage::AsyncRead:
695+
return VGetAsync();
696+
case NKikimrBlobStorage::FastRead:
697+
return VGetFast();
698+
case NKikimrBlobStorage::Discover:
699+
return VGetDiscover();
700+
case NKikimrBlobStorage::LowRead:
701+
return VGetLow();
702+
}
681703
}
704+
const ::NMonitoring::TDeprecatedCounter &GetCounter(NKikimrBlobStorage::EPutHandleClass handleClass) const {
705+
switch (handleClass) {
706+
case NKikimrBlobStorage::TabletLog:
707+
return VPutTabletLog();
708+
case NKikimrBlobStorage::AsyncBlob:
709+
return VPutAsyncBlob();
710+
case NKikimrBlobStorage::UserData:
711+
return VPutUserData();
712+
}
713+
}
714+
};
715+
716+
///////////////////////////////////////////////////////////////////////////////////
717+
// TResponseStatusGroup
718+
///////////////////////////////////////////////////////////////////////////////////
719+
class TResponseStatusGroup {
720+
public:
721+
TIntrusivePtr<::NMonitoring::TDynamicCounters> Group;
682722

683-
COUNTER_DEF(ResponsesWithStatusError);
684-
COUNTER_DEF(ResponsesWithStatusRace);
685-
COUNTER_DEF(ResponsesWithStatusBlocked);
686-
COUNTER_DEF(ResponsesWithStatusOutOfSpace);
687-
COUNTER_DEF(ResponsesWithStatusDeadline);
688-
COUNTER_DEF(ResponsesWithStatusNotReady);
689-
COUNTER_DEF(ResponsesWithStatusVdiskErrorState);
723+
THandleClassGroup ResponsesWithStatusError;
724+
THandleClassGroup ResponsesWithStatusRace;
725+
THandleClassGroup ResponsesWithStatusBlocked;
726+
THandleClassGroup ResponsesWithStatusOutOfSpace;
727+
THandleClassGroup ResponsesWithStatusDeadline;
728+
THandleClassGroup ResponsesWithStatusNotReady;
729+
THandleClassGroup ResponsesWithStatusVdiskErrorState;
730+
731+
TResponseStatusGroup(const TIntrusivePtr<::NMonitoring::TDynamicCounters>& counters)
732+
: Group(counters->GetSubgroup("subsystem", "statuses"))
733+
, ResponsesWithStatusError(Group, "status", "ERROR")
734+
, ResponsesWithStatusRace(Group, "status", "RACE")
735+
, ResponsesWithStatusBlocked(Group, "status", "BLOCKED")
736+
, ResponsesWithStatusOutOfSpace(Group, "status", "OUT_OF_SPACE")
737+
, ResponsesWithStatusDeadline(Group, "status", "DEADLINE")
738+
, ResponsesWithStatusNotReady(Group, "status", "NOT_READY")
739+
, ResponsesWithStatusVdiskErrorState(Group, "status", "VDISK_STATUS_ERROR")
740+
{}
741+
742+
template <typename THandleClassType>
743+
const ::NMonitoring::TDeprecatedCounter &GetCounter(NKikimrProto::EReplyStatus status, THandleClassType handleClass) const {
744+
switch (status) {
745+
case NKikimrProto::ERROR:
746+
return ResponsesWithStatusError.GetCounter(handleClass);
747+
case NKikimrProto::RACE:
748+
return ResponsesWithStatusRace.GetCounter(handleClass);
749+
case NKikimrProto::BLOCKED:
750+
return ResponsesWithStatusBlocked.GetCounter(handleClass);
751+
case NKikimrProto::OUT_OF_SPACE:
752+
return ResponsesWithStatusOutOfSpace.GetCounter(handleClass);
753+
case NKikimrProto::DEADLINE:
754+
return ResponsesWithStatusDeadline.GetCounter(handleClass);
755+
case NKikimrProto::NOTREADY:
756+
return ResponsesWithStatusNotReady.GetCounter(handleClass);
757+
case NKikimrProto::VDISK_ERROR_STATE:
758+
return ResponsesWithStatusVdiskErrorState.GetCounter(handleClass);
759+
default: break;
760+
}
761+
}
690762
};
691763

692764
///////////////////////////////////////////////////////////////////////////////////

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

Lines changed: 85 additions & 50 deletions
Original file line numberDiff line numberDiff line change
@@ -7,16 +7,10 @@
77
namespace NKikimr {
88

99
template <class TRecord>
10-
void ReportResponse(TRecord record, const TLogoBlobID& blobId, const TIntrusivePtr<TVDiskContext>& vCtx);
11-
12-
template <class TRecord>
13-
void ReportOSStatus(TRecord record, const TLogoBlobID& blobId, const TIntrusivePtr<TVDiskContext>& vCtx);
10+
void ReportResponse(const TRecord& record, const TIntrusivePtr<TVDiskContext>& vCtx);
1411
void LogOOSStatus(ui32 flags, const TLogoBlobID& blobId, const TString& vDiskLogPrefix, std::atomic<ui32>& curFlags);
1512
void UpdateMonOOSStatus(ui32 flags, const std::shared_ptr<NMonGroup::TOutOfSpaceGroup>& monGroup);
16-
17-
template <class TRecord>
18-
void ReportResponseStatus(TRecord record, const TLogoBlobID& blobId, const TIntrusivePtr<TVDiskContext>& vCtx);
19-
void UpdateMonResponseStatus(NKikimrProto::EReplyStatus status, const std::shared_ptr<NMonGroup::TResponseStatusGroup>& monGroup);
13+
void UpdateMonResponseStatus(NKikimrProto::EReplyStatus status, HandleClassType handleClass, const std::shared_ptr<NMonGroup::TResponseStatusGroup>& monGroup);
2014

2115
void SendVDiskResponse(const TActorContext &ctx, const TActorId &recipient, IEventBase *ev, ui64 cookie, const TIntrusivePtr<TVDiskContext>& vCtx) {
2216
ui32 channel = TInterconnectChannels::IC_BLOBSTORAGE;
@@ -28,20 +22,20 @@ void SendVDiskResponse(const TActorContext &ctx, const TActorId &recipient, IEve
2822

2923
void SendVDiskResponse(const TActorContext &ctx, const TActorId &recipient, IEventBase *ev, ui64 cookie, ui32 channel, const TIntrusivePtr<TVDiskContext>& vCtx) {
3024
if (vCtx) {
31-
switch(ev->Type()) {
32-
case TEvBlobStorage::TEvVPutResult::EventType: {
33-
TEvBlobStorage::TEvVPutResult* event = static_cast<TEvBlobStorage::TEvVPutResult *>(ev);
34-
ReportResponse(event->Record, LogoBlobIDFromLogoBlobID(event->Record.GetBlobID()), vCtx);
35-
break;
36-
}
37-
case TEvBlobStorage::TEvVMultiPutResult::EventType: {
38-
TEvBlobStorage::TEvVMultiPutResult *event = static_cast<TEvBlobStorage::TEvVMultiPutResult *>(ev);
39-
if (event->Record.ItemsSize() > 0) {
40-
const auto& item = event->Record.GetItems(0);
41-
ReportResponse(event->Record, LogoBlobIDFromLogoBlobID(item.GetBlobID()), vCtx);
42-
}
43-
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, vCtx); \
30+
break; \
4431
}
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
4539
}
4640
}
4741

@@ -76,43 +70,75 @@ void SendVDiskResponse(const TActorContext &ctx, const TActorId &recipient, IEve
7670
}
7771
}
7872

79-
template <class TRecord>
80-
void ReportResponse(TRecord record, const TLogoBlobID& blobId, const TIntrusivePtr<TVDiskContext>& vCtx) {
81-
ReportOSStatus(record, blobId, vCtx);
82-
ReportResponseStatus(record, blobId, vCtx);
83-
}
73+
template <typename T, typename Tuple>
74+
struct IsInTypes;
8475

85-
template <class TRecord>
86-
void ReportResponseStatus(TRecord record, const TLogoBlobID& blobId, const TIntrusivePtr<TVDiskContext>& vCtx) {
87-
UpdateMonResponseStatus(record.GetStatus(), vCtx->ResponseStatusMonGroup);
88-
}
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+
};
8980

90-
void UpdateMonResponseStatus(NKikimrProto::EReplyStatus status, const std::shared_ptr<NMonGroup::TResponseStatusGroup>& monGroup) {
91-
if (!monGroup) {
92-
return;
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 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 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 TIntrusivePtr<TVDiskContext>& vCtx) {
112+
UpdateMonResponseStatus(record.GetStatus(), record.GetHandleClass(), vCtx->ResponseStatusMonGroup);
93113
}
94114

95-
if (status == NKikimrProto::ERROR) {
96-
monGroup->ResponsesWithStatusError().Inc();
97-
} else if (status == NKikimrProto::RACE) {
98-
monGroup->ResponsesWithStatusRace().Inc();
99-
} else if (status == NKikimrProto::BLOCKED) {
100-
monGroup->ResponsesWithStatusBlocked().Inc();
101-
} else if (status == NKikimrProto::OUT_OF_SPACE) {
102-
monGroup->ResponsesWithStatusOutOfSpace().Inc();
103-
} else if (status == NKikimrProto::DEADLINE) {
104-
monGroup->ResponsesWithStatusDeadline().Inc();
105-
} else if (status == NKikimrProto::NOTREADY) {
106-
monGroup->ResponsesWithStatusNotReady().Inc();
107-
} else if (status == NKikimrProto::VDISK_ERROR_STATE) {
108-
monGroup->ResponsesWithStatusVdiskErrorState().Inc();
115+
template<>
116+
void Report(const NKikimrBlobStorage::TEvVMultiPutResult& record, const TIntrusivePtr<TVDiskContext>& vCtx) {
117+
for (const auto& item : record.GetItems()) {
118+
UpdateMonResponseStatus(item.GetStatus(), record.GetHandleClass(), vCtx->ResponseStatusMonGroup);
109119
}
110120
}
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 TIntrusivePtr<TVDiskContext>& vCtx) { \
127+
TReporting##NAME::Report(record, 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 TIntrusivePtr<TVDiskContext>& vCtx) {}
133+
134+
DEFUNE_REPORT(OSStatus)
135+
DEFUNE_REPORT(ResponseStatus)
136+
#undef DEFUNE_REPORT
111137

112138
template <class TRecord>
113-
void ReportOSStatus(TRecord record, const TLogoBlobID& blobId, const TIntrusivePtr<TVDiskContext>& vCtx) {
114-
LogOOSStatus(record.GetStatusFlags(), blobId, vCtx->VDiskLogPrefix, vCtx->CurrentOOSStatusFlag);
115-
UpdateMonOOSStatus(record.GetStatusFlags(), vCtx->OOSMonGroup);
139+
void ReportResponse(const TRecord& record, const TIntrusivePtr<TVDiskContext>& vCtx) {
140+
ReportOSStatus(record, vCtx);
141+
ReportResponseStatus(record, vCtx);
116142
}
117143

118144
void LogOOSStatus(ui32 flags, const TLogoBlobID& blobId, const TString& vDiskLogPrefix, std::atomic<ui32>& curFlags) {
@@ -157,4 +183,13 @@ void UpdateMonOOSStatus(ui32 flags, const std::shared_ptr<NMonGroup::TOutOfSpace
157183
}
158184
}
159185

186+
void UpdateMonResponseStatus(NKikimrProto::EReplyStatus status, HandleClassType handleClass,
187+
const std::shared_ptr<NMonGroup::TResponseStatusGroup>& monGroup) {
188+
if (!monGroup) {
189+
return;
190+
}
191+
192+
monGroup->GetCounter(status, handleClass).Inc();
193+
}
194+
160195
} //NKikimr

0 commit comments

Comments
 (0)