rollbar · akornich · Nov 5, 2021 · Oct 18, 2021 · Oct 19, 2021 · Oct 19, 2021
diff --git a/Rollbar.App.Config/AppConfigUtility.cs b/Rollbar.App.Config/AppConfigUtility.cs
@@ -18,6 +18,7 @@ public static class AppConfigUtility
         /// </summary>
         /// <param name="config">The configuration.</param>
         /// <returns>false when the configuration was not found, otherwise true.</returns>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage("Minor Code Smell", "S4136:Method overloads should be grouped together", Justification = "Intentionally split by settings kind.")]
         public static bool LoadAppSettings(RollbarInfrastructureConfig config)
         {
             return AppConfigUtility.LoadAppSettings(config, RollbarConfigSection.GetConfiguration());
@@ -36,191 +37,179 @@ public static bool LoadAppSettings(RollbarInfrastructureConfig config, RollbarCo
                 return false;
             }
 
-            // infrastructure options:
-            //////////////////////////
-
-            RollbarInfrastructureOptions infrastructureOptions = new RollbarInfrastructureOptions();
+            LoadInfrastructureOptions(config, rollbarConfigSection);
+            LoadOfflinePayloadStoreOptions(config, rollbarConfigSection);
+            LoadDestinationOptions(config, rollbarConfigSection);
+            LoadDeveloperOptions(config, rollbarConfigSection);
+            LoadHttpProxyOptions(config, rollbarConfigSection);
+            LoadDataSecurityOptions(config, rollbarConfigSection);
+            LoadTelemetryOptions(config);
 
-            if(rollbarConfigSection.MaxReportsPerMinute.HasValue)
+            var validationResults = config.Validate();
+            bool configLoadingResult = 
+                (validationResults == null) || (validationResults.Count == 0);
+            Debug.Assert(configLoadingResult);
+            return configLoadingResult;
+        }
+
+        private static void LoadInfrastructureOptions(RollbarInfrastructureConfig config, RollbarConfigSection rollbarConfigSection)
+        {
+            RollbarInfrastructureOptions infrastructureOptions = new();
+
+            if (rollbarConfigSection.MaxReportsPerMinute.HasValue)
             {
                 infrastructureOptions.MaxReportsPerMinute = rollbarConfigSection.MaxReportsPerMinute.Value;
             }
 
-            if(rollbarConfigSection.ReportingQueueDepth.HasValue)
+            if (rollbarConfigSection.ReportingQueueDepth.HasValue)
             {
                 infrastructureOptions.ReportingQueueDepth = rollbarConfigSection.ReportingQueueDepth.Value;
             }
 
-            if(rollbarConfigSection.MaxItems.HasValue)
+            if (rollbarConfigSection.MaxItems.HasValue)
             {
                 infrastructureOptions.MaxItems = rollbarConfigSection.MaxItems.Value;
             }
 
-            if(rollbarConfigSection.CaptureUncaughtExceptions.HasValue)
+            if (rollbarConfigSection.CaptureUncaughtExceptions.HasValue)
             {
                 infrastructureOptions.CaptureUncaughtExceptions = rollbarConfigSection.CaptureUncaughtExceptions.Value;
             }
 
-            if(rollbarConfigSection.PayloadPostTimeout.HasValue)
+            if (rollbarConfigSection.PayloadPostTimeout.HasValue)
             {
                 infrastructureOptions.PayloadPostTimeout = rollbarConfigSection.PayloadPostTimeout.Value;
             }
 
             config.RollbarInfrastructureOptions.Reconfigure(infrastructureOptions);
+        }
 
