YQ-998 Add checkpoint storage metrics (#16828)

kardymonds · web-flow · commit d5ac20e67b93 · 2025-04-25T09:02:58.000+03:00
diff --git a/ydb/core/fq/libs/checkpoint_storage/storage_proxy.cpp b/ydb/core/fq/libs/checkpoint_storage/storage_proxy.cpp
@@ -29,6 +29,41 @@ namespace {
 
 ////////////////////////////////////////////////////////////////////////////////
 
+struct TStorageProxyMetrics : public TThrRefBase {
+    explicit TStorageProxyMetrics(const ::NMonitoring::TDynamicCounterPtr& counters)
+        : Counters(counters)
+        , Errors(Counters->GetCounter("Errors", true))
+        , Inflight(Counters->GetCounter("Inflight"))
+        , LatencyMs(Counters->GetHistogram("LatencyMs", ::NMonitoring::ExplicitHistogram({1, 5, 20, 100, 500, 2000, 10000, 50000})))
+    {}
+
+    ::NMonitoring::TDynamicCounterPtr Counters;
+    ::NMonitoring::TDynamicCounters::TCounterPtr Errors;
+    ::NMonitoring::TDynamicCounters::TCounterPtr Inflight;
+    ::NMonitoring::THistogramPtr LatencyMs;
+};
+
+using TStorageProxyMetricsPtr = TIntrusivePtr<TStorageProxyMetrics>;
+
+struct TRequestContext : public TThrRefBase {
+    TInstant StartTime = TInstant::Now();
+    const TStorageProxyMetricsPtr Metrics;
+    
+    TRequestContext(const TStorageProxyMetricsPtr& metrics)
+        : Metrics(metrics) {
+        Metrics->Inflight->Inc();
+    }
+
+    ~TRequestContext() {
+        Metrics->Inflight->Dec();
+        Metrics->LatencyMs->Collect((TInstant::Now() - StartTime).MilliSeconds());
+    }
+
+    void IncError() {
+        Metrics->Errors->Inc();
+    }
+};
+
 class TStorageProxy : public TActorBootstrapped<TStorageProxy> {
     NConfig::TCheckpointCoordinatorConfig Config;
     NConfig::TCommonConfig CommonConfig;
@@ -38,13 +73,15 @@ class TStorageProxy : public TActorBootstrapped<TStorageProxy> {
     TActorId ActorGC;
     NKikimr::TYdbCredentialsProviderFactory CredentialsProviderFactory;
     TYqSharedResources::TPtr YqSharedResources;
+    const TStorageProxyMetricsPtr Metrics;
 
 public:
     explicit TStorageProxy(
         const NConfig::TCheckpointCoordinatorConfig& config,
         const NConfig::TCommonConfig& commonConfig,
         const NKikimr::TYdbCredentialsProviderFactory& credentialsProviderFactory,
-        const TYqSharedResources::TPtr& yqSharedResources);
+        const TYqSharedResources::TPtr& yqSharedResources,
+        const ::NMonitoring::TDynamicCounterPtr& counters);
 
     void Bootstrap();
 
@@ -103,12 +140,14 @@ TStorageProxy::TStorageProxy(
     const NConfig::TCheckpointCoordinatorConfig& config,
     const NConfig::TCommonConfig& commonConfig,
     const NKikimr::TYdbCredentialsProviderFactory& credentialsProviderFactory,
-    const TYqSharedResources::TPtr& yqSharedResources)
+    const TYqSharedResources::TPtr& yqSharedResources,
+    const ::NMonitoring::TDynamicCounterPtr& counters)
     : Config(config)
     , CommonConfig(commonConfig)
     , StorageConfig(Config.GetStorage())
     , CredentialsProviderFactory(credentialsProviderFactory)
-    , YqSharedResources(yqSharedResources) {
+    , YqSharedResources(yqSharedResources)
+    , Metrics(MakeIntrusive<TStorageProxyMetrics>(counters)) {
     FillDefaultParameters(Config, StorageConfig);
 }
 
@@ -138,17 +177,21 @@ void TStorageProxy::Bootstrap() {
 }
 
 void TStorageProxy::Handle(TEvCheckpointStorage::TEvRegisterCoordinatorRequest::TPtr& ev) {
+    auto context = MakeIntrusive<TRequestContext>(Metrics);
+
     const auto* event = ev->Get();
     LOG_STREAMS_STORAGE_SERVICE_DEBUG("[" << event->CoordinatorId << "] Got TEvRegisterCoordinatorRequest")
 
     CheckpointStorage->RegisterGraphCoordinator(event->CoordinatorId)
         .Apply([coordinatorId = event->CoordinatorId,
                 cookie = ev->Cookie,
                 sender = ev->Sender,
-                actorSystem = TActivationContext::ActorSystem()] (const NThreading::TFuture<NYql::TIssues>& issuesFuture) {
+                actorSystem = TActivationContext::ActorSystem(),
+                context] (const NThreading::TFuture<NYql::TIssues>& issuesFuture) {
             auto response = std::make_unique<TEvCheckpointStorage::TEvRegisterCoordinatorResponse>();
             response->Issues = issuesFuture.GetValue();
             if (response->Issues) {
+                context->IncError();
                 LOG_STREAMS_STORAGE_SERVICE_AS_WARN(*actorSystem, "[" << coordinatorId << "] Failed to register graph: " << response->Issues.ToString())
             } else {
                 LOG_STREAMS_STORAGE_SERVICE_AS_INFO(*actorSystem, "[" << coordinatorId << "] Graph registered")
@@ -159,6 +202,7 @@ void TStorageProxy::Handle(TEvCheckpointStorage::TEvRegisterCoordinatorRequest::
 }
 
 void TStorageProxy::Handle(TEvCheckpointStorage::TEvCreateCheckpointRequest::TPtr& ev) {
+    auto context = MakeIntrusive<TRequestContext>(Metrics);
     const auto* event = ev->Get();
     LOG_STREAMS_STORAGE_SERVICE_DEBUG("[" << event->CoordinatorId << "] [" << event->CheckpointId << "] Got TEvCreateCheckpointRequest")
 
@@ -169,7 +213,8 @@ void TStorageProxy::Handle(TEvCheckpointStorage::TEvCreateCheckpointRequest::TPt
                 sender = ev->Sender,
                 totalGraphCheckpointsSizeLimit = Config.GetStateStorageLimits().GetMaxGraphCheckpointsSizeBytes(),
                 graphDesc = std::move(event->GraphDescription),
-                storage = CheckpointStorage]
+                storage = CheckpointStorage,
+                context]
                (const NThreading::TFuture<ICheckpointStorage::TGetTotalCheckpointsStateSizeResult>& resultFuture) {
             auto [totalGraphCheckpointsSize, issues] = resultFuture.GetValue();
 
@@ -179,6 +224,7 @@ void TStorageProxy::Handle(TEvCheckpointStorage::TEvCreateCheckpointRequest::TPt
                 issues.AddIssue(std::move(ss.Str()));
             }
             if (issues) {
+                context->IncError();
                 return NThreading::MakeFuture(ICheckpointStorage::TCreateCheckpointResult {TString(), std::move(issues) } );
             }
             if (std::holds_alternative<TString>(graphDesc)) {
@@ -191,11 +237,13 @@ void TStorageProxy::Handle(TEvCheckpointStorage::TEvCreateCheckpointRequest::TPt
                 coordinatorId = event->CoordinatorId,
                 cookie = ev->Cookie,
                 sender = ev->Sender,
-                actorSystem = TActivationContext::ActorSystem()]
+                actorSystem = TActivationContext::ActorSystem(),
+                context]
                (const NThreading::TFuture<ICheckpointStorage::TCreateCheckpointResult>& resultFuture) {
             auto [graphDescId, issues] = resultFuture.GetValue();
             auto response = std::make_unique<TEvCheckpointStorage::TEvCreateCheckpointResponse>(checkpointId, std::move(issues), std::move(graphDescId));
             if (response->Issues) {
+                context->IncError();
                 LOG_STREAMS_STORAGE_SERVICE_AS_WARN(*actorSystem, "[" << coordinatorId << "] [" << checkpointId << "] Failed to create checkpoint: " << response->Issues.ToString());
             } else {
                 LOG_STREAMS_STORAGE_SERVICE_AS_INFO(*actorSystem, "[" << coordinatorId << "] [" << checkpointId << "] Checkpoint created");
@@ -206,18 +254,21 @@ void TStorageProxy::Handle(TEvCheckpointStorage::TEvCreateCheckpointRequest::TPt
 }
 
 void TStorageProxy::Handle(TEvCheckpointStorage::TEvSetCheckpointPendingCommitStatusRequest::TPtr& ev) {
+    auto context = MakeIntrusive<TRequestContext>(Metrics);
     const auto* event = ev->Get();
     LOG_STREAMS_STORAGE_SERVICE_DEBUG("[" << event->CoordinatorId << "] [" << event->CheckpointId << "] Got TEvSetCheckpointPendingCommitStatusRequest")
     CheckpointStorage->UpdateCheckpointStatus(event->CoordinatorId, event->CheckpointId, ECheckpointStatus::PendingCommit, ECheckpointStatus::Pending, event->StateSizeBytes)
         .Apply([checkpointId = event->CheckpointId,
                 coordinatorId = event->CoordinatorId,
                 cookie = ev->Cookie,
                 sender = ev->Sender,
-                actorSystem = TActivationContext::ActorSystem()]
+                actorSystem = TActivationContext::ActorSystem(),
+                context]
                (const NThreading::TFuture<NYql::TIssues>& issuesFuture) {
             auto issues = issuesFuture.GetValue();
             auto response = std::make_unique<TEvCheckpointStorage::TEvSetCheckpointPendingCommitStatusResponse>(checkpointId, std::move(issues));
             if (response->Issues) {
+                context->IncError();
                 LOG_STREAMS_STORAGE_SERVICE_AS_WARN(*actorSystem, "[" << coordinatorId << "] [" << checkpointId << "] Failed to set 'PendingCommit' status: " << response->Issues.ToString())
             } else {
                 LOG_STREAMS_STORAGE_SERVICE_AS_INFO(*actorSystem, "[" << coordinatorId << "] [" << checkpointId << "] Status updated to 'PendingCommit'")
@@ -228,6 +279,7 @@ void TStorageProxy::Handle(TEvCheckpointStorage::TEvSetCheckpointPendingCommitSt
 }
 
 void TStorageProxy::Handle(TEvCheckpointStorage::TEvCompleteCheckpointRequest::TPtr& ev) {
+    auto context = MakeIntrusive<TRequestContext>(Metrics);
     const auto* event = ev->Get();
     LOG_STREAMS_STORAGE_SERVICE_DEBUG("[" << event->CoordinatorId << "] [" << event->CheckpointId << "] Got TEvCompleteCheckpointRequest")
     CheckpointStorage->UpdateCheckpointStatus(event->CoordinatorId, event->CheckpointId, ECheckpointStatus::Completed, ECheckpointStatus::PendingCommit, event->StateSizeBytes)
@@ -238,11 +290,13 @@ void TStorageProxy::Handle(TEvCheckpointStorage::TEvCompleteCheckpointRequest::T
                 type = event->Type,
                 gcEnabled = Config.GetCheckpointGarbageConfig().GetEnabled(),
                 actorGC = ActorGC,
-                actorSystem = TActivationContext::ActorSystem()]
+                actorSystem = TActivationContext::ActorSystem(),
+                context]
                (const NThreading::TFuture<NYql::TIssues>& issuesFuture) {
             auto issues = issuesFuture.GetValue();
             auto response = std::make_unique<TEvCheckpointStorage::TEvCompleteCheckpointResponse>(checkpointId, std::move(issues));
             if (response->Issues) {
+                context->IncError();
                 LOG_STREAMS_STORAGE_SERVICE_AS_DEBUG(*actorSystem, "[" << coordinatorId << "] [" << checkpointId << "] Failed to set 'Completed' status: " << response->Issues.ToString())
             } else {
                 LOG_STREAMS_STORAGE_SERVICE_AS_INFO(*actorSystem, "[" << coordinatorId << "] [" << checkpointId << "] Status updated to 'Completed'")
@@ -258,17 +312,20 @@ void TStorageProxy::Handle(TEvCheckpointStorage::TEvCompleteCheckpointRequest::T
 }
 
 void TStorageProxy::Handle(TEvCheckpointStorage::TEvAbortCheckpointRequest::TPtr& ev) {
+    auto context = MakeIntrusive<TRequestContext>(Metrics);
     const auto* event = ev->Get();
     LOG_STREAMS_STORAGE_SERVICE_DEBUG("[" << event->CoordinatorId << "] [" << event->CheckpointId << "] Got TEvAbortCheckpointRequest")
     CheckpointStorage->AbortCheckpoint(event->CoordinatorId,event->CheckpointId)
         .Apply([checkpointId = event->CheckpointId,
                 coordinatorId = event->CoordinatorId,
                 cookie = ev->Cookie,
                 sender = ev->Sender,
-                actorSystem = TActivationContext::ActorSystem()] (const NThreading::TFuture<NYql::TIssues>& issuesFuture) {
+                actorSystem = TActivationContext::ActorSystem(),
+                context] (const NThreading::TFuture<NYql::TIssues>& issuesFuture) {
             auto issues = issuesFuture.GetValue();
             auto response = std::make_unique<TEvCheckpointStorage::TEvAbortCheckpointResponse>(checkpointId, std::move(issues));
             if (response->Issues) {
+                context->IncError();
                 LOG_STREAMS_STORAGE_SERVICE_AS_WARN(*actorSystem, "[" << coordinatorId << "] [" << checkpointId << "] Failed to abort checkpoint: " << response->Issues.ToString())
             } else {
                 LOG_STREAMS_STORAGE_SERVICE_AS_INFO(*actorSystem, "[" << coordinatorId << "] [" << checkpointId << "] Checkpoint aborted")
@@ -279,16 +336,19 @@ void TStorageProxy::Handle(TEvCheckpointStorage::TEvAbortCheckpointRequest::TPtr
 }
 
 void TStorageProxy::Handle(TEvCheckpointStorage::TEvGetCheckpointsMetadataRequest::TPtr& ev) {
+    auto context = MakeIntrusive<TRequestContext>(Metrics);
     const auto* event = ev->Get();
     LOG_STREAMS_STORAGE_SERVICE_DEBUG("[" << event->GraphId << "] Got TEvGetCheckpointsMetadataRequest");
     CheckpointStorage->GetCheckpoints(event->GraphId, event->Statuses, event->Limit, event->LoadGraphDescription)
         .Apply([graphId = event->GraphId,
                 cookie = ev->Cookie,
                 sender = ev->Sender,
-                actorSystem = TActivationContext::ActorSystem()] (const NThreading::TFuture<ICheckpointStorage::TGetCheckpointsResult>& futureResult) {
+                actorSystem = TActivationContext::ActorSystem(),
+                context] (const NThreading::TFuture<ICheckpointStorage::TGetCheckpointsResult>& futureResult) {
             auto result = futureResult.GetValue();
             auto response = std::make_unique<TEvCheckpointStorage::TEvGetCheckpointsMetadataResponse>(result.first, result.second);
             if (response->Issues) {
+                context->IncError();
                 LOG_STREAMS_STORAGE_SERVICE_AS_WARN(*actorSystem, "[" << graphId << "] Failed to get checkpoints: " << response->Issues.ToString())
             }
             LOG_STREAMS_STORAGE_SERVICE_AS_DEBUG(*actorSystem, "[" << graphId << "] Send TEvGetCheckpointsMetadataResponse")
@@ -297,6 +357,7 @@ void TStorageProxy::Handle(TEvCheckpointStorage::TEvGetCheckpointsMetadataReques
 }
 
 void TStorageProxy::Handle(NYql::NDq::TEvDqCompute::TEvSaveTaskState::TPtr& ev) {
+    auto context = MakeIntrusive<TRequestContext>(Metrics);
     auto* event = ev->Get();
     const auto checkpointId = TCheckpointId(event->Checkpoint.GetGeneration(), event->Checkpoint.GetId());
     LOG_STREAMS_STORAGE_SERVICE_DEBUG("[" << event->GraphId << "] [" << checkpointId << "] Got TEvSaveTaskState: task " << event->TaskId);
@@ -321,7 +382,8 @@ void TStorageProxy::Handle(NYql::NDq::TEvDqCompute::TEvSaveTaskState::TPtr& ev)
                 taskId = event->TaskId,
                 cookie = ev->Cookie,
                 sender = ev->Sender,
-                actorSystem = TActivationContext::ActorSystem()](const NThreading::TFuture<IStateStorage::TSaveStateResult>& futureResult) {
+                actorSystem = TActivationContext::ActorSystem(),
+                context](const NThreading::TFuture<IStateStorage::TSaveStateResult>& futureResult) {
             LOG_STREAMS_STORAGE_SERVICE_AS_DEBUG(*actorSystem, "[" << graphId << "] [" << checkpointId << "] TEvSaveTaskState Apply: task: " << taskId)
             const auto& issues = futureResult.GetValue().second;
             auto response = std::make_unique<NYql::NDq::TEvDqCompute::TEvSaveTaskStateResult>();
@@ -331,6 +393,7 @@ void TStorageProxy::Handle(NYql::NDq::TEvDqCompute::TEvSaveTaskState::TPtr& ev)
             response->Record.SetTaskId(taskId);
 
             if (issues) {
+                context->IncError();
                 LOG_STREAMS_STORAGE_SERVICE_AS_WARN(*actorSystem, "[" << graphId << "] [" << checkpointId << "] Failed to save task state: task: " << taskId << ", issues: " << issues.ToString())
                 response->Record.SetStatus(NYql::NDqProto::TEvSaveTaskStateResult::STORAGE_ERROR);
             } else {
@@ -342,6 +405,7 @@ void TStorageProxy::Handle(NYql::NDq::TEvDqCompute::TEvSaveTaskState::TPtr& ev)
 }
 
 void TStorageProxy::Handle(NYql::NDq::TEvDqCompute::TEvGetTaskState::TPtr& ev) {
+    auto context = MakeIntrusive<TRequestContext>(Metrics);
     const auto* event = ev->Get();
     const auto checkpointId = TCheckpointId(event->Checkpoint.GetGeneration(), event->Checkpoint.GetId());
     LOG_STREAMS_STORAGE_SERVICE_DEBUG("[" << event->GraphId << "] [" << checkpointId << "] Got TEvGetTaskState: tasks {" << JoinSeq(", ", event->TaskIds) << "}");
@@ -353,12 +417,14 @@ void TStorageProxy::Handle(NYql::NDq::TEvDqCompute::TEvGetTaskState::TPtr& ev) {
                 taskIds = event->TaskIds,
                 cookie = ev->Cookie,
                 sender = ev->Sender,
-                actorSystem = TActivationContext::ActorSystem()](const NThreading::TFuture<IStateStorage::TGetStateResult>& resultFuture) {
+                actorSystem = TActivationContext::ActorSystem(),
+                context](const NThreading::TFuture<IStateStorage::TGetStateResult>& resultFuture) {
             auto result = resultFuture.GetValue();
 
             auto response = std::make_unique<NYql::NDq::TEvDqCompute::TEvGetTaskStateResult>(checkpointId, result.second, generation);
             std::swap(response->States, result.first);
             if (response->Issues) {
+                context->IncError();
                 LOG_STREAMS_STORAGE_SERVICE_AS_WARN(*actorSystem, "[" << graphId << "] [" << checkpointId << "] Failed to get task state: tasks: {" << JoinSeq(", ", taskIds) << "}, issues: " << response->Issues.ToString());
             }
             LOG_STREAMS_STORAGE_SERVICE_AS_DEBUG(*actorSystem, "[" << graphId << "] [" << checkpointId << "] Send TEvGetTaskStateResult: tasks: {" << JoinSeq(", ", taskIds) << "}");
@@ -374,9 +440,10 @@ std::unique_ptr<NActors::IActor> NewStorageProxy(
     const NConfig::TCheckpointCoordinatorConfig& config,
     const NConfig::TCommonConfig& commonConfig,
     const NKikimr::TYdbCredentialsProviderFactory& credentialsProviderFactory,
-    const TYqSharedResources::TPtr& yqSharedResources)
+    const TYqSharedResources::TPtr& yqSharedResources,
+    const ::NMonitoring::TDynamicCounterPtr& counters)
 {
-    return std::unique_ptr<NActors::IActor>(new TStorageProxy(config, commonConfig, credentialsProviderFactory, yqSharedResources));
+    return std::unique_ptr<NActors::IActor>(new TStorageProxy(config, commonConfig, credentialsProviderFactory, yqSharedResources, counters));
 }
 
 } // namespace NFq
diff --git a/ydb/core/fq/libs/checkpoint_storage/storage_proxy.h b/ydb/core/fq/libs/checkpoint_storage/storage_proxy.h
@@ -16,6 +16,7 @@ std::unique_ptr<NActors::IActor> NewStorageProxy(
     const NConfig::TCheckpointCoordinatorConfig& config,
     const NConfig::TCommonConfig& commonConfig,
     const NKikimr::TYdbCredentialsProviderFactory& credentialsProviderFactory,
-    const TYqSharedResources::TPtr& yqSharedResources);
+    const TYqSharedResources::TPtr& yqSharedResources,
+    const ::NMonitoring::TDynamicCounterPtr& counters);
 
 } // namespace NFq
diff --git a/ydb/core/fq/libs/checkpoint_storage/storage_service.cpp b/ydb/core/fq/libs/checkpoint_storage/storage_service.cpp
@@ -12,9 +12,10 @@ std::unique_ptr<NActors::IActor> NewCheckpointStorageService(
     const NConfig::TCheckpointCoordinatorConfig& config,
     const NConfig::TCommonConfig& commonConfig,
     const NKikimr::TYdbCredentialsProviderFactory& credentialsProviderFactory,
-    const TYqSharedResources::TPtr& yqSharedResources)
+    const TYqSharedResources::TPtr& yqSharedResources,
+    const ::NMonitoring::TDynamicCounterPtr& counters)
 {
-    return NewStorageProxy(config, commonConfig, credentialsProviderFactory, yqSharedResources);
+    return NewStorageProxy(config, commonConfig, credentialsProviderFactory, yqSharedResources, counters);
 }
 
 } // namespace NFq
diff --git a/ydb/core/fq/libs/checkpoint_storage/storage_service.h b/ydb/core/fq/libs/checkpoint_storage/storage_service.h
@@ -16,6 +16,7 @@ std::unique_ptr<NActors::IActor> NewCheckpointStorageService(
     const NConfig::TCheckpointCoordinatorConfig& config,
     const NConfig::TCommonConfig& commonConfig,
     const NKikimr::TYdbCredentialsProviderFactory& credentialsProviderFactory,
-    const TYqSharedResources::TPtr& yqSharedResources);
+    const TYqSharedResources::TPtr& yqSharedResources,
+    const ::NMonitoring::TDynamicCounterPtr& counters);
 
 } // namespace NFq
diff --git a/ydb/core/fq/libs/checkpoint_storage/ut/storage_service_ydb_ut.cpp b/ydb/core/fq/libs/checkpoint_storage/ut/storage_service_ydb_ut.cpp
@@ -59,7 +59,7 @@ TRuntimePtr PrepareTestActorRuntime(const char* tablePrefix, bool enableGc = fal
 
     auto credFactory = NKikimr::CreateYdbCredentialsProviderFactory;
     auto yqSharedResources = NFq::TYqSharedResources::Cast(NFq::CreateYqSharedResourcesImpl({}, credFactory, MakeIntrusive<NMonitoring::TDynamicCounters>()));
-    auto storageService = NewCheckpointStorageService(config, commonConfig, credFactory, yqSharedResources);
+    auto storageService = NewCheckpointStorageService(config, commonConfig, credFactory, yqSharedResources, MakeIntrusive<::NMonitoring::TDynamicCounters>());
 
     runtime->AddLocalService(
         NYql::NDq::MakeCheckpointStorageID(),
diff --git a/ydb/core/fq/libs/init/init.cpp b/ydb/core/fq/libs/init/init.cpp

Original file line number	Diff line number	Diff line change
`@@ -12,9 +12,10 @@ std::unique_ptr<NActors::IActor> NewCheckpointStorageService(`
`12`	`12`	`const NConfig::TCheckpointCoordinatorConfig& config,`
`13`	`13`	`const NConfig::TCommonConfig& commonConfig,`
`14`	`14`	`const NKikimr::TYdbCredentialsProviderFactory& credentialsProviderFactory,`
`15`		`- const TYqSharedResources::TPtr& yqSharedResources)`
	`15`	`+ const TYqSharedResources::TPtr& yqSharedResources,`
	`16`	`+ const ::NMonitoring::TDynamicCounterPtr& counters)`
`16`	`17`	`{`
`17`		`- return NewStorageProxy(config, commonConfig, credentialsProviderFactory, yqSharedResources);`
	`18`	`+ return NewStorageProxy(config, commonConfig, credentialsProviderFactory, yqSharedResources, counters);`
`18`	`19`	`}`
`19`	`20`
`20`	`21`	`} // namespace NFq`