datashard: add setting for backup table stats report interval

Author: ztlpn

ydb/core/protos/datashard_config.proto

@@ -27,4 +27,5 @@ message TDataShardConfig {
     optional uint64 IncrementalRestoreReadAheadHi = 21 [default = 1048576];
     optional uint64 InMemoryStateMigrationTimeoutMs = 24 [default = 1000];
     optional uint32 StatsReportIntervalSeconds = 25 [default = 10];
+    optional uint32 BackupTableStatsReportIntervalSeconds = 26 [default = 30];
 }

ydb/core/tx/datashard/datashard__stats.cpp

@@ -579,8 +579,20 @@ class TDataShard::TTxInitiateStatsUpdate : public NTabletFlatExecutor::TTransact
 };
 
 TDuration TDataShard::GetStatsReportInterval(const TAppData& appData) const {
-    return TDuration::Seconds(
-        appData.DataShardConfig.GetStatsReportIntervalSeconds());
+    const auto& userTables = GetUserTables();
+    const bool isBackup = !userTables.empty() && std::all_of(userTables.begin(), userTables.end(),
+        [](const auto& kv) { return kv.second->IsBackup; });
+
+    if (isBackup) {
+        // Clamp the interval for backup tables to the value for ordinary tables, as it
+        // makes no sense for the latter to be longer than the former.
+        auto interval = std::max(
+            appData.DataShardConfig.GetBackupTableStatsReportIntervalSeconds(),
+            appData.DataShardConfig.GetStatsReportIntervalSeconds());
+        return TDuration::Seconds(interval);
+    } else {
+        return TDuration::Seconds(appData.DataShardConfig.GetStatsReportIntervalSeconds());
+    }
 }
 
 void TDataShard::UpdateTableStats(const TActorContext &ctx) {

ydb/core/tx/datashard/datashard_ut_stats.cpp

@@ -834,6 +834,47 @@ Y_UNIT_TEST_SUITE(DataShardStats) {
         WaitTableStats(runtime, shard1, DoesNotHaveSchemaChangesCondition());
     }
 
+    Y_UNIT_TEST(BackupTableStatsReportInterval) {
+        TPortManager pm;
+        TServerSettings serverSettings(pm.GetPort(2134));
+        serverSettings.SetDomainName("Root")
+            .SetUseRealThreads(false);
+
+        TServer::TPtr server = new TServer(serverSettings);
+        auto& runtime = *server->GetRuntime();
+        auto sender = runtime.AllocateEdgeActor();
+
+        runtime.SetLogPriority(NKikimrServices::TX_DATASHARD, NLog::PRI_TRACE);
+
+        InitRoot(server, sender);
+
+        auto [shards, tableId1] = CreateShardedTable(server, sender, "/Root", "table-1", 1);
+
+        // Create a backup copy table
+        {
+            auto senderCopy = runtime.AllocateEdgeActor();
+            ui64 txId = AsyncCreateCopyTable(
+                server, senderCopy, "/Root", "table-2", "/Root/table-1", /*isBackup=*/true);
+            WaitTxNotification(server, senderCopy, txId);
+        }
+        auto tableId2 = ResolveTableId(server, sender, "/Root/table-2");
+
+        std::unordered_map<TLocalPathId, size_t> tableToStatsCount;
+        auto observerFunc = [&](auto& ev) {
+            const NKikimrTxDataShard::TEvPeriodicTableStats& record = ev->Get()->Record;
+            ++tableToStatsCount[record.GetTableLocalId()];
+        };
+        auto observer = runtime.AddObserver<TEvDataShard::TEvPeriodicTableStats>(observerFunc);
+
+        runtime.WaitFor("First stats event", [&]{ return !tableToStatsCount.empty(); });
+        runtime.SimulateSleep(TDuration::Seconds(45));
+        // Once every 10 seconds
+        UNIT_ASSERT_GE(tableToStatsCount[tableId1.PathId.LocalPathId], 4);
+        UNIT_ASSERT_LE(tableToStatsCount[tableId1.PathId.LocalPathId], 5);
+        // Once every 30 seconds
+        UNIT_ASSERT_GE(tableToStatsCount[tableId2.PathId.LocalPathId], 1);
+        UNIT_ASSERT_LE(tableToStatsCount[tableId2.PathId.LocalPathId], 2);
+    }
 }
 
 }

ydb/core/tx/datashard/ut_common/datashard_ut_common.cpp

@@ -1319,12 +1319,14 @@ ui64 AsyncCreateCopyTable(
         TActorId sender,
         const TString &root,
         const TString &name,
-        const TString &from)
+        const TString &from,
+        bool isBackup)
 {
     auto request = SchemeTxTemplate(NKikimrSchemeOp::ESchemeOpCreateTable, root);
     auto& desc = *request->Record.MutableTransaction()->MutableModifyScheme()->MutableCreateTable();
     desc.SetName(name);
     desc.SetCopyFromTable(from);
+    desc.SetIsBackup(isBackup);
 
     return RunSchemeTx(*server->GetRuntime(), std::move(request), sender);
 }

ydb/core/tx/datashard/ut_common/datashard_ut_common.h

@@ -531,7 +531,8 @@ ui64 AsyncCreateCopyTable(Tests::TServer::TPtr server,
                           TActorId sender,
                           const TString &root,
                           const TString &name,
-                          const TString &from);
+                          const TString &from,
+                          bool isBackup = false);
 
 NKikimrTxDataShard::TEvCompactTableResult CompactTable(
     TTestActorRuntime& runtime, ui64 shardId, const TTableId& tableId, bool compactBorrowed = false);