Merge remote-tracking branch 'origin/master' into users/trivediyash/CFPDeleteMetadata

yash2710 · yash2710 · commit 9d39e1fe38fa · 2025-11-10T09:59:18.000-08:00
diff --git a/Microsoft.Azure.Cosmos/src/HttpClient/CosmosHttpClientCore.cs b/Microsoft.Azure.Cosmos/src/HttpClient/CosmosHttpClientCore.cs
@@ -388,7 +388,7 @@ private async Task<HttpResponseMessage> SendHttpHelperAsync(
                             return responseMessage;
                         }
 
-                        bool isOutOfRetries = CosmosHttpClientCore.IsOutOfRetries(timeoutPolicy, startDateTimeUtc, timeoutEnumerator);
+                        bool isOutOfRetries = CosmosHttpClientCore.IsOutOfRetries(timeoutEnumerator);
                         if (isOutOfRetries)
                         {
                             return responseMessage;
@@ -402,7 +402,7 @@ private async Task<HttpResponseMessage> SendHttpHelperAsync(
                             datum.RecordHttpException(requestMessage, e, resourceType, requestStartTime);
                             trace = datum.Trace;
                         }
-                        bool isOutOfRetries = CosmosHttpClientCore.IsOutOfRetries(timeoutPolicy, startDateTimeUtc, timeoutEnumerator);
+                        bool isOutOfRetries = CosmosHttpClientCore.IsOutOfRetries(timeoutEnumerator);
 
                         switch (e)
                         {
@@ -415,7 +415,7 @@ private async Task<HttpResponseMessage> SendHttpHelperAsync(
 
                                 // Convert OperationCanceledException to 408 when the HTTP client throws it. This makes it clear that the 
                                 // the request timed out and was not user canceled operation.
-                                if (isOutOfRetries || !timeoutPolicy.IsSafeToRetry(requestMessage.Method))
+                                if (isOutOfRetries || !CosmosHttpClientCore.IsSafeToRetry(documentServiceRequest))
                                 {
                                     // throw current exception (caught in transport handler)
                                     string message =
@@ -440,14 +440,14 @@ private async Task<HttpResponseMessage> SendHttpHelperAsync(
 
                                 break;
                             case WebException webException:
-                                if (isOutOfRetries || (!timeoutPolicy.IsSafeToRetry(requestMessage.Method) && !WebExceptionUtility.IsWebExceptionRetriable(webException)))
+                                if (isOutOfRetries || (!CosmosHttpClientCore.IsSafeToRetry(documentServiceRequest) && !WebExceptionUtility.IsWebExceptionRetriable(webException)))
                                 {
                                     throw;
                                 }
 
                                 break;
                             case HttpRequestException httpRequestException:
-                                if (isOutOfRetries || !timeoutPolicy.IsSafeToRetry(requestMessage.Method))
+                                if (isOutOfRetries || !CosmosHttpClientCore.IsSafeToRetry(documentServiceRequest))
                                 {
                                     throw;
                                 }
@@ -493,13 +493,24 @@ private async Task<HttpResponseMessage> SendHttpHelperAsync(
         }
 
         private static bool IsOutOfRetries(
-            HttpTimeoutPolicy timeoutPolicy,
-            DateTime startDateTimeUtc,
             IEnumerator<(TimeSpan requestTimeout, TimeSpan delayForNextRequest)> timeoutEnumerator)
         {
             return !timeoutEnumerator.MoveNext(); // No more retries are configured
         }
 
+        private static bool IsSafeToRetry(DocumentServiceRequest documentServiceRequest)
+        {
+            // Three scenarios are safely retriable:
+            // 1) If request is null since they are originated from GetAsync calls
+            // 2) If request is read-only
+            // 3) If request is an address request.
+            if (documentServiceRequest == null)
+            {
+                return true;
+            }
+            return documentServiceRequest.IsReadOnlyRequest || documentServiceRequest.ResourceType == ResourceType.Address;
+        }
+
         private async Task<HttpResponseMessage> ExecuteHttpHelperAsync(
             HttpRequestMessage requestMessage,
             ResourceType resourceType,
diff --git a/Microsoft.Azure.Cosmos/src/HttpClient/HttpTimeoutPolicy.cs b/Microsoft.Azure.Cosmos/src/HttpClient/HttpTimeoutPolicy.cs
@@ -13,7 +13,6 @@ internal abstract class HttpTimeoutPolicy
         public abstract string TimeoutPolicyName { get; }
         public abstract int TotalRetryCount { get; }
         public abstract IEnumerator<(TimeSpan requestTimeout, TimeSpan delayForNextRequest)> GetTimeoutEnumerator();
-        public abstract bool IsSafeToRetry(HttpMethod httpMethod);
 
         public abstract bool ShouldRetryBasedOnResponse(HttpMethod requestHttpMethod, HttpResponseMessage responseMessage);
 
diff --git a/Microsoft.Azure.Cosmos/src/HttpClient/HttpTimeoutPolicyControlPlaneRead.cs b/Microsoft.Azure.Cosmos/src/HttpClient/HttpTimeoutPolicyControlPlaneRead.cs
@@ -32,12 +32,6 @@ private HttpTimeoutPolicyControlPlaneRead()
             return this.TimeoutsAndDelays.GetEnumerator();
         }
 
-        // This is for control plane reads which should always be safe to retry on.
-        public override bool IsSafeToRetry(HttpMethod httpMethod)
-        {
-            return true;
-        }
-
         public override bool ShouldRetryBasedOnResponse(HttpMethod requestHttpMethod, HttpResponseMessage responseMessage)
         {
             return false;
diff --git a/Microsoft.Azure.Cosmos/src/HttpClient/HttpTimeoutPolicyControlPlaneRetriableHotPath.cs b/Microsoft.Azure.Cosmos/src/HttpClient/HttpTimeoutPolicyControlPlaneRetriableHotPath.cs
@@ -36,13 +36,6 @@ private HttpTimeoutPolicyControlPlaneRetriableHotPath(bool shouldThrow503OnTimeo
             return this.TimeoutsAndDelays.GetEnumerator();
         }
 
-        // The hot path should always be safe to retires since it should be retrieving meta data 
-        // information that is not idempotent.
-        public override bool IsSafeToRetry(HttpMethod httpMethod)
-        {
-            return true;
-        }
-
         public override bool ShouldRetryBasedOnResponse(HttpMethod requestHttpMethod, HttpResponseMessage responseMessage)
         { 
             if (responseMessage == null)
@@ -55,11 +48,6 @@ public override bool ShouldRetryBasedOnResponse(HttpMethod requestHttpMethod, Ht
                 return false;
             }
 
-            if (!this.IsSafeToRetry(requestHttpMethod))
-            {
-                return false;
-            }
-
             return true;
         }
 
diff --git a/Microsoft.Azure.Cosmos/src/HttpClient/HttpTimeoutPolicyDefault.cs b/Microsoft.Azure.Cosmos/src/HttpClient/HttpTimeoutPolicyDefault.cs
@@ -36,13 +36,6 @@ private HttpTimeoutPolicyDefault(bool shouldThrow503OnTimeout)
             return this.TimeoutsAndDelays.GetEnumerator();
         }
 
-        // Assume that it is not safe to retry unless it is a get method.
-        // Create and other operations could have succeeded even though a timeout occurred.
-        public override bool IsSafeToRetry(HttpMethod httpMethod)
-        {
-            return httpMethod == HttpMethod.Get;
-        }
-
         public override bool ShouldRetryBasedOnResponse(HttpMethod requestHttpMethod, HttpResponseMessage responseMessage)
         {
             return false;
diff --git a/Microsoft.Azure.Cosmos/src/HttpClient/HttpTimeoutPolicyForPartitionFailover.cs b/Microsoft.Azure.Cosmos/src/HttpClient/HttpTimeoutPolicyForPartitionFailover.cs
@@ -35,13 +35,6 @@ private HttpTimeoutPolicyForPartitionFailover(bool shouldThrow503OnTimeout)
             return this.TimeoutsAndDelays.GetEnumerator();
         }
 
-        // Assume that it is not safe to retry unless it is a get method.
-        // Create and other operations could have succeeded even though a timeout occurred.
-        public override bool IsSafeToRetry(HttpMethod httpMethod)
-        {
-            return httpMethod == HttpMethod.Get;
-        }
-
         public override bool ShouldRetryBasedOnResponse(HttpMethod requestHttpMethod, HttpResponseMessage responseMessage)
         {
             return false;
diff --git a/Microsoft.Azure.Cosmos/src/HttpClient/HttpTimeoutPolicyForThinClient.cs b/Microsoft.Azure.Cosmos/src/HttpClient/HttpTimeoutPolicyForThinClient.cs
@@ -39,11 +39,6 @@ private HttpTimeoutPolicyForThinClient(
             return this.TimeoutsAndDelays.GetEnumerator();
         }
 
-        public override bool IsSafeToRetry(HttpMethod httpMethod)
-        {
-            return this.shouldRetry;
-        }
-
         public override bool ShouldRetryBasedOnResponse(HttpMethod requestHttpMethod, HttpResponseMessage responseMessage)
         { 
             if (responseMessage == null)
@@ -56,7 +51,7 @@ public override bool ShouldRetryBasedOnResponse(HttpMethod requestHttpMethod, Ht
                 return false;
             }
 
-            if (!this.IsSafeToRetry(requestHttpMethod))
+            if (!this.shouldRetry)
             {
                 return false;
             }
diff --git a/Microsoft.Azure.Cosmos/src/HttpClient/HttpTimeoutPolicyNoRetry.cs b/Microsoft.Azure.Cosmos/src/HttpClient/HttpTimeoutPolicyNoRetry.cs
@@ -31,12 +31,6 @@ private HttpTimeoutPolicyNoRetry()
             return this.TimeoutsAndDelays.GetEnumerator();
         }
 
-        // Always Unsafe to retry
-        public override bool IsSafeToRetry(HttpMethod httpMethod)
-        {
-            return false;
-        }
-
         public override bool ShouldRetryBasedOnResponse(HttpMethod requestHttpMethod, HttpResponseMessage responseMessage)
         {
             return false;
diff --git a/Microsoft.Azure.Cosmos/tests/Microsoft.Azure.Cosmos.Tests/CosmosHttpClientCoreTests.cs b/Microsoft.Azure.Cosmos/tests/Microsoft.Azure.Cosmos.Tests/CosmosHttpClientCoreTests.cs
@@ -123,7 +123,8 @@ async Task<HttpResponseMessage> sendFunc(HttpRequestMessage request, Cancellatio
                         resourceType: ResourceType.Collection,
                         timeoutPolicy: currentTimeoutPolicy.Key,
                         clientSideRequestStatistics: new ClientSideRequestStatisticsTraceDatum(DateTime.UtcNow, trace),
-                        cancellationToken: default);
+                        cancellationToken: default,
+                        documentServiceRequest: CreateDocumentServiceRequestByOperation(ResourceType.Collection, OperationType.Read));
 
                     Assert.AreEqual(HttpStatusCode.OK, responseMessage.StatusCode);
                 }
@@ -266,7 +267,8 @@ Task<HttpResponseMessage> sendFunc(HttpRequestMessage request, CancellationToken
                         resourceType: ResourceType.Collection,
                         timeoutPolicy: HttpTimeoutPolicyDefault.Instance,
                         clientSideRequestStatistics: new ClientSideRequestStatisticsTraceDatum(DateTime.UtcNow, trace),
-                        cancellationToken: default);
+                        cancellationToken: default,
+                        documentServiceRequest: CreateDocumentServiceRequestByOperation(ResourceType.Collection, OperationType.Read));
                 }
             }
             catch (Exception)
@@ -281,7 +283,7 @@ Task<HttpResponseMessage> sendFunc(HttpRequestMessage request, CancellationToken
         public async Task HttpTimeoutThrow503TestAsync()
         {
 
-            async Task TestScenarioAsync(HttpMethod method, ResourceType resourceType, HttpTimeoutPolicy timeoutPolicy, Type expectedException, int expectedNumberOfRetrys)
+            async Task TestScenarioAsync(HttpMethod method, ResourceType resourceType, OperationType operationType, HttpTimeoutPolicy timeoutPolicy, Type expectedException, int expectedNumberOfRetrys)
             {
                 int count = 0;
                 Task<HttpResponseMessage> sendFunc(HttpRequestMessage request, CancellationToken cancellationToken)
@@ -306,7 +308,8 @@ Task<HttpResponseMessage> sendFunc(HttpRequestMessage request, CancellationToken
                             resourceType: resourceType,
                             timeoutPolicy: timeoutPolicy,
                             clientSideRequestStatistics: new ClientSideRequestStatisticsTraceDatum(DateTime.UtcNow, trace),
-                            cancellationToken: default);
+                            cancellationToken: default,
+                            documentServiceRequest: CreateDocumentServiceRequestByOperation(resourceType, operationType));
                     }
                 }
                 catch (Exception e)
@@ -328,19 +331,19 @@ Task<HttpResponseMessage> sendFunc(HttpRequestMessage request, CancellationToken
             }
 
             //Data plane read
-            await TestScenarioAsync(HttpMethod.Get, ResourceType.Document, HttpTimeoutPolicyDefault.InstanceShouldThrow503OnTimeout, typeof(CosmosException), 3);
+            await TestScenarioAsync(HttpMethod.Get, ResourceType.Document, OperationType.Read, HttpTimeoutPolicyDefault.InstanceShouldThrow503OnTimeout, typeof(CosmosException), 3);
 
             //Data plane write (Should throw a 408 OperationCanceledException rather than a 503)
-            await TestScenarioAsync(HttpMethod.Post, ResourceType.Document, HttpTimeoutPolicyDefault.Instance, typeof(TaskCanceledException), 1);
+            await TestScenarioAsync(HttpMethod.Post, ResourceType.Document, OperationType.Upsert, HttpTimeoutPolicyDefault.Instance, typeof(TaskCanceledException), 1);
 
             //Meta data read
-            await TestScenarioAsync(HttpMethod.Get, ResourceType.Database, HttpTimeoutPolicyDefault.InstanceShouldThrow503OnTimeout, typeof(CosmosException), 3);
+            await TestScenarioAsync(HttpMethod.Get, ResourceType.Database, OperationType.Read, HttpTimeoutPolicyDefault.InstanceShouldThrow503OnTimeout, typeof(CosmosException), 3);
 
             //Query plan read (note all query plan operations are reads).
-            await TestScenarioAsync(HttpMethod.Get, ResourceType.Document, HttpTimeoutPolicyDefault.InstanceShouldThrow503OnTimeout, typeof(CosmosException), 3);
+            await TestScenarioAsync(HttpMethod.Get, ResourceType.Document, OperationType.Read, HttpTimeoutPolicyDefault.InstanceShouldThrow503OnTimeout, typeof(CosmosException), 3);
 
             //Metadata Write (Should throw a 408 OperationCanceledException rather than a 503)
-            await TestScenarioAsync(HttpMethod.Post, ResourceType.Document, HttpTimeoutPolicyDefault.Instance, typeof(TaskCanceledException), 1);
+            await TestScenarioAsync(HttpMethod.Post, ResourceType.Document, OperationType.Upsert, HttpTimeoutPolicyDefault.Instance, typeof(TaskCanceledException), 1);
         }
 
         [TestMethod]
@@ -433,7 +436,8 @@ async Task<HttpResponseMessage> sendFunc(HttpRequestMessage request, Cancellatio
                         resourceType: ResourceType.Document,
                         timeoutPolicy: HttpTimeoutPolicyControlPlaneRetriableHotPath.Instance,
                         clientSideRequestStatistics: new ClientSideRequestStatisticsTraceDatum(DateTime.UtcNow, trace),
-                        cancellationToken: default);
+                        cancellationToken: default,
+                        documentServiceRequest: documentServiceRequest);
 
                 Assert.AreEqual(HttpStatusCode.OK, responseMessage.StatusCode);
             }
