Rate Limiter metrics have been added in control plane proxy (#10652)

Author: dorooleg

ydb/core/fq/libs/control_plane_proxy/actors/counters.h

@@ -171,6 +171,7 @@ enum ERequestTypeCommon {
     RTC_DELETE_BINDING_IN_YDB,
     RTC_CREATE_COMPUTE_DATABASE,
     RTC_LIST_CPS_ENTITY,
+    RTC_RATE_LIMITER,
     RTC_MAX,
 };
 
@@ -228,6 +229,7 @@ class TCounters : public virtual TThrRefBase {
         {MakeIntrusive<TRequestCommonCounters>("DeleteBindingInYDB")},
         {MakeIntrusive<TRequestCommonCounters>("CreateComputeDatabase")},
         {MakeIntrusive<TRequestCommonCounters>("ListCPSEntities")},
+        {MakeIntrusive<TRequestCommonCounters>("RateLimiter")},
     });
 
     TTtlCache<TMetricsScope, TScopeCountersPtr, TMap> ScopeCounters{TTtlCacheSettings{}.SetTtl(TDuration::Days(1))};

ydb/core/fq/libs/control_plane_proxy/actors/request_actor.h

@@ -192,11 +192,23 @@ class TCreateQueryRequestActor :
                                             TEvControlPlaneStorage::TEvCreateQueryResponse,
                                             TEvControlPlaneProxy::TEvCreateQueryRequest,
                                             TEvControlPlaneProxy::TEvCreateQueryResponse>;
-    using TBaseRequestActor::TBaseRequestActor;
+
+        TCreateQueryRequestActor(typename TEvControlPlaneProxy::TEvCreateQueryRequest::TPtr requestProxy,
+                                 const TControlPlaneProxyConfig& config,
+                                 const TActorId& serviceId,
+                                 const TRequestCounters& counters,
+                                 const TRequestCommonCountersPtr& rateLimiterCounters,
+                                 const std::function<void(const TDuration&, bool, bool)>& probe,
+                                 const TPermissions& availablePermissions,
+                                 bool replyWithResponseOnSuccess = true)
+        : TBaseRequestActor(requestProxy, config, serviceId, counters, probe, availablePermissions, replyWithResponseOnSuccess)
+        , RateLimiterCounters(rateLimiterCounters) {
+    }
 
     STFUNC(StateFunc) {
         switch (ev->GetTypeRewrite()) {
             hFunc(TEvRateLimiter::TEvCreateResourceResponse, Handle);
+            cFunc(NActors::TEvents::TSystem::Wakeup, HandleTimeout);
             default:
                 return TBaseRequestActor::StateFunc(ev);
         }
@@ -208,6 +220,16 @@ class TCreateQueryRequestActor :
                     || !Config.ComputeConfig.YdbComputeControlPlaneEnabled(RequestProxy->Get()->Scope));
     }
 
+    void HandleTimeout() {
+        // Don't need to set the RateLimiterCreationInProgress = false 
+        // because of the PassAway will be called in this callback
+        if (RateLimiterCreationInProgress) {
+            RateLimiterCounters->Timeout->Inc();
+            RateLimiterCounters->InFly->Dec();
+        }
+        TBaseRequestActor::HandleTimeout();
+    }
+
     void OnBootstrap() override {
         this->UnsafeBecome(&TCreateQueryRequestActor::StateFunc);
         if (ShouldCreateRateLimiter()) {
@@ -223,9 +245,13 @@ class TCreateQueryRequestActor :
                                                           10); // percent -> milliseconds
             CPP_LOG_T("Create rate limiter resource for cloud with limit " << cloudLimit
                                                                            << "ms");
+            RateLimiterCreationInProgress = true;
+            RateLimiterCounters->InFly->Inc();
+            StartRateLimiterCreation = TInstant::Now();
             Send(RateLimiterControlPlaneServiceId(),
                  new TEvRateLimiter::TEvCreateResource(RequestProxy->Get()->CloudId, cloudLimit));
         } else {
+            RateLimiterCounters->Error->Inc();
             NYql::TIssues issues;
             NYql::TIssue issue =
                 MakeErrorIssue(TIssuesIds::INTERNAL_ERROR,
@@ -238,12 +264,17 @@ class TCreateQueryRequestActor :
     }
 
     void Handle(TEvRateLimiter::TEvCreateResourceResponse::TPtr& ev) {
+        RateLimiterCreationInProgress = false;
+        RateLimiterCounters->InFly->Dec();
+        RateLimiterCounters->LatencyMs->Collect((TInstant::Now() - StartRateLimiterCreation).MilliSeconds());
         CPP_LOG_D(
             "Create response from rate limiter service. Success: " << ev->Get()->Success);
         if (ev->Get()->Success) {
+            RateLimiterCounters->Ok->Inc();
             QuoterResourceCreated = true;
             SendRequestIfCan();
         } else {
+            RateLimiterCounters->Error->Inc();
             NYql::TIssue issue("Failed to create rate limiter resource");
             for (const NYql::TIssue& i : ev->Get()->Issues) {
                 issue.AddSubIssue(MakeIntrusive<NYql::TIssue>(i));
@@ -257,6 +288,11 @@ class TCreateQueryRequestActor :
     bool CanSendRequest() const override {
         return (QuoterResourceCreated || !ShouldCreateRateLimiter()) && TBaseRequestActor::CanSendRequest();
     }
+
+private:
+    TInstant StartRateLimiterCreation;
+    bool RateLimiterCreationInProgress = false;
+    TRequestCommonCountersPtr RateLimiterCounters;
 };
 
 } // namespace NFq::NPrivate

ydb/core/fq/libs/control_plane_proxy/control_plane_proxy.cpp

@@ -706,6 +706,7 @@ class TControlPlaneProxyActor : public NActors::TActorBootstrapped<TControlPlane
                                               Config,
                                               ControlPlaneStorageServiceActorId(),
                                               requestCounters,
+                                              Counters.GetCommonCounters(RTC_RATE_LIMITER),
                                               probe,
                                               availablePermissions));
     }