support per database grpc proxy counters KIKIMR-13269

ref:5537071be6e171b959e6328e77c9fa70a55a38d8

11 files changed, 410 insertions, 62 deletions

diff --git a/ydb/core/grpc_services/counters/CMakeLists.txt b/ydb/core/grpc_services/counters/CMakeLists.txt
index 31801fa6580..17c796752c6 100644
--- a/ydb/core/grpc_services/counters/CMakeLists.txt
+++ b/ydb/core/grpc_services/counters/CMakeLists.txt
@@ -20,4 +20,5 @@ target_link_libraries(core-grpc_services-counters PUBLIC
 )
 target_sources(core-grpc_services-counters PRIVATE
   ${CMAKE_SOURCE_DIR}/ydb/core/grpc_services/counters/counters.cpp
+  ${CMAKE_SOURCE_DIR}/ydb/core/grpc_services/counters/proxy_counters.cpp
 )
diff --git a/ydb/core/grpc_services/counters/proxy_counters.cpp b/ydb/core/grpc_services/counters/proxy_counters.cpp
new file mode 100644
index 00000000000..dc5b3e345d5
--- /dev/null
+++ b/ydb/core/grpc_services/counters/proxy_counters.cpp
@@ -0,0 +1,321 @@
+#include "proxy_counters.h"
+
+#include <ydb/core/base/counters.h>
+#include <ydb/core/sys_view/service/sysview_service.h>
+#include <ydb/core/sys_view/service/db_counters.h>
+#include <ydb/core/util/concurrent_rw_hash.h>
+
+#include <library/cpp/actors/core/actorsystem.h>
+
+namespace NKikimr {
+namespace NGRpcService {
+
+class TGRpcProxyCounters : public IGRpcProxyCounters {
+protected:
+    NMonitoring::TDynamicCounters::TCounterPtr DatabaseAccessDenyCounter_;
+    NMonitoring::TDynamicCounters::TCounterPtr DatabaseSchemeErrorCounter_;
+    NMonitoring::TDynamicCounters::TCounterPtr DatabaseUnavailableCounter_;
+    NMonitoring::TDynamicCounters::TCounterPtr DatabaseRateLimitedCounter_;
+    NMonitoring::TDynamicCounters::TCounterPtr ConsumedRUCounter_;
+    NMonitoring::THistogramPtr ThrottleDelayHistogram_;
+
+public:
+    using TPtr = TIntrusivePtr<TGRpcProxyCounters>;
+
+    TGRpcProxyCounters(NMonitoring::TDynamicCounterPtr counters, bool forDatabase) {
+        NMonitoring::TDynamicCounterPtr group;
+        if (forDatabase) {
+            group = counters->GetSubgroup("group", "grpc");
+        } else {
+            group = GetServiceCounters(counters, "grpc");
+        }
+
+        DatabaseAccessDenyCounter_ = group->GetCounter("databaseAccessDeny", true);
+        DatabaseSchemeErrorCounter_ = group->GetCounter("databaseSchemeError", true);
+        DatabaseUnavailableCounter_ = group->GetCounter("databaseUnavailable", true);
+
+        DatabaseRateLimitedCounter_ = group->GetCounter("api.grpc.request.throughput_quota_exceeded_count", true);
+
+        ConsumedRUCounter_ = group->GetCounter("api.grpc.response.consumed_request_units", true);
+
+        ThrottleDelayHistogram_ = group->GetHistogram(
+            "api.grpc.request.throttling_delay_milliseconds",
+            NMonitoring::ExponentialHistogram(20, 2, 1));
+    }
+
+    void IncDatabaseAccessDenyCounter() override {
+        DatabaseAccessDenyCounter_->Inc();
+    }
+
+    void IncDatabaseSchemeErrorCounter() override {
+        DatabaseSchemeErrorCounter_->Inc();
+    }
+
+    void IncDatabaseUnavailableCounter() override {
+        DatabaseUnavailableCounter_->Inc();
+    }
+
+    void IncDatabaseRateLimitedCounter() override {
+        DatabaseRateLimitedCounter_->Inc();
+    }
+
+    void AddConsumedRequestUnits(ui64 requestUnits) override {
+        ConsumedRUCounter_->Add(requestUnits);
+    }
+
+    void ReportThrottleDelay(const TDuration& duration) override {
+        ThrottleDelayHistogram_->Collect(duration.MilliSeconds());
+    }
+};
+
+
+#define DB_GRPC_PROXY_CUMULATIVE_COUNTERS_MAP(XX) \
+    XX(DB_GRPC_PROXY_ACCESS_DENY, DatabaseAccessDenyCounter_) \
+    XX(DB_GRPC_PROXY_SCHEME_ERROR, DatabaseSchemeErrorCounter_) \
+    XX(DB_GRPC_PROXY_UNAVAILABLE, DatabaseUnavailableCounter_) \
+    XX(DB_GRPC_PROXY_RATE_LIMITED, DatabaseRateLimitedCounter_) \
+    XX(DB_GRPC_PROXY_CONSUMED_RU, ConsumedRUCounter_)
+
+#define DB_GRPC_PROXY_HISTOGRAM_COUNTERS_MAP(XX) \
+    XX(DB_GRPC_PROXY_THROTTLE_DELAY, ThrottleDelayHistogram_)
+
+template <typename T>
+void SaveHistogram(T& histogram, int index, const NMonitoring::THistogramPtr& hgram) {
+    auto* buckets = histogram[index].MutableBuckets();
+    auto snapshot = hgram->Snapshot();
+    auto count = snapshot->Count();
+    buckets->Resize(count, 0);
+    for (size_t i = 0; i < count; ++i) {
+        (*buckets)[i] = snapshot->Value(i);
+    }
+}
+
+template <typename T>
+void LoadHistogram(T& histogram, int index, NMonitoring::THistogramPtr& hgram) {
+    auto* buckets = histogram[index].MutableBuckets();
+    auto snapshot = hgram->Snapshot();
+    auto count = snapshot->Count();
+    buckets->Resize(count, 0);
+    hgram->Reset();
+    for (ui32 i = 0; i < count; ++i) {
+        hgram->Collect(snapshot->UpperBound(i), (*buckets)[i]);
+    }
+}
+
+void AggregateHistogram(NMonitoring::THistogramPtr& dst, const NMonitoring::THistogramPtr& src) {
+    auto srcSnapshot = src->Snapshot();
+    auto srcCount = srcSnapshot->Count();
+    auto dstSnapshot = dst->Snapshot();
+    auto dstCount = dstSnapshot->Count();
+
+    for (ui32 b = 0; b < std::min(srcCount, dstCount); ++b) {
+        dst->Collect(dstSnapshot->UpperBound(b), srcSnapshot->Value(b));
+    }
+}
+
+class TGRpcProxyDbCounters : public TGRpcProxyCounters, public NSysView::IDbCounters {
+    enum ECumulativeCounter {
+        DB_GRPC_PROXY_CUMULATIVE_COUNTERS_MAP(ENUM_VALUE_GEN_NO_VALUE)
+        DB_GRPC_PROXY_CUMULATIVE_COUNTER_SIZE
+    };
+    enum EHistogramCounter {
+        DB_GRPC_PROXY_HISTOGRAM_COUNTERS_MAP(ENUM_VALUE_GEN_NO_VALUE)
+        DB_GRPC_PROXY_HISTOGRAM_COUNTER_SIZE
+    };
+
+public:
+    using TPtr = TIntrusivePtr<TGRpcProxyDbCounters>;
+
+    explicit TGRpcProxyDbCounters(NMonitoring::TDynamicCounterPtr counters)
+        : TGRpcProxyCounters(counters, true)
+    {}
+
+    void ToProto(NKikimr::NSysView::TDbServiceCounters& counters) override {
+        auto* grpc = counters.Proto().MutableGRpcProxyCounters();
+        auto* main = grpc->MutableRequestCounters();
+        auto* cumulative = main->MutableCumulative();
+        auto* histogram = main->MutableHistogram();
+
+        cumulative->Resize(DB_GRPC_PROXY_CUMULATIVE_COUNTER_SIZE, 0);
+        if (main->HistogramSize() < DB_GRPC_PROXY_HISTOGRAM_COUNTER_SIZE) {
+            auto missing = DB_GRPC_PROXY_HISTOGRAM_COUNTER_SIZE - main->HistogramSize();
+            for (; missing > 0; --missing) {
+                main->AddHistogram();
+            }
+        }
+
+#define SAVE_CUMULATIVE_COUNTER(INDEX, TARGET) { (*cumulative)[INDEX] = (TARGET)->Val(); }
+#define SAVE_HISTOGRAM_COUNTER(INDEX, TARGET) { SaveHistogram(*histogram, INDEX, (TARGET)); }
+
+        DB_GRPC_PROXY_CUMULATIVE_COUNTERS_MAP(SAVE_CUMULATIVE_COUNTER)
+        DB_GRPC_PROXY_HISTOGRAM_COUNTERS_MAP(SAVE_HISTOGRAM_COUNTER)
+    }
+
+    void FromProto(NKikimr::NSysView::TDbServiceCounters& counters) override {
+        auto* grpc = counters.Proto().MutableGRpcProxyCounters();
+        auto* main = grpc->MutableRequestCounters();
+        auto* cumulative = main->MutableCumulative();
+        auto* histogram = main->MutableHistogram();
+
+        cumulative->Resize(DB_GRPC_PROXY_CUMULATIVE_COUNTER_SIZE, 0);
+        if (main->HistogramSize() < DB_GRPC_PROXY_HISTOGRAM_COUNTER_SIZE) {
+            auto missing = DB_GRPC_PROXY_HISTOGRAM_COUNTER_SIZE - main->HistogramSize();
+            for (; missing > 0; --missing) {
+                main->AddHistogram();
+            }
+        }
+
+#define LOAD_CUMULATIVE_COUNTER(INDEX, TARGET) { (TARGET)->Set((*cumulative)[INDEX]); }
+#define LOAD_HISTOGRAM_COUNTER(INDEX, TARGET) { LoadHistogram(*histogram, INDEX, (TARGET)); }
+
+        DB_GRPC_PROXY_CUMULATIVE_COUNTERS_MAP(LOAD_CUMULATIVE_COUNTER)
+        DB_GRPC_PROXY_HISTOGRAM_COUNTERS_MAP(LOAD_HISTOGRAM_COUNTER)
+    }
+
+    void AggregateFrom(TGRpcProxyDbCounters& other) {
+#define AGGR_CUMULATIVE_COUNTER(INDEX, TARGET) { *TARGET += other.TARGET->Val(); }
+#define AGGR_HISTOGRAM_COUNTER(INDEX, TARGET) { AggregateHistogram(TARGET, other.TARGET); }
+
+        DB_GRPC_PROXY_CUMULATIVE_COUNTERS_MAP(AGGR_CUMULATIVE_COUNTER);
+        DB_GRPC_PROXY_HISTOGRAM_COUNTERS_MAP(AGGR_HISTOGRAM_COUNTER);
+    }
+};
+
+
+class TGRpcProxyDbCountersRegistry {
+    NMonitoring::TDynamicCounterPtr Root;
+    TConcurrentRWHashMap<TString, TGRpcProxyDbCounters::TPtr, 256> DbCounters;
+    TActorSystem* ActorSystem = {};
+    TActorId DbWatcherActorId;
+
+    class TGRpcProxyDbWatcherCallback : public NKikimr::NSysView::TDbWatcherCallback {
+    public:
+        void OnDatabaseRemoved(const TString& database, TPathId) override {
+            Singleton<TGRpcProxyDbCountersRegistry>()->RemoveDbProxyCounters(database);
+        }
+    };
+
+public:
+    TGRpcProxyDbCountersRegistry()
+        : Root(new NMonitoring::TDynamicCounters)
+    {}
+
+    void Initialize(TActorSystem* actorSystem) {
+        if (Y_LIKELY(ActorSystem)) {
+            return;
+        }
+        ActorSystem = actorSystem;
+
+        auto callback = MakeIntrusive<TGRpcProxyDbWatcherCallback>();
+        DbWatcherActorId = ActorSystem->Register(NSysView::CreateDbWatcherActor(callback));
+    }
+
+    TGRpcProxyDbCounters::TPtr GetDbProxyCounters(const TString& database) {
+        TGRpcProxyDbCounters::TPtr dbCounters;
+        if (DbCounters.Get(database, dbCounters)) {
+            return dbCounters;
+        }
+
+        dbCounters = DbCounters.InsertIfAbsentWithInit(database, [&database, this] {
+            auto counters = MakeIntrusive<TGRpcProxyDbCounters>(Root);
+
+            if (ActorSystem) {
+                auto evRegister = MakeHolder<NSysView::TEvSysView::TEvRegisterDbCounters>(
+                    NKikimrSysView::GRPC_PROXY, database, counters);
+
+                ActorSystem->Send(NSysView::MakeSysViewServiceID(ActorSystem->NodeId), evRegister.Release());
+
+                if (DbWatcherActorId) {
+                    auto evWatch = MakeHolder<NSysView::TEvSysView::TEvWatchDatabase>(database);
+                    ActorSystem->Send(DbWatcherActorId, evWatch.Release());
+                }
+            }
+
+            return counters;
+        });
+
+        return dbCounters;
+    }
+
+    void RemoveDbProxyCounters(const TString& database) {
+        DbCounters.Erase(database);
+    }
+};
+
+
+class TGRpcProxyCountersWrapper : public IGRpcProxyCounters {
+    IGRpcProxyCounters::TPtr Common;
+    NMonitoring::TDynamicCounterPtr Root;
+    TGRpcProxyDbCounters::TPtr Db;
+
+public:
+    explicit TGRpcProxyCountersWrapper(IGRpcProxyCounters::TPtr common)
+        : Common(common)
+        , Root(new NMonitoring::TDynamicCounters)
+        , Db(new TGRpcProxyDbCounters(Root))
+    {}
+
+    void IncDatabaseAccessDenyCounter() override {
+        Common->IncDatabaseAccessDenyCounter();
+        Db->IncDatabaseAccessDenyCounter();
+    }
+
+    void IncDatabaseSchemeErrorCounter() override {
+        Common->IncDatabaseSchemeErrorCounter();
+        Db->IncDatabaseSchemeErrorCounter();
+    }
+
+    void IncDatabaseUnavailableCounter() override {
+        Common->IncDatabaseUnavailableCounter();
+        Db->IncDatabaseUnavailableCounter();
+    }
+
+    void IncDatabaseRateLimitedCounter() override {
+        Common->IncDatabaseRateLimitedCounter();
+        Db->IncDatabaseRateLimitedCounter();
+    }
+
+    void AddConsumedRequestUnits(ui64 requestUnits) override {
+        Common->AddConsumedRequestUnits(requestUnits);
+        Db->AddConsumedRequestUnits(requestUnits);
+    }
+
+    void ReportThrottleDelay(const TDuration& duration) override {
+        Common->ReportThrottleDelay(duration);
+        Db->ReportThrottleDelay(duration);
+    }
+
+    void UseDatabase(const TString& database) override {
+        if (database.empty()) {
+            return;
+        }
+
+        auto counters = Singleton<TGRpcProxyDbCountersRegistry>()->GetDbProxyCounters(database);
+        counters->AggregateFrom(*Db);
+        Db = counters;
+    }
+};
+
+
+IGRpcProxyCounters::TPtr WrapGRpcProxyDbCounters(IGRpcProxyCounters::TPtr common) {
+    return MakeIntrusive<TGRpcProxyCountersWrapper>(common);
+}
+
+IGRpcProxyCounters::TPtr CreateGRpcProxyCounters(NMonitoring::TDynamicCounterPtr appCounters) {
+    return MakeIntrusive<TGRpcProxyCounters>(appCounters, false);
+}
+
+TIntrusivePtr<NSysView::IDbCounters> CreateGRpcProxyDbCounters(
+    NMonitoring::TDynamicCounterPtr externalGroup,
+    NMonitoring::TDynamicCounterPtr internalGroup)
+{
+    Y_UNUSED(externalGroup);
+    return MakeIntrusive<TGRpcProxyDbCounters>(internalGroup);
+}
+
+void InitializeGRpcProxyDbCountersRegistry(TActorSystem* actorSystem) {
+    Singleton<TGRpcProxyDbCountersRegistry>()->Initialize(actorSystem);
+}
+
+}
+}
diff --git a/ydb/core/grpc_services/counters/proxy_counters.h b/ydb/core/grpc_services/counters/proxy_counters.h
new file mode 100644
index 00000000000..27e6217465f
--- /dev/null
+++ b/ydb/core/grpc_services/counters/proxy_counters.h
@@ -0,0 +1,36 @@
+#pragma once
+
+#include <ydb/core/sys_view/common/events.h>
+
+#include <library/cpp/monlib/dynamic_counters/counters.h>
+
+namespace NKikimr {
+namespace NGRpcService {
+
+class IGRpcProxyCounters : public virtual TThrRefBase {
+public:
+    using TPtr = TIntrusivePtr<IGRpcProxyCounters>;
+
+    virtual void IncDatabaseAccessDenyCounter() = 0;
+    virtual void IncDatabaseSchemeErrorCounter() = 0;
+    virtual void IncDatabaseUnavailableCounter() = 0;
+    virtual void IncDatabaseRateLimitedCounter() = 0;
+
+    virtual void AddConsumedRequestUnits(ui64 requestUnits) = 0;
+    virtual void ReportThrottleDelay(const TDuration& duration) = 0;
+
+    virtual void UseDatabase(const TString& database) { Y_UNUSED(database); }
+};
+
+IGRpcProxyCounters::TPtr WrapGRpcProxyDbCounters(IGRpcProxyCounters::TPtr common);
+
+IGRpcProxyCounters::TPtr CreateGRpcProxyCounters(NMonitoring::TDynamicCounterPtr appCounters);
+
+TIntrusivePtr<NSysView::IDbCounters> CreateGRpcProxyDbCounters(
+    NMonitoring::TDynamicCounterPtr externalGroup,
+    NMonitoring::TDynamicCounterPtr internalGroup);
+
+void InitializeGRpcProxyDbCountersRegistry(TActorSystem* actorSystem);
+
+}
+}
diff --git a/ydb/core/grpc_services/grpc_proxy_counters.h b/ydb/core/grpc_services/grpc_proxy_counters.h
deleted file mode 100644
index 9d936f2ccec..00000000000
--- a/ydb/core/grpc_services/grpc_proxy_counters.h
+++ /dev/null
@@ -1,47 +0,0 @@
-#pragma once
-#include "defs.h"
-
-#include <library/cpp/monlib/dynamic_counters/counters.h>
-
-#include <ydb/core/base/counters.h>
-
-namespace NKikimr {
-namespace NGRpcService {
-
-class TGrpcProxyCounters : public TThrRefBase  {
-public:
-    using TPtr = TIntrusivePtr<TGrpcProxyCounters>;
-    explicit TGrpcProxyCounters(const TIntrusivePtr<NMonitoring::TDynamicCounters>& counters) {
-        auto group = GetServiceCounters(counters, "grpc");
-
-        DatabaseAccessDenyCounter_ = group->GetCounter("databaseAccessDeny", true);
-        DatabaseSchemeErrorCounter_ = group->GetCounter("databaseSchemeError", true);
-        DatabaseUnavailableCounter_ = group->GetCounter("databaseUnavailable", true);
-        DatabaseRateLimitedCounter_ = group->GetCounter("databaseRateLimited", true);
-    }
-
-    void IncDatabaseAccessDenyCounter() {
-        DatabaseAccessDenyCounter_->Inc();
-    }
-
-    void IncDatabaseSchemeErrorCounter() {
-        DatabaseSchemeErrorCounter_->Inc();
-    }
-
-    void IncDatabaseUnavailableCounter() {
-        DatabaseUnavailableCounter_->Inc();
-    }
-
-    void IncDatabaseRateLimitedCounter() {
-        DatabaseRateLimitedCounter_->Inc();
-    }
-
-private:
-    NMonitoring::TDynamicCounters::TCounterPtr DatabaseAccessDenyCounter_;
-    NMonitoring::TDynamicCounters::TCounterPtr DatabaseSchemeErrorCounter_;
-    NMonitoring::TDynamicCounters::TCounterPtr DatabaseUnavailableCounter_;
-    NMonitoring::TDynamicCounters::TCounterPtr DatabaseRateLimitedCounter_;
-};
-
-}
-}
diff --git a/ydb/core/grpc_services/grpc_request_check_actor.h b/ydb/core/grpc_services/grpc_request_check_actor.h
index 04c72abe6de..21e822e2609 100644
--- a/ydb/core/grpc_services/grpc_request_check_actor.h
+++ b/ydb/core/grpc_services/grpc_request_check_actor.h
@@ -1,6 +1,5 @@
 #pragma once
 #include "defs.h"
