feat postgresql: add omit-statement-timeout-for-autocommit for transaction pooler mode

commit_hash:ab8215021bd4f49da2b0c30a6fa26b1617429ee8

Author: oigolovanova

postgresql/dynamic_configs/POSTGRES_CONNECTION_SETTINGS.yaml

@@ -73,4 +73,17 @@ schema:
                     type: boolean
                     default: true
                     description: Whether statement timeout is affected by deadline propagation
+                omit-statement-timeout-for-autocommit:
+                    type: boolean
+                    default: false
+                    description: |-
+                        DANGEROUS, DO NOT ENABLE unless you fully understand the consequences.
+
+                        Has effect only in `transaction` pooler mode. When enabled, no `SET statement_timeout` is sent
+                        before autocommit statements. This saves one network round trip per query.
+
+                        The catch: without `statement_timeout` a stuck or slow query is no longer aborted by the framework, so it
+                        can hold the connection indefinitely. Deadline propagation implemented on top of `statement_timeout`
+                        stops working for such queries as well. A single misbehaving query can therefore exhaust the whole
+                        connection pool and take the service down
 

postgresql/include/userver/storages/postgres/options.hpp

@@ -312,6 +312,11 @@ struct ConnectionSettings {
 
     PoolerMode pooler_mode{PoolerMode::kSession};
 
+    /// DANGEROUS. Has effect only in @ref PoolerMode::kTransaction. When set, no `SET statement_timeout` is sent
+    /// before autocommit statements, saving a round trip at the cost of losing statement_timeout enforcement (and
+    /// deadline propagation built on top of it) for such queries
+    bool omit_statement_timeout_for_autocommit = false;
+
     bool operator==(const ConnectionSettings& rhs) const {
         return !RequiresConnectionReset(rhs) && recent_errors_threshold == rhs.recent_errors_threshold;
     }
@@ -323,7 +328,8 @@ struct ConnectionSettings {
                max_prepared_cache_size != rhs.max_prepared_cache_size || pipeline_mode != rhs.pipeline_mode ||
                max_ttl != rhs.max_ttl || discard_on_connect != rhs.discard_on_connect ||
                omit_describe_mode != rhs.omit_describe_mode || application_name != rhs.application_name ||
-               pooler_mode != rhs.pooler_mode;
+               pooler_mode != rhs.pooler_mode ||
+               omit_statement_timeout_for_autocommit != rhs.omit_statement_timeout_for_autocommit;
     }
 };
 
@@ -336,6 +342,7 @@ struct ConnectionSettingsDynamic final {
     std::optional<std::chrono::seconds> max_ttl{};
     std::optional<ConnectionSettings::DiscardOnConnectOptions> discard_on_connect{};
     std::optional<bool> deadline_propagation_enabled{};
+    std::optional<bool> omit_statement_timeout_for_autocommit{};
 };
 
 /// @brief PostgreSQL statements metrics options

postgresql/src/storages/postgres/component.cpp