-            // telemetry options:
-            /////////////////////
-
-            RollbarTelemetryOptions telemetryOptions = new RollbarTelemetryOptions();
-            if(AppConfigUtility.LoadAppSettings(telemetryOptions))
-            {
-                config.RollbarTelemetryOptions.Reconfigure(telemetryOptions);
-            }
+        private static void LoadOfflinePayloadStoreOptions(RollbarInfrastructureConfig config, RollbarConfigSection rollbarConfigSection)
+        {
+            RollbarOfflineStoreOptions offlineStoreOptions = new();
 
-            //if(telemetryConfigSection.TelemetryEnabled.HasValue)
-            //{
-            //    telemetryOptions.TelemetryEnabled = telemetryConfigSection.TelemetryEnabled.Value;
-            //}
-            //if(telemetryConfigSection.TelemetryQueueDepth.HasValue)
-            //{
-            //    telemetryOptions.TelemetryQueueDepth = telemetryConfigSection.TelemetryQueueDepth.Value;
-            //}
-            //if(telemetryConfigSection.TelemetryAutoCollectionTypes.HasValue)
-            //{
-            //    telemetryOptions.TelemetryAutoCollectionTypes = telemetryConfigSection.TelemetryAutoCollectionTypes.Value;
-            //}
-            //if(telemetryConfigSection.TelemetryAutoCollectionInterval.HasValue)
-            //{
-            //    telemetryOptions.TelemetryAutoCollectionInterval = telemetryConfigSection.TelemetryAutoCollectionInterval.Value;
-            //}
-
-            //config.RollbarTelemetryOptions.Reconfigure(telemetryOptions);
-
-            // offline payload store options:
-            /////////////////////////////////
-
-            RollbarOfflineStoreOptions offlineStoreOptions = new RollbarOfflineStoreOptions();
-
-            if(rollbarConfigSection.EnableLocalPayloadStore.HasValue)
+            if (rollbarConfigSection.EnableLocalPayloadStore.HasValue)
             {
                 offlineStoreOptions.EnableLocalPayloadStore = rollbarConfigSection.EnableLocalPayloadStore.Value;
             }
 
-            if(!string.IsNullOrWhiteSpace(rollbarConfigSection.LocalPayloadStoreFileName))
+            if (!string.IsNullOrWhiteSpace(rollbarConfigSection.LocalPayloadStoreFileName))
             {
                 offlineStoreOptions.LocalPayloadStoreFileName = rollbarConfigSection.LocalPayloadStoreFileName;
             }
 
-            if(!string.IsNullOrWhiteSpace(rollbarConfigSection.LocalPayloadStoreLocationPath))
+            if (!string.IsNullOrWhiteSpace(rollbarConfigSection.LocalPayloadStoreLocationPath))
             {
                 offlineStoreOptions.LocalPayloadStoreLocationPath = rollbarConfigSection.LocalPayloadStoreLocationPath;
             }
 
             config.RollbarOfflineStoreOptions.Reconfigure(offlineStoreOptions);
+        }
 
-            // logger destination options:
-            //////////////////////////////
-
-            if(!string.IsNullOrWhiteSpace(rollbarConfigSection.AccessToken))
+        private static void LoadDestinationOptions(RollbarInfrastructureConfig config, RollbarConfigSection rollbarConfigSection)
+        {
+            if (!string.IsNullOrWhiteSpace(rollbarConfigSection.AccessToken))
             {
-                RollbarDestinationOptions destinationOptions = 
-                    new RollbarDestinationOptions(rollbarConfigSection.AccessToken);
+                RollbarDestinationOptions destinationOptions = new(rollbarConfigSection.AccessToken);
 
-                if(!string.IsNullOrWhiteSpace(rollbarConfigSection.Environment))
+                if (!string.IsNullOrWhiteSpace(rollbarConfigSection.Environment))
                 {
                     destinationOptions.Environment = rollbarConfigSection.Environment;
                 }
 
-                if(!string.IsNullOrWhiteSpace(rollbarConfigSection.EndPoint))
+                if (!string.IsNullOrWhiteSpace(rollbarConfigSection.EndPoint))
                 {
                     destinationOptions.EndPoint = rollbarConfigSection.EndPoint;
                 }
 
                 config.RollbarLoggerConfig.RollbarDestinationOptions.Reconfigure(destinationOptions);
             }
+        }
 
