cps metrics has been reduced

12 files changed, 334 insertions, 216 deletions

diff --git a/ydb/core/yq/libs/control_plane_storage/control_plane_storage_counters.cpp b/ydb/core/yq/libs/control_plane_storage/control_plane_storage_counters.cpp
index a1d2aac5446..99e21544655 100644
--- a/ydb/core/yq/libs/control_plane_storage/control_plane_storage_counters.cpp
+++ b/ydb/core/yq/libs/control_plane_storage/control_plane_storage_counters.cpp
@@ -2,11 +2,22 @@
 
 namespace NYq {
 
-TRequestCounters::TRequestCounters(const TString& name)
+TRequestScopeCounters::TRequestScopeCounters(const TString& name)
     : Name(name) {}
 
-void TRequestCounters::Register(const ::NMonitoring::TDynamicCounterPtr& counters) {
-    auto requestCounters = counters->GetSubgroup("request", Name);
+void TRequestScopeCounters::Register(const ::NMonitoring::TDynamicCounterPtr& counters) {
+    auto requestCounters = counters->GetSubgroup("request_scope", Name);
+    InFly = requestCounters->GetCounter("InFly", false);
+    Ok = requestCounters->GetCounter("Ok", true);
+    Error = requestCounters->GetCounter("Error", true);
+    Retry = requestCounters->GetCounter("Retry", true);
+}
+
+TRequestCommonCounters::TRequestCommonCounters(const TString& name)
+    : Name(name) {}
+
+void TRequestCommonCounters::Register(const ::NMonitoring::TDynamicCounterPtr& counters) {
+    auto requestCounters = counters->GetSubgroup("request_common", Name);
     InFly = requestCounters->GetCounter("InFly", false);
     Ok = requestCounters->GetCounter("Ok", true);
     Error = requestCounters->GetCounter("Error", true);
@@ -17,11 +28,10 @@ void TRequestCounters::Register(const ::NMonitoring::TDynamicCounterPtr& counter
     Issues = requestCounters->GetSubgroup("subcomponent", "Issues");
 }
 
-NMonitoring::IHistogramCollectorPtr TRequestCounters::GetLatencyHistogramBuckets() {
+NMonitoring::IHistogramCollectorPtr TRequestCommonCounters::GetLatencyHistogramBuckets() {
     return NMonitoring::ExplicitHistogram({0, 1, 2, 5, 10, 20, 50, 100, 500, 1000, 2000, 5000, 10000, 30000, 50000, 500000});
 }
 
-
 TFinalStatusCounters::TFinalStatusCounters(const ::NMonitoring::TDynamicCounterPtr& counters) {
     auto subgroup = counters->GetSubgroup("subcomponent", "FinalStatus");
     Completed = subgroup->GetCounter("COMPLETED", true);
diff --git a/ydb/core/yq/libs/control_plane_storage/control_plane_storage_counters.h b/ydb/core/yq/libs/control_plane_storage/control_plane_storage_counters.h
index 066dead2685..2a688cb6f21 100644
--- a/ydb/core/yq/libs/control_plane_storage/control_plane_storage_counters.h
+++ b/ydb/core/yq/libs/control_plane_storage/control_plane_storage_counters.h
@@ -5,7 +5,21 @@
 
 namespace NYq {
 
-class TRequestCounters: public virtual TThrRefBase {
+class TRequestScopeCounters: public virtual TThrRefBase {
+public:
+    const TString Name;
+
+    ::NMonitoring::TDynamicCounters::TCounterPtr InFly;
+    ::NMonitoring::TDynamicCounters::TCounterPtr Ok;
+    ::NMonitoring::TDynamicCounters::TCounterPtr Error;
+    ::NMonitoring::TDynamicCounters::TCounterPtr Retry;
+
+    explicit TRequestScopeCounters(const TString& name);
+
+    void Register(const ::NMonitoring::TDynamicCounterPtr& counters);
+};
+
+class TRequestCommonCounters: public virtual TThrRefBase {
 public:
     const TString Name;
 
@@ -15,10 +29,10 @@ public:
     ::NMonitoring::TDynamicCounters::TCounterPtr Retry;
     ::NMonitoring::TDynamicCounters::TCounterPtr RequestBytes;
     ::NMonitoring::TDynamicCounters::TCounterPtr ResponseBytes;
-    NMonitoring::THistogramPtr LatencyMs;
+    ::NMonitoring::THistogramPtr LatencyMs;
     ::NMonitoring::TDynamicCounterPtr Issues;
 
-    explicit TRequestCounters(const TString& name);
+    explicit TRequestCommonCounters(const TString& name);
 
     void Register(const ::NMonitoring::TDynamicCounterPtr& counters);
 
diff --git a/ydb/core/yq/libs/control_plane_storage/internal/nodes_health_check.cpp b/ydb/core/yq/libs/control_plane_storage/internal/nodes_health_check.cpp
index fef2da81722..0c589ceb7e3 100644
--- a/ydb/core/yq/libs/control_plane_storage/internal/nodes_health_check.cpp
+++ b/ydb/core/yq/libs/control_plane_storage/internal/nodes_health_check.cpp
@@ -7,11 +7,11 @@ namespace NYq {
 void TYdbControlPlaneStorageActor::Handle(TEvControlPlaneStorage::TEvNodesHealthCheckRequest::TPtr& ev)
 {
     TInstant startTime = TInstant::Now();
-    TRequestCountersPtr requestCounters = Counters.GetCommonCounters(RTC_NODES_HEALTH_CHECK);
-    requestCounters->InFly->Inc();
+    TRequestCounters requestCounters{nullptr, Counters.GetCommonCounters(RTC_NODES_HEALTH_CHECK)};
+    requestCounters.IncInFly();
 
     const TEvControlPlaneStorage::TEvNodesHealthCheckRequest& event = *ev->Get();
-    requestCounters->RequestBytes->Add(event.GetByteSize());
+    requestCounters.Common->RequestBytes->Add(event.GetByteSize());
     const auto& request = event.Request;
     const TString tenant = request.tenant();
     const auto& node = request.node();
diff --git a/ydb/core/yq/libs/control_plane_storage/internal/rate_limiter_resources.cpp b/ydb/core/yq/libs/control_plane_storage/internal/rate_limiter_resources.cpp
index 750d349db38..00814c6a03c 100644
--- a/ydb/core/yq/libs/control_plane_storage/internal/rate_limiter_resources.cpp
+++ b/ydb/core/yq/libs/control_plane_storage/internal/rate_limiter_resources.cpp
@@ -45,7 +45,7 @@ class TRateLimiterRequestActor : public NActors::TActor<TDerived> {
 public:
     using TResponseEvent = TResponse;
 
-    TRateLimiterRequestActor(TInstant startTime, typename TRequest::TPtr&& ev, TRequestCountersPtr requestCounters, TDebugInfoPtr debugInfo)
+    TRateLimiterRequestActor(TInstant startTime, typename TRequest::TPtr&& ev, TRequestCounters requestCounters, TDebugInfoPtr debugInfo)
         : NActors::TActor<TDerived>(&TDerived::StateFunc)
         , Request(std::move(ev))
         , RequestCounters(std::move(requestCounters))
@@ -138,15 +138,15 @@ public:
     void SendResponseEventAndPassAway(std::unique_ptr<TResponse> event, bool success) {
         event->DebugInfo = std::move(DebugInfo);
 
-        RequestCounters->ResponseBytes->Add(event->GetByteSize());
-        RequestCounters->InFly->Dec();
+        RequestCounters.Common->ResponseBytes->Add(event->GetByteSize());
+        RequestCounters.IncInFly();
         if (success) {
-            RequestCounters->Ok->Inc();
+            RequestCounters.IncOk();
         } else {
-            RequestCounters->Error->Inc();
+            RequestCounters.IncError();
         }
         const TDuration duration = TInstant::Now() - StartTime;
-        RequestCounters->LatencyMs->Collect(duration.MilliSeconds());
+        RequestCounters.Common->LatencyMs->Collect(duration.MilliSeconds());
 
         TDerived::LwProbe(QueryId, duration, success);
 
@@ -157,7 +157,7 @@ public:
 
 protected:
     const typename TRequest::TPtr Request;
-    TRequestCountersPtr RequestCounters;
+    TRequestCounters RequestCounters;
     TDebugInfoPtr DebugInfo;
     const TString QueryId;
     const TString OwnerId;
@@ -272,9 +272,9 @@ const TString TRateLimiterDeleteRequest::RequestTypeName = "DeleteRateLimiterRes
 template <class TEventPtr, class TRequestActor, TYdbControlPlaneStorageActor::ERequestTypeCommon requestType>
 void TYdbControlPlaneStorageActor::HandleRateLimiterImpl(TEventPtr& ev) {
     const TInstant startTime = TInstant::Now();
-    TRequestCountersPtr requestCounters = Counters.GetCommonCounters(requestType);
-    requestCounters->InFly->Inc();
-    requestCounters->RequestBytes->Add(ev->Get()->GetByteSize());
+    TRequestCounters requestCounters{nullptr, Counters.GetCommonCounters(requestType)};
+    requestCounters.IncInFly();
+    requestCounters.Common->RequestBytes->Add(ev->Get()->GetByteSize());
 
     auto& request = ev->Get()->Request;
     const TString& queryId = request.query_id().value();
diff --git a/ydb/core/yq/libs/control_plane_storage/internal/task_get.cpp b/ydb/core/yq/libs/control_plane_storage/internal/task_get.cpp
index f6d749e91c0..f33261b49a4 100644
--- a/ydb/core/yq/libs/control_plane_storage/internal/task_get.cpp
+++ b/ydb/core/yq/libs/control_plane_storage/internal/task_get.cpp
@@ -204,8 +204,8 @@ TDuration ExtractLimit(const TTask& task) {
 void TYdbControlPlaneStorageActor::Handle(TEvControlPlaneStorage::TEvGetTaskRequest::TPtr& ev)
 {
     TInstant startTime = TInstant::Now();
-    TRequestCountersPtr requestCounters = Counters.GetCommonCounters(RTC_GET_TASK);
-    requestCounters->InFly->Inc();
+    TRequestCounters requestCounters{nullptr, Counters.GetCommonCounters(RTC_GET_TASK)};
+    requestCounters.IncInFly();
 
     auto& request = ev->Get()->Request;
     const TString owner = request.owner_id();
diff --git a/ydb/core/yq/libs/control_plane_storage/internal/task_ping.cpp b/ydb/core/yq/libs/control_plane_storage/internal/task_ping.cpp
index e103a2bad20..4cb71db428a 100644
--- a/ydb/core/yq/libs/control_plane_storage/internal/task_ping.cpp
+++ b/ydb/core/yq/libs/control_plane_storage/internal/task_ping.cpp
@@ -445,9 +445,9 @@ void TYdbControlPlaneStorageActor::Handle(TEvControlPlaneStorage::TEvPingTaskReq
     Fq::Private::PingTaskRequest& request = ev->Get()->Request;
     const TString cloudId = "";
     const TString scope = request.scope();
-    TRequestCountersPtr requestCounters = Counters.GetScopeCounters("" /*CloudId*/, scope, RTS_PING_TASK);
-    requestCounters->InFly->Inc();
-    requestCounters->RequestBytes->Add(ev->Get()->GetByteSize());
+    TRequestCounters requestCounters = Counters.GetCounters("" /*CloudId*/, scope, RTS_PING_TASK, RTC_PING_TASK);
+    requestCounters.IncInFly();
+    requestCounters.Common->RequestBytes->Add(ev->Get()->GetByteSize());
     const TString queryId = request.query_id().value();
     const TString owner = request.owner_id();
     const TInstant deadline = NProtoInterop::CastFromProto(request.deadline());
diff --git a/ydb/core/yq/libs/control_plane_storage/internal/task_result_write.cpp b/ydb/core/yq/libs/control_plane_storage/internal/task_result_write.cpp
index 7d822f4f471..c7cdbc37380 100644
--- a/ydb/core/yq/libs/control_plane_storage/internal/task_result_write.cpp
+++ b/ydb/core/yq/libs/control_plane_storage/internal/task_result_write.cpp
@@ -5,10 +5,10 @@ namespace NYq {
 void TYdbControlPlaneStorageActor::Handle(TEvControlPlaneStorage::TEvWriteResultDataRequest::TPtr& ev)
 {
     TInstant startTime = TInstant::Now();
-    TRequestCountersPtr requestCounters = Counters.GetCommonCounters(RTC_WRITE_RESULT_DATA);
-    requestCounters->InFly->Inc();
+    TRequestCounters requestCounters{nullptr, Counters.GetCommonCounters(RTC_WRITE_RESULT_DATA)};
+    requestCounters.IncInFly();
 
-    requestCounters->RequestBytes->Add(ev->Get()->GetByteSize());
+    requestCounters.Common->RequestBytes->Add(ev->Get()->GetByteSize());
     auto& request = ev->Get()->Request;
     const TString resultId = request.result_id().value();
     const int32_t resultSetId = request.result_set_id();
diff --git a/ydb/core/yq/libs/control_plane_storage/ydb_control_plane_storage.cpp b/ydb/core/yq/libs/control_plane_storage/ydb_control_plane_storage.cpp
index e26f3c44577..cab6faa2889 100644
--- a/ydb/core/yq/libs/control_plane_storage/ydb_control_plane_storage.cpp
+++ b/ydb/core/yq/libs/control_plane_storage/ydb_control_plane_storage.cpp
@@ -329,7 +329,7 @@ std::pair<TAsyncStatus, std::shared_ptr<TVector<NYdb::TResultSet>>> TYdbControlP
     NActors::TActorSystem* actorSystem,
     const TString& query,
     const NYdb::TParams& params,
-    const TRequestCountersPtr& requestCounters,
+    const TRequestCounters& requestCounters,
     TDebugInfoPtr debugInfo,
     TTxSettings transactionMode,
     bool retryOnTli)
@@ -337,9 +337,9 @@ std::pair<TAsyncStatus, std::shared_ptr<TVector<NYdb::TResultSet>>> TYdbControlP
     auto resultSet = std::make_shared<TVector<NYdb::TResultSet>>();
 
     std::shared_ptr<int> retryCount = std::make_shared<int>();
-    auto handler = [=](TSession& session) {
+    auto handler = [=, requestCounters=requestCounters](TSession& session) mutable {
         if (*retryCount != 0) {
-            requestCounters->Retry->Inc();
+            requestCounters.IncRetry();
         }
         ++(*retryCount);
         CollectDebugInfo(query, params, session, debugInfo);
@@ -406,7 +406,7 @@ TAsyncStatus TYdbControlPlaneStorageActor::Write(
     NActors::TActorSystem* actorSystem,
     const TString& query,
     const NYdb::TParams& params,
-    const TRequestCountersPtr& requestCounters,
+    const TRequestCounters& requestCounters,
     TDebugInfoPtr debugInfo,
     const TVector<TValidationQuery>& validators,
     TTxSettings transactionMode,
@@ -433,9 +433,9 @@ TAsyncStatus TYdbControlPlaneStorageActor::Write(
         });
     };
 
-    auto handler = [=] (TSession session) {
+    auto handler = [=, requestCounters=requestCounters] (TSession session) mutable {
         if (*retryCount != 0) {
-            requestCounters->Retry->Inc();
+            requestCounters.IncRetry();
         }
         ++(*retryCount);
         std::shared_ptr<bool> successFinish = std::make_shared<bool>();
@@ -468,7 +468,7 @@ TAsyncStatus TYdbControlPlaneStorageActor::Write(
 
 NThreading::TFuture<void> TYdbControlPlaneStorageActor::PickTask(
     const TPickTaskParams& taskParams,
-    const TRequestCountersPtr& requestCounters,
+    const TRequestCounters& requestCounters,
     TDebugInfoPtr debugInfo,
     std::shared_ptr<TResponseTasks> responseTasks,
     const TVector<TValidationQuery>& validators,
@@ -489,7 +489,7 @@ TAsyncStatus TYdbControlPlaneStorageActor::ReadModifyWrite(
     const TString& readQuery,
     const NYdb::TParams& readParams,
     const std::function<std::pair<TString, NYdb::TParams>(const TVector<NYdb::TResultSet>&)>& prepare,
-    const TRequestCountersPtr& requestCounters,
+    const TRequestCounters& requestCounters,
     TDebugInfoPtr debugInfo,
     const TVector<TValidationQuery>& validators,
     TTxSettings transactionMode,
@@ -569,9 +569,9 @@ TAsyncStatus TYdbControlPlaneStorageActor::ReadModifyWrite(
         });
     };
 
-    auto handler = [=] (TSession session) {
+    auto handler = [=, requestCounters=requestCounters] (TSession session) mutable {
         if (*retryCount != 0) {
-            requestCounters->Retry->Inc();
+            requestCounters.IncRetry();
         }
         ++(*retryCount);
 
diff --git a/ydb/core/yq/libs/control_plane_storage/ydb_control_plane_storage_bindings.cpp b/ydb/core/yq/libs/control_plane_storage/ydb_control_plane_storage_bindings.cpp
index 12cfefd822d..8f32943d7aa 100644
--- a/ydb/core/yq/libs/control_plane_storage/ydb_control_plane_storage_bindings.cpp
+++ b/ydb/core/yq/libs/control_plane_storage/ydb_control_plane_storage_bindings.cpp
@@ -14,9 +14,9 @@ void TYdbControlPlaneStorageActor::Handle(TEvControlPlaneStorage::TEvCreateBindi
     const TEvControlPlaneStorage::TEvCreateBindingRequest& event = *ev->Get();
     const TString cloudId = event.CloudId;
     const TString scope = event.Scope;
-    TRequestCountersPtr requestCounters = Counters.GetScopeCounters(cloudId, scope, RTS_CREATE_BINDING);
-    requestCounters->InFly->Inc();
-    requestCounters->RequestBytes->Add(event.GetByteSize());
+    TRequestCounters requestCounters = Counters.GetCounters(cloudId, scope, RTS_CREATE_BINDING, RTC_CREATE_BINDING);
+    requestCounters.IncInFly();
+    requestCounters.Common->RequestBytes->Add(event.GetByteSize());
     const TString user = event.User;
     const TString token = event.Token;
     TPermissions permissions = Config.Proto.GetEnablePermissions()
@@ -151,9 +151,9 @@ void TYdbControlPlaneStorageActor::Handle(TEvControlPlaneStorage::TEvListBinding
     const TEvControlPlaneStorage::TEvListBindingsRequest& event = *ev->Get();
     const TString cloudId = event.CloudId;
     const TString scope = event.Scope;
-    TRequestCountersPtr requestCounters = Counters.GetScopeCounters(cloudId, scope, RTS_LIST_BINDINGS);
-    requestCounters->InFly->Inc();
-    requestCounters->RequestBytes->Add(event.GetByteSize());
+    TRequestCounters requestCounters = Counters.GetCounters(cloudId, scope, RTS_LIST_BINDINGS, RTC_LIST_BINDINGS);
+    requestCounters.IncInFly();
+    requestCounters.Common->RequestBytes->Add(event.GetByteSize());
     const YandexQuery::ListBindingsRequest& request = event.Request;
     const TString user = event.User;
     const TString pageToken = request.page_token();
@@ -296,9 +296,9 @@ void TYdbControlPlaneStorageActor::Handle(TEvControlPlaneStorage::TEvDescribeBin
     const TEvControlPlaneStorage::TEvDescribeBindingRequest& event = *ev->Get();
     const TString cloudId = event.CloudId;
     const TString scope = event.Scope;
-    TRequestCountersPtr requestCounters = Counters.GetScopeCounters(cloudId, scope, RTS_DESCRIBE_BINDING);
-    requestCounters->InFly->Inc();
-    requestCounters->RequestBytes->Add(event.GetByteSize());
+    TRequestCounters requestCounters = Counters.GetCounters(cloudId, scope, RTS_DESCRIBE_BINDING, RTC_DESCRIBE_BINDING);
+    requestCounters.IncInFly();
+    requestCounters.Common->RequestBytes->Add(event.GetByteSize());
     const YandexQuery::DescribeBindingRequest& request = event.Request;
     const TString bindingId = request.binding_id();
     const TString user = event.User;
@@ -383,9 +383,9 @@ void TYdbControlPlaneStorageActor::Handle(TEvControlPlaneStorage::TEvModifyBindi
     const TEvControlPlaneStorage::TEvModifyBindingRequest& event = *ev->Get();
     const TString cloudId = event.CloudId;
     const TString scope = event.Scope;
-    TRequestCountersPtr requestCounters = Counters.GetScopeCounters(cloudId, scope, RTS_MODIFY_BINDING);
-    requestCounters->InFly->Inc();
-    requestCounters->RequestBytes->Add(event.GetByteSize());
+    TRequestCounters requestCounters = Counters.GetCounters(cloudId, scope, RTS_MODIFY_BINDING, RTC_MODIFY_BINDING);
+    requestCounters.IncInFly();
+    requestCounters.Common->RequestBytes->Add(event.GetByteSize());
     const YandexQuery::ModifyBindingRequest& request = event.Request;
     const TString bindingId = request.binding_id();
     const TString user = event.User;
@@ -580,9 +580,9 @@ void TYdbControlPlaneStorageActor::Handle(TEvControlPlaneStorage::TEvDeleteBindi
     const TEvControlPlaneStorage::TEvDeleteBindingRequest& event = *ev->Get();
     const TString cloudId = event.CloudId;
     const TString scope = event.Scope;
-    TRequestCountersPtr requestCounters = Counters.GetScopeCounters(cloudId, scope, RTS_DELETE_BINDING);
-    requestCounters->InFly->Inc();
-    requestCounters->RequestBytes->Add(event.GetByteSize());
+    TRequestCounters requestCounters = Counters.GetCounters(cloudId, scope, RTS_DELETE_BINDING, RTC_DELETE_BINDING);
+    requestCounters.IncInFly();
+    requestCounters.Common->RequestBytes->Add(event.GetByteSize());
     const YandexQuery::DeleteBindingRequest& request = event.Request;
     const TString user = event.User;
     const TString token = event.Token;
diff --git a/ydb/core/yq/libs/control_plane_storage/ydb_control_plane_storage_connections.cpp b/ydb/core/yq/libs/control_plane_storage/ydb_control_plane_storage_connections.cpp
index 822cf82f26a..e6915b8f4ae 100644
--- a/ydb/core/yq/libs/control_plane_storage/ydb_control_plane_storage_connections.cpp
+++ b/ydb/core/yq/libs/control_plane_storage/ydb_control_plane_storage_connections.cpp
@@ -16,9 +16,9 @@ void TYdbControlPlaneStorageActor::Handle(TEvControlPlaneStorage::TEvCreateConne
     const TEvControlPlaneStorage::TEvCreateConnectionRequest& event = *ev->Get();
     const TString cloudId = event.CloudId;
     const TString scope = event.Scope;
-    TRequestCountersPtr requestCounters = Counters.GetScopeCounters(cloudId, scope, RTS_CREATE_CONNECTION);
-    requestCounters->InFly->Inc();
-    requestCounters->RequestBytes->Add(event.GetByteSize());
+    TRequestCounters requestCounters = Counters.GetCounters(cloudId, scope, RTS_CREATE_CONNECTION, RTC_CREATE_CONNECTION);
+    requestCounters.IncInFly();
+    requestCounters.Common->RequestBytes->Add(event.GetByteSize());
     const YandexQuery::CreateConnectionRequest& request = event.Request;
     const TString user = event.User;
     const TString token = event.Token;
@@ -145,9 +145,9 @@ void TYdbControlPlaneStorageActor::Handle(TEvControlPlaneStorage::TEvListConnect
     const TEvControlPlaneStorage::TEvListConnectionsRequest& event = *ev->Get();
     const TString cloudId = event.CloudId;
     const TString scope = event.Scope;
-    TRequestCountersPtr requestCounters = Counters.GetScopeCounters(cloudId, scope, RTS_LIST_CONNECTIONS);
-    requestCounters->InFly->Inc();
-    requestCounters->RequestBytes->Add(event.GetByteSize());
+    TRequestCounters requestCounters = Counters.GetCounters(cloudId, scope, RTS_LIST_CONNECTIONS, RTC_LIST_CONNECTIONS);
+    requestCounters.IncInFly();
+    requestCounters.Common->RequestBytes->Add(event.GetByteSize());
     const YandexQuery::ListConnectionsRequest& request = event.Request;
 
     const TString user = event.User;
@@ -278,9 +278,9 @@ void TYdbControlPlaneStorageActor::Handle(TEvControlPlaneStorage::TEvDescribeCon
     const TEvControlPlaneStorage::TEvDescribeConnectionRequest& event = *ev->Get();
     const TString cloudId = event.CloudId;
     const TString scope = event.Scope;
-    TRequestCountersPtr requestCounters = Counters.GetScopeCounters(cloudId, scope, RTS_DESCRIBE_CONNECTION);
-    requestCounters->InFly->Inc();
-    requestCounters->RequestBytes->Add(event.GetByteSize());
+    TRequestCounters requestCounters = Counters.GetCounters(cloudId, scope, RTS_DESCRIBE_CONNECTION, RTC_DESCRIBE_CONNECTION);
+    requestCounters.IncInFly();
+    requestCounters.Common->RequestBytes->Add(event.GetByteSize());
     const YandexQuery::DescribeConnectionRequest& request = event.Request;
     const TString user = event.User;
     const TString connectionId = request.connection_id();
@@ -374,9 +374,9 @@ void TYdbControlPlaneStorageActor::Handle(TEvControlPlaneStorage::TEvModifyConne
     const TEvControlPlaneStorage::TEvModifyConnectionRequest& event = *ev->Get();
     const TString cloudId = event.CloudId;
     const TString scope = event.Scope;
-    TRequestCountersPtr requestCounters = Counters.GetScopeCounters(cloudId, scope, RTS_MODIFY_CONNECTION);
-    requestCounters->InFly->Inc();
-    requestCounters->RequestBytes->Add(event.GetByteSize());
+    TRequestCounters requestCounters = Counters.GetCounters(cloudId, scope, RTS_MODIFY_CONNECTION, RTC_MODIFY_CONNECTION);
+    requestCounters.IncInFly();
+    requestCounters.Common->RequestBytes->Add(event.GetByteSize());
     const TString user = event.User;
     const TString token = event.Token;
     TPermissions permissions = Config.Proto.GetEnablePermissions()
@@ -551,9 +551,9 @@ void TYdbControlPlaneStorageActor::Handle(TEvControlPlaneStorage::TEvDeleteConne
     const TEvControlPlaneStorage::TEvDeleteConnectionRequest& event = *ev->Get();
     const TString cloudId = event.CloudId;
     const TString scope = event.Scope;
-    TRequestCountersPtr requestCounters = Counters.GetScopeCounters(cloudId, scope, RTS_DELETE_CONNECTION);
-    requestCounters->InFly->Inc();
-    requestCounters->RequestBytes->Add(event.GetByteSize());
+    TRequestCounters requestCounters = Counters.GetCounters(cloudId, scope, RTS_DELETE_CONNECTION, RTC_DELETE_CONNECTION);
+    requestCounters.IncInFly();
+    requestCounters.Common->RequestBytes->Add(event.GetByteSize());
     const YandexQuery::DeleteConnectionRequest& request = event.Request;
 
     const TString user = event.User;
diff --git a/ydb/core/yq/libs/control_plane_storage/ydb_control_plane_storage_impl.h b/ydb/core/yq/libs/control_plane_storage/ydb_control_plane_storage_impl.h
index 0c08f7235fb..ce7e71f31b4 100644
--- a/ydb/core/yq/libs/control_plane_storage/ydb_control_plane_storage_impl.h
+++ b/ydb/core/yq/libs/control_plane_storage/ydb_control_plane_storage_impl.h
@@ -93,74 +93,122 @@ TAsyncStatus ExecDbRequest(TDbPool::TPtr dbPool, std::function<NYdb::TAsyncStatu
 
 LWTRACE_USING(YQ_CONTROL_PLANE_STORAGE_PROVIDER);
 
-using TRequestCountersPtr = TIntrusivePtr<TRequestCounters>;
+using TRequestScopeCountersPtr = TIntrusivePtr<TRequestScopeCounters>;
+using TRequestCommonCountersPtr = TIntrusivePtr<TRequestCommonCounters>;
 
-    template<typename T>
-    THashMap<TString, T> GetEntitiesWithVisibilityPriority(const TResultSet& resultSet, const TString& columnName)
-    {
-        THashMap<TString, T> entities;
-        TResultSetParser parser(resultSet);
-        while (parser.TryNextRow()) {
-            T entity;
-            Y_VERIFY(entity.ParseFromString(*parser.ColumnParser(columnName).GetOptionalString()));
-            const TString name = entity.content().name();
-            if (auto it = entities.find(name); it != entities.end()) {
-                const auto visibility = entity.content().acl().visibility();
-                if (visibility == YandexQuery::Acl::PRIVATE) {
-                    entities[name] = std::move(entity);
-                }
-            } else {
-                entities[name] = std::move(entity);
-            }
+struct TRequestCounters {
+    TRequestScopeCountersPtr Scope;
+    TRequestCommonCountersPtr Common;
+
+    void IncInFly() {
+        if (Scope) {
+            Scope->InFly->Inc();
+        }
+        if (Common) {
+            Common->InFly->Inc();
         }
+    }
 
-        return entities;
+    void DecInFly() {
+        if (Scope) {
+            Scope->InFly->Inc();
+        }
+        if (Common) {
+            Common->InFly->Inc();
+        }
     }
 
-    template<typename T>
-    TVector<T> GetEntities(const TResultSet& resultSet, const TString& columnName)
-    {
-        TVector<T> entities;
-        TResultSetParser parser(resultSet);
-        while (parser.TryNextRow()) {
-            Y_VERIFY(entities.emplace_back().ParseFromString(*parser.ColumnParser(columnName).GetOptionalString()));
+    void IncOk() {
+        if (Scope) {
+            Scope->Ok->Inc();
+        }
+        if (Common) {
+            Common->Ok->Inc();
         }
-        return entities;
     }
 
-void InsertIdempotencyKey(TSqlQueryBuilder& builder, const TString& scope, const TString& idempotencyKey, const TString& response, const TInstant& expireAt);
+    void DecOk() {
+        if (Scope) {
+            Scope->Ok->Inc();
+        }
+        if (Common) {
+            Common->Ok->Inc();
+        }
+    }
 
-void ReadIdempotencyKeyQuery(TSqlQueryBuilder& builder, const TString& scope, const TString& idempotencyKey);
+    void IncError() {
+        if (Scope) {
+            Scope->Error->Inc();
+        }
+        if (Common) {
+            Common->Error->Inc();
+        }
+    }
 
-class TRequestCountersScope {
-    TRequestCountersPtr Counters;
-public:
-    TRequestCountersScope(TRequestCountersPtr counters, ui64 requestSize) : Counters(counters) {
-        StartTime = TInstant::Now();
-        Counters->InFly->Inc();
-        Counters->RequestBytes->Add(requestSize);
+    void DecError() {
+        if (Scope) {
+            Scope->Error->Inc();
+        }
+        if (Common) {
+            Common->Error->Inc();
+        }
+    }
+
+    void IncRetry() {
+        if (Scope) {
+            Scope->Retry->Inc();
+        }
+        if (Common) {
+            Common->Retry->Inc();
+        }
+    }
+
+    void DecRetry() {
+        if (Scope) {
+            Scope->Retry->Inc();
+        }
+        if (Common) {
+            Common->Retry->Inc();
+        }
     }
+};
 
-    void Reply(const NYql::TIssues& issues, ui64 resultSize) {
-        Delta = TInstant::Now() - StartTime;
-        Counters->ResponseBytes->Add(resultSize);
-        Counters->InFly->Dec();
-        Counters->LatencyMs->Collect(Delta.MilliSeconds());
-        if (issues) {
-            Counters->Error->Inc();
-            for (const auto& issue : issues) {
-                NYql::WalkThroughIssues(issue, true, [&counters=Counters](const NYql::TIssue& err, ui16 level) {
-                    Y_UNUSED(level);
-                    counters->Issues->GetCounter(ToString(err.GetCode()), true)->Inc();
-                });
+template<typename T>
+THashMap<TString, T> GetEntitiesWithVisibilityPriority(const TResultSet& resultSet, const TString& columnName)
+{
+    THashMap<TString, T> entities;
+    TResultSetParser parser(resultSet);
+    while (parser.TryNextRow()) {
+        T entity;
+        Y_VERIFY(entity.ParseFromString(*parser.ColumnParser(columnName).GetOptionalString()));
+        const TString name = entity.content().name();
+        if (auto it = entities.find(name); it != entities.end()) {
+            const auto visibility = entity.content().acl().visibility();
+            if (visibility == YandexQuery::Acl::PRIVATE) {
+                entities[name] = std::move(entity);
             }
         } else {
-            Counters->Ok->Inc();
+            entities[name] = std::move(entity);
         }
     }
-    TInstant StartTime;
-    TDuration Delta;
-};
+
+    return entities;
+}
+
+template<typename T>
+TVector<T> GetEntities(const TResultSet& resultSet, const TString& columnName)
+{
+    TVector<T> entities;
+    TResultSetParser parser(resultSet);
+    while (parser.TryNextRow()) {
+        Y_VERIFY(entities.emplace_back().ParseFromString(*parser.ColumnParser(columnName).GetOptionalString()));
+    }
+    return entities;
+}
+
+void InsertIdempotencyKey(TSqlQueryBuilder& builder, const TString& scope, const TString& idempotencyKey, const TString& response, const TInstant& expireAt);
+
+void ReadIdempotencyKeyQuery(TSqlQueryBuilder& builder, const TString& scope, const TString& idempotencyKey);
 
 class TYdbControlPlaneStorageActor : public NActors::TActorBootstrapped<TYdbControlPlaneStorageActor> {
     enum ERequestTypeScope {
@@ -195,6 +243,27 @@ class TYdbControlPlaneStorageActor : public NActors::TActorBootstrapped<TYdbCont
         RTS_QUOTA_USAGE,
         RTC_CREATE_RATE_LIMITER_RESOURCE,
         RTC_DELETE_RATE_LIMITER_RESOURCE,
+        RTC_CREATE_QUERY,
+        RTC_LIST_QUERIES,
+        RTC_DESCRIBE_QUERY,
+        RTC_GET_QUERY_STATUS,
+        RTC_MODIFY_QUERY,
+        RTC_DELETE_QUERY,
+        RTC_CONTROL_QUERY,
+        RTC_GET_RESULT_DATA,
+        RTC_LIST_JOBS_DATA,
+        RTC_DESCRIBE_JOB,
+        RTC_CREATE_CONNECTION,
+        RTC_LIST_CONNECTIONS,
+        RTC_DESCRIBE_CONNECTION,
+        RTC_MODIFY_CONNECTION,
+        RTC_DELETE_CONNECTION,
+        RTC_CREATE_BINDING,
+        RTC_LIST_BINDINGS,
+        RTC_DESCRIBE_BINDING,
+        RTC_MODIFY_BINDING,
+        RTC_DELETE_BINDING,
+        RTC_PING_TASK,
         RTC_MAX,
     };
 
@@ -208,17 +277,38 @@ class TYdbControlPlaneStorageActor : public NActors::TActorBootstrapped<TYdbCont
             }
         };
 
-        using TScopeCounters = std::array<TRequestCountersPtr, RTS_MAX>;
+        using TScopeCounters = std::array<TRequestScopeCountersPtr, RTS_MAX>;
         using TScopeCountersPtr = std::shared_ptr<TScopeCounters>;
         using TFinalStatusCountersPtr = TIntrusivePtr<TFinalStatusCounters>;
 
-        std::array<TRequestCountersPtr, RTC_MAX> CommonRequests = CreateArray<RTC_MAX, TRequestCountersPtr>({
-            { MakeIntrusive<TRequestCounters>("WriteResultData") },
-            { MakeIntrusive<TRequestCounters>("GetTask") },
-            { MakeIntrusive<TRequestCounters>("NodesHealthCheck") },
-            { MakeIntrusive<TRequestCounters>("GetQuotaUsage") },
-            { MakeIntrusive<TRequestCounters>("CreateRateLimiterResource") },
-            { MakeIntrusive<TRequestCounters>("DeleteRateLimiterResource") },
+        std::array<TRequestCommonCountersPtr, RTC_MAX> CommonRequests = CreateArray<RTC_MAX, TRequestCommonCountersPtr>({
+            { MakeIntrusive<TRequestCommonCounters>("WriteResultData") },
+            { MakeIntrusive<TRequestCommonCounters>("GetTask") },
+            { MakeIntrusive<TRequestCommonCounters>("NodesHealthCheck") },
+            { MakeIntrusive<TRequestCommonCounters>("GetQuotaUsage") },
+            { MakeIntrusive<TRequestCommonCounters>("CreateRateLimiterResource") },
+            { MakeIntrusive<TRequestCommonCounters>("DeleteRateLimiterResource") },
+            { MakeIntrusive<TRequestCommonCounters>("CreateQuery") },
+            { MakeIntrusive<TRequestCommonCounters>("ListQueries") },
+            { MakeIntrusive<TRequestCommonCounters>("DescribeQuery") },
+            { MakeIntrusive<TRequestCommonCounters>("GetQueryStatus") },
+            { MakeIntrusive<TRequestCommonCounters>("ModifyQuery") },
+            { MakeIntrusive<TRequestCommonCounters>("DeleteQuery") },
+            { MakeIntrusive<TRequestCommonCounters>("ControlQuery") },
+            { MakeIntrusive<TRequestCommonCounters>("GetResultData") },
+            { MakeIntrusive<TRequestCommonCounters>("ListJobs") },
+            { MakeIntrusive<TRequestCommonCounters>("DescribeJob") },
+            { MakeIntrusive<TRequestCommonCounters>("CreateConnection") },
+            { MakeIntrusive<TRequestCommonCounters>("ListConnections") },
+            { MakeIntrusive<TRequestCommonCounters>("DescribeConnection") },
+            { MakeIntrusive<TRequestCommonCounters>("ModifyConnection") },
+            { MakeIntrusive<TRequestCommonCounters>("DeleteConnection") },
+            { MakeIntrusive<TRequestCommonCounters>("CreateBinding") },
+            { MakeIntrusive<TRequestCommonCounters>("ListBindings") },
+            { MakeIntrusive<TRequestCommonCounters>("DescribeBinding") },
+            { MakeIntrusive<TRequestCommonCounters>("ModifyBinding") },
+            { MakeIntrusive<TRequestCommonCounters>("DeleteBinding") },
+            { MakeIntrusive<TRequestCommonCounters>("PingTask") },
         });
 
         TMap<TMetricsScope, TScopeCountersPtr> ScopeCounters;
@@ -235,7 +325,11 @@ class TYdbControlPlaneStorageActor : public NActors::TActorBootstrapped<TYdbCont
             }
         }
 
-        TRequestCountersPtr GetCommonCounters(ERequestTypeCommon type) {
+        TRequestCounters GetCounters(const TString& cloudId, const TString& scope, ERequestTypeScope scopeType, ERequestTypeCommon commonType) {
+            return {GetScopeCounters(cloudId, scope, scopeType), GetCommonCounters(commonType)};
+        }
+
+        TRequestCommonCountersPtr GetCommonCounters(ERequestTypeCommon type) {
             return CommonRequests[type];
         }
 
@@ -255,35 +349,35 @@ class TYdbControlPlaneStorageActor : public NActors::TActorBootstrapped<TYdbCont
             return finalStatusCounters;
         }
 
-        TRequestCountersPtr GetScopeCounters(const TString& cloudId, const TString& scope, ERequestTypeScope type) {
+        TRequestScopeCountersPtr GetScopeCounters(const TString& cloudId, const TString& scope, ERequestTypeScope type) {
             TMetricsScope key{cloudId, scope};
             auto it = ScopeCounters.find(key);
             if (it != ScopeCounters.end()) {
                 return (*it->second)[type];
             }
 
-            auto scopeRequests = std::make_shared<TScopeCounters>(CreateArray<RTS_MAX, TRequestCountersPtr>({
-                { MakeIntrusive<TRequestCounters>("CreateQuery") },
-                { MakeIntrusive<TRequestCounters>("ListQueries") },
-                { MakeIntrusive<TRequestCounters>("DescribeQuery") },
-                { MakeIntrusive<TRequestCounters>("GetQueryStatus") },
-                { MakeIntrusive<TRequestCounters>("ModifyQuery") },
-                { MakeIntrusive<TRequestCounters>("DeleteQuery") },
-                { MakeIntrusive<TRequestCounters>("ControlQuery") },
-                { MakeIntrusive<TRequestCounters>("GetResultData") },
-                { MakeIntrusive<TRequestCounters>("ListJobs") },
-                { MakeIntrusive<TRequestCounters>("DescribeJob") },
-                { MakeIntrusive<TRequestCounters>("CreateConnection") },
-                { MakeIntrusive<TRequestCounters>("ListConnections") },
-                { MakeIntrusive<TRequestCounters>("DescribeConnection") },
-                { MakeIntrusive<TRequestCounters>("ModifyConnection") },
-                { MakeIntrusive<TRequestCounters>("DeleteConnection") },
-                { MakeIntrusive<TRequestCounters>("CreateBinding") },
-                { MakeIntrusive<TRequestCounters>("ListBindings") },
-                { MakeIntrusive<TRequestCounters>("DescribeBinding") },
-                { MakeIntrusive<TRequestCounters>("ModifyBinding") },
-                { MakeIntrusive<TRequestCounters>("DeleteBinding") },
-                { MakeIntrusive<TRequestCounters>("PingTask") },
+            auto scopeRequests = std::make_shared<TScopeCounters>(CreateArray<RTS_MAX, TRequestScopeCountersPtr>({
+                { MakeIntrusive<TRequestScopeCounters>("CreateQuery") },
+                { MakeIntrusive<TRequestScopeCounters>("ListQueries") },
+                { MakeIntrusive<TRequestScopeCounters>("DescribeQuery") },
+                { MakeIntrusive<TRequestScopeCounters>("GetQueryStatus") },
+                { MakeIntrusive<TRequestScopeCounters>("ModifyQuery") },
+                { MakeIntrusive<TRequestScopeCounters>("DeleteQuery") },
+                { MakeIntrusive<TRequestScopeCounters>("ControlQuery") },
+                { MakeIntrusive<TRequestScopeCounters>("GetResultData") },
+                { MakeIntrusive<TRequestScopeCounters>("ListJobs") },
+                { MakeIntrusive<TRequestScopeCounters>("DescribeJob") },
+                { MakeIntrusive<TRequestScopeCounters>("CreateConnection") },
+                { MakeIntrusive<TRequestScopeCounters>("ListConnections") },
+                { MakeIntrusive<TRequestScopeCounters>("DescribeConnection") },
+                { MakeIntrusive<TRequestScopeCounters>("ModifyConnection") },
+                { MakeIntrusive<TRequestScopeCounters>("DeleteConnection") },
+                { MakeIntrusive<TRequestScopeCounters>("CreateBinding") },
+                { MakeIntrusive<TRequestScopeCounters>("ListBindings") },
+                { MakeIntrusive<TRequestScopeCounters>("DescribeBinding") },
+                { MakeIntrusive<TRequestScopeCounters>("ModifyBinding") },
+                { MakeIntrusive<TRequestScopeCounters>("DeleteBinding") },
+                { MakeIntrusive<TRequestScopeCounters>("PingTask") },
             }));
 
             auto scopeCounters = (cloudId ? Counters->GetSubgroup("cloud_id", cloudId) : Counters)
@@ -472,7 +566,7 @@ private:
         NActors::TActorSystem* actorSystem,
         const TString& query,
         const NYdb::TParams& params,
-        const TRequestCountersPtr& requestCounters,
+        const TRequestCounters& requestCounters,
         TDebugInfoPtr debugInfo,
         TTxSettings transactionMode = TTxSettings::SerializableRW(),
         bool retryOnTli = true);
@@ -490,7 +584,7 @@ private:
         NActors::TActorSystem* actorSystem,
         const TString& query,
         const NYdb::TParams& params,
-        const TRequestCountersPtr& requestCounters,
+        const TRequestCounters& requestCounters,
         TDebugInfoPtr debugInfo,
         const TVector<TValidationQuery>& validators = {},
         TTxSettings transactionMode = TTxSettings::SerializableRW(),
@@ -501,7 +595,7 @@ private:
         const TString& readQuery,
         const NYdb::TParams& readParams,
         const std::function<std::pair<TString, NYdb::TParams>(const TVector<NYdb::TResultSet>&)>& prepare,
-        const TRequestCountersPtr& requestCounters,
+        const TRequestCounters& requestCounters,
         TDebugInfoPtr debugInfo = {},
         const TVector<TValidationQuery>& validators = {},
         TTxSettings transactionMode = TTxSettings::SerializableRW(),
@@ -514,11 +608,11 @@ private:
         TActorId self,
         const RequestEventPtr& ev,
         const TInstant& startTime,
-        const TRequestCountersPtr& requestCounters,
+        const TRequestCounters& requestCounters,
         const std::function<Result()>& prepare,
         TDebugInfoPtr debugInfo)
     {
-        return status.Apply([=](const auto& future) {
+        return status.Apply([=, requestCounters=requestCounters](const auto& future) mutable {
             NYql::TIssues internalIssues;
             NYql::TIssues issues;
             Result result;
@@ -556,11 +650,11 @@ private:
                 event->DebugInfo = debugInfo;
                 responseByteSize = event->GetByteSize();
                 actorSystem->Send(new IEventHandle(ev->Sender, self, event.release(), 0, ev->Cookie));
-                requestCounters->Error->Inc();
+                requestCounters.IncError();
                 for (const auto& issue : issues) {
                     NYql::WalkThroughIssues(issue, true, [&requestCounters](const NYql::TIssue& err, ui16 level) {
                       Y_UNUSED(level);
-                      requestCounters->Issues->GetCounter(ToString(err.GetCode()), true)->Inc();
+                      requestCounters.Common->Issues->GetCounter(ToString(err.GetCode()), true)->Inc();
                     });
                 }
             } else {
@@ -569,12 +663,12 @@ private:
                 event->DebugInfo = debugInfo;
                 responseByteSize = event->GetByteSize();
                 actorSystem->Send(new IEventHandle(ev->Sender, self, event.release(), 0, ev->Cookie));
-                requestCounters->Ok->Inc();
+                requestCounters.IncOk();
             }
-            requestCounters->InFly->Dec();
-            requestCounters->ResponseBytes->Add(responseByteSize);
+            requestCounters.IncInFly();
+            requestCounters.Common->ResponseBytes->Add(responseByteSize);
             TDuration delta = TInstant::Now() - startTime;
-            requestCounters->LatencyMs->Collect(delta.MilliSeconds());
+            requestCounters.Common->LatencyMs->Collect(delta.MilliSeconds());
             return MakeFuture(!issues);
         });
     }
@@ -586,11 +680,11 @@ private:
         TActorId self,
         const RequestEventPtr& ev,
         const TInstant& startTime,
-        const TRequestCountersPtr& requestCounters,
+        const TRequestCounters& requestCounters,
         const std::function<std::pair<Result, AuditDetails>()>& prepare,
         TDebugInfoPtr debugInfo)
     {
-        return status.Apply([=](const auto& future) {
+        return status.Apply([=, requestCounters=requestCounters](const auto& future) mutable {
             NYql::TIssues internalIssues;
             NYql::TIssues issues;
             Result result;
@@ -631,11 +725,11 @@ private:
                 event->DebugInfo = debugInfo;
                 responseByteSize = event->GetByteSize();
                 actorSystem->Send(new IEventHandle(ev->Sender, self, event.release(), 0, ev->Cookie));
-                requestCounters->Error->Inc();
+                requestCounters.IncError();
                 for (const auto& issue : issues) {
                     NYql::WalkThroughIssues(issue, true, [&requestCounters](const NYql::TIssue& err, ui16 level) {
                       Y_UNUSED(level);
-                      requestCounters->Issues->GetCounter(ToString(err.GetCode()), true)->Inc();
+                      requestCounters.Common->Issues->GetCounter(ToString(err.GetCode()), true)->Inc();
                     });
                 }
             } else {
@@ -644,12 +738,12 @@ private:
                 event->DebugInfo = debugInfo;
                 responseByteSize = event->GetByteSize();
                 actorSystem->Send(new IEventHandle(ev->Sender, self, event.release(), 0, ev->Cookie));
-                requestCounters->Ok->Inc();
+                requestCounters.IncOk();
             }
-            requestCounters->InFly->Dec();
-            requestCounters->ResponseBytes->Add(responseByteSize);
+            requestCounters.DecInFly();
+            requestCounters.Common->ResponseBytes->Add(responseByteSize);
             TDuration delta = TInstant::Now() - startTime;
-            requestCounters->LatencyMs->Collect(delta.MilliSeconds());
+            requestCounters.Common->LatencyMs->Collect(delta.MilliSeconds());
             return MakeFuture(!issues);
         });
     }
@@ -661,11 +755,11 @@ private:
         TActorId self,
         const RequestEventPtr& ev,
         const TInstant& startTime,
-        const TRequestCountersPtr& requestCounters,
+        const TRequestCounters& requestCounters,
         const std::function<Result()>& prepare,
         TDebugInfoPtr debugInfo)
     {
-        return status.Apply([=](const auto& future) {
+        return status.Apply([=, requestCounters=requestCounters](const auto& future) mutable {
             NYql::TIssues internalIssues;
             NYql::TIssues issues;
             Result result;
@@ -701,11 +795,11 @@ private:
                 event->DebugInfo = debugInfo;
                 responseByteSize = event->GetByteSize();
                 actorSystem->Send(new IEventHandle(ev->Sender, self, event.release(), 0, ev->Cookie));
-                requestCounters->Error->Inc();
+                requestCounters.IncError();
                 for (const auto& issue : issues) {
                     NYql::WalkThroughIssues(issue, true, [&requestCounters](const NYql::TIssue& err, ui16 level) {
                       Y_UNUSED(level);
-                      requestCounters->Issues->GetCounter(ToString(err.GetCode()), true)->Inc();
+                      requestCounters.Common->Issues->GetCounter(ToString(err.GetCode()), true)->Inc();
                     });
                 }
             } else {
@@ -714,12 +808,12 @@ private:
                 event->DebugInfo = debugInfo;
                 responseByteSize = event->GetByteSize();
                 actorSystem->Send(new IEventHandle(ev->Sender, self, event.release(), 0, ev->Cookie));
-                requestCounters->Ok->Inc();
+                requestCounters.IncOk();
             }
-            requestCounters->InFly->Dec();
-            requestCounters->ResponseBytes->Add(responseByteSize);
+            requestCounters.IncInFly();
+            requestCounters.Common->ResponseBytes->Add(responseByteSize);
             TDuration delta = TInstant::Now() - startTime;
-            requestCounters->LatencyMs->Collect(delta.MilliSeconds());
+            requestCounters.Common->LatencyMs->Collect(delta.MilliSeconds());
             return MakeFuture(!issues);
         });
     }
@@ -729,13 +823,13 @@ private:
                             const NYql::TIssues& issues,
                             ui64 cookie,
                             const TDuration& delta,
-                            const TRequestCountersPtr& requestCounters) {
+                            TRequestCounters requestCounters) {
         std::unique_ptr<T> event(new T{issues});
-        requestCounters->ResponseBytes->Add(event->GetByteSize());
+        requestCounters.Common->ResponseBytes->Add(event->GetByteSize());
         Send(sender, event.release(), 0, cookie);
-        requestCounters->InFly->Dec();
-        requestCounters->Error->Inc();
-        requestCounters->LatencyMs->Collect(delta.MilliSeconds());
+        requestCounters.DecInFly();
+        requestCounters.IncError();
+        requestCounters.Common->LatencyMs->Collect(delta.MilliSeconds());
     }
 
     static YandexQuery::CommonMeta CreateCommonMeta(const TString& id, const TString& user, const TInstant& startTime, int64_t revision) {
@@ -772,7 +866,7 @@ private:
 
     NThreading::TFuture<void> PickTask(
         const TPickTaskParams& taskParams,
-        const TRequestCountersPtr& requestCounters,
+        const TRequestCounters& requestCounters,
         TDebugInfoPtr debugInfo,
         std::shared_ptr<TResponseTasks> responseTasks,
         const TVector<TValidationQuery>& validators = {},
diff --git a/ydb/core/yq/libs/control_plane_storage/ydb_control_plane_storage_queries.cpp b/ydb/core/yq/libs/control_plane_storage/ydb_control_plane_storage_queries.cpp
index a431b8945f0..a7d06d8f7b0 100644
--- a/ydb/core/yq/libs/control_plane_storage/ydb_control_plane_storage_queries.cpp
+++ b/ydb/core/yq/libs/control_plane_storage/ydb_control_plane_storage_queries.cpp
@@ -97,9 +97,9 @@ void TYdbControlPlaneStorageActor::Handle(TEvControlPlaneStorage::TEvCreateQuery
         }
     }
     const TString scope = event.Scope;
-    TRequestCountersPtr requestCounters = Counters.GetScopeCounters(cloudId, scope, RTS_CREATE_QUERY);
-    requestCounters->InFly->Inc();
-    requestCounters->RequestBytes->Add(event.GetByteSize());
+    TRequestCounters requestCounters = Counters.GetCounters(cloudId, scope, RTS_CREATE_QUERY, RTC_CREATE_QUERY);
+    requestCounters.IncInFly();
+    requestCounters.Common->RequestBytes->Add(event.GetByteSize());
     const TString user = event.User;
     const TString token = event.Token;
     TPermissions permissions = Config.Proto.GetEnablePermissions()
@@ -368,9 +368,9 @@ void TYdbControlPlaneStorageActor::Handle(TEvControlPlaneStorage::TEvListQueries
     const TEvControlPlaneStorage::TEvListQueriesRequest& event = *ev->Get();
     const TString cloudId = event.CloudId;
     const TString scope = event.Scope;
-    TRequestCountersPtr requestCounters = Counters.GetScopeCounters(cloudId, scope, RTS_LIST_QUERIES);
-    requestCounters->InFly->Inc();
-    requestCounters->RequestBytes->Add(event.GetByteSize());
+    TRequestCounters requestCounters = Counters.GetCounters(cloudId, scope, RTS_LIST_QUERIES, RTC_LIST_QUERIES);
+    requestCounters.IncInFly();
+    requestCounters.Common->RequestBytes->Add(event.GetByteSize());
 
     const TString user = event.User;
     const TString token = event.Token;
@@ -533,9 +533,9 @@ void TYdbControlPlaneStorageActor::Handle(TEvControlPlaneStorage::TEvDescribeQue
     const TEvControlPlaneStorage::TEvDescribeQueryRequest& event = *ev->Get();
     const TString cloudId = event.CloudId;
     const TString scope = event.Scope;
-    TRequestCountersPtr requestCounters = Counters.GetScopeCounters(cloudId, scope, RTS_DESCRIBE_QUERY);
-    requestCounters->InFly->Inc();
-    requestCounters->RequestBytes->Add(event.GetByteSize());
+    TRequestCounters requestCounters = Counters.GetCounters(cloudId, scope, RTS_DESCRIBE_QUERY, RTC_DESCRIBE_QUERY);
+    requestCounters.IncInFly();
+    requestCounters.Common->RequestBytes->Add(event.GetByteSize());
     const TString user = event.User;
     const TString token = event.Token;
     TPermissions permissions = Config.Proto.GetEnablePermissions()
@@ -656,9 +656,9 @@ void TYdbControlPlaneStorageActor::Handle(TEvControlPlaneStorage::TEvGetQuerySta
     const TEvControlPlaneStorage::TEvGetQueryStatusRequest& event = *ev->Get();
     const TString cloudId = event.CloudId;
     const TString scope = event.Scope;
-    TRequestCountersPtr requestCounters = Counters.GetScopeCounters(cloudId, scope, RTS_GET_QUERY_STATUS);
-    requestCounters->InFly->Inc();
-    requestCounters->RequestBytes->Add(event.GetByteSize());
+    TRequestCounters requestCounters = Counters.GetCounters(cloudId, scope, RTS_GET_QUERY_STATUS, RTC_GET_QUERY_STATUS);
+    requestCounters.IncInFly();
+    requestCounters.Common->RequestBytes->Add(event.GetByteSize());
     const TString user = event.User;
     const TString token = event.Token;
     TPermissions permissions = Config.Proto.GetEnablePermissions()
@@ -741,9 +741,9 @@ void TYdbControlPlaneStorageActor::Handle(TEvControlPlaneStorage::TEvModifyQuery
     TEvControlPlaneStorage::TEvModifyQueryRequest& event = *ev->Get();
     const TString cloudId = event.CloudId;
     const TString scope = event.Scope;
-    TRequestCountersPtr requestCounters = Counters.GetScopeCounters(cloudId, scope, RTS_MODIFY_QUERY);
-    requestCounters->InFly->Inc();
-    requestCounters->RequestBytes->Add(event.GetByteSize());
+    TRequestCounters requestCounters = Counters.GetCounters(cloudId, scope, RTS_MODIFY_QUERY, RTC_MODIFY_QUERY);
+    requestCounters.IncInFly();
+    requestCounters.Common->RequestBytes->Add(event.GetByteSize());
     const TString user = event.User;
     const TString token = event.Token;
     TPermissions permissions = Config.Proto.GetEnablePermissions()
@@ -1123,9 +1123,9 @@ void TYdbControlPlaneStorageActor::Handle(TEvControlPlaneStorage::TEvDeleteQuery
     const TEvControlPlaneStorage::TEvDeleteQueryRequest& event = *ev->Get();
     const TString cloudId = event.CloudId;
     const TString scope = event.Scope;
-    TRequestCountersPtr requestCounters = Counters.GetScopeCounters(cloudId, scope, RTS_DELETE_QUERY);
-    requestCounters->InFly->Inc();
-    requestCounters->RequestBytes->Add(event.GetByteSize());
+    TRequestCounters requestCounters = Counters.GetCounters(cloudId, scope, RTS_DELETE_QUERY, RTC_DELETE_QUERY);
+    requestCounters.IncInFly();
+    requestCounters.Common->RequestBytes->Add(event.GetByteSize());
     const TString user = event.User;
     const TString token = event.Token;
     TPermissions permissions = Config.Proto.GetEnablePermissions()
@@ -1238,9 +1238,9 @@ void TYdbControlPlaneStorageActor::Handle(TEvControlPlaneStorage::TEvControlQuer
     const TEvControlPlaneStorage::TEvControlQueryRequest& event = *ev->Get();
     const TString cloudId = event.CloudId;
     const TString scope = event.Scope;
-    TRequestCountersPtr requestCounters = Counters.GetScopeCounters(cloudId, scope, RTS_CONTROL_QUERY);
-    requestCounters->InFly->Inc();
-    requestCounters->RequestBytes->Add(event.GetByteSize());
+    TRequestCounters requestCounters = Counters.GetCounters(cloudId, scope, RTS_CONTROL_QUERY, RTC_CONTROL_QUERY);
+    requestCounters.IncInFly();
+    requestCounters.Common->RequestBytes->Add(event.GetByteSize());
     const YandexQuery::ControlQueryRequest& request = event.Request;
     const TString user = event.User;
     const TString queryId = request.query_id();
@@ -1461,9 +1461,9 @@ void TYdbControlPlaneStorageActor::Handle(TEvControlPlaneStorage::TEvGetResultDa
     const TEvControlPlaneStorage::TEvGetResultDataRequest& event = *ev->Get();
     const TString cloudId = event.CloudId;
     const TString scope = event.Scope;
-    TRequestCountersPtr requestCounters = Counters.GetScopeCounters(cloudId, scope, RTS_GET_RESULT_DATA);
-    requestCounters->InFly->Inc();
-    requestCounters->RequestBytes->Add(event.GetByteSize());
+    TRequestCounters requestCounters = Counters.GetCounters(cloudId, scope, RTS_GET_RESULT_DATA, RTC_GET_RESULT_DATA);
+    requestCounters.IncInFly();
+    requestCounters.Common->RequestBytes->Add(event.GetByteSize());
 
     const YandexQuery::GetResultDataRequest& request = event.Request;
     const TString user = event.User;
@@ -1595,9 +1595,9 @@ void TYdbControlPlaneStorageActor::Handle(TEvControlPlaneStorage::TEvListJobsReq
     const TEvControlPlaneStorage::TEvListJobsRequest& event = *ev->Get();
     const TString cloudId = event.CloudId;
     const TString scope = event.Scope;
-    TRequestCountersPtr requestCounters = Counters.GetScopeCounters(cloudId, scope, RTS_LIST_JOBS_DATA);
-    requestCounters->InFly->Inc();
-    requestCounters->RequestBytes->Add(event.GetByteSize());
+    TRequestCounters requestCounters = Counters.GetCounters(cloudId, scope, RTS_LIST_JOBS_DATA, RTC_LIST_JOBS_DATA);
+    requestCounters.IncInFly();
+    requestCounters.Common->RequestBytes->Add(event.GetByteSize());
     const YandexQuery::ListJobsRequest& request = event.Request;
     const TString user = event.User;
     TString queryId = request.query_id(); // TODO: remove it
@@ -1727,9 +1727,9 @@ void TYdbControlPlaneStorageActor::Handle(TEvControlPlaneStorage::TEvDescribeJob
     const TEvControlPlaneStorage::TEvDescribeJobRequest& event = *ev->Get();
     const TString cloudId = event.CloudId;
     const TString scope = event.Scope;
-    TRequestCountersPtr requestCounters = Counters.GetScopeCounters(cloudId, scope, RTS_DESCRIBE_JOB);
-    requestCounters->InFly->Inc();
-    requestCounters->RequestBytes->Add(event.GetByteSize());
+    TRequestCounters requestCounters = Counters.GetCounters(cloudId, scope, RTS_DESCRIBE_JOB, RTC_DESCRIBE_JOB);
+    requestCounters.IncInFly();
+    requestCounters.Common->RequestBytes->Add(event.GetByteSize());
     const YandexQuery::DescribeJobRequest& request = event.Request;
 
     const TString user = event.User;