@@ -95,6 +95,10 @@ void MergeConnectionSettings(
         MergeField(static_settings.recent_errors_threshold, dynamic_settings.recent_errors_threshold);
         MergeField(static_settings.discard_on_connect, dynamic_settings.discard_on_connect);
         MergeField(static_settings.deadline_propagation_enabled, dynamic_settings.deadline_propagation_enabled);
+        MergeField(
+            static_settings.omit_statement_timeout_for_autocommit,
+            dynamic_settings.omit_statement_timeout_for_autocommit
+        );
         if (const auto max_ttl = dynamic_settings.max_ttl; max_ttl) {
             static_settings.max_ttl = *max_ttl;
         }

postgresql/src/storages/postgres/component.yaml

@@ -86,6 +86,14 @@ properties:
         type: boolean
         description: whether statement timeout is affected by deadline propagation
         default: true
+    omit-statement-timeout-for-autocommit:
+        type: boolean
+        description: |
+            DANGEROUS. Has effect only in `transaction` pooler mode. When enabled,
+            no SET statement_timeout is sent before autocommit statements, saving a round
+            trip at the cost of losing statement_timeout enforcement for such queries.
+            Keep it false
+        default: false
     monitoring-dbalias:
         type: string
         description: |

postgresql/src/storages/postgres/detail/connection_impl.cpp

@@ -453,7 +453,8 @@ Connection::Statistics ConnectionImpl::GetStatsAndReset() {
 }
 
 bool ConnectionImpl::ShouldWrapInAutoTransaction(const std::string_view statement) const noexcept {
-    return IsTransactionPooler() && !IsInTransaction() && !ICaseStartsWith(statement, kStatementVacuum);
+    return IsTransactionPooler() && !settings_.omit_statement_timeout_for_autocommit && !IsInTransaction() &&
+           !ICaseStartsWith(statement, kStatementVacuum);
 }
 
 ResultSet ConnectionImpl::ExecuteCommandInAutoTransaction(
@@ -513,7 +514,11 @@ ResultSet ConnectionImpl::ExecuteCommand(
         return ExecuteCommandInAutoTransaction(query, params, statement_cmd_ctl, deadline);
     }
 
-    SetStatementTimeout(statement_cmd_ctl);
+    // In transaction pooler mode with omit_statement_timeout_for_autocommit enabled we deliberately skip
+    // SET statement_timeout for autocommit statements to save a round trip (see @ref POSTGRES_CONNECTION_SETTINGS)
+    if (!(IsTransactionPooler() && settings_.omit_statement_timeout_for_autocommit && !IsInTransaction())) {
+        SetStatementTimeout(statement_cmd_ctl);
+    }
 
     return PreparedStatementsEnabled(statement_cmd_ctl)
                ? ExecuteCommand(query, params, deadline, logging::Level::kInfo, true)

postgresql/src/storages/postgres/postgres_config.cpp

@@ -98,6 +98,9 @@ ConnectionSettings ParseConnectionSettings(const ConfigType& config) {
             ? ConnectionSettings::kDiscardAll
             : ConnectionSettings::kDiscardNone;
     settings.deadline_propagation_enabled = config["deadline-propagation-enabled"].template As<bool>(true);
+    settings
+        .omit_statement_timeout_for_autocommit = config["omit-statement-timeout-for-autocommit"].template As<bool>(false
+    );
     settings.application_name =
         config["application_name"].template As<std::string>(USERVER_NAMESPACE::utils::GetUserverIdentifier());
 
@@ -150,6 +153,12 @@ ConnectionSettingsDynamic Parse(const formats::json::Value& config, formats::par
     if (const auto dp_enabled = config["deadline-propagation-enabled"].As<std::optional<bool>>(); dp_enabled) {
         settings.deadline_propagation_enabled = *dp_enabled;
     }
+    if (const auto omit_statement_timeout_for_autocommit =
+            config["omit-statement-timeout-for-autocommit"].As<std::optional<bool>>();
+        omit_statement_timeout_for_autocommit)
+    {
+        settings.omit_statement_timeout_for_autocommit = *omit_statement_timeout_for_autocommit;
+    }
 
     return settings;
 }

postgresql/src/storages/postgres/tests/connection_transaction_mode_pgtest.cpp

@@ -252,6 +252,30 @@ UTEST_F(PostgreTransactionModeConnection, DuplicatePreparedStatementDirtyConnect
     EXPECT_FALSE(conn->IsBroken());
 }
 
+UTEST_F(PostgreTransactionModeConnection, OmitStatementTimeoutForAutocommitSkipsAutoTransactionAndStatementTimeout) {
+    pg::detail::ConnectionPtr conn{nullptr};
+    auto settings = MakeTransactionPoolerSettings();
+    settings.omit_statement_timeout_for_autocommit = true;
+    UEXPECT_NO_THROW(conn = MakeConnection(GetDsnFromEnv(), GetTaskProcessor(), settings));
+    ASSERT_TRUE(conn);
+
+    const DefaultCommandControlScope scope{kTransactionPoolerCmdCtl};
+
+    UEXPECT_NO_THROW(ZeroBackendStatementTimeout(conn));
+    GetLogCapture().Clear();
+
+    UEXPECT_NO_THROW(conn->Execute("SELECT pg_sleep(0.3)"));
+
+    const auto set_config_logs = GetLogCapture().Filter([&](const utest::LogRecord& log) {
+        return log.GetTagOptional(tracing::kDatabaseStatementName) == kSetConfigStatementName;
+    });
+    EXPECT_THAT(set_config_logs, ::testing::IsEmpty());
+    UEXPECT_NO_THROW(ExpectBackendStatementTimeout(conn, "0"));
+
+    UEXPECT_NO_THROW(conn->CancelAndCleanup(utest::kMaxTestWaitTime));
+    EXPECT_FALSE(conn->IsBroken());
+}
+
 }  // namespace
 
 USERVER_NAMESPACE_END