-            // logger developer options:
-            ////////////////////////////
-
-            if(rollbarConfigSection.Enabled.HasValue)
+        private static void LoadDeveloperOptions(RollbarInfrastructureConfig config, RollbarConfigSection rollbarConfigSection)
+        {
+            if (rollbarConfigSection.Enabled.HasValue)
             {
                 config.RollbarLoggerConfig.RollbarDeveloperOptions.Enabled = rollbarConfigSection.Enabled.Value;
             }
 
-            if(rollbarConfigSection.Transmit.HasValue)
+            if (rollbarConfigSection.Transmit.HasValue)
             {
                 config.RollbarLoggerConfig.RollbarDeveloperOptions.Transmit = rollbarConfigSection.Transmit.Value;
             }
 
-            if(rollbarConfigSection.RethrowExceptionsAfterReporting.HasValue)
+            if (rollbarConfigSection.RethrowExceptionsAfterReporting.HasValue)
             {
                 config.RollbarLoggerConfig.RollbarDeveloperOptions.RethrowExceptionsAfterReporting = rollbarConfigSection.RethrowExceptionsAfterReporting.Value;
             }
 
-            if(rollbarConfigSection.LogLevel.HasValue)
+            if (rollbarConfigSection.LogLevel.HasValue)
             {
                 config.RollbarLoggerConfig.RollbarDeveloperOptions.LogLevel = rollbarConfigSection.LogLevel.Value;
             }
+        }
 
-            // logger HTTP proxy options:
-            /////////////////////////////
-
-            if(!string.IsNullOrWhiteSpace(rollbarConfigSection.ProxyAddress))
+        private static void LoadHttpProxyOptions(RollbarInfrastructureConfig config, RollbarConfigSection rollbarConfigSection)
+        {
+            if (!string.IsNullOrWhiteSpace(rollbarConfigSection.ProxyAddress))
             {
-                HttpProxyOptions httpProxyOptions = new HttpProxyOptions(rollbarConfigSection.ProxyAddress);
+                HttpProxyOptions httpProxyOptions = new(rollbarConfigSection.ProxyAddress);
 
-                if(!string.IsNullOrWhiteSpace(rollbarConfigSection.ProxyUsername))
+                if (!string.IsNullOrWhiteSpace(rollbarConfigSection.ProxyUsername))
                 {
                     httpProxyOptions.ProxyUsername = rollbarConfigSection.ProxyUsername;
                 }
 
-                if(!string.IsNullOrWhiteSpace(rollbarConfigSection.ProxyPassword))
+                if (!string.IsNullOrWhiteSpace(rollbarConfigSection.ProxyPassword))
                 {
                     httpProxyOptions.ProxyPassword = rollbarConfigSection.ProxyPassword;
                 }
 
                 config.RollbarLoggerConfig.HttpProxyOptions.Reconfigure(httpProxyOptions);
             }
+        }
 
-            // logger data security options:
-            ////////////////////////////////
-
-            RollbarDataSecurityOptions dataSecurityOptions = new RollbarDataSecurityOptions();
+        private static void LoadDataSecurityOptions(RollbarInfrastructureConfig config, RollbarConfigSection rollbarConfigSection)
+        {
+            RollbarDataSecurityOptions dataSecurityOptions = new();
 
-            if(rollbarConfigSection.ScrubFields != null && rollbarConfigSection.ScrubFields.Length > 0)
+            if (rollbarConfigSection.ScrubFields != null && rollbarConfigSection.ScrubFields.Length > 0)
             {
                 dataSecurityOptions.ScrubFields =
-                    string.IsNullOrEmpty(rollbarConfigSection.ScrubFields) ? new string[0]
+                    string.IsNullOrEmpty(rollbarConfigSection.ScrubFields) ? Array.Empty<string>()
                     : rollbarConfigSection.ScrubFields.Split(listValueSplitters, StringSplitOptions.RemoveEmptyEntries);
             }
 
-            if(rollbarConfigSection.ScrubSafelistFields != null && rollbarConfigSection.ScrubSafelistFields.Length > 0)
+            if (rollbarConfigSection.ScrubSafelistFields != null && rollbarConfigSection.ScrubSafelistFields.Length > 0)
             {
                 dataSecurityOptions.ScrubSafelistFields =
-                    string.IsNullOrEmpty(rollbarConfigSection.ScrubSafelistFields) ? new string[0]
+                    string.IsNullOrEmpty(rollbarConfigSection.ScrubSafelistFields) ? Array.Empty<string>()
                     : rollbarConfigSection.ScrubSafelistFields.Split(listValueSplitters, StringSplitOptions.RemoveEmptyEntries);
             }
 
-            if(rollbarConfigSection.PersonDataCollectionPolicies.HasValue)
+            if (rollbarConfigSection.PersonDataCollectionPolicies.HasValue)
             {
                 dataSecurityOptions.PersonDataCollectionPolicies = rollbarConfigSection.PersonDataCollectionPolicies.Value;
             }
 
-            if(rollbarConfigSection.IpAddressCollectionPolicy.HasValue)
+            if (rollbarConfigSection.IpAddressCollectionPolicy.HasValue)
             {
                 dataSecurityOptions.IpAddressCollectionPolicy = rollbarConfigSection.IpAddressCollectionPolicy.Value;
             }
 
             config.RollbarLoggerConfig.RollbarDataSecurityOptions.Reconfigure(dataSecurityOptions);
+        }
 
