Renamed some fields. Added exponential calculator

Author: dylan-asos

src/SendGrid/Reliability/ReliabilitySettings.cs

@@ -21,9 +21,9 @@ public ReliabilitySettings()
         }
 
         /// <summary>
-        ///     Gets or sets the number of retries to execute against when sending an HTTP Request before throwing an exception. Defaults to 0 (no retries, you must explicitly enable)
+        ///     Gets or sets the maximum number of retries to execute against when sending an HTTP Request before throwing an exception. Defaults to 0 (no retries, you must explicitly enable)
         /// </summary>
-        public int RetryCount
+        public int MaximumNumberOfRetries
         {
             get
             {
@@ -39,7 +39,7 @@ public int RetryCount
 
                 if (value > 5)
                 {
-                    throw new ArgumentException("The maximum number of retries is 5");
+                    throw new ArgumentException("The maximum number of retries that can be attempted is 5");
                 }
 
                 this.retryCount = value;

src/SendGrid/Reliability/RetryDelegatingHandler.cs

@@ -11,7 +11,7 @@
     /// </summary>
     public class RetryDelegatingHandler : DelegatingHandler
     {
-        private static List<int> retriableStatusCodes = new List<int>() { 500, 502, 503, 504 };
+        private static readonly List<int> RetriableStatusCodes = new List<int>() { 500, 502, 503, 504 };
 
         private readonly ReliabilitySettings settings;
 
@@ -32,12 +32,15 @@ public RetryDelegatingHandler(HttpMessageHandler innerHandler, ReliabilitySettin
 
         protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
         {
-            if (this.settings.RetryCount == 0)
+            if (this.settings.MaximumNumberOfRetries == 0)
             {
                 return await base.SendAsync(request, cancellationToken).ConfigureAwait(false);
             }
 
             HttpResponseMessage responseMessage = null;
+            var backOffCalculator = new ExponentialBackOffCalculator(settings.RetryInterval);
+
+            var waitFor = settings.RetryInterval;
             var numberOfAttempts = 0;
             var sent = false;
 
@@ -55,25 +58,27 @@ protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage
                 {
                     numberOfAttempts++;
 
-                    if (numberOfAttempts > this.settings.RetryCount)
+                    if (numberOfAttempts > this.settings.MaximumNumberOfRetries)
                     {
                         throw new TimeoutException();
                     }
 
                     // ReSharper disable once MethodSupportsCancellation, cancel will be indicated on the token
-                    await Task.Delay(this.settings.RetryInterval).ConfigureAwait(false);
+                    await Task.Delay(waitFor).ConfigureAwait(false);
                 }
                 catch (HttpRequestException)
                 {
                     numberOfAttempts++;
 
-                    if (numberOfAttempts > this.settings.RetryCount)
+                    if (numberOfAttempts > this.settings.MaximumNumberOfRetries)
                     {
                         throw;
                     }
 
-                    await Task.Delay(this.settings.RetryInterval).ConfigureAwait(false);
+                    await Task.Delay(waitFor).ConfigureAwait(false);
                 }
+
+                waitFor = backOffCalculator.GetNextWaitInterval(numberOfAttempts);
             }
 
             return responseMessage;
@@ -83,10 +88,31 @@ private static void ThrowHttpRequestExceptionIfResponseCodeIsRetriable(HttpRespo
         {
             int statusCode = (int)responseMessage.StatusCode;
 
-            if (retriableStatusCodes.Contains(statusCode))
+            if (RetriableStatusCodes.Contains(statusCode))
             {
                 throw new HttpRequestException(string.Format("Http status code '{0}' indicates server error", statusCode));
             }
         }
+
+        private class ExponentialBackOffCalculator
+        {
+            private TimeSpan baseInterval;
+
+            private readonly Random random = new Random();
+
+            public ExponentialBackOffCalculator(TimeSpan baseInterval)
+            {
+                this.baseInterval = baseInterval;
+            }
+
+            public TimeSpan GetNextWaitInterval(int numberOfAttempts)
+            {
+                var interval = this.baseInterval.TotalMilliseconds + (Math.Pow(2, numberOfAttempts) * 1000);
+
+                var randomDelay = this.random.Next(0, 1000);
+
+                return TimeSpan.FromMilliseconds(interval + randomDelay);
+            }
+        }
     }
 }

tests/SendGrid.Tests/Integration.cs

@@ -6141,7 +6141,7 @@ public async Task TestRetryBehaviourThrowsTimeoutException()
             var options = new SendGridClientOptions
             {
                 ApiKey = fixture.apiKey,
-                ReliabilitySettings = { RetryCount = 1 },
+                ReliabilitySettings = { MaximumNumberOfRetries = 1 },
                 Host = "http://localhost:4010"
             };
 
@@ -6169,7 +6169,7 @@ public async Task TestRetryBehaviourSucceedsOnSecondAttempt()
             var options = new SendGridClientOptions
             {
                 ApiKey = fixture.apiKey,
-                ReliabilitySettings = { RetryCount = 1 }
+                ReliabilitySettings = { MaximumNumberOfRetries = 1 }
             };
 
             var id = "test_url_param";

tests/SendGrid.Tests/Reliability/RetryDelegatingHandlerTests.cs

@@ -17,7 +17,7 @@ public RetryDelegatingHandlerTests()
         {
             var reliabilitySettings = new ReliabilitySettings
             {
-                RetryCount = 1
+                MaximumNumberOfRetries = 1
             };
             innerHandler = new RetryTestBehaviourDelegatingHandler();
             client = new HttpClient(new RetryDelegatingHandler(innerHandler, reliabilitySettings))
@@ -119,15 +119,15 @@ public void ReliabilitySettingsShouldNotAllowNegativeRetryCount()
         {
             var settings = new ReliabilitySettings();
 
-            Assert.Throws<ArgumentException>(() => settings.RetryCount = -1);
+            Assert.Throws<ArgumentException>(() => settings.MaximumNumberOfRetries = -1);
         }
 
         [Fact]
         public void ReliabilitySettingsShouldNotAllowRetryCountGreaterThan5()
         {
             var settings = new ReliabilitySettings();
 
-            Assert.Throws<ArgumentException>(() => settings.RetryCount = 6);
+            Assert.Throws<ArgumentException>(() => settings.MaximumNumberOfRetries = 6);
         }
 
         [Fact]