@@ -492,7 +496,7 @@ public void CreateHttpClientHandlerCreatesCorrectValueType()
         public async Task HttpTimeoutPolicyForThinClientOn503TestAsync()
         {
 
-            async Task TestScenarioAsync(HttpMethod method, ResourceType resourceType, HttpTimeoutPolicy timeoutPolicy, Type expectedException, int expectedNumberOfRetrys)
+            async Task TestScenarioAsync(HttpMethod method, ResourceType resourceType, OperationType operationType, HttpTimeoutPolicy timeoutPolicy, Type expectedException, int expectedNumberOfRetrys)
             {
                 int count = 0;
                 Task<HttpResponseMessage> sendFunc(HttpRequestMessage request, CancellationToken cancellationToken)
@@ -517,7 +521,8 @@ Task<HttpResponseMessage> sendFunc(HttpRequestMessage request, CancellationToken
                             resourceType: resourceType,
                             timeoutPolicy: timeoutPolicy,
                             clientSideRequestStatistics: new ClientSideRequestStatisticsTraceDatum(DateTime.UtcNow, trace),
-                            cancellationToken: default);
+                            cancellationToken: default,
+                            documentServiceRequest: CreateDocumentServiceRequestByOperation(resourceType, operationType));
                     }
                 }
                 catch (Exception e)