-
-            var validationResults = config.Validate();
-            bool configLoadingResult = 
-                (validationResults == null) || (validationResults.Count == 0);
-            Debug.Assert(configLoadingResult);
-            return configLoadingResult;
+        private static void LoadTelemetryOptions(RollbarInfrastructureConfig config)
+        {
+            RollbarTelemetryOptions telemetryOptions = new();
+            if (AppConfigUtility.LoadAppSettings(telemetryOptions))
+            {
+                config.RollbarTelemetryOptions.Reconfigure(telemetryOptions);
+            }
         }
 
+
         #endregion RollbarConfig
 
         #region TelemetryConfig

diff --git a/Rollbar.App.Config/RollbarConfigSection.cs b/Rollbar.App.Config/RollbarConfigSection.cs
@@ -16,7 +16,7 @@
     public class RollbarConfigSection
             : ConfigurationSection
     {
-        private static readonly TraceSource traceSource = new TraceSource(typeof(RollbarConfigSection).FullName);
+        private static readonly TraceSource traceSource = new(typeof(RollbarConfigSection).FullName);
 
         /// <summary>
         /// Gets the configuration.

diff --git a/Rollbar.App.Config/RollbarTelemetryConfigSection.cs b/Rollbar.App.Config/RollbarTelemetryConfigSection.cs
@@ -17,7 +17,7 @@
     public class RollbarTelemetryConfigSection
             : ConfigurationSection
     {
-        private static readonly TraceSource traceSource = new TraceSource(typeof(RollbarTelemetryConfigSection).FullName);
+        private static readonly TraceSource traceSource = new(typeof(RollbarTelemetryConfigSection).FullName);
 
         /// <summary>
         /// Gets the configuration.
@@ -34,11 +34,10 @@ public class RollbarTelemetryConfigSection
             }
             catch (System.Exception ex)
             {
+                string msg = $"Error while attempting to get RollbarTelemetryConfigSection:{Environment.NewLine}{ex}";
                 //let's just trace it for now:
-                System.Diagnostics.Trace.TraceError(
-                    "Error while attempting to get RollbarTelemetryConfigSection:" + System.Environment.NewLine + ex
-                    );
-                traceSource.TraceEvent(TraceEventType.Warning, 0, $"Error while attempting to get RollbarTelemetryConfigSection:{Environment.NewLine}{ex}");
+                System.Diagnostics.Trace.TraceError(msg);
+                traceSource.TraceEvent(TraceEventType.Warning, 0, msg);
                 return null;
             }
         }

