chore: Make initialization success event parameter reflect the initia…

…l config fetch (#169)

* set flag to success instead of changing flow

* Collapse 500 errors to one set - and set initialization to failure if the first request is a 500 or invalid

* Update tests

* Don't upgrade test apps for test harness yet

* Don't immediately retry failed config requests

This causes issues with the test harness - and resulting in a bad test failure because of the SDK retrying the request on >= 500 error response codes.

* retryonce for legacy testing

* Use previous logic for setting config polling delay

* Set initialized on any successful config call

DevCycle.SDK.Server.Common/Policies/ClientPolicy.cs

@@ -11,19 +11,20 @@ public class ClientPolicy
     {
         public AsyncPolicyWrap<RestResponse> ExponentialBackoffRetryPolicyWithTimeout { get; }
         public AsyncRetryPolicy<RestResponse> RetryOncePolicy { get; }
+        public AsyncTimeoutPolicy TimeoutPolicy { get; }
         private static ClientPolicy _instance = new ClientPolicy();
 
         private ClientPolicy()
         {
-            AsyncTimeoutPolicy timeoutPolicy = Policy.TimeoutAsync(5, TimeoutStrategy.Pessimistic);
+            TimeoutPolicy = Policy.TimeoutAsync(5, TimeoutStrategy.Pessimistic);
             AsyncRetryPolicy<RestResponse> exponentialBackoffRetryPolicy = Policy
                 .HandleResult<RestResponse>(res => (int)res.StatusCode >= 500)
                 .WaitAndRetryAsync(5, retryAttempt => {
                   var delay = Math.Pow(2, retryAttempt) * 100;
                   var randomSum = delay * 0.2 * new Random().NextDouble();
                   return TimeSpan.FromMilliseconds(delay + randomSum);
                 });
-            ExponentialBackoffRetryPolicyWithTimeout = exponentialBackoffRetryPolicy.WrapAsync(timeoutPolicy);
+            ExponentialBackoffRetryPolicyWithTimeout = exponentialBackoffRetryPolicy.WrapAsync(TimeoutPolicy);
 
             RetryOncePolicy = Policy
                 .HandleResult<RestResponse>(res => (int)res.StatusCode >= 500)

DevCycle.SDK.Server.Local.MSTests/EnvironmentConfigManagerTest.cs

@@ -47,8 +47,8 @@ private Tuple<EnvironmentConfigManager, MockHttpMessageHandler, MockedRequest> g
             var cfgManager = new EnvironmentConfigManager(sdkKey, new DevCycleLocalOptions(),
                 loggerFactory, new LocalBucketing(), restClientOptions: new DevCycleRestClientOptions()
                     { ConfigureMessageHandler = _ => mockHttp },
-                initializedHandler: (isError && !isRetryableError)
-                    ? DidNotInitializeSubscriber
+                initializedHandler: isError
+                    ? (isRetryableError ? DidInitializeSubscriberFailFirstConfigFetch : DidNotInitializeSubscriber)
                     : DidInitializeSubscriber);
 
             return new Tuple<EnvironmentConfigManager, MockHttpMessageHandler, MockedRequest>(cfgManager, mockHttp,
@@ -111,6 +111,12 @@ private void DidInitializeSubscriber(object o, DevCycleEventArgs e)
             Assert.IsTrue(e.Success);
             Assert.AreEqual(0, e.Errors.Count);
         }
+
+        private void DidInitializeSubscriberFailFirstConfigFetch(object o, DevCycleEventArgs e)
+        {
+            Assert.IsFalse(e.Success);
+            Assert.AreEqual(0, e.Errors.Count);
+        }
 
         private void DidNotInitializeSubscriber(object o, DevCycleEventArgs e)
         {

DevCycle.SDK.Server.Local/ConfigManager/EnvironmentConfigManager.cs

@@ -118,7 +118,7 @@ public void Dispose()
 
         private void OnInitialized(DevCycleEventArgs e)
         {
-            Initialized = true;
+            Initialized = e.Success;
             initializedHandler?.Invoke(this, e);
         }
 
@@ -157,13 +157,18 @@ private async Task FetchConfigAsyncWithTask(uint lastmodified = 0)
             switch (res.StatusCode)
             {
                 // Status code of 0 means some other error (like a network error) occurred
-                case >= HttpStatusCode.InternalServerError or 0 when Config != null:
-                    logger.LogError(res.ErrorException,
-                        "Failed to download config, using cached version: {ConfigEtag}, {Lastmodified}", configEtag,
-                        configLastModified);
-                    break;
                 case >= HttpStatusCode.InternalServerError or 0:
-                    logger.LogError(res.ErrorException, "Failed to download DevCycle config");
+                    if (Config != null)
+                    {
+                        logger.LogError(res.ErrorException,
+                            "Failed to download config, using cached version: {ConfigEtag}, {Lastmodified}", configEtag,
+                            configLastModified);
+                    }
+                    else
+                    {
+                        initializationEvent.Success = false;
+                        logger.LogError(res.ErrorException, "Failed to download initial DevCycle config");
+                    }
                     break;
                 case >= HttpStatusCode.BadRequest:
                 {
@@ -232,8 +237,10 @@ private async Task FetchConfigAsyncWithTask(uint lastmodified = 0)
                         localBucketing.StoreConfig(sdkKey, res.Content);
                         configEtag = etag;
                         configLastModified = lastModified;
+                        Config = res.Content;
                         logger.LogDebug("Config successfully initialized with etag: {ConfigEtag}, {lastmodified}",
                             configEtag, configLastModified);
+                        Initialized = true;
                     }
                     catch (Exception e)
                     {