PPAF: Fixes issue where setting RequestTimeout to 0 second will cause PPAF dynamic enablement to break (#5427)

# Pull Request Template

## Description


This pull request improves the handling of invalid request timeout
values in the Cosmos client and adds a new integration test to verify
the behavior. The main focus is ensuring that when a request timeout of
0ms is set, the client falls back to a safe default for hedging
thresholds, preventing potential issues with failover strategies.

**Partition-level failover and hedging logic improvements:**

* Updated `InitializePartitionLevelFailoverWithDefaultHedging` in
`DocumentClient.cs` to check if `RequestTimeout` is set to 0ms, and if
so, fallback to `DefaultHedgingThresholdInMilliseconds` and log a
warning. This prevents invalid timeout values from causing issues with
availability strategies.

**Testing and validation:**

* Added a new test method `ClinetOverrides0msRequestTimeoutValueForPPAF`
in `CosmosItemIntegrationTests.cs` to verify that when the client is
configured with a 0ms request timeout, the hedging threshold is not set
to 0, ensuring the fallback logic works as intended. The test also
intercepts gateway responses to simulate specific conditions.

## Type of change

Please delete options that are not relevant.

- [] Bug fix (non-breaking change which fixes an issue)

## Closing issues

To automatically close an issue: closes #5430

---------

Co-authored-by: Debdatta Kunda <[email protected]>

Author: NaluTripician

Microsoft.Azure.Cosmos/src/DocumentClient.cs

@@ -6863,9 +6863,20 @@ internal void InitializePartitionLevelFailoverWithDefaultHedging()
             {
                 // The default threshold is the minimum value of 1 second and a fraction (currently it's half) of
                 // the request timeout value provided by the end customer.
-                double defaultThresholdInMillis = Math.Min(
-                    DocumentClient.DefaultHedgingThresholdInMilliseconds,
-                    this.ConnectionPolicy.RequestTimeout.TotalMilliseconds / 2);
+                double defaultThresholdInMillis;
+                
+                if (this.ConnectionPolicy.RequestTimeout.TotalMilliseconds == 0)
+                {
+                    // If the request timeout is 0, we will use the default hedging theshold value
+                    defaultThresholdInMillis = DocumentClient.DefaultHedgingThresholdInMilliseconds;
+                    DefaultTrace.TraceWarning("DocumentClient: Request timeout is set to 0, which is not a valid value. Falling back to default hedging threshold of {0} ms", defaultThresholdInMillis);
+                }
+                else
+                {
+                    defaultThresholdInMillis = Math.Min(
+                        DocumentClient.DefaultHedgingThresholdInMilliseconds,
+                        this.ConnectionPolicy.RequestTimeout.TotalMilliseconds / 2);
+                }
 
                 this.ConnectionPolicy.AvailabilityStrategy = AvailabilityStrategy.SDKDefaultCrossRegionHedgingStrategyForPPAF(
                     threshold: TimeSpan.FromMilliseconds(defaultThresholdInMillis),

Microsoft.Azure.Cosmos/tests/Microsoft.Azure.Cosmos.EmulatorTests/CosmosItemIntegrationTests.cs

@@ -2195,6 +2195,70 @@ public async Task CreateItemAsync_WithThinClientEnabledAndCircuitBreakerEnabledA
                 await this.TryDeleteItems(itemsList);
             }
         }
+
+        [TestMethod]
+        [Owner("ntripician")]
+        [TestCategory("MultiRegion")]
+        [Timeout(70000)]
+        public async Task ClinetOverrides0msRequestTimeoutValueForPPAF()
+        {
+            // Arrange.
+            
+            // Now that the ppaf enablement flag is returned from gateway, we need to intercept the response and remove the flag from the response, so that
+            // the environment variable set above is honored.
+            HttpClientHandlerHelper httpClientHandlerHelper = new HttpClientHandlerHelper()
+            {
+                ResponseIntercepter = async (response, request) =>
+                {
+                    string json = await response?.Content?.ReadAsStringAsync();
+                    if (json.Length > 0 && json.Contains("enablePerPartitionFailoverBehavior"))
+                    {
+                        JObject parsedDatabaseAccountResponse = JObject.Parse(json);
+                        parsedDatabaseAccountResponse.Property("enablePerPartitionFailoverBehavior").Value = "true";
+
+                        HttpResponseMessage interceptedResponse = new()
+                        {
+                            StatusCode = response.StatusCode,
+                            Content = new StringContent(parsedDatabaseAccountResponse.ToString()),
+                            Version = response.Version,
+                            ReasonPhrase = response.ReasonPhrase,
+                            RequestMessage = response.RequestMessage,
+                        };
+
+                        return interceptedResponse;
+                    }
+
+                    return response;
+                },
+            };
+
+            List<string> preferredRegions = new List<string> { region1, region2, region3 };
+            CosmosClientOptions cosmosClientOptions = new CosmosClientOptions()
+            {
+                ConsistencyLevel = ConsistencyLevel.Session,
+                RequestTimeout = TimeSpan.FromSeconds(0),
+                ApplicationPreferredRegions = preferredRegions,
+                HttpClientFactory = () => new HttpClient(httpClientHandlerHelper),
+            };
+
+
+            using CosmosClient cosmosClient = new(connectionString: this.connectionString, clientOptions: cosmosClientOptions);
+            Database database = cosmosClient.GetDatabase(MultiRegionSetupHelpers.dbName);
+            Container container = database.GetContainer(MultiRegionSetupHelpers.containerName);
+
+            try
+            {
+                //request to start document client initiation 
+                _ = await container.ReadItemAsync<CosmosIntegrationTestObject>("id", new PartitionKey("pk1"));
+            }
+            catch { }
+
+            // Act and Assert.
+
+            CrossRegionHedgingAvailabilityStrategy strat = cosmosClient.DocumentClient.ConnectionPolicy.AvailabilityStrategy as CrossRegionHedgingAvailabilityStrategy;
+            Assert.IsNotNull(strat);
+            Assert.AreNotEqual(0, strat.Threshold);
+        }
 
         private async Task TryCreateItems(List<CosmosIntegrationTestObject> testItems)
         {