From 8c53bd3ccf668698c472b475603ff8f3ea42d300 Mon Sep 17 00:00:00 2001
From: Andrey Kornich <akornich@gmail.com>
Date: Thu, 10 Mar 2022 19:49:30 -0800
Subject: [PATCH 1/4] fix: ref #623

---
 .../Infrastructure/RollbarQueueController.cs  | 18 +++++++-
 Rollbar/RollbarInfrastructure.cs              | 42 ++++++++++++-------
 .../Telemetry/RollbarTelemetryCollector.cs    | 19 ++++++---
 SdkCommon.csproj                              |  6 +--
 4 files changed, 61 insertions(+), 24 deletions(-)

diff --git a/Rollbar/Infrastructure/RollbarQueueController.cs b/Rollbar/Infrastructure/RollbarQueueController.cs
index 35c59ba4..bc7d1fc5 100644
--- a/Rollbar/Infrastructure/RollbarQueueController.cs
+++ b/Rollbar/Infrastructure/RollbarQueueController.cs
@@ -41,6 +41,11 @@ internal sealed class RollbarQueueController
     {
         #region singleton implementation
 
+        //private static RollbarQueueController _singleton;
+
+        private static readonly Lazy<RollbarQueueController> lazy =
+            new Lazy<RollbarQueueController>(() => new RollbarQueueController());
+
         /// <summary>
         /// Gets the instance.
         /// </summary>
@@ -49,7 +54,15 @@ public static RollbarQueueController? Instance
         {
             get
             {
-                return NestedSingleInstance.TheInstance;
+                //return NestedSingleInstance.TheInstance;
+
+                //if (_singleton == null)
+                //{
+                //    _singleton = new RollbarQueueController();
+                //}
+                //return _singleton;
+
+                return RollbarInfrastructure.Instance.IsInitialized ? lazy.Value : null;
             }
         }
 
@@ -85,7 +98,8 @@ private NestedSingleInstance()
         /// <summary>
         /// The trace source
         /// </summary>
-        private static readonly TraceSource traceSource = new TraceSource(typeof(RollbarQueueController).FullName ?? "RollbarQueueController");
+        private static readonly TraceSource traceSource = 
+            new TraceSource(typeof(RollbarQueueController).FullName ?? "RollbarQueueController");
 
         /// <summary>
         /// Enum PayloadTraceSources
diff --git a/Rollbar/RollbarInfrastructure.cs b/Rollbar/RollbarInfrastructure.cs
index 533d79c1..9ce23f28 100644
--- a/Rollbar/RollbarInfrastructure.cs
+++ b/Rollbar/RollbarInfrastructure.cs
@@ -24,18 +24,25 @@ public class RollbarInfrastructure
         : IRollbarInfrastructure
         , IDisposable
     {
-        private static readonly TraceSource traceSource = new TraceSource(typeof(RollbarInfrastructure).FullName ?? "RollbarInfrastructure");
+        private static readonly TraceSource traceSource = 
+            new TraceSource(typeof(RollbarInfrastructure).FullName ?? "RollbarInfrastructure");
 
-        internal readonly TimeSpan _sleepInterval = TimeSpan.FromMilliseconds(25);
+        internal readonly TimeSpan _sleepInterval = 
+            TimeSpan.FromMilliseconds(25);
 
         private readonly object _syncLock = new object();
 
-        private bool _isInitialized = false;
+        private bool _initializedOnce = false;
 
         private IRollbarInfrastructureConfig? _config;
 
         #region singleton implementation
 
+        //private static RollbarInfrastructure _singleton; 
+
+        private static readonly Lazy<RollbarInfrastructure> lazy =
+            new Lazy<RollbarInfrastructure>(() => new RollbarInfrastructure());
+
         /// <summary>
         /// Gets the instance.
         /// </summary>
@@ -44,7 +51,15 @@ public static RollbarInfrastructure Instance
         {
             get
             {
-                return NestedSingleInstance.TheInstance;
+                //return NestedSingleInstance.TheInstance;
+
+                //if (_singleton == null)
+                //{
+                //    _singleton = new RollbarQueueController();
+                //}
+                //return _singleton;
+
+                return lazy.Value;
             }
         }
 
@@ -85,7 +100,7 @@ public bool IsInitialized
         {
             get
             {
-                return this._isInitialized;
+                return this._initializedOnce;
             }
         }
 
@@ -153,7 +168,7 @@ public void Init(IRollbarInfrastructureConfig config)
 
             lock(this._syncLock)
             {
-                if(this._isInitialized)
+                if(this._initializedOnce)
                 {
                     string msg = $"{typeof(RollbarInfrastructure).Name} can not be initialized more than once!";
                     traceSource.TraceInformation(msg);
@@ -163,16 +178,15 @@ public void Init(IRollbarInfrastructureConfig config)
                         );
                 }
 
-                this._config = config;
-                this.ValidateConfiguration();
-                this._config.Reconfigured += _config_Reconfigured;
-
-                this._isInitialized = true;
-
                 // now, since the basic infrastructure seems to be good and initialized,
                 // let's initialize all the dependent services of the infrastructure:
                 try
                 {
+                    this._config = config;
+                    this.ValidateConfiguration();
+                    this._config.Reconfigured += _config_Reconfigured;
+                    this._initializedOnce = true;
+
                     RollbarQueueController.Instance!.Init(config);
                     RollbarTelemetryCollector.Instance!.Init(config.RollbarTelemetryOptions);
                     // NOTE: RollbarConfig
@@ -183,7 +197,7 @@ public void Init(IRollbarInfrastructureConfig config)
                 }
                 catch(Exception ex)
                 {
-                    this._isInitialized = false;
+                    this._initializedOnce = false;
 
                     throw new RollbarException(
                         InternalRollbarError.InfrastructureError,
@@ -197,7 +211,7 @@ public void Init(IRollbarInfrastructureConfig config)
 
         private void ValidateConfiguration()
         {
-            if(this._isInitialized)
+            if(this._initializedOnce)
             {
                 return;
             }
diff --git a/Rollbar/Telemetry/RollbarTelemetryCollector.cs b/Rollbar/Telemetry/RollbarTelemetryCollector.cs
index b2ae7072..017e5f74 100644
--- a/Rollbar/Telemetry/RollbarTelemetryCollector.cs
+++ b/Rollbar/Telemetry/RollbarTelemetryCollector.cs
@@ -16,20 +16,29 @@ internal class RollbarTelemetryCollector
     {
         private static readonly TraceSource traceSource = 
             new TraceSource(typeof(RollbarTelemetryCollector).FullName ?? "RollbarTelemetryCollector");
-        
+
         #region singleton implementation
 
+        private static readonly Lazy<RollbarTelemetryCollector> lazy =
+            new Lazy<RollbarTelemetryCollector>(() => new RollbarTelemetryCollector());
+
         /// <summary>
         /// Gets the instance.
         /// </summary>
-        /// <value>
-        /// The instance.
-        /// </value>
+        /// <value>The instance.</value>
         public static RollbarTelemetryCollector? Instance
         {
             get
             {
-                return NestedSingleInstance.TheInstance;
+                //return NestedSingleInstance.TheInstance;
+
+                //if (_singleton == null)
+                //{
+                //    _singleton = new RollbarQueueController();
+                //}
+                //return _singleton;
+
+                return RollbarInfrastructure.Instance.IsInitialized ? lazy.Value : null;
             }
         }
 
diff --git a/SdkCommon.csproj b/SdkCommon.csproj
index 161afa07..6786317d 100644
--- a/SdkCommon.csproj
+++ b/SdkCommon.csproj
@@ -24,14 +24,14 @@
   </ItemGroup>
   
   <PropertyGroup Label="SDK Release Essential Info">
-    <SdkVersion>5.1.1</SdkVersion>           <!-- Required: major.minor.patch -->
+    <SdkVersion>5.1.2</SdkVersion>           <!-- Required: major.minor.patch -->
     <SdkVersionSuffix></SdkVersionSuffix>     <!-- Optional. Examples: alpha, beta, preview, RC etc. -->
     <SdkLtsRelease>false</SdkLtsRelease>      <!-- Optional. Examples: false (default) or true. -->
     <SdkReleaseNotes>                         <!-- Required -->
 
-      - fix: resolve GH #615 - ConnectivityMonitor tests wrong thing
+		fix: resolve #623 - NullReference exception while initializing RollbarInfrastructure
 
-    </SdkReleaseNotes>                        
+	</SdkReleaseNotes>                        
 
     <!--
     Release Notes Tagging Conventions:

From 83cd67f63981cc5687a9555e1be7d5c6265e516a Mon Sep 17 00:00:00 2001
From: Andrey Kornich <akornich@gmail.com>
Date: Fri, 11 Mar 2022 16:14:51 -0800
Subject: [PATCH 2/4] fix: ref #623

refactoring RollbarInfrastructure
---
 .../Infrastructure/RollbarQueueController.cs  | 57 ++++++++++---------
 Rollbar/RollbarInfrastructure.cs              | 54 +++++++-----------
 .../Telemetry/RollbarTelemetryCollector.cs    | 51 ++++++++++-------
 Samples/Sample.VBNet.ConsoleApp/App.config    |  8 +--
 .../My Project/Resources.Designer.vb          |  2 +-
 .../My Project/Settings.Designer.vb           |  2 +-
 6 files changed, 86 insertions(+), 88 deletions(-)

diff --git a/Rollbar/Infrastructure/RollbarQueueController.cs b/Rollbar/Infrastructure/RollbarQueueController.cs
index bc7d1fc5..d7e890e7 100644
--- a/Rollbar/Infrastructure/RollbarQueueController.cs
+++ b/Rollbar/Infrastructure/RollbarQueueController.cs
@@ -41,11 +41,20 @@ internal sealed class RollbarQueueController
     {
         #region singleton implementation
 
-        //private static RollbarQueueController _singleton;
-
-        private static readonly Lazy<RollbarQueueController> lazy =
+        private static readonly Lazy<RollbarQueueController> lazySingleton =
             new Lazy<RollbarQueueController>(() => new RollbarQueueController());
 
+        //private static bool allowSingleton = false;
+        //internal static void AllowSingleton()
+        //{
+        //    allowSingleton = true;
+        //}
+
+        //private static readonly object classLock = new object();
+        //private static volatile RollbarQueueController? singleton;
+
+
+
         /// <summary>
         /// Gets the instance.
         /// </summary>
@@ -54,15 +63,26 @@ public static RollbarQueueController? Instance
         {
             get
             {
-                //return NestedSingleInstance.TheInstance;
+                if (!RollbarInfrastructure.Instance.IsInitialized)
+                {
+                    return null;
+                }
 
-                //if (_singleton == null)
+                //if (singleton == null)
                 //{
-                //    _singleton = new RollbarQueueController();
+                //    lock (classLock)
+                //    {
+                //        if (singleton == null)
+                //        {
+                //            singleton = new RollbarQueueController();
+                //        }
+                //    }
                 //}
-                //return _singleton;
+                //return singleton;
+
+                //return allowSingleton ? lazySingleton.Value : null;
 
-                return RollbarInfrastructure.Instance.IsInitialized ? lazy.Value : null;
+                return lazySingleton.Value;
             }
         }
 
@@ -71,26 +91,7 @@ public static RollbarQueueController? Instance
         /// </summary>
         private RollbarQueueController()
         {
-        }
-
-        /// <summary>
-        /// Class NestedSingleInstance. This class cannot be inherited.
-        /// </summary>
-        private sealed class NestedSingleInstance
-        {
-            /// <summary>
-            /// Prevents a default instance of the <see cref="NestedSingleInstance"/> class from being created.
-            /// </summary>
-            private NestedSingleInstance()
-            {
-            }
-
-            /// <summary>
-            /// The instance
-            /// </summary>
-            internal static readonly RollbarQueueController? TheInstance =
-                RollbarInfrastructure.Instance.IsInitialized ? new RollbarQueueController()
-                : null;
+            traceSource.TraceInformation($"Creating the {typeof(RollbarQueueController).Name}...");
         }
 
         #endregion singleton implementation
diff --git a/Rollbar/RollbarInfrastructure.cs b/Rollbar/RollbarInfrastructure.cs
index 9ce23f28..d42f09d2 100644
--- a/Rollbar/RollbarInfrastructure.cs
+++ b/Rollbar/RollbarInfrastructure.cs
@@ -20,7 +20,7 @@
     /// 
     /// </summary>
     /// <seealso cref="System.IDisposable" />
-    public class RollbarInfrastructure
+    public sealed class RollbarInfrastructure
         : IRollbarInfrastructure
         , IDisposable
     {
@@ -38,11 +38,12 @@ public class RollbarInfrastructure
 
         #region singleton implementation
 
-        //private static RollbarInfrastructure _singleton; 
-
-        private static readonly Lazy<RollbarInfrastructure> lazy =
+        private static readonly Lazy<RollbarInfrastructure> lazySingleton =
             new Lazy<RollbarInfrastructure>(() => new RollbarInfrastructure());
 
+        //private static readonly object classLock = new object();
+        //private static volatile RollbarInfrastructure? singleton;
+
         /// <summary>
         /// Gets the instance.
         /// </summary>
@@ -51,15 +52,19 @@ public static RollbarInfrastructure Instance
         {
             get
             {
-                //return NestedSingleInstance.TheInstance;
-
-                //if (_singleton == null)
+                //if (singleton == null)
                 //{
-                //    _singleton = new RollbarQueueController();
+                //    lock (classLock)
+                //    {
+                //        if (singleton == null)
+                //        {
+                //            singleton = new RollbarInfrastructure();
+                //        }
+                //    }
                 //}
-                //return _singleton;
+                //return singleton;
 
-                return lazy.Value;
+                return lazySingleton.Value;
             }
         }
 
@@ -71,25 +76,6 @@ private RollbarInfrastructure()
             traceSource.TraceInformation($"Creating the {typeof(RollbarInfrastructure).Name}...");
         }
 
-        /// <summary>
-        /// Class NestedSingleInstance. This class cannot be inherited.
-        /// </summary>
-        private sealed class NestedSingleInstance
-        {
-            /// <summary>
-            /// Prevents a default instance of the <see cref="NestedSingleInstance"/> class from being created.
-            /// </summary>
-            private NestedSingleInstance()
-            {
-            }
-
-            /// <summary>
-            /// The instance
-            /// </summary>
-            internal static readonly RollbarInfrastructure TheInstance =
-                new RollbarInfrastructure();
-        }
-
         #endregion singleton implementation
 
         /// <summary>
@@ -165,6 +151,9 @@ public IRollbarInfrastructureConfig Config
         public void Init(IRollbarInfrastructureConfig config)
         {
             Assumption.AssertNotNull(config, nameof(config));
+            Assumption.AssertNotNull(RollbarInfrastructure.Instance, nameof(RollbarInfrastructure.Instance));
+            Assumption.AssertFalse(RollbarInfrastructure.Instance.IsInitialized, nameof(RollbarInfrastructure.Instance.IsInitialized));
+
 
             lock(this._syncLock)
             {
@@ -186,9 +175,10 @@ public void Init(IRollbarInfrastructureConfig config)
                     this.ValidateConfiguration();
                     this._config.Reconfigured += _config_Reconfigured;
                     this._initializedOnce = true;
+                    Assumption.AssertTrue(RollbarInfrastructure.Instance.IsInitialized, nameof(RollbarInfrastructure.Instance.IsInitialized));
 
-                    RollbarQueueController.Instance!.Init(config);
-                    RollbarTelemetryCollector.Instance!.Init(config.RollbarTelemetryOptions);
+                    RollbarQueueController.Instance?.Init(config);
+                    RollbarTelemetryCollector.Instance?.Init(config.RollbarTelemetryOptions);
                     // NOTE: RollbarConfig
                     // - init ConnectivityMonitor service as needed
                     //   NOTE: It should be sufficient to make ConnectivityMonitor as internal class
@@ -264,7 +254,7 @@ private void CompleteProcessing()
         /// Releases unmanaged and - optionally - managed resources.
         /// </summary>
         /// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
-        protected virtual void Dispose(bool disposing)
+        private void Dispose(bool disposing)
         {
             if(!disposedValue)
             {
diff --git a/Rollbar/Telemetry/RollbarTelemetryCollector.cs b/Rollbar/Telemetry/RollbarTelemetryCollector.cs
index 017e5f74..41d8f762 100644
--- a/Rollbar/Telemetry/RollbarTelemetryCollector.cs
+++ b/Rollbar/Telemetry/RollbarTelemetryCollector.cs
@@ -10,7 +10,7 @@
     /// <summary>
     /// Implements Rollbar telemetry collector service.
     /// </summary>
-    internal class RollbarTelemetryCollector
+    internal sealed class RollbarTelemetryCollector
         : IRollbarTelemetryCollector
         , IDisposable
     {
@@ -19,9 +19,18 @@ internal class RollbarTelemetryCollector
 
         #region singleton implementation
 
-        private static readonly Lazy<RollbarTelemetryCollector> lazy =
+        private static readonly Lazy<RollbarTelemetryCollector> lazySingleton =
             new Lazy<RollbarTelemetryCollector>(() => new RollbarTelemetryCollector());
 
+        //private static bool allowSingleton = false;
+        //internal static void AllowSingleton()
+        //{
+        //    allowSingleton = true;
+        //}
+
+        //private static readonly object classLock = new object();
+        //private static volatile RollbarTelemetryCollector? singleton;
+
         /// <summary>
         /// Gets the instance.
         /// </summary>
@@ -30,15 +39,26 @@ public static RollbarTelemetryCollector? Instance
         {
             get
             {
-                //return NestedSingleInstance.TheInstance;
+                if (!RollbarInfrastructure.Instance.IsInitialized)
+                {
+                    return null;
+                }
 
-                //if (_singleton == null)
+                //if (singleton == null)
                 //{
-                //    _singleton = new RollbarQueueController();
+                //    lock (classLock)
+                //    {
+                //        if (singleton == null)
+                //        {
+                //            singleton = new RollbarTelemetryCollector();
+                //        }
+                //    }
                 //}
-                //return _singleton;
+                //return singleton;
+
+                //return allowSingleton ? lazySingleton.Value : null;
 
-                return RollbarInfrastructure.Instance.IsInitialized ? lazy.Value : null;
+                return lazySingleton.Value;
             }
         }
 
@@ -47,20 +67,7 @@ public static RollbarTelemetryCollector? Instance
         /// </summary>
         private RollbarTelemetryCollector()
         {
-        }
-
-        private sealed class NestedSingleInstance
-        {
-            private NestedSingleInstance()
-            {
-            }
-
-            /// <summary>
-            /// The singleton-like instance of the service.
-            /// </summary>
-            internal static readonly RollbarTelemetryCollector? TheInstance =
-                RollbarInfrastructure.Instance.IsInitialized ? new RollbarTelemetryCollector()
-                : null;
+            traceSource.TraceInformation($"Creating the {typeof(RollbarTelemetryCollector).Name}...");
         }
 
         #endregion singleton implementation
@@ -327,7 +334,7 @@ private void KeepCollectingTelemetry(object? data)
         /// Releases unmanaged and - optionally - managed resources.
         /// </summary>
         /// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
-        protected virtual void Dispose(bool disposing)
+        private void Dispose(bool disposing)
         {
             if (!disposedValue)
             {
diff --git a/Samples/Sample.VBNet.ConsoleApp/App.config b/Samples/Sample.VBNet.ConsoleApp/App.config
index bcb2ae2d..a58a46ef 100644
--- a/Samples/Sample.VBNet.ConsoleApp/App.config
+++ b/Samples/Sample.VBNet.ConsoleApp/App.config
@@ -1,13 +1,13 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <configuration>
     <startup> 
-        <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.8" />
+        <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.8"/>
     </startup>
   <runtime>
     <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
       <dependentAssembly>
-        <assemblyIdentity name="System.Runtime.CompilerServices.Unsafe" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
-        <bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
+        <assemblyIdentity name="System.Runtime.CompilerServices.Unsafe" publicKeyToken="b03f5f7f11d50a3a" culture="neutral"/>
+        <bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0"/>
       </dependentAssembly>
     </assemblyBinding>
   </runtime>
diff --git a/Samples/Sample.VBNet.ConsoleApp/My Project/Resources.Designer.vb b/Samples/Sample.VBNet.ConsoleApp/My Project/Resources.Designer.vb
index 9608190f..b64fba16 100644
--- a/Samples/Sample.VBNet.ConsoleApp/My Project/Resources.Designer.vb	
+++ b/Samples/Sample.VBNet.ConsoleApp/My Project/Resources.Designer.vb	
@@ -22,7 +22,7 @@ Namespace My.Resources
     '''<summary>
     '''  A strongly-typed resource class, for looking up localized strings, etc.
     '''</summary>
-    <Global.System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "16.0.0.0"),  _
+    <Global.System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "17.0.0.0"),  _
      Global.System.Diagnostics.DebuggerNonUserCodeAttribute(),  _
      Global.System.Runtime.CompilerServices.CompilerGeneratedAttribute(),  _
      Global.Microsoft.VisualBasic.HideModuleNameAttribute()>  _
diff --git a/Samples/Sample.VBNet.ConsoleApp/My Project/Settings.Designer.vb b/Samples/Sample.VBNet.ConsoleApp/My Project/Settings.Designer.vb
index 1e3cf95f..9eeb56e9 100644
--- a/Samples/Sample.VBNet.ConsoleApp/My Project/Settings.Designer.vb	
+++ b/Samples/Sample.VBNet.ConsoleApp/My Project/Settings.Designer.vb	
@@ -15,7 +15,7 @@ Option Explicit On
 Namespace My
     
     <Global.System.Runtime.CompilerServices.CompilerGeneratedAttribute(),  _
-     Global.System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "16.8.1.0"),  _
+     Global.System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "17.1.0.0"),  _
      Global.System.ComponentModel.EditorBrowsableAttribute(Global.System.ComponentModel.EditorBrowsableState.Advanced)>  _
     Partial Friend NotInheritable Class MySettings
         Inherits Global.System.Configuration.ApplicationSettingsBase

From e636f0d26263c6fc85d740a62aec59ae9e376f79 Mon Sep 17 00:00:00 2001
From: Andrey Kornich <akornich@gmail.com>
Date: Sat, 12 Mar 2022 00:34:51 -0800
Subject: [PATCH 3/4] fix: ref #623

changing to alternative singleton implementations that do not rely on .NET runtime static members handling.
---
 Rollbar/Common/EmptyDisposable.cs             | 44 ++++++-----
 .../RollbarConnectivityMonitor.cs             | 28 +------
 .../Infrastructure/RollbarQueueController.cs  | 37 +---------
 Rollbar/Infrastructure/_RollbarPackages.cd    |  2 +-
 Rollbar/RollbarDataScrubbingHelper.cs         | 30 +++-----
 Rollbar/RollbarInfrastructure.cs              | 74 ++++++++++---------
 Rollbar/RollbarLocator.cs                     | 29 +++++---
 .../Telemetry/RollbarTelemetryCollector.cs    | 35 +--------
 Rollbar/Telemetry/_Telemetry.cd               | 58 ++++-----------
 Rollbar/_Rollbar.cd                           | 36 ++-------
 Rollbar/_RollbarConfig.cd                     |  2 +-
 Rollbar/_RollbarInfrastructure.cd             | 21 +-----
 Rollbar/_RollbarLogger.cd                     |  9 +--
 Rollbar/_RollbarPackagingStrategies.cd        | 24 +++---
 14 files changed, 130 insertions(+), 299 deletions(-)

diff --git a/Rollbar/Common/EmptyDisposable.cs b/Rollbar/Common/EmptyDisposable.cs
index 4c581cc4..2685b63d 100644
--- a/Rollbar/Common/EmptyDisposable.cs
+++ b/Rollbar/Common/EmptyDisposable.cs
@@ -1,6 +1,7 @@
 namespace Rollbar.Common
 {
     using System;
+    using System.Diagnostics;
     using System.Collections.Generic;
     using System.Text;
 
@@ -11,46 +12,43 @@
     public sealed class EmptyDisposable
         : IDisposable
     {
-        /// <summary>
-        /// Prevents a default instance of the <see cref="EmptyDisposable"/> class from being created.
-        /// </summary>
-        private EmptyDisposable()
-        {
-        }
+        private static readonly TraceSource traceSource =
+            new TraceSource(typeof(EmptyDisposable).FullName ?? "EmptyDisposable");
+
+        #region singleton implementation
+
+        private static readonly Lazy<EmptyDisposable> lazySingleton =
+            new Lazy<EmptyDisposable>(() => new EmptyDisposable());
 
         /// <summary>
-        /// Gets the singleton-like IRollbar instance.
+        /// Gets the instance.
         /// </summary>
-        /// <value>
-        /// The single shared IRollbar instance.
-        /// </value>
+        /// <value>The instance.</value>
         public static EmptyDisposable Instance
         {
             get
             {
-                return NestedSingleInstance.TheInstance;
+                return lazySingleton.Value;
             }
         }
 
         /// <summary>
-        /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
+        /// Prevents a default instance of the <see cref="EmptyDisposable" /> class from being created.
         /// </summary>
-        public void Dispose()
+        private EmptyDisposable()
         {
-            // no-op...
+            traceSource.TraceInformation($"Creating the {typeof(EmptyDisposable).Name}...");
         }
 
-        private sealed class NestedSingleInstance
-        {
-            static NestedSingleInstance()
-            {
-            }
+        #endregion singleton implementation
 
-            private NestedSingleInstance()
-            {
-            }
 
-            internal static readonly EmptyDisposable TheInstance = new EmptyDisposable();
+        /// <summary>
+        /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
+        /// </summary>
+        public void Dispose()
+        {
+            // no-op...
         }
     }
 }
diff --git a/Rollbar/Infrastructure/RollbarConnectivityMonitor.cs b/Rollbar/Infrastructure/RollbarConnectivityMonitor.cs
index da69da4b..e065efaf 100644
--- a/Rollbar/Infrastructure/RollbarConnectivityMonitor.cs
+++ b/Rollbar/Infrastructure/RollbarConnectivityMonitor.cs
@@ -10,7 +10,7 @@
     /// Implements the <see cref="System.IDisposable" />
     /// </summary>
     /// <seealso cref="System.IDisposable" />
-    internal class RollbarConnectivityMonitor
+    internal sealed class RollbarConnectivityMonitor
         : IRollbarConnectivityMonitor
         , IDisposable
     {
@@ -30,14 +30,14 @@ public static RollbarConnectivityMonitor? Instance
         {
             get
             {
-                return NestedSingleInstance.TheInstance;
+                return RollbarInfrastructure.Instance.ConnectivityMonitor as RollbarConnectivityMonitor;
             }
         }
 
         /// <summary>
         /// Prevents a default instance of the <see cref="RollbarConnectivityMonitor"/> class from being created.
         /// </summary>
-        private RollbarConnectivityMonitor()
+        internal RollbarConnectivityMonitor()
         {
             TimeSpan initialDelay = TimeSpan.Zero;
             this._minMonitoringInterval = TimeSpan.FromSeconds(10);
@@ -56,26 +56,6 @@ private RollbarConnectivityMonitor()
             this.CheckConnectivityStatus(null);
         }
 
-        /// <summary>
-        /// Class NestedSingleInstance. This class cannot be inherited.
-        /// </summary>
-        private sealed class NestedSingleInstance
-        {
-            /// <summary>
-            /// Prevents a default instance of the <see cref="NestedSingleInstance" /> class from being created.
-            /// </summary>
-            private NestedSingleInstance()
-            {
-            }
-
-            /// <summary>
-            /// The instance
-            /// </summary>
-            internal static readonly RollbarConnectivityMonitor? TheInstance =
-                RollbarInfrastructure.Instance.IsInitialized ? new RollbarConnectivityMonitor()
-                : null;
-        }
-
         #endregion singleton implementation
 
         /// <summary>
@@ -264,7 +244,7 @@ public static bool TestApiServer()
         /// </summary>
         /// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
         [System.Diagnostics.CodeAnalysis.SuppressMessage("Major Code Smell", "S1066:Collapsible \"if\" statements should be merged", Justification = "Promotes better code structure.")]
-        protected virtual void Dispose(bool disposing)
+        private void Dispose(bool disposing)
         {
             if(!_disposedValue)
             {
diff --git a/Rollbar/Infrastructure/RollbarQueueController.cs b/Rollbar/Infrastructure/RollbarQueueController.cs
index d7e890e7..9191d65f 100644
--- a/Rollbar/Infrastructure/RollbarQueueController.cs
+++ b/Rollbar/Infrastructure/RollbarQueueController.cs
@@ -41,20 +41,6 @@ internal sealed class RollbarQueueController
     {
         #region singleton implementation
 
-        private static readonly Lazy<RollbarQueueController> lazySingleton =
-            new Lazy<RollbarQueueController>(() => new RollbarQueueController());
-
-        //private static bool allowSingleton = false;
-        //internal static void AllowSingleton()
-        //{
-        //    allowSingleton = true;
-        //}
-
-        //private static readonly object classLock = new object();
-        //private static volatile RollbarQueueController? singleton;
-
-
-
         /// <summary>
         /// Gets the instance.
         /// </summary>
@@ -63,33 +49,14 @@ public static RollbarQueueController? Instance
         {
             get
             {
-                if (!RollbarInfrastructure.Instance.IsInitialized)
-                {
-                    return null;
-                }
-
-                //if (singleton == null)
-                //{
-                //    lock (classLock)
-                //    {
-                //        if (singleton == null)
-                //        {
-                //            singleton = new RollbarQueueController();
-                //        }
-                //    }
-                //}
-                //return singleton;
-
-                //return allowSingleton ? lazySingleton.Value : null;
-
-                return lazySingleton.Value;
+                return RollbarInfrastructure.Instance.QueueController as RollbarQueueController;
             }
         }
 
         /// <summary>
         /// Prevents a default instance of the <see cref="RollbarQueueController" /> class from being created.
         /// </summary>
-        private RollbarQueueController()
+        internal RollbarQueueController()
         {
             traceSource.TraceInformation($"Creating the {typeof(RollbarQueueController).Name}...");
         }
diff --git a/Rollbar/Infrastructure/_RollbarPackages.cd b/Rollbar/Infrastructure/_RollbarPackages.cd
index 904bad5d..10952330 100644
--- a/Rollbar/Infrastructure/_RollbarPackages.cd
+++ b/Rollbar/Infrastructure/_RollbarPackages.cd
@@ -3,7 +3,7 @@
   <Class Name="Rollbar.RollbarPackageBase">
     <Position X="6.5" Y="1.5" Width="4" />
     <TypeIdentifier>
-      <HashCode>AAAABAAAAAgAAAAAAgAAAEAAAACBAIAAAAAAQAAQAAA=</HashCode>
+      <HashCode>AAAABAAAAAgAAAAgAgAAAAAAAACBAIAAAAAAQAAQAAA=</HashCode>
       <FileName>Infrastructure\RollbarPackageBase.cs</FileName>
     </TypeIdentifier>
     <Lollipop Position="0.2" />
diff --git a/Rollbar/RollbarDataScrubbingHelper.cs b/Rollbar/RollbarDataScrubbingHelper.cs
index 29e82943..a1882f64 100644
--- a/Rollbar/RollbarDataScrubbingHelper.cs
+++ b/Rollbar/RollbarDataScrubbingHelper.cs
@@ -1,6 +1,7 @@
 namespace Rollbar
 {
     using System;
+    using System.Diagnostics;
     using System.Linq;
     using System.Collections.Generic;
 
@@ -14,9 +15,14 @@
     /// </remarks>
     public class RollbarDataScrubbingHelper
     {
+        private static readonly TraceSource traceSource =
+    new TraceSource(typeof(RollbarDataScrubbingHelper).FullName ?? "RollbarDataScrubbingHelper");
 
         #region singleton implementation
 
+        private static readonly Lazy<RollbarDataScrubbingHelper> lazySingleton =
+            new Lazy<RollbarDataScrubbingHelper>(() => new RollbarDataScrubbingHelper());
+
         /// <summary>
         /// Gets the instance.
         /// </summary>
@@ -25,34 +31,16 @@ public static RollbarDataScrubbingHelper Instance
         {
             get
             {
-                return NestedSingleInstance.TheInstance;
+                return lazySingleton.Value;
             }
         }
 
         /// <summary>
-        /// Prevents a default instance of the <see cref="RollbarDataScrubbingHelper" /> class from being created.
+        /// Prevents a default instance of the <see cref="EmptyDisposable" /> class from being created.
         /// </summary>
         private RollbarDataScrubbingHelper()
         {
-        }
-
-        /// <summary>
-        /// Class NestedSingleInstance. This class cannot be inherited.
-        /// </summary>
-        private sealed class NestedSingleInstance
-        {
-            /// <summary>
-            /// Prevents a default instance of the <see cref="NestedSingleInstance" /> class from being created.
-            /// </summary>
-            private NestedSingleInstance()
-            {
-            }
-
-            /// <summary>
-            /// The instance
-            /// </summary>
-            internal static readonly RollbarDataScrubbingHelper TheInstance =
-                new RollbarDataScrubbingHelper();
+            traceSource.TraceInformation($"Creating the {typeof(RollbarDataScrubbingHelper).Name}...");
         }
 
         #endregion singleton implementation
diff --git a/Rollbar/RollbarInfrastructure.cs b/Rollbar/RollbarInfrastructure.cs
index d42f09d2..873ed352 100644
--- a/Rollbar/RollbarInfrastructure.cs
+++ b/Rollbar/RollbarInfrastructure.cs
@@ -32,18 +32,25 @@ public sealed class RollbarInfrastructure
 
         private readonly object _syncLock = new object();
 
-        private bool _initializedOnce = false;
+        //private bool _initializedOnce = false;
 
         private IRollbarInfrastructureConfig? _config;
 
+        private readonly Lazy<RollbarQueueController> _lazyQueueController =
+            new Lazy<RollbarQueueController>(() => new RollbarQueueController());
+
+        private readonly Lazy<RollbarTelemetryCollector> _lazyTelemetryCollector =
+            new Lazy<RollbarTelemetryCollector>(() => new RollbarTelemetryCollector());
+        
+        private readonly Lazy<RollbarConnectivityMonitor> _lazyConnectivityMonitor =
+            new Lazy<RollbarConnectivityMonitor>(() => new RollbarConnectivityMonitor());
+
+
         #region singleton implementation
 
         private static readonly Lazy<RollbarInfrastructure> lazySingleton =
             new Lazy<RollbarInfrastructure>(() => new RollbarInfrastructure());
 
-        //private static readonly object classLock = new object();
-        //private static volatile RollbarInfrastructure? singleton;
-
         /// <summary>
         /// Gets the instance.
         /// </summary>
@@ -52,18 +59,6 @@ public static RollbarInfrastructure Instance
         {
             get
             {
-                //if (singleton == null)
-                //{
-                //    lock (classLock)
-                //    {
-                //        if (singleton == null)
-                //        {
-                //            singleton = new RollbarInfrastructure();
-                //        }
-                //    }
-                //}
-                //return singleton;
-
                 return lazySingleton.Value;
             }
         }
@@ -86,7 +81,9 @@ public bool IsInitialized
         {
             get
             {
-                return this._initializedOnce;
+                return (this._lazyQueueController.IsValueCreated 
+                    && this._lazyTelemetryCollector.IsValueCreated
+                    && this._lazyConnectivityMonitor.IsValueCreated);
             }
         }
 
@@ -98,7 +95,12 @@ public IRollbarQueueController? QueueController
         {
             get
             {
-                return RollbarQueueController.Instance;
+                if (!this._lazyQueueController.IsValueCreated)
+                {
+                    return null;
+                }
+
+                return this._lazyQueueController.Value;
             }
         }
 
@@ -110,7 +112,12 @@ public IRollbarTelemetryCollector? TelemetryCollector
         {
             get
             {
-                return RollbarTelemetryCollector.Instance;
+                if (!this._lazyTelemetryCollector.IsValueCreated)
+                {
+                    return null;
+                }
+
+                return this._lazyTelemetryCollector.Value;
             }
         }
 
@@ -122,7 +129,12 @@ public IRollbarConnectivityMonitor? ConnectivityMonitor
         {
             get
             {
-                return RollbarConnectivityMonitor.Instance;
+                if (!this._lazyConnectivityMonitor.IsValueCreated)
+                {
+                    return null;
+                }
+
+                return _lazyConnectivityMonitor.Value;
             }
         }
 
@@ -154,10 +166,9 @@ public void Init(IRollbarInfrastructureConfig config)
             Assumption.AssertNotNull(RollbarInfrastructure.Instance, nameof(RollbarInfrastructure.Instance));
             Assumption.AssertFalse(RollbarInfrastructure.Instance.IsInitialized, nameof(RollbarInfrastructure.Instance.IsInitialized));
 
-
             lock(this._syncLock)
             {
-                if(this._initializedOnce)
+                if(this.IsInitialized)
                 {
                     string msg = $"{typeof(RollbarInfrastructure).Name} can not be initialized more than once!";
                     traceSource.TraceInformation(msg);
@@ -174,20 +185,14 @@ public void Init(IRollbarInfrastructureConfig config)
                     this._config = config;
                     this.ValidateConfiguration();
                     this._config.Reconfigured += _config_Reconfigured;
-                    this._initializedOnce = true;
-                    Assumption.AssertTrue(RollbarInfrastructure.Instance.IsInitialized, nameof(RollbarInfrastructure.Instance.IsInitialized));
-
-                    RollbarQueueController.Instance?.Init(config);
-                    RollbarTelemetryCollector.Instance?.Init(config.RollbarTelemetryOptions);
-                    // NOTE: RollbarConfig
-                    // - init ConnectivityMonitor service as needed
-                    //   NOTE: It should be sufficient to make ConnectivityMonitor as internal class
-                    //         It is only used by RollbarClient and RollbarQueueController that are 
-                    //         already properly deactivated in single-threaded environments.
+                    this._lazyQueueController.Value.Init(config);
+                    this._lazyTelemetryCollector.Value.Init(config.RollbarTelemetryOptions);
+                    _ = this._lazyConnectivityMonitor.Value;
+                    //Assumption.AssertTrue(RollbarInfrastructure.Instance.IsInitialized, nameof(RollbarInfrastructure.Instance.IsInitialized));
                 }
                 catch(Exception ex)
                 {
-                    this._initializedOnce = false;
+                    //this._initializedOnce = false;
 
                     throw new RollbarException(
                         InternalRollbarError.InfrastructureError,
@@ -201,8 +206,9 @@ public void Init(IRollbarInfrastructureConfig config)
 
         private void ValidateConfiguration()
         {
-            if(this._initializedOnce)
+            if(this.IsInitialized)
             {
+                // nice short-cut:
                 return;
             }
 
diff --git a/Rollbar/RollbarLocator.cs b/Rollbar/RollbarLocator.cs
index e8e58992..0f3663c4 100644
--- a/Rollbar/RollbarLocator.cs
+++ b/Rollbar/RollbarLocator.cs
@@ -1,32 +1,39 @@
 namespace Rollbar
 {
+    using System;
+
+    using System.Diagnostics;
 
     /// <summary>
     /// Singleton-like locator of the single shared instance of IRollbar component.
     /// </summary>
-    public class RollbarLocator
+    public sealed class RollbarLocator
     {
+        private static readonly TraceSource traceSource =
+            new TraceSource(typeof(RollbarLocator).FullName ?? "RollbarLocator");
+
+        #region singleton implementation
+
+        private static readonly Lazy<IRollbar> lazySingleton =
+            new Lazy<IRollbar>(() => RollbarFactory.CreateNew());
+
         /// <summary>
         /// Gets the singleton-like IRollbar instance.
         /// </summary>
-        /// <value>
-        /// The single shared IRollbar instance.
-        /// </value>
+        /// <value>The instance.</value>
         public static IRollbar RollbarInstance
         {
             get
             {
-                return NestedSingleInstance.Instance;
+                return lazySingleton.Value;
             }
         }
 
-        private sealed class NestedSingleInstance
+        private RollbarLocator()
         {
-            private NestedSingleInstance()
-            {
-            }
-
-            internal static readonly IRollbar Instance = RollbarFactory.CreateNew();
+            traceSource.TraceInformation($"Creating the {typeof(RollbarLocator).Name}...");
         }
+
+        #endregion singleton implementation
     }
 }
diff --git a/Rollbar/Telemetry/RollbarTelemetryCollector.cs b/Rollbar/Telemetry/RollbarTelemetryCollector.cs
index 41d8f762..4331b879 100644
--- a/Rollbar/Telemetry/RollbarTelemetryCollector.cs
+++ b/Rollbar/Telemetry/RollbarTelemetryCollector.cs
@@ -19,18 +19,6 @@ internal sealed class RollbarTelemetryCollector
 
         #region singleton implementation
 
-        private static readonly Lazy<RollbarTelemetryCollector> lazySingleton =
-            new Lazy<RollbarTelemetryCollector>(() => new RollbarTelemetryCollector());
-
-        //private static bool allowSingleton = false;
-        //internal static void AllowSingleton()
-        //{
-        //    allowSingleton = true;
-        //}
-
-        //private static readonly object classLock = new object();
-        //private static volatile RollbarTelemetryCollector? singleton;
-
         /// <summary>
         /// Gets the instance.
         /// </summary>
@@ -39,33 +27,14 @@ public static RollbarTelemetryCollector? Instance
         {
             get
             {
-                if (!RollbarInfrastructure.Instance.IsInitialized)
-                {
-                    return null;
-                }
-
-                //if (singleton == null)
-                //{
-                //    lock (classLock)
-                //    {
-                //        if (singleton == null)
-                //        {
-                //            singleton = new RollbarTelemetryCollector();
-                //        }
-                //    }
-                //}
-                //return singleton;
-
-                //return allowSingleton ? lazySingleton.Value : null;
-
-                return lazySingleton.Value;
+                return RollbarInfrastructure.Instance.TelemetryCollector as RollbarTelemetryCollector;
             }
         }
 
         /// <summary>
         /// Prevents a default instance of the <see cref="RollbarTelemetryCollector"/> class from being created.
         /// </summary>
-        private RollbarTelemetryCollector()
+        internal RollbarTelemetryCollector()
         {
             traceSource.TraceInformation($"Creating the {typeof(RollbarTelemetryCollector).Name}...");
         }
diff --git a/Rollbar/Telemetry/_Telemetry.cd b/Rollbar/Telemetry/_Telemetry.cd
index bc3103c0..58f1e9a0 100644
--- a/Rollbar/Telemetry/_Telemetry.cd
+++ b/Rollbar/Telemetry/_Telemetry.cd
@@ -1,68 +1,36 @@
 <?xml version="1.0" encoding="utf-8"?>
 <ClassDiagram MajorVersion="1" MinorVersion="1" MembersFormat="FullSignature">
-  <Class Name="Rollbar.Telemetry.TelemetryCollector">
-    <Position X="0.5" Y="4" Width="5.5" />
-    <Compartments>
-      <Compartment Name="Nested Types" Collapsed="false" />
-    </Compartments>
-    <NestedTypes>
-      <Class Name="Rollbar.Telemetry.TelemetryCollector.NestedSingleInstance">
-        <TypeIdentifier>
-          <NewMemberFileName>Telemetry\TelemetryCollector.cs</NewMemberFileName>
-        </TypeIdentifier>
-      </Class>
-    </NestedTypes>
-    <TypeIdentifier>
-      <HashCode>AAAIAYAAEiAgAgABAAAAUACAAAAIgAIASBBQAiIAAAA=</HashCode>
-      <FileName>Telemetry\TelemetryCollector.cs</FileName>
-    </TypeIdentifier>
-    <Lollipop Position="0.2" />
-  </Class>
-  <Class Name="Rollbar.Telemetry.TelemetryConfig">
-    <Position X="6.25" Y="4" Width="9.5" />
-    <TypeIdentifier>
-      <HashCode>AAAAAAAAQAAAABAAAAACAAACAAAAAAAQAAACABAAAAA=</HashCode>
-      <FileName>Telemetry\TelemetryConfig.cs</FileName>
-    </TypeIdentifier>
-    <Lollipop Position="0.2" />
-  </Class>
-  <Class Name="Rollbar.Telemetry.TelemetryQueue">
-    <Position X="6.25" Y="7.5" Width="3" />
+  <Class Name="Rollbar.TelemetryQueue">
+    <Position X="0.5" Y="0.5" Width="3" />
     <TypeIdentifier>
       <HashCode>AABAAAAAAAAkAgAAEAAAEAAAAAAABAAAAAIAAAAIAAA=</HashCode>
       <FileName>Telemetry\TelemetryQueue.cs</FileName>
     </TypeIdentifier>
   </Class>
-  <Class Name="Rollbar.Telemetry.TelemetryUtility">
-    <Position X="3.25" Y="13.5" Width="2.5" />
+  <Class Name="Rollbar.TelemetryUtility">
+    <Position X="0.5" Y="4.5" Width="2.5" />
     <TypeIdentifier>
       <HashCode>AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAA=</HashCode>
       <FileName>Telemetry\TelemetryUtility.cs</FileName>
     </TypeIdentifier>
   </Class>
-  <Interface Name="Rollbar.Telemetry.ITelemetryCollector">
-    <Position X="0.5" Y="0.5" Width="3.75" />
-    <TypeIdentifier>
-      <HashCode>AAAAAAAAEgAgAgAAAAAAUAAAAAAAAAAAABBQAAAAAAA=</HashCode>
-      <FileName>Telemetry\ITelemetryCollector.cs</FileName>
-    </TypeIdentifier>
-  </Interface>
-  <Interface Name="Rollbar.Telemetry.ITelemetryConfig">
-    <Position X="6.25" Y="0.5" Width="4" />
+  <Class Name="Rollbar.RollbarTelemetryCollector">
+    <Position X="4" Y="3.25" Width="5.5" />
     <TypeIdentifier>
-      <HashCode>AAAAAAAAAAAAABAAAAACAAAAAAAAAAAAAAACABAAAAA=</HashCode>
-      <FileName>Telemetry\ITelemetryConfig.cs</FileName>
+      <HashCode>AAAIAIAAEiAgAgABAAAAUACAAAAIgAIASBBSAiIAABA=</HashCode>
+      <FileName>Telemetry\RollbarTelemetryCollector.cs</FileName>
     </TypeIdentifier>
-  </Interface>
-  <Enum Name="Rollbar.Telemetry.TelemetryAutoCollectionSettings">
-    <Position X="0.5" Y="13.5" Width="2.25" />
+    <Lollipop Position="0.2" />
+  </Class>
+  <Enum Name="Rollbar.TelemetryAutoCollectionSettings">
+    <Position X="5.5" Y="0.5" Width="4.5" />
     <TypeIdentifier>
       <HashCode>AAAAAAAABAAAAAABAAAAAAgAAAAAAAAAgAAAAAEAAAA=</HashCode>
       <FileName>Telemetry\TelemetryAutoCollectionSettings.cs</FileName>
     </TypeIdentifier>
   </Enum>
   <Enum Name="Rollbar.DTOs.TelemetryType">
-    <Position X="11.5" Y="0.5" Width="1.5" />
+    <Position X="3.75" Y="0.5" Width="1.5" />
     <TypeIdentifier>
       <HashCode>AAAAAAAAQAAAAQAAAAAAAAAACAgAAAAAAAAAAAUAQAA=</HashCode>
       <FileName>DTOs\TelemetryType.cs</FileName>
diff --git a/Rollbar/_Rollbar.cd b/Rollbar/_Rollbar.cd
index 886c254c..9ff7b4c4 100644
--- a/Rollbar/_Rollbar.cd
+++ b/Rollbar/_Rollbar.cd
@@ -5,15 +5,8 @@
     <Compartments>
       <Compartment Name="Nested Types" Collapsed="false" />
     </Compartments>
-    <NestedTypes>
-      <Class Name="Rollbar.RollbarLocator.NestedSingleInstance">
-        <TypeIdentifier>
-          <NewMemberFileName>RollbarLocator.cs</NewMemberFileName>
-        </TypeIdentifier>
-      </Class>
-    </NestedTypes>
     <TypeIdentifier>
-      <HashCode>AAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=</HashCode>
+      <HashCode>AAAAAAQAAAAAAgABAAAAAAAAAAAAAAAAAAAAAAAAAAA=</HashCode>
       <FileName>RollbarLocator.cs</FileName>
     </TypeIdentifier>
   </Class>
@@ -55,20 +48,15 @@
     </TypeIdentifier>
     <Lollipop Position="0.2" />
   </Class>
-  <Class Name="Rollbar.RollbarQueueController">
+  <Class Name="Rollbar.Infrastructure.RollbarQueueController">
     <Position X="18" Y="0.75" Width="5.5" />
     <Compartments>
       <Compartment Name="Nested Types" Collapsed="false" />
     </Compartments>
     <NestedTypes>
-      <Class Name="Rollbar.RollbarQueueController.NestedSingleInstance">
+      <Enum Name="Rollbar.Infrastructure.RollbarQueueController.PayloadTraceSources" Collapsed="true">
         <TypeIdentifier>
-          <NewMemberFileName>RollbarQueueController.cs</NewMemberFileName>
-        </TypeIdentifier>
-      </Class>
-      <Enum Name="Rollbar.RollbarQueueController.PayloadTraceSources">
-        <TypeIdentifier>
-          <NewMemberFileName>RollbarQueueController.cs</NewMemberFileName>
+          <NewMemberFileName>Infrastructure\RollbarQueueController.cs</NewMemberFileName>
         </TypeIdentifier>
       </Enum>
     </NestedTypes>
@@ -80,15 +68,8 @@
   </Class>
   <Class Name="Rollbar.RollbarInfrastructure">
     <Position X="10.5" Y="4.25" Width="6.25" />
-    <NestedTypes>
-      <Class Name="Rollbar.RollbarInfrastructure.NestedSingleInstance" Collapsed="true">
-        <TypeIdentifier>
-          <NewMemberFileName>RollbarInfrastructure.cs</NewMemberFileName>
-        </TypeIdentifier>
-      </Class>
-    </NestedTypes>
     <TypeIdentifier>
-      <HashCode>AAAIAAAQAiAgAAEhAAAAAAAAAIAAgAIAYAICBggAAAA=</HashCode>
+      <HashCode>AAAIAAAAAiAgAgEhAAAAAAAAIIABgAIAYAICBggAAAA=</HashCode>
       <FileName>RollbarInfrastructure.cs</FileName>
     </TypeIdentifier>
     <Lollipop Position="0.2" />
@@ -98,13 +79,6 @@
     <Compartments>
       <Compartment Name="Nested Types" Collapsed="false" />
     </Compartments>
-    <NestedTypes>
-      <Class Name="Rollbar.RollbarTelemetryCollector.NestedSingleInstance">
-        <TypeIdentifier>
-          <NewMemberFileName>Telemetry\RollbarTelemetryCollector.cs</NewMemberFileName>
-        </TypeIdentifier>
-      </Class>
-    </NestedTypes>
     <TypeIdentifier>
       <HashCode>AAAIAIAAEiAgAgABAAAAUACAAAAIgAIASBBSAiIAABA=</HashCode>
       <FileName>Telemetry\RollbarTelemetryCollector.cs</FileName>
diff --git a/Rollbar/_RollbarConfig.cd b/Rollbar/_RollbarConfig.cd
index 3a585c65..4554aaa6 100644
--- a/Rollbar/_RollbarConfig.cd
+++ b/Rollbar/_RollbarConfig.cd
@@ -24,7 +24,7 @@
   <Interface Name="Rollbar.IRollbarDeveloperOptions">
     <Position X="0.5" Y="10.25" Width="3.5" />
     <TypeIdentifier>
-      <HashCode>AAAAAAAAAAAAAIAAAAAAAAAAAAAAAAIIAAAEBAAAAAA=</HashCode>
+      <HashCode>AAAAAAAAAAAAAIAAAAAAAAAAAAAAAAIIAAAEBAQAAAA=</HashCode>
       <FileName>IRollbarDeveloperOptions.cs</FileName>
     </TypeIdentifier>
   </Interface>
diff --git a/Rollbar/_RollbarInfrastructure.cd b/Rollbar/_RollbarInfrastructure.cd
index 487df3b6..bd9d114f 100644
--- a/Rollbar/_RollbarInfrastructure.cd
+++ b/Rollbar/_RollbarInfrastructure.cd
@@ -8,11 +8,6 @@
       <Compartment Name="Nested Types" Collapsed="false" />
     </Compartments>
     <NestedTypes>
-      <Class Name="Rollbar.Infrastructure.RollbarQueueController.NestedSingleInstance" Collapsed="true">
-        <TypeIdentifier>
-          <NewMemberFileName>Infrastructure\RollbarQueueController.cs</NewMemberFileName>
-        </TypeIdentifier>
-      </Class>
       <Enum Name="Rollbar.Infrastructure.RollbarQueueController.PayloadTraceSources">
         <TypeIdentifier>
           <NewMemberFileName>Infrastructure\RollbarQueueController.cs</NewMemberFileName>
@@ -30,15 +25,8 @@
     <Compartments>
       <Compartment Name="Nested Types" Collapsed="false" />
     </Compartments>
-    <NestedTypes>
-      <Class Name="Rollbar.RollbarInfrastructure.NestedSingleInstance" Collapsed="true">
-        <TypeIdentifier>
-          <NewMemberFileName>RollbarInfrastructure.cs</NewMemberFileName>
-        </TypeIdentifier>
-      </Class>
-    </NestedTypes>
     <TypeIdentifier>
-      <HashCode>AAAIAAAQAiAgAAEhAAAAAAAAAIAAgAIAYAICBggAAAA=</HashCode>
+      <HashCode>AAAIAAAAAiAgAgEhAAAAAAAAIIABgAIAYAICBggAAAA=</HashCode>
       <FileName>RollbarInfrastructure.cs</FileName>
     </TypeIdentifier>
     <Lollipop Position="0.2" />
@@ -51,13 +39,6 @@
       <Compartment Name="Private" Collapsed="true" />
       <Compartment Name="Nested Types" Collapsed="false" />
     </Compartments>
-    <NestedTypes>
-      <Class Name="Rollbar.RollbarTelemetryCollector.NestedSingleInstance" Collapsed="true">
-        <TypeIdentifier>
-          <NewMemberFileName>Telemetry\RollbarTelemetryCollector.cs</NewMemberFileName>
-        </TypeIdentifier>
-      </Class>
-    </NestedTypes>
     <TypeIdentifier>
       <HashCode>AAAIAIAAEiAgAgABAAAAUACAAAAIgAIASBBSAiIAABA=</HashCode>
       <FileName>Telemetry\RollbarTelemetryCollector.cs</FileName>
diff --git a/Rollbar/_RollbarLogger.cd b/Rollbar/_RollbarLogger.cd
index 28db75d9..9ece4fe2 100644
--- a/Rollbar/_RollbarLogger.cd
+++ b/Rollbar/_RollbarLogger.cd
@@ -5,15 +5,8 @@
     <Compartments>
       <Compartment Name="Nested Types" Collapsed="false" />
     </Compartments>
-    <NestedTypes>
-      <Class Name="Rollbar.RollbarLocator.NestedSingleInstance" Collapsed="true">
-        <TypeIdentifier>
-          <NewMemberFileName>RollbarLocator.cs</NewMemberFileName>
-        </TypeIdentifier>
-      </Class>
-    </NestedTypes>
     <TypeIdentifier>
-      <HashCode>AAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=</HashCode>
+      <HashCode>AAAAAAQAAAAAAgABAAAAAAAAAAAAAAAAAAAAAAAAAAA=</HashCode>
       <FileName>RollbarLocator.cs</FileName>
     </TypeIdentifier>
   </Class>
diff --git a/Rollbar/_RollbarPackagingStrategies.cd b/Rollbar/_RollbarPackagingStrategies.cd
index c7973219..6f2ad34f 100644
--- a/Rollbar/_RollbarPackagingStrategies.cd
+++ b/Rollbar/_RollbarPackagingStrategies.cd
@@ -4,14 +4,14 @@
     <Position X="0.5" Y="9.5" Width="6" />
     <TypeIdentifier>
       <HashCode>AAAAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAA=</HashCode>
-      <FileName>ExceptionPackage.cs</FileName>
+      <FileName>PayloadPackages\ExceptionPackage.cs</FileName>
     </TypeIdentifier>
   </Class>
   <Class Name="Rollbar.RollbarPackageBase">
     <Position X="4.5" Y="0.5" Width="4.75" />
     <TypeIdentifier>
-      <HashCode>AAAABAAAAAgAAAAAAgAAAEAAAACBAIAAAAAAQAAQAAA=</HashCode>
-      <FileName>RollbarPackageBase.cs</FileName>
+      <HashCode>AAAABAAAAAgAAAAgAgAAAAAAAACBAIAAAAAAQAAQAAA=</HashCode>
+      <FileName>Infrastructure\RollbarPackageBase.cs</FileName>
     </TypeIdentifier>
     <Lollipop Position="0.2" />
   </Class>
@@ -19,7 +19,7 @@
     <Position X="8" Y="5.5" Width="7.75" />
     <TypeIdentifier>
       <HashCode>AAAABAAAAAAAAAAAAgAAAAAAAAAAAAAAgAAAQACwAAA=</HashCode>
-      <FileName>RollbarPackageDecoratorBase.cs</FileName>
+      <FileName>Infrastructure\RollbarPackageDecoratorBase.cs</FileName>
     </TypeIdentifier>
     <Lollipop Position="0.2" />
   </Class>
@@ -27,49 +27,49 @@
     <Position X="8" Y="10" Width="9" />
     <TypeIdentifier>
       <HashCode>AAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAgAAA=</HashCode>
-      <FileName>PersonPackageDecorator.cs</FileName>
+      <FileName>PayloadPackageDecorators\PersonPackageDecorator.cs</FileName>
     </TypeIdentifier>
   </Class>
   <Class Name="Rollbar.MessagePackage">
     <Position X="0.5" Y="5.5" Width="6" />
     <TypeIdentifier>
       <HashCode>IAAAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAA=</HashCode>
-      <FileName>MessagePackage.cs</FileName>
+      <FileName>PayloadPackages\MessagePackage.cs</FileName>
     </TypeIdentifier>
   </Class>
   <Class Name="Rollbar.BodyPackage">
     <Position X="0.5" Y="14" Width="6" />
     <TypeIdentifier>
       <HashCode>AAAABAAAAAAACAAAAAAAAAQAAAAAAAAAAAACAAAAAAA=</HashCode>
-      <FileName>BodyPackage.cs</FileName>
+      <FileName>PayloadPackages\BodyPackage.cs</FileName>
     </TypeIdentifier>
   </Class>
   <Class Name="Rollbar.DataPackage">
     <Position X="0.5" Y="17.25" Width="6" />
     <TypeIdentifier>
       <HashCode>AAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAA=</HashCode>
-      <FileName>DataPackage.cs</FileName>
+      <FileName>PayloadPackages\DataPackage.cs</FileName>
     </TypeIdentifier>
   </Class>
   <Class Name="Rollbar.CustomKeyValuePackageDecorator">
     <Position X="8" Y="12.75" Width="9" />
     <TypeIdentifier>
       <HashCode>AAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAgAAA=</HashCode>
-      <FileName>CustomKeyValuePackageDecorator.cs</FileName>
+      <FileName>PayloadPackageDecorators\CustomKeyValuePackageDecorator.cs</FileName>
     </TypeIdentifier>
   </Class>
   <Class Name="Rollbar.ObjectPackage">
     <Position X="0.5" Y="19.5" Width="8" />
     <TypeIdentifier>
       <HashCode>AAAAJAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAIAAAA=</HashCode>
-      <FileName>ObjectPackage.cs</FileName>
+      <FileName>PayloadPackages\ObjectPackage.cs</FileName>
     </TypeIdentifier>
   </Class>
   <Class Name="Rollbar.HttpRequestMessagePackageDecorator">
     <Position X="8" Y="15.75" Width="9" />
     <TypeIdentifier>
-      <HashCode>AAAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAACAAAgABA=</HashCode>
-      <FileName>HttpRequestMessagePackageDecorator.cs</FileName>
+      <HashCode>AAAAAAAAAAAAAAABAAAAAAAAAAABQAAAAAACAAAgABA=</HashCode>
+      <FileName>PayloadPackageDecorators\HttpRequestMessagePackageDecorator.cs</FileName>
     </TypeIdentifier>
   </Class>
   <Interface Name="Rollbar.IRollbarPackage">

From 6ddf15bed62e6cde3b9d4efb96bd1611bccb619b Mon Sep 17 00:00:00 2001
From: Andrey Kornich <akornich@gmail.com>
Date: Mon, 14 Mar 2022 13:28:39 -0700
Subject: [PATCH 4/4] fix: resolve #623

code cleanup
---
 Rollbar/RollbarInfrastructure.cs | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/Rollbar/RollbarInfrastructure.cs b/Rollbar/RollbarInfrastructure.cs
index 873ed352..917c6fd7 100644
--- a/Rollbar/RollbarInfrastructure.cs
+++ b/Rollbar/RollbarInfrastructure.cs
@@ -32,8 +32,6 @@ public sealed class RollbarInfrastructure
 
         private readonly object _syncLock = new object();
 
-        //private bool _initializedOnce = false;
-
         private IRollbarInfrastructureConfig? _config;
 
         private readonly Lazy<RollbarQueueController> _lazyQueueController =
@@ -192,8 +190,6 @@ public void Init(IRollbarInfrastructureConfig config)
                 }
                 catch(Exception ex)
                 {
-                    //this._initializedOnce = false;
-
                     throw new RollbarException(
                         InternalRollbarError.InfrastructureError,
                         "Exception while initializing the internal services!",