@@ -542,6 +547,7 @@ Task<HttpResponseMessage> sendFunc(HttpRequestMessage request, CancellationToken
             await TestScenarioAsync(
                 method: HttpMethod.Get,
                 resourceType: ResourceType.Document,
+                operationType: OperationType.Read,
                 timeoutPolicy: HttpTimeoutPolicy.GetTimeoutPolicy(
                     documentServiceRequest: CosmosHttpClientCoreTests.CreateDocumentServiceRequestByOperation(ResourceType.Document, OperationType.Read),
                     isPartitionLevelFailoverEnabled: false,
@@ -553,6 +559,7 @@ await TestScenarioAsync(
             await TestScenarioAsync(
                 method: HttpMethod.Get,
                 resourceType: ResourceType.Document,
+                operationType: OperationType.Read,
                 timeoutPolicy: HttpTimeoutPolicy.GetTimeoutPolicy(
                     documentServiceRequest: CosmosHttpClientCoreTests.CreateDocumentServiceRequestByOperation(ResourceType.Document, OperationType.Query),
                     isPartitionLevelFailoverEnabled: false,
@@ -564,6 +571,7 @@ await TestScenarioAsync(
             await TestScenarioAsync(
                 method: HttpMethod.Post,
                 resourceType: ResourceType.Document,
+                operationType: OperationType.Upsert,
                 timeoutPolicy: HttpTimeoutPolicy.GetTimeoutPolicy(
                     documentServiceRequest: CosmosHttpClientCoreTests.CreateDocumentServiceRequestByOperation(ResourceType.Document, OperationType.Create),
                     isPartitionLevelFailoverEnabled: false,
@@ -575,6 +583,7 @@ await TestScenarioAsync(
             await TestScenarioAsync(
                 method: HttpMethod.Get,
                 resourceType: ResourceType.Database,
+                operationType: OperationType.Read,
                 timeoutPolicy: HttpTimeoutPolicy.GetTimeoutPolicy(
                     documentServiceRequest: CosmosHttpClientCoreTests.CreateDocumentServiceRequestByOperation(ResourceType.Database, OperationType.Read),
                     isPartitionLevelFailoverEnabled: false,
@@ -583,6 +592,7 @@ await TestScenarioAsync(
                 expectedNumberOfRetrys: 3);
         }
 
+
         private static DocumentServiceRequest CreateDocumentServiceRequestByOperation(
             ResourceType resourceType,
             OperationType operationType)
diff --git a/Microsoft.Azure.Cosmos/tests/Microsoft.Azure.Cosmos.Tests/GatewayStoreModelTest.cs b/Microsoft.Azure.Cosmos/tests/Microsoft.Azure.Cosmos.Tests/GatewayStoreModelTest.cs
@@ -889,15 +889,22 @@ public async Task GatewayStatsDurationTest()
                                                                                     DocumentClientEventSource.Instance);
 
             using (ITrace trace = Tracing.Trace.GetRootTrace(nameof(GatewayStatsDurationTest)))
-            {
-
+            {
+
                 Tracing.TraceData.ClientSideRequestStatisticsTraceDatum clientSideRequestStatistics = new Tracing.TraceData.ClientSideRequestStatisticsTraceDatum(DateTime.UtcNow, trace);
 
                 await cosmosHttpClient.SendHttpAsync(() => new ValueTask<HttpRequestMessage>(new HttpRequestMessage(HttpMethod.Get, "http://someuri.com")),
                                                       ResourceType.Document,
                                                       HttpTimeoutPolicyDefault.InstanceShouldThrow503OnTimeout,
                                                       clientSideRequestStatistics,
-                                                      CancellationToken.None);
+                                                      CancellationToken.None,
+                                                      documentServiceRequest: new DocumentServiceRequest(
+                                                                                OperationType.Read,
+                                                                                ResourceType.Document,
+                                                                                $"dbs/dummy_db_id/colls/dummy_ct_id",
+                                                                                body: null,
+                                                                                AuthorizationTokenType.PrimaryMasterKey,
+                                                                                headers: null));
 
                 Assert.AreEqual(clientSideRequestStatistics.HttpResponseStatisticsList.Count, 2);
                 // The duration is calculated using date times which can cause the duration to be slightly off. This allows for up to 15 Ms of variance.

Original file line number	Diff line number	Diff line change
`@@ -388,7 +388,7 @@ private async Task<HttpResponseMessage> SendHttpHelperAsync(`
`388`	`388`	`return responseMessage;`
`389`	`389`	`}`
`390`	`390`
`391`		`- bool isOutOfRetries = CosmosHttpClientCore.IsOutOfRetries(timeoutPolicy, startDateTimeUtc, timeoutEnumerator);`
	`391`	`+ bool isOutOfRetries = CosmosHttpClientCore.IsOutOfRetries(timeoutEnumerator);`
`392`	`392`	`if (isOutOfRetries)`
`393`	`393`	`{`
`394`	`394`	`return responseMessage;`
`@@ -402,7 +402,7 @@ private async Task<HttpResponseMessage> SendHttpHelperAsync(`
`402`	`402`	`datum.RecordHttpException(requestMessage, e, resourceType, requestStartTime);`
`403`	`403`	`trace = datum.Trace;`
`404`	`404`	`}`
`405`		`- bool isOutOfRetries = CosmosHttpClientCore.IsOutOfRetries(timeoutPolicy, startDateTimeUtc, timeoutEnumerator);`
	`405`	`+ bool isOutOfRetries = CosmosHttpClientCore.IsOutOfRetries(timeoutEnumerator);`
`406`	`406`
`407`	`407`	`switch (e)`
`408`	`408`	`{`
`@@ -415,7 +415,7 @@ private async Task<HttpResponseMessage> SendHttpHelperAsync(`
`415`	`415`
`416`	`416`	`// Convert OperationCanceledException to 408 when the HTTP client throws it. This makes it clear that the`
`417`	`417`	`// the request timed out and was not user canceled operation.`
`418`		`- if (isOutOfRetries \|\| !timeoutPolicy.IsSafeToRetry(requestMessage.Method))`
	`418`	`+ if (isOutOfRetries \|\| !CosmosHttpClientCore.IsSafeToRetry(documentServiceRequest))`
`419`	`419`	`{`
`420`	`420`	`// throw current exception (caught in transport handler)`
`421`	`421`	`string message =`
`@@ -440,14 +440,14 @@ private async Task<HttpResponseMessage> SendHttpHelperAsync(`
`440`	`440`
`441`	`441`	`break;`
`442`	`442`	`case WebException webException:`
`443`		`- if (isOutOfRetries \|\| (!timeoutPolicy.IsSafeToRetry(requestMessage.Method) && !WebExceptionUtility.IsWebExceptionRetriable(webException)))`
	`443`	`+ if (isOutOfRetries \|\| (!CosmosHttpClientCore.IsSafeToRetry(documentServiceRequest) && !WebExceptionUtility.IsWebExceptionRetriable(webException)))`
`444`	`444`	`{`
`445`	`445`	`throw;`
`446`	`446`	`}`
`447`	`447`
`448`	`448`	`break;`
`449`	`449`	`case HttpRequestException httpRequestException:`
`450`		`- if (isOutOfRetries \|\| !timeoutPolicy.IsSafeToRetry(requestMessage.Method))`
	`450`	`+ if (isOutOfRetries \|\| !CosmosHttpClientCore.IsSafeToRetry(documentServiceRequest))`
`451`	`451`	`{`
`452`	`452`	`throw;`
`453`	`453`	`}`
`@@ -493,13 +493,24 @@ private async Task<HttpResponseMessage> SendHttpHelperAsync(`
`493`	`493`	`}`
`494`	`494`
`495`	`495`	`private static bool IsOutOfRetries(`
`496`		`- HttpTimeoutPolicy timeoutPolicy,`
`497`		`- DateTime startDateTimeUtc,`
`498`	`496`	`IEnumerator<(TimeSpan requestTimeout, TimeSpan delayForNextRequest)> timeoutEnumerator)`
`499`	`497`	`{`
`500`	`498`	`return !timeoutEnumerator.MoveNext(); // No more retries are configured`
`501`	`499`	`}`
`502`	`500`
	`501`	`+ private static bool IsSafeToRetry(DocumentServiceRequest documentServiceRequest)`
	`502`	`+ {`
	`503`	`+ // Three scenarios are safely retriable:`
	`504`	`+ // 1) If request is null since they are originated from GetAsync calls`
	`505`	`+ // 2) If request is read-only`
	`506`	`+ // 3) If request is an address request.`
	`507`	`+ if (documentServiceRequest == null)`
	`508`	`+ {`
	`509`	`+ return true;`
	`510`	`+ }`
	`511`	`+ return documentServiceRequest.IsReadOnlyRequest \|\| documentServiceRequest.ResourceType == ResourceType.Address;`
	`512`	`+ }`
	`513`	`+`
`503`	`514`	`private async Task<HttpResponseMessage> ExecuteHttpHelperAsync(`
`504`	`515`	`HttpRequestMessage requestMessage,`
`505`	`516`	`ResourceType resourceType,`
Original file line number	Diff line number	Diff line change
`@@ -32,12 +32,6 @@ private HttpTimeoutPolicyControlPlaneRead()`
`32`	`32`	`return this.TimeoutsAndDelays.GetEnumerator();`
`33`	`33`	`}`
`34`	`34`
`35`		`- // This is for control plane reads which should always be safe to retry on.`
`36`		`- public override bool IsSafeToRetry(HttpMethod httpMethod)`
`37`		`- {`
`38`		`- return true;`
`39`		`- }`
`40`		`-`
`41`	`35`	`public override bool ShouldRetryBasedOnResponse(HttpMethod requestHttpMethod, HttpResponseMessage responseMessage)`
`42`	`36`	`{`
`43`	`37`	`return false;`
Original file line number	Diff line number	Diff line change
`@@ -36,13 +36,6 @@ private HttpTimeoutPolicyControlPlaneRetriableHotPath(bool shouldThrow503OnTimeo`
`36`	`36`	`return this.TimeoutsAndDelays.GetEnumerator();`
`37`	`37`	`}`
`38`	`38`
`39`		`- // The hot path should always be safe to retires since it should be retrieving meta data`
`40`		`- // information that is not idempotent.`
`41`		`- public override bool IsSafeToRetry(HttpMethod httpMethod)`
`42`		`- {`
`43`		`- return true;`
`44`		`- }`
`45`		`-`
`46`	`39`	`public override bool ShouldRetryBasedOnResponse(HttpMethod requestHttpMethod, HttpResponseMessage responseMessage)`
`47`	`40`	`{`
`48`	`41`	`if (responseMessage == null)`
`@@ -55,11 +48,6 @@ public override bool ShouldRetryBasedOnResponse(HttpMethod requestHttpMethod, Ht`
`55`	`48`	`return false;`
`56`	`49`	`}`
`57`	`50`
`58`		`- if (!this.IsSafeToRetry(requestHttpMethod))`
`59`		`- {`
`60`		`- return false;`
`61`		`- }`
`62`		`-`
`63`	`51`	`return true;`
`64`	`52`	`}`
`65`	`53`
Original file line number	Diff line number	Diff line change
`@@ -35,13 +35,6 @@ private HttpTimeoutPolicyForPartitionFailover(bool shouldThrow503OnTimeout)`
`35`	`35`	`return this.TimeoutsAndDelays.GetEnumerator();`
`36`	`36`	`}`
`37`	`37`
`38`		`- // Assume that it is not safe to retry unless it is a get method.`
`39`		`- // Create and other operations could have succeeded even though a timeout occurred.`
`40`		`- public override bool IsSafeToRetry(HttpMethod httpMethod)`
`41`		`- {`
`42`		`- return httpMethod == HttpMethod.Get;`
`43`		`- }`
`44`		`-`
`45`	`38`	`public override bool ShouldRetryBasedOnResponse(HttpMethod requestHttpMethod, HttpResponseMessage responseMessage)`
`46`	`39`	`{`
`47`	`40`	`return false;`
Original file line number	Diff line number	Diff line change
`@@ -39,11 +39,6 @@ private HttpTimeoutPolicyForThinClient(`
`39`	`39`	`return this.TimeoutsAndDelays.GetEnumerator();`
`40`	`40`	`}`
`41`	`41`
`42`		`- public override bool IsSafeToRetry(HttpMethod httpMethod)`
`43`		`- {`
`44`		`- return this.shouldRetry;`
`45`		`- }`
`46`		`-`
`47`	`42`	`public override bool ShouldRetryBasedOnResponse(HttpMethod requestHttpMethod, HttpResponseMessage responseMessage)`
`48`	`43`	`{`
`49`	`44`	`if (responseMessage == null)`
`@@ -56,7 +51,7 @@ public override bool ShouldRetryBasedOnResponse(HttpMethod requestHttpMethod, Ht`
`56`	`51`	`return false;`
`57`	`52`	`}`
`58`	`53`
`59`		`- if (!this.IsSafeToRetry(requestHttpMethod))`
	`54`	`+ if (!this.shouldRetry)`
`60`	`55`	`{`
`61`	`56`	`return false;`
`62`	`57`	`}`
Original file line number	Diff line number	Diff line change
`@@ -31,12 +31,6 @@ private HttpTimeoutPolicyNoRetry()`
`31`	`31`	`return this.TimeoutsAndDelays.GetEnumerator();`
`32`	`32`	`}`
`33`	`33`
`34`		`- // Always Unsafe to retry`
`35`		`- public override bool IsSafeToRetry(HttpMethod httpMethod)`
`36`		`- {`
`37`		`- return false;`
`38`		`- }`
`39`		`-`
`40`	`34`	`public override bool ShouldRetryBasedOnResponse(HttpMethod requestHttpMethod, HttpResponseMessage responseMessage)`
`41`	`35`	`{`
`42`	`36`	`return false;`