Refactored, use HttpStatusCode enum for retriable errors and better naming

Author: dylan-asos

src/SendGrid/Reliability/RetryDelegatingHandler.cs

@@ -2,6 +2,7 @@
 {
     using System;
     using System.Collections.Generic;
+    using System.Net;
     using System.Net.Http;
     using System.Threading;
     using System.Threading.Tasks;
@@ -11,7 +12,14 @@
     /// </summary>
     public class RetryDelegatingHandler : DelegatingHandler
     {
-        private static readonly List<int> RetriableStatusCodes = new List<int>() { 500, 502, 503, 504 };
+        private static readonly List<HttpStatusCode> RetriableServerErrorStatusCodes =
+            new List<HttpStatusCode>()
+            {
+                HttpStatusCode.InternalServerError,
+                HttpStatusCode.BadGateway,
+                HttpStatusCode.ServiceUnavailable,
+                HttpStatusCode.GatewayTimeout
+            };
 
         private readonly ReliabilitySettings settings;
 
@@ -26,6 +34,11 @@ public RetryDelegatingHandler(ReliabilitySettings settings)
         {
         }
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="RetryDelegatingHandler"/> class.
+        /// </summary>
+        /// <param name="innerHandler">A HttpMessageHandler instance to set as the innner handler</param>
+        /// <param name="settings">A ReliabilitySettings instance</param>
         public RetryDelegatingHandler(HttpMessageHandler innerHandler, ReliabilitySettings settings)
             : base(innerHandler)
         {
@@ -41,12 +54,13 @@ protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage
 
             HttpResponseMessage responseMessage = null;
 
-            var waitFor = settings.RetryInterval;
             var numberOfAttempts = 0;
             var sent = false;
 
             while (!sent)
             {
+                var waitFor = this.GetNextWaitInterval(numberOfAttempts);
+
                 try
                 {
                     responseMessage = await base.SendAsync(request, cancellationToken).ConfigureAwait(false);
@@ -78,30 +92,33 @@ protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage
 
                     await Task.Delay(waitFor).ConfigureAwait(false);
                 }
-
-                waitFor = GetNextWaitInterval(numberOfAttempts);
             }
 
             return responseMessage;
         }
 
         private static void ThrowHttpRequestExceptionIfResponseCodeCanBeRetried(HttpResponseMessage responseMessage)
         {
-            int statusCode = (int)responseMessage.StatusCode;
-
-            if (RetriableStatusCodes.Contains(statusCode))
+            if (RetriableServerErrorStatusCodes.Contains(responseMessage.StatusCode))
             {
-                throw new HttpRequestException(string.Format("Http status code '{0}' indicates server error", statusCode));
+                throw new HttpRequestException(string.Format("Http status code '{0}' indicates server error", responseMessage.StatusCode));
             }
         }
 
         private TimeSpan GetNextWaitInterval(int numberOfAttempts)
         {
-            var interval = this.settings.RetryInterval.TotalMilliseconds + (Math.Pow(2, numberOfAttempts) * 1000);
+            var randomDelay = this.random.Next(0, 500);
+
+            if (numberOfAttempts == 0)
+            {
+                return TimeSpan.FromMilliseconds(this.settings.RetryInterval.TotalMilliseconds + randomDelay);
+            }
+
+            var exponentialIncrease = Math.Pow(2, numberOfAttempts) * 1000;
 
-            var randomDelay = this.random.Next(0, 1000);
+            var actualIncrease = TimeSpan.FromMilliseconds(this.settings.RetryInterval.TotalMilliseconds + exponentialIncrease + randomDelay);
 
-            return TimeSpan.FromMilliseconds(interval + randomDelay);
+            return actualIncrease;
         }
     }
 }