feat userver/ydb: add keepalive options to YDB driver config

Exposes `tcp-keepalive`, `grpc-keepalive-timeout`, and `grpc-keepalive-permit-without-calls `from ydb-cpp-sdk

via @ref ydb::Component static config and NYdb::TDriverConfig. When tcp-keepalive is set, all subkeys are required.
commit_hash:26073b3ccb69c06134537ef67ec84a07baeb379a

Author: don-dron

ydb/src/ydb/component.yaml

@@ -67,17 +67,49 @@ properties:
                 network-threads-num:
                     type: integer
                     minimum: 1
-                    default: 2
                     description: |
-                        Number of gRPC worker threads in YDB C++ SDK (NYdb::TDriverConfig::SetNetworkThreadsNum).
-                        Defaults to the SDK default (2).
+                        NYdb::TDriverConfig::SetNetworkThreadsNum. If omitted, not set (SDK default).
                 client-threads-num:
                     type: integer
                     minimum: 0
-                    default: 0
                     description: |
-                        Number of threads for async user callbacks in YDB C++ SDK (NYdb::TDriverConfig::SetClientThreadsNum).
-                        0 means adaptive thread pool (SDK default).
+                        NYdb::TDriverConfig::SetClientThreadsNum. If omitted, not set (SDK default).
+                tcp-keepalive:
+                    type: object
+                    additionalProperties: false
+                    description: |
+                        NYdb::TDriverConfig::SetTcpKeepAliveSettings. If the whole block is omitted, not set (SDK default).
+                        Use 0 for idle/count/interval on Linux to mean OS default.
+                    properties:
+                        enabled:
+                            type: boolean
+                            description: enable TCP keepalive on gRPC sockets (Linux; if omitted in a partial block, parser default
+                                applies)
+                        idle-sec:
+                            type: integer
+                            minimum: 0
+                            description: seconds idle before first keepalive probe (0 = OS default on Linux)
+                        probe-count:
+                            type: integer
+                            minimum: 0
+                            description: unacknowledged probes before drop (0 = OS default on Linux)
+                        interval-sec:
+                            type: integer
+                            minimum: 0
+                            description: seconds between probes (0 = OS default on Linux)
+                    required:
+                      - enabled
+                      - idle-sec
+                      - probe-count
+                      - interval-sec
+                grpc-keepalive-timeout:
+                    type: string
+                    description: |
+                        Duration string, e.g. 10s. NYdb::TDriverConfig::SetGRpcKeepAliveTimeout. If omitted, not set (SDK default).
+                grpc-keepalive-permit-without-calls:
+                    type: boolean
+                    description: |
+                        NYdb::TDriverConfig::SetGRpcKeepAlivePermitWithoutCalls. If omitted, not set (SDK default).
                 prefer_local_dc:
                     type: boolean
                     default: true

ydb/src/ydb/impl/config.cpp