-#include "grpc_proxy_counters.h"
 #include "local_rate_limiter.h"
 #include "operation_helpers.h"
 #include "rpc_calls.h"
@@ -10,6 +9,7 @@
 #include <ydb/core/base/path.h>
 #include <ydb/core/base/subdomain.h>
 #include <ydb/core/base/kikimr_issue.h>
+#include <ydb/core/grpc_services/counters/proxy_counters.h>
 #include <ydb/core/security/secure_request.h>
 #include <ydb/core/tx/scheme_cache/scheme_cache.h>
 
@@ -74,7 +74,7 @@ public:
         const TSchemeBoardEvents::TDescribeSchemeResult& schemeData,
         TIntrusivePtr<TSecurityObject> securityObject,
         TAutoPtr<TEventHandle<TEvent>> request,
-        TGrpcProxyCounters::TPtr counters,
+        IGRpcProxyCounters::TPtr counters,
         bool skipCheckConnectRigths)
         : Owner_(owner)
         , Request_(std::move(request))
@@ -96,6 +96,10 @@ public:
     void Bootstrap(const TActorContext& ctx) {
         TBase::Become(&TSelf::DbAccessStateFunc);
 
+        if (AppData()->FeatureFlags.GetEnableDbCounters()) {
+            Counters_ = WrapGRpcProxyDbCounters(Counters_);
+        }
+
         {
             auto [error, issue] = CheckConnectRight();
             if (error) {
@@ -171,6 +175,7 @@ public:
         GrpcRequestBaseCtx_->UpdateAuthState(NGrpc::TAuthState::AS_OK);
         GrpcRequestBaseCtx_->SetInternalToken(TBase::GetSerializedToken());
         GrpcRequestBaseCtx_->UseDatabase(database);
+        Counters_->UseDatabase(database);
         ReplyBackAndDie();
     }
 
@@ -201,6 +206,7 @@ private:
             TDuration delay = TInstant::Now() - time;
             switch (resp.operation().status()) {
                 case Ydb::StatusIds::SUCCESS:
+                    Counters_->ReportThrottleDelay(delay);
                     LOG_DEBUG_S(*TlsActivationContext, NKikimrServices::GRPC_SERVER, "Request delayed for " << delay << " by ratelimiter");
                     SetTokenAndDie(CheckedDatabaseName_);
                     break;
@@ -237,12 +243,15 @@ private:
     TRespHook CreateRlRespHook(Ydb::RateLimiter::AcquireResourceRequest&& req) {
         const auto& databasename = CheckedDatabaseName_;
         auto token = TBase::GetSerializedToken();
-        return [req{std::move(req)}, databasename, token](TRespHookCtx::TPtr ctx) mutable {
+        auto counters = Counters_;
+        return [req{std::move(req)}, databasename, token, counters](TRespHookCtx::TPtr ctx) mutable {
 
             LOG_DEBUG(*TlsActivationContext, NKikimrServices::GRPC_SERVER,
                 "Response hook called to report RU usage, database: %s, request: %s, consumed: %d",
                 databasename.c_str(), ctx->GetRequestName().c_str(), ctx->GetConsumedRu());
 
+            counters->AddConsumedRequestUnits(ctx->GetConsumedRu());
+
             if (ctx->GetConsumedRu() >= 1) {
                 // We already count '1' on start request
                 req.set_used(ctx->GetConsumedRu() - 1);
@@ -391,7 +400,7 @@ private:
 
     const TActorId Owner_;
     TAutoPtr<TEventHandle<TEvent>> Request_;
-    TGrpcProxyCounters::TPtr Counters_;
+    IGRpcProxyCounters::TPtr Counters_;
     TIntrusivePtr<TSecurityObject> SecurityObject_;
     TString CheckedDatabaseName_;
     IRequestProxyCtx* GrpcRequestBaseCtx_;
@@ -441,7 +450,7 @@ IActor* CreateGrpcRequestCheckActor(
     const TSchemeBoardEvents::TDescribeSchemeResult& schemeData,
     TIntrusivePtr<TSecurityObject> securityObject,
     TAutoPtr<TEventHandle<TEvent>> request,
-    TGrpcProxyCounters::TPtr counters,
+    IGRpcProxyCounters::TPtr counters,
     bool skipCheckConnectRigths) {
 
     return new TGrpcRequestCheckActor<TEvent>(owner, schemeData, std::move(securityObject), std::move(request), counters, skipCheckConnectRigths);
diff --git a/ydb/core/grpc_services/grpc_request_proxy.cpp b/ydb/core/grpc_services/grpc_request_proxy.cpp
index eeac1849b8e..1f9115e22ca 100644
--- a/ydb/core/grpc_services/grpc_request_proxy.cpp
+++ b/ydb/core/grpc_services/grpc_request_proxy.cpp
@@ -1,6 +1,5 @@
-#include "grpc_proxy_counters.h"
-#include "grpc_request_check_actor.h"
 #include "grpc_request_proxy.h"
+#include "grpc_request_check_actor.h"
 #include "local_rate_limiter.h"
 #include "operation_helpers.h"
 
@@ -8,6 +7,7 @@
 #include <ydb/core/cms/console/configs_dispatcher.h>
 #include <ydb/core/cms/console/console.h>
 #include <ydb/core/mind/tenant_pool.h>
+#include <ydb/core/grpc_services/counters/proxy_counters.h>
 #include <ydb/core/tx/tx_proxy/proxy.h>
 #include <ydb/core/tx/scheme_board/scheme_board.h>
 
@@ -293,7 +293,7 @@ private:
     TActorId SchemeCache;
     bool DynamicNode = false;
     TString RootDatabase;
-    TIntrusivePtr<TGrpcProxyCounters> Counters;
+    IGRpcProxyCounters::TPtr Counters;
 };
 
 void TGRpcRequestProxyImpl::Bootstrap(const TActorContext& ctx) {
@@ -316,7 +316,8 @@ void TGRpcRequestProxyImpl::Bootstrap(const TActorContext& ctx) {
             nodeID, (DynamicNode ? "dynamic" : "static"));
     }
 
-    Counters = MakeIntrusive<TGrpcProxyCounters>(AppData()->Counters);
+    Counters = CreateGRpcProxyCounters(AppData()->Counters);
+    InitializeGRpcProxyDbCountersRegistry(ctx.ActorSystem());
 
     RootDatabase = DatabaseFromDomain();
     TDatabaseInfo& database = Databases[RootDatabase];
diff --git a/ydb/core/grpc_services/grpc_request_proxy_simple.cpp b/ydb/core/grpc_services/grpc_request_proxy_simple.cpp
index 1289da317cb..0fe48eff998 100644
--- a/ydb/core/grpc_services/grpc_request_proxy_simple.cpp
+++ b/ydb/core/grpc_services/grpc_request_proxy_simple.cpp
@@ -1,9 +1,9 @@
-#include "grpc_proxy_counters.h"
 #include "grpc_request_check_actor.h"
 #include "grpc_request_proxy.h"
 #include "operation_helpers.h"
 
 #include <ydb/core/base/appdata.h>
+#include <ydb/core/grpc_services/counters/proxy_counters.h>
 
 #include <util/system/hostname.h>
 
@@ -140,7 +140,7 @@ private:
     }
 
     NKikimrConfig::TAppConfig AppConfig;
-    TIntrusivePtr<TGrpcProxyCounters> Counters;
+    IGRpcProxyCounters::TPtr Counters;
 };
 
 void TGRpcRequestProxySimple::Bootstrap(const TActorContext& ctx) {
@@ -148,7 +148,8 @@ void TGRpcRequestProxySimple::Bootstrap(const TActorContext& ctx) {
 
     LOG_NOTICE(ctx, NKikimrServices::GRPC_SERVER, "Grpc simple request proxy started, nodeid# %d", nodeID);
 
-    Counters = MakeIntrusive<TGrpcProxyCounters>(AppData()->Counters);
+    Counters = CreateGRpcProxyCounters(AppData()->Counters);
+    InitializeGRpcProxyDbCountersRegistry(ctx.ActorSystem());
 
     Become(&TThis::StateFunc);
 }
diff --git a/ydb/core/protos/sys_view.proto b/ydb/core/protos/sys_view.proto
index cfc03662725..44abe035159 100644
--- a/ydb/core/protos/sys_view.proto
+++ b/ydb/core/protos/sys_view.proto
@@ -512,18 +512,24 @@ message TDbGRpcCounters {
     optional TDbCounters RequestCounters = 3;
 }
 
+message TDbGRpcProxyCounters {
+    optional TDbCounters RequestCounters = 1;
+}
+
 message TDbServiceCounters {
     optional TDbCounters Main = 1;
     repeated TDbTabletCounters TabletCounters = 2;
     repeated TDbGRpcCounters GRpcCounters = 3;
+    optional TDbGRpcProxyCounters GRpcProxyCounters = 4;
 }
 
 enum EDbCountersService {
     KQP = 1;
     TABLETS = 2;
     GRPC = 3;
-    RESERVED_1 = 4;
+    GRPC_PROXY = 4;
     RESERVED_2 = 5;
+    RESERVED_3 = 6;
 }
 
 // node -> sysview processor tablet
diff --git a/ydb/core/sys_view/common/events.h b/ydb/core/sys_view/common/events.h
index 6e19aadc2b7..df73e745f55 100644
--- a/ydb/core/sys_view/common/events.h
+++ b/ydb/core/sys_view/common/events.h
@@ -13,7 +13,7 @@ namespace NSysView {
 
 using TShardIdx = std::pair<ui64, ui64>;
 
-class IDbCounters : public TThrRefBase {
+class IDbCounters : public virtual TThrRefBase {
 public:
     virtual void ToProto(NKikimr::NSysView::TDbServiceCounters& counters) = 0;
     virtual void FromProto(NKikimr::NSysView::TDbServiceCounters& counters) = 0;
diff --git a/ydb/core/sys_view/processor/db_counters.cpp b/ydb/core/sys_view/processor/db_counters.cpp
index 42bfbd62691..62fce6030d1 100644
--- a/ydb/core/sys_view/processor/db_counters.cpp
+++ b/ydb/core/sys_view/processor/db_counters.cpp
@@ -2,7 +2,8 @@
 
 #include <ydb/core/base/counters.h>
 #include <ydb/core/base/path.h>
-#include <ydb/core/grpc_services/grpc_helper.h>
+#include <ydb/core/grpc_services/counters/counters.h>
+#include <ydb/core/grpc_services/counters/proxy_counters.h>
 #include <ydb/core/kqp/counters/kqp_counters.h>
 #include <ydb/core/tablet/tablet_counters_aggregator.h>
 #include <ydb/core/tablet_flat/flat_executor_counters.h>
@@ -156,6 +157,11 @@ static void AggregateCounters(NKikimr::NSysView::TDbServiceCounters* dst,
         auto* dstReq = dst->FindOrAddGRpcCounters(srcReq.GetGRpcService(), srcReq.GetGRpcRequest());
         TAggrSum::Apply(dstReq->MutableRequestCounters(), srcReq.GetRequestCounters());
     }
+
+    if (src.HasGRpcProxyCounters()) {
+        TAggrSum::Apply(dst->Proto().MutableGRpcProxyCounters()->MutableRequestCounters(),
+            src.GetGRpcProxyCounters().GetRequestCounters());
+    }
 }
 
 static void AggregateIncrementalCounters(NKikimr::NSysView::TDbServiceCounters* dst,
@@ -241,6 +247,9 @@ TIntrusivePtr<IDbCounters> TSysViewProcessor::CreateCountersForService(
     case NKikimrSysView::GRPC:
         result = NGRpcService::CreateGRpcDbCounters(ExternalGroup, InternalGroup);
         break;
+    case NKikimrSysView::GRPC_PROXY:
+        result = NGRpcService::CreateGRpcProxyDbCounters(ExternalGroup, InternalGroup);
+        break;
     default:
         break;
     }
diff --git a/ydb/core/sys_view/service/sysview_service.cpp b/ydb/core/sys_view/service/sysview_service.cpp
index 1f569065999..00554259286 100644
--- a/ydb/core/sys_view/service/sysview_service.cpp
+++ b/ydb/core/sys_view/service/sysview_service.cpp
@@ -291,6 +291,17 @@ static void CalculateCountersDiff(NKikimrSysView::TDbServiceCounters* diff,
             CopyCounters(diffR->MutableRequestCounters(), currentR.GetRequestCounters());
         }
     }
+
+    if (current.Proto().HasGRpcProxyCounters()) {
+        if (prev.Proto().HasGRpcProxyCounters()) {
+            CalculateCountersDiff(diff->MutableGRpcProxyCounters()->MutableRequestCounters(),
+                current.Proto().GetGRpcProxyCounters().GetRequestCounters(),
+                *prev.Proto().MutableGRpcProxyCounters()->MutableRequestCounters());
+        } else {
+            CopyCounters(diff->MutableGRpcProxyCounters()->MutableRequestCounters(),
+                current.Proto().GetGRpcProxyCounters().GetRequestCounters());
+        }
+    }
 }
 
 class TSysViewService : public TActorBootstrapped<TSysViewService> {