diff --git a/Rollbar.AppSettings.Json/AppSettingsUtility.cs b/Rollbar.AppSettings.Json/AppSettingsUtility.cs
@@ -208,8 +208,8 @@ public static bool LoadAppSettings(RollbarTelemetryOptions config, IConfiguratio
             string fileFullName = Path.Combine(folderPath, appSettingsFileName);
             if (!File.Exists(fileFullName))
             {
-                //NOTE: the following line causes the RollbarTraceListener into infinite creation loop and subsequent stck overflow:
-                //Debug.WriteLine($"File: {fileFullName} does not exist...");
+                //NOTE: Do not Trace/Debug anything here,
+                //      sinse it would cause the RollbarTraceListener into infinite creation loop and subsequent stack overflow!
 
                 return null;
             }
@@ -222,18 +222,6 @@ public static bool LoadAppSettings(RollbarTelemetryOptions config, IConfiguratio
             return appConfiguration;
         }
 
-        /// <summary>
-        /// Loads the application settings.
-        /// </summary>
-        /// <typeparam name="TSection">The type of the t section.</typeparam>
-        /// <param name="sectionName">Name of the section.</param>
-        /// <param name="appSettings">The application settings.</param>
-        /// <returns>TSection.</returns>
-        private static TSection LoadAppSettings<TSection>(string sectionName, IConfiguration appSettings)
-        {
-            return appSettings.GetSection(sectionName).Get<TSection>();
-        }
-
         /// <summary>
         /// Loads the application settings.
         /// </summary>

diff --git a/Rollbar.AppSettings.Json/RollbarConfigurationUtil.cs b/Rollbar.AppSettings.Json/RollbarConfigurationUtil.cs
@@ -16,10 +16,8 @@ public static class RollbarConfigurationUtil
         /// <returns></returns>
         public static IRollbarInfrastructureConfig DeduceRollbarConfig(IConfiguration configuration)
         {
-            //if (RollbarLocator.RollbarInstance.Config.RollbarDestinationOptions.AccessToken != null)
             if (RollbarInfrastructure.Instance.Config?.RollbarLoggerConfig?.RollbarDestinationOptions?.AccessToken != null)
             {
-                //return RollbarLocator.RollbarInstance.Config;
                 return RollbarInfrastructure.Instance.Config;
             }
 
@@ -30,7 +28,7 @@ public static IRollbarInfrastructureConfig DeduceRollbarConfig(IConfiguration co
             Assumption.AssertNotNull(configuration, nameof(configuration));
 
             const string defaultAccessToken = "none";
-            RollbarInfrastructureConfig rollbarConfig = new RollbarInfrastructureConfig(defaultAccessToken);
+            RollbarInfrastructureConfig rollbarConfig = new(defaultAccessToken);
             AppSettingsUtility.LoadAppSettings(rollbarConfig, configuration);
 
             if (rollbarConfig.RollbarLoggerConfig.RollbarDestinationOptions.AccessToken == defaultAccessToken)
@@ -61,7 +59,7 @@ public static IRollbarInfrastructureConfig DeduceRollbarConfig
32E8
(IConfiguration co
         /// <returns></returns>
         public static IRollbarTelemetryOptions DeduceRollbarTelemetryConfig(IConfiguration configuration)
         {
-            RollbarTelemetryOptions config = new RollbarTelemetryOptions();
+            RollbarTelemetryOptions config = new();
             AppSettingsUtility.LoadAppSettings(config, configuration);
 
             RollbarTelemetryCollector.Instance?.Config?.Reconfigure(config);

diff --git a/Rollbar.Deploys/Internal/Deployment.cs b/Rollbar.Deploys/Internal/Deployment.cs
@@ -5,12 +5,8 @@
     /// <summary>
     /// Models data used for registering a deployment instance.
     /// </summary>
-    /// [TODO] Eventually, make this class internal AND remove all the [Obsolete] attributes ...
-    [Obsolete("This type is obsolete. Instead, use Rollbar.Deploys.IDeployment.", false)]
- #pragma warning disable CA1724 // The type name conflicts with the namespace
-   public class Deployment 
+   internal class Deployment 
         : IDeployment
-#pragma warning restore CA1724 // The type name conflicts with the namespace
     { 
         /// <summary>
         /// Prevents a default instance of the <see cref="Deployment"/> class from being created.
@@ -25,7 +21,6 @@ private Deployment()
         /// </summary>
         /// <param name="environment">The environment.</param>
         /// <param name="revision">The revision.</param>
-        [Obsolete("This constructor is obsolete. Instead, use Rollbar.Deploys.DeploymentFactory.CreateDeployment(...)", false)]
         public Deployment(string environment, string revision)
             : this(null, environment, revision)
         {
@@ -38,7 +33,6 @@ public Deployment(string environment, string revision)
         /// <param name="writeAccessToken">The write access token.</param>
         /// <param name="environment">The environment.</param>
         /// <param name="revision">The revision.</param>
-        [Obsolete("This constructor is obsolete. Instead, use Rollbar.Deploys.DeploymentFactory.CreateDeployment(...)", false)]
         public Deployment(string? writeAccessToken, string? environment, string? revision)
         {
             this.WriteAccessToken = writeAccessToken;