@@ -67,8 +67,21 @@ DriverSettings ParseDriverSettings(
     auto config_database = dbconfig["database"].As<std::optional<std::string>>();
 
     result.prefer_local_dc = dbconfig["prefer_local_dc"].As<bool>(result.prefer_local_dc);
-    result.network_threads_num = dbconfig["network-threads-num"].As<std::size_t>(result.network_threads_num);
-    result.client_threads_num = dbconfig["client-threads-num"].As<std::size_t>(result.client_threads_num);
+    result.network_threads_num = dbconfig["network-threads-num"].As<std::optional<std::size_t>>();
+    result.client_threads_num = dbconfig["client-threads-num"].As<std::optional<std::size_t>>();
+
+    if (!dbconfig["tcp-keepalive"].IsMissing()) {
+        const auto tcp = dbconfig["tcp-keepalive"];
+        result.tcp_keepalive = TcpKeepaliveSettings{
+            tcp["enabled"].As<bool>(),
+            tcp["idle-sec"].As<std::size_t>(),
+            tcp["probe-count"].As<std::size_t>(),
+            tcp["interval-sec"].As<std::size_t>(),
+        };
+    }
+    result.grpc_keepalive_timeout = dbconfig["grpc-keepalive-timeout"].As<std::optional<std::chrono::milliseconds>>();
+    result.grpc_keepalive_permit_without_calls =
+        dbconfig["grpc-keepalive-permit-without-calls"].As<std::optional<bool>>();
 
     result.endpoint = MergeWithSecdist(dbsecdist.endpoint, std::move(config_endpoint), dbconfig, "endpoint");
     result.database = MergeWithSecdist(dbsecdist.database, std::move(config_database), dbconfig, "database");
@@ -85,8 +98,6 @@ DriverSettings ParseDriverSettings(
     return result;
 }
 
-using OptMs = std::optional<std::chrono::milliseconds>;
-
 const dynamic_config::Key<std::unordered_map<std::string, utils::RetryBudgetSettings>> kRetryBudgetSettings(
     "YDB_RETRY_BUDGET",
     dynamic_config::DefaultAsJsonString("{}")

ydb/src/ydb/impl/config.hpp

@@ -37,12 +37,24 @@ struct TableSettings {
 
 struct TopicSettings {};
 
+struct TcpKeepaliveSettings {
+    bool enabled;
+    std::size_t idle_sec;
+    std::size_t probe_count;
+    std::size_t interval_sec;
+};
+
 struct DriverSettings {
     std::string endpoint;
     std::string database;
 
-    std::size_t network_threads_num{2};
-    std::size_t client_threads_num{0};
+    std::optional<std::size_t> network_threads_num{};
+    std::optional<std::size_t> client_threads_num{};
+
+    std::optional<TcpKeepaliveSettings> tcp_keepalive{};
+
+    std::optional<std::chrono::milliseconds> grpc_keepalive_timeout{};
+    std::optional<bool> grpc_keepalive_permit_without_calls{};
 
     bool prefer_local_dc{false};
     std::optional<std::string> oauth_token;

ydb/src/ydb/impl/driver.cpp

@@ -28,9 +28,13 @@ Driver::Driver(std::string dbname, impl::DriverSettings settings)
             settings.prefer_local_dc
                 ? NYdb::EBalancingPolicy::UsePreferableLocation
                 : NYdb::EBalancingPolicy::UseAllNodes
-        )
-        .SetNetworkThreadsNum(settings.network_threads_num)
-        .SetClientThreadsNum(settings.client_threads_num);
+        );
+    if (settings.network_threads_num.has_value()) {
+        driver_config.SetNetworkThreadsNum(*settings.network_threads_num);
+    }
+    if (settings.client_threads_num.has_value()) {
+        driver_config.SetClientThreadsNum(*settings.client_threads_num);
+    }
 
     if (settings.secure_connection_cert.has_value()) {
         driver_config.UseSecureConnection(*settings.secure_connection_cert);
@@ -51,6 +55,21 @@ Driver::Driver(std::string dbname, impl::DriverSettings settings)
         driver_config.SetCredentialsProviderFactory(NYdb::CreateLoginCredentialsProviderFactory(std::move(creds)));
     }
 
+    if (settings.tcp_keepalive.has_value()) {
+        driver_config.SetTcpKeepAliveSettings(
+            settings.tcp_keepalive->enabled,
+            settings.tcp_keepalive->idle_sec,
+            settings.tcp_keepalive->probe_count,
+            settings.tcp_keepalive->interval_sec
+        );
+    }
+    if (settings.grpc_keepalive_timeout.has_value()) {
+        driver_config.SetGRpcKeepAliveTimeout(TDuration(*settings.grpc_keepalive_timeout));
+    }
+    if (settings.grpc_keepalive_permit_without_calls.has_value()) {
+        driver_config.SetGRpcKeepAlivePermitWithoutCalls(*settings.grpc_keepalive_permit_without_calls);
+    }
+
     driver_ = std::make_unique<NYdb::TDriver>(driver_config);
     NSolomonStatExtension::AddMetricRegistry(*driver_, native_metrics_.get());
 }