Merge branch 'develop'

Todd Lair · Todd Lair · commit d141b67fdcb5 · 2022-01-19T09:43:51.000-06:00
diff --git a/Src/StackifyLib.AspNetCore/Extensions.cs b/Src/StackifyLib.AspNetCore/Extensions.cs
@@ -11,18 +11,30 @@ public static void ConfigureStackifyLogging(this Microsoft.AspNetCore.Builder.IA
             try
             {
                 Configure.SubscribeToWebRequestDetails(app.ApplicationServices);
+            }
+            catch (Exception ex)
+            {
+                Debug.WriteLine($"#Extensions - #AspNetCore - Error Subscribing to WebRequestDetails {ex}");
+                StackifyLib.Utils.StackifyAPILogger.Log("#Extensions - #AspNetCore - Error Subscribing to WebRequestDetails", ex);
+            }
 
-                if (configuration != null)
+            try
+            {
+                if (configuration == null)
                 {
-                    StackifyLib.Config.SetConfiguration(configuration);
-
-                    //tell it to load all the settings since we now have the config
-                    Config.LoadSettings();
+                    StackifyLib.Utils.StackifyAPILogger.Log("#Extensions - #AspNetCore - Empty configuration, ignoring");
+                    return;
                 }
+
+                StackifyLib.Utils.StackifyAPILogger.Log("#Extensions - #AspNetCore - ConfigureStackifyLogging - Initialize");
+                StackifyLib.Config.SetConfiguration(configuration);
+                StackifyLib.Utils.StackifyAPILogger.Log("#Extensions - #AspNetCore - ConfigureStackifyLogging - Settings Loaded");
+                Config.LoadSettings();
             }
             catch (Exception ex)
             {
-                Debug.WriteLine($"Error in ConfigureStackifyLogging {ex}");
+                Debug.WriteLine($"#Extensions - #AspNetCore - Error in ConfigureStackifyLogging {ex}");
+                StackifyLib.Utils.StackifyAPILogger.Log("#Extensions - #AspNetCore - Error in ConfigureStackifyLogging", ex);
             }
         }
     }
diff --git a/Src/StackifyLib.AspNetCore/StackifyLib.AspNetCore.csproj b/Src/StackifyLib.AspNetCore/StackifyLib.AspNetCore.csproj
@@ -2,15 +2,15 @@
 
   <PropertyGroup>
     <AssemblyTitle>StackifyLib for AspNetCore</AssemblyTitle>
-    <VersionPrefix>2.1.0</VersionPrefix>
+    <VersionPrefix>2.1.6</VersionPrefix>
     <TargetFrameworks>netstandard2.0;net461;net462</TargetFrameworks>
     <AssemblyName>StackifyLib.AspNetCore</AssemblyName>
     <PackageId>StackifyLib.AspNetCore</PackageId>
     <PackageTags>stackify;metrics;errors;logs</PackageTags>
     <GenerateAssemblyConfigurationAttribute>false</GenerateAssemblyConfigurationAttribute>
     <GenerateAssemblyCompanyAttribute>false</GenerateAssemblyCompanyAttribute>
     <GenerateAssemblyProductAttribute>false</GenerateAssemblyProductAttribute>
-    <Version>2.1.6</Version>
+    <Version>2.1.6-beta</Version>
     <Description>StackifyLib.AspNetCore</Description>
     <PackageLicenseUrl>https://github.com/stackify/stackify-api-dotnet/blob/master/LICENSE</PackageLicenseUrl>
     <PackageProjectUrl>https://github.com/stackify/stackify-api-dotnet</PackageProjectUrl>
diff --git a/Src/StackifyLib/Config.cs b/Src/StackifyLib/Config.cs
@@ -38,9 +38,22 @@ public static void LoadSettings()
             try
             {
                 if (IsStackifyJsonLoaded == false) {
+                    StackifyAPILogger.Log($"#Config - LoadSettings - Stackify JSON - Read");
                     ReadStackifyJSONConfig(); // TODO: Better way?
                 }
 
+                if (IsStackifyJsonLoaded == true)
+                {
+                    StackifyAPILogger.Log($"#Config - LoadSettings - Stackify JSON Loaded");
+                }
+
+#if NETCORE || NETCOREX
+                if (_configuration != null)
+                {
+                    StackifyAPILogger.Log($"#Config - LoadSettings - Configuration Set");
+                }
+#endif
+
                 CaptureServerVariables = Get("Stackify.CaptureServerVariables", bool.FalseString).Equals(bool.TrueString, StringComparison.CurrentCultureIgnoreCase);
 
                 CaptureSessionVariables = Get("Stackify.CaptureSessionVariables", bool.FalseString).Equals(bool.TrueString, StringComparison.CurrentCultureIgnoreCase);
@@ -134,7 +147,7 @@ public static void LoadSettings()
                 }
 
                 var rumKey = Get("Stackify.Rum_Key");
-                if (Regex.IsMatch(rumKey, "^[A-Za-z0-9_-]+$"))
+                if (string.IsNullOrWhiteSpace(rumKey) == false && Regex.IsMatch(rumKey, "^[A-Za-z0-9_-]+$"))
                 {
                     RumKey = rumKey;
                 }
@@ -143,6 +156,15 @@ public static void LoadSettings()
             {
                 StackifyAPILogger.Log("#Config #LoadSettings failed", ex);
             }
+
+            try
+            {
+                StackifyAPILogger.EvaluateLogEnabled();
+            }
+            catch (Exception ex)
+            {
+                StackifyAPILogger.Log("#Config #LoadSettings StackifyAPILogger.EvaluateLogEnabled failed", ex);
+            }
         }
 
         public static string ApiKey { get; set; }
@@ -197,6 +219,7 @@ public static void LoadSettings()
         internal static string Get(string key, string defaultValue = null)
         {
             string v = null;
+            string section = null;
 
             try
             {
@@ -207,55 +230,69 @@ internal static string Get(string key, string defaultValue = null)
                     {
                         var appSettings = _configuration.GetSection("Stackify");
                         v = appSettings[key.Replace("Stackify.", string.Empty)];
+                        section = "ConfigStackify";
 
                         //Get settings from Stackify.json
-                        if (string.IsNullOrEmpty(v))
+                        if (string.IsNullOrWhiteSpace(v))
                         {
                             var key2 = key.Replace("Stackify.", string.Empty);
                             var stackifyJson = _configuration.GetSection(key2);
                             v = stackifyJson.Value;
-                            if (string.IsNullOrEmpty(v))
+                            section = "ConfigDirect";
+
+                            if (string.IsNullOrWhiteSpace(v))
                             {
                                 // Search in Retrace, but key will likely still be Stackify.name, not Retrace.name in the code
                                 var retraceAppSettings = _configuration.GetSection("Retrace");
                                 v = retraceAppSettings[key.Replace("Stackify.", string.Empty)];
+                                section = "ConfigRetrace";
                             }
                         }
                     }
 #endif
 
 #if NETFULL
-				    if (string.IsNullOrEmpty(v))
-				    {
-				        v = System.Configuration.ConfigurationManager.AppSettings[key];
-				    }
+                    if (string.IsNullOrWhiteSpace(v))
+                    {
+                        v = System.Configuration.ConfigurationManager.AppSettings[key];
+                        section = "AppSettings";
+                    }
 #endif
 
-                        if (string.IsNullOrEmpty(v))
-                        {
-                            v = System.Environment.GetEnvironmentVariable(key);
-                        }
+                    if (string.IsNullOrWhiteSpace(v))
+                    {
+                        v = System.Environment.GetEnvironmentVariable(key);
+                        section = "Env";
+                    }
 
-                        if (string.IsNullOrEmpty(v))
-                        {
-                            v = System.Environment.GetEnvironmentVariable(key.ToUpperInvariant());
-                        }
+                    if (string.IsNullOrWhiteSpace(v))
+                    {
+                        v = System.Environment.GetEnvironmentVariable(key.ToUpperInvariant());
+                        section = "EnvUpper";
+                    }
 
-                        if (string.IsNullOrEmpty(v))
-                        {
-                            // Linux systems do not allow period in an environment variable name
-                            v = System.Environment.GetEnvironmentVariable(key.Replace('.', '_').ToUpperInvariant());
-                        }
+                    if (string.IsNullOrWhiteSpace(v))
+                    {
+                        // Linux systems do not allow period in an environment variable name
+                        v = System.Environment.GetEnvironmentVariable(key.Replace('.', '_').ToUpperInvariant());
+                        section = "EnvUpperLinux";
+                    }
 
-                        if (string.IsNullOrEmpty(v) && key.StartsWith("Stackify."))
-                        {
-                            v = System.Environment.GetEnvironmentVariable("RETRACE_" + key.Substring(9).Replace('.', '_').ToUpperInvariant());
-                        }
+                    if (string.IsNullOrWhiteSpace(v) && key.StartsWith("Stackify."))
+                    {
+                        v = System.Environment.GetEnvironmentVariable("RETRACE_" + key.Substring(9).Replace('.', '_').ToUpperInvariant());
+                        section = "EnvUpperLinuxRetrace";
+                    }
+
+                    if (string.IsNullOrWhiteSpace(v) == false)
+                    {
+                        StackifyAPILogger.Log($"#Config - #Get - Section: {section} - Key: {key} - Value: {v ?? "Empty"}");
+                    }
                 }
             }
-	    catch (Exception ex)
+            catch (Exception ex)
             {
-                StackifyAPILogger.Log("#Config #Get failed", ex);
+                StackifyAPILogger.Log("#Config - #Get - #Failed", ex);
             }
             finally
             {
@@ -278,13 +315,11 @@ public static void ReadStackifyJSONConfig()
                 string jsonPath = string.Empty;
                 string json = string.Empty;
 
-                ASPEnvironment = "Production";
-
-                if (!String.IsNullOrEmpty(ASPEnvironment))
+                if (!String.IsNullOrWhiteSpace(ASPEnvironment))
                 {
                     jsonPath = Path.Combine(baseDirectory, $"Stackify.{ASPEnvironment}.json");
                 }
-                else if (!String.IsNullOrEmpty(DotnetEnvironment))
+                else if (!String.IsNullOrWhiteSpace(DotnetEnvironment))
                 {
                     jsonPath = Path.Combine(baseDirectory, $"Stackify.{DotnetEnvironment}.json");
                 }
@@ -293,6 +328,7 @@ public static void ReadStackifyJSONConfig()
                     jsonPath = Path.Combine(baseDirectory, "Stackify.json");
                 }
 
+                StackifyAPILogger.Log($"#Config #Json Load - Path: {jsonPath}");
                 if (File.Exists(jsonPath))
                 {
                     using (var fs = new FileStream(jsonPath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
@@ -312,11 +348,11 @@ public static void ReadStackifyJSONConfig()
                     string iisBaseDirectory = System.Web.Hosting.HostingEnvironment.ApplicationPhysicalPath;
                     string iisJsonPath = string.Empty;
 
-                    if (!String.IsNullOrEmpty(ASPEnvironment))
+                    if (!String.IsNullOrWhiteSpace(ASPEnvironment))
                     {
                         iisJsonPath = Path.Combine(iisBaseDirectory, $"Stackify.{ASPEnvironment}.json");
                     }
-                    else if (!String.IsNullOrEmpty(DotnetEnvironment))
+                    else if (!String.IsNullOrWhiteSpace(DotnetEnvironment))
                     {
                         iisJsonPath = Path.Combine(iisBaseDirectory, $"Stackify.{DotnetEnvironment}.json");
                     }
@@ -325,6 +361,7 @@ public static void ReadStackifyJSONConfig()
                         iisJsonPath = Path.Combine(iisBaseDirectory, "Stackify.json");
                     }
 
+                    StackifyAPILogger.Log($"#Config #Json Load - Path: {iisJsonPath}");
                     if (File.Exists(iisJsonPath))
                     {
                         using (var fs = new FileStream(iisJsonPath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
@@ -402,6 +439,7 @@ public static void SetStackifyObj(JObject obj)
             AppName = TryGetValue(obj, "AppName") ?? AppName;
             Environment = TryGetValue(obj, "Environment") ?? Environment;
             ApiKey = TryGetValue(obj, "ApiKey") ?? ApiKey;
+            StackifyAPILogger.Log($"#Config #Json #SetStackifyObj Load - AppName: {AppName} - Environment: {Environment} - ApiKey: {ApiKey}");
         }
 
         private static string TryGetValue(JToken jToken, string key)
@@ -424,6 +462,7 @@ private static string TryGetValue(JToken jToken, string key)
                 }
 
                 r = val.ToString();
+                StackifyAPILogger.Log($"#Config #TryGetValue #Json Success - Key: {key} - Value: {r ?? "Empty"}");
             }
             catch (Exception ex)
             {
diff --git a/Src/StackifyLib/Extensions.cs b/Src/StackifyLib/Extensions.cs
@@ -34,16 +34,20 @@ public static StackifyLib.StackifyError NewStackifyError(this Exception ex)
 #if NETCORE || NETCOREX
         public static void ConfigureStackifyLogging(this Microsoft.Extensions.Configuration.IConfiguration configuration)
         {
+            StackifyAPILogger.Log("#Extensions - ConfigureStackifyLogging - Initialize");
             Config.SetConfiguration(configuration);
             //tell it to load all the settings since we now have the config
             Config.LoadSettings();
+            StackifyAPILogger.Log("#Extensions - ConfigureStackifyLogging - Settings Loaded");
         }
 
         public static void ConfigureStackifyLib(this Microsoft.Extensions.Configuration.IConfiguration configuration)
         {
+            StackifyAPILogger.Log("#Extensions - ConfigureStackifyLib - Initialize");
             Config.SetConfiguration(configuration);
             //tell it to load all the settings since we now have the config
             Config.LoadSettings();
+            StackifyAPILogger.Log("#Extensions - ConfigureStackifyLib - Settings Loaded");
         }
 #endif
     }
diff --git a/Src/StackifyLib/Models/EnvironmentDetail.cs b/Src/StackifyLib/Models/EnvironmentDetail.cs
@@ -490,5 +490,37 @@ public string AppNameToUse()
 
             return AppName;
         }
+
+        public void UpdateAppName()
+        {
+            if (!string.IsNullOrEmpty(ConfiguredAppName))
+            {
+                return;
+            }
+            
+            if (!string.IsNullOrEmpty(Config.AppName))
+            {
+                ConfiguredAppName = Config.AppName;
+                return;
+            }
+
+            ConfiguredAppName = Config.Get("Stackify.AppName");
+        }
+
+        public void UpdateEnvironmentName()
+        {
+            if (!string.IsNullOrEmpty(ConfiguredEnvironmentName))
+            {
+                return;
+            }
+            
+            if (!string.IsNullOrEmpty(Config.Environment))
+            {
+                ConfiguredEnvironmentName = Config.Environment;
+                return;
+            }
+
+            ConfiguredEnvironmentName = Config.Get("Stackify.Environment");
+        }
     }
 }
diff --git a/Src/StackifyLib/StackifyLib.csproj b/Src/StackifyLib/StackifyLib.csproj
@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <AssemblyTitle>Stackify API</AssemblyTitle>
-    <VersionPrefix>2.2.3</VersionPrefix>
+    <VersionPrefix>2.2.5</VersionPrefix>
     <TargetFrameworks>netstandard2.0;net40;net45;net451;net452;net46;net461;net462</TargetFrameworks>
     <AssemblyName>StackifyLib</AssemblyName>
     <PackageId>StackifyLib</PackageId>
@@ -13,15 +13,15 @@
     <GenerateAssemblyCompanyAttribute>false</GenerateAssemblyCompanyAttribute>
     <GenerateAssemblyProductAttribute>false</GenerateAssemblyProductAttribute>
     <GenerateAssemblyCopyrightAttribute>false</GenerateAssemblyCopyrightAttribute>
-    <Version>2.2.3</Version>
+    <Version>2.2.5</Version>
     <Authors>StackifyLib</Authors>
     <PackageProjectUrl>https://github.com/stackify/stackify-api-dotnet</PackageProjectUrl>
     <PackageLicenseUrl>https://github.com/stackify/stackify-api-dotnet/blob/master/LICENSE</PackageLicenseUrl>
     <RepositoryUrl>https://github.com/stackify/stackify-api-dotnet</RepositoryUrl>
     <RepositoryType>git</RepositoryType>
     <PackageIconUrl>https://stackify.com/wp-content/uploads/2017/02/stk.png</PackageIconUrl>
-    <AssemblyVersion>2.2.3.0</AssemblyVersion>
-    <FileVersion>2.2.3.0</FileVersion>
+    <AssemblyVersion>2.2.5.0</AssemblyVersion>
+    <FileVersion>2.2.5.0</FileVersion>
     <PackageReleaseNotes>Remove default internal file logger</PackageReleaseNotes>
   </PropertyGroup>
 
diff --git a/Src/StackifyLib/Utils/HttpClient.cs b/Src/StackifyLib/Utils/HttpClient.cs
@@ -302,6 +302,16 @@ public bool IdentifyApp()
                 }
                 StackifyAPILogger.Log("Calling to Identify App");
                 EnvironmentDetail env = EnvironmentDetail.Get();
+                env.UpdateEnvironmentName();
+                env.UpdateAppName();
+                if (string.IsNullOrEmpty(env.ConfiguredAppName) && !string.IsNullOrEmpty(Config.AppName)) {
+                    env.ConfiguredAppName = Config.AppName;
+                }
+
+                if (string.IsNullOrEmpty(env.ConfiguredEnvironmentName) && !string.IsNullOrEmpty(Config.Environment)) {
+                    env.ConfiguredEnvironmentName = Config.Environment;
+                }
+
                 string jsonData = JsonConvert.SerializeObject(env, new JsonSerializerSettings() { NullValueHandling = NullValueHandling.Ignore });
 
                 var response =
diff --git a/Src/StackifyLib/Utils/StackifyAPILogger.cs b/Src/StackifyLib/Utils/StackifyAPILogger.cs
@@ -19,7 +19,6 @@ public class StackifyAPILogger
 
         static StackifyAPILogger()
         {
-            EvaluateLogEnabled();
         }
 
         public static bool LogEnabled
@@ -85,7 +84,7 @@ public static void Log(string message, Exception ex, bool logAnyways = false)
             }
         }
 
-        private static void EvaluateLogEnabled()
+        public static void EvaluateLogEnabled()
         {
             if (_logEnabled == null)
             {

Original file line number	Diff line number	Diff line change
`@@ -11,18 +11,30 @@ public static void ConfigureStackifyLogging(this Microsoft.AspNetCore.Builder.IA`
`11`	`11`	`try`
`12`	`12`	`{`
`13`	`13`	`Configure.SubscribeToWebRequestDetails(app.ApplicationServices);`
	`14`	`+ }`
	`15`	`+ catch (Exception ex)`
	`16`	`+ {`
	`17`	`+ Debug.WriteLine($"#Extensions - #AspNetCore - Error Subscribing to WebRequestDetails {ex}");`
	`18`	`+ StackifyLib.Utils.StackifyAPILogger.Log("#Extensions - #AspNetCore - Error Subscribing to WebRequestDetails", ex);`
	`19`	`+ }`
`14`	`20`
`15`		`- if (configuration != null)`
	`21`	`+ try`
	`22`	`+ {`
	`23`	`+ if (configuration == null)`
`16`	`24`	`{`
`17`		`- StackifyLib.Config.SetConfiguration(configuration);`
`18`		`-`
`19`		`- //tell it to load all the settings since we now have the config`
`20`		`- Config.LoadSettings();`
	`25`	`+ StackifyLib.Utils.StackifyAPILogger.Log("#Extensions - #AspNetCore - Empty configuration, ignoring");`
	`26`	`+ return;`
`21`	`27`	`}`
	`28`	`+`
	`29`	`+ StackifyLib.Utils.StackifyAPILogger.Log("#Extensions - #AspNetCore - ConfigureStackifyLogging - Initialize");`
	`30`	`+ StackifyLib.Config.SetConfiguration(configuration);`
	`31`	`+ StackifyLib.Utils.StackifyAPILogger.Log("#Extensions - #AspNetCore - ConfigureStackifyLogging - Settings Loaded");`
	`32`	`+ Config.LoadSettings();`
`22`	`33`	`}`
`23`	`34`	`catch (Exception ex)`
`24`	`35`	`{`
`25`		`- Debug.WriteLine($"Error in ConfigureStackifyLogging {ex}");`
	`36`	`+ Debug.WriteLine($"#Extensions - #AspNetCore - Error in ConfigureStackifyLogging {ex}");`
	`37`	`+ StackifyLib.Utils.StackifyAPILogger.Log("#Extensions - #AspNetCore - Error in ConfigureStackifyLogging", ex);`
`26`	`38`	`}`
`27`	`39`	`}`
`28`	`40`	`}`
Original file line number	Diff line number	Diff line change
`@@ -38,9 +38,22 @@ public static void LoadSettings()`
`38`	`38`	`try`
`39`	`39`	`{`
`40`	`40`	`if (IsStackifyJsonLoaded == false) {`
	`41`	`+ StackifyAPILogger.Log($"#Config - LoadSettings - Stackify JSON - Read");`
`41`	`42`	`ReadStackifyJSONConfig(); // TODO: Better way?`
`42`	`43`	`}`
`43`	`44`
	`45`	`+ if (IsStackifyJsonLoaded == true)`
	`46`	`+ {`
	`47`	`+ StackifyAPILogger.Log($"#Config - LoadSettings - Stackify JSON Loaded");`
	`48`	`+ }`
	`49`	`+`
	`50`	`+#if NETCORE \|\| NETCOREX`
	`51`	`+ if (_configuration != null)`
	`52`	`+ {`
	`53`	`+ StackifyAPILogger.Log($"#Config - LoadSettings - Configuration Set");`
	`54`	`+ }`
	`55`	`+#endif`
	`56`	`+`
`44`	`57`	`CaptureServerVariables = Get("Stackify.CaptureServerVariables", bool.FalseString).Equals(bool.TrueString, StringComparison.CurrentCultureIgnoreCase);`
`45`	`58`
`46`	`59`	`CaptureSessionVariables = Get("Stackify.CaptureSessionVariables", bool.FalseString).Equals(bool.TrueString, StringComparison.CurrentCultureIgnoreCase);`
`@@ -134,7 +147,7 @@ public static void LoadSettings()`
`134`	`147`	`}`
`135`	`148`
`136`	`149`	`var rumKey = Get("Stackify.Rum_Key");`
`137`		`- if (Regex.IsMatch(rumKey, "^[A-Za-z0-9_-]+$"))`
	`150`	`+ if (string.IsNullOrWhiteSpace(rumKey) == false && Regex.IsMatch(rumKey, "^[A-Za-z0-9_-]+$"))`
`138`	`151`	`{`
`139`	`152`	`RumKey = rumKey;`
`140`	`153`	`}`
`@@ -143,6 +156,15 @@ public static void LoadSettings()`
`143`	`156`	`{`
`144`	`157`	`StackifyAPILogger.Log("#Config #LoadSettings failed", ex);`
`145`	`158`	`}`
	`159`	`+`
	`160`	`+ try`
	`161`	`+ {`
	`162`	`+ StackifyAPILogger.EvaluateLogEnabled();`
	`163`	`+ }`
	`164`	`+ catch (Exception ex)`
	`165`	`+ {`
	`166`	`+ StackifyAPILogger.Log("#Config #LoadSettings StackifyAPILogger.EvaluateLogEnabled failed", ex);`
	`167`	`+ }`
`146`	`168`	`}`
`147`	`169`
`148`	`170`	`public static string ApiKey { get; set; }`
`@@ -197,6 +219,7 @@ public static void LoadSettings()`
`197`	`219`	`internal static string Get(string key, string defaultValue = null)`
`198`	`220`	`{`
`199`	`221`	`string v = null;`
	`222`	`+ string section = null;`
`200`	`223`
`201`	`224`	`try`
`202`	`225`	`{`
`@@ -207,55 +230,69 @@ internal static string Get(string key, string defaultValue = null)`
`207`	`230`	`{`
`208`	`231`	`var appSettings = _configuration.GetSection("Stackify");`
`209`	`232`	`v = appSettings[key.Replace("Stackify.", string.Empty)];`
	`233`	`+ section = "ConfigStackify";`
`210`	`234`
`211`	`235`	`//Get settings from Stackify.json`
`212`		`- if (string.IsNullOrEmpty(v))`
	`236`	`+ if (string.IsNullOrWhiteSpace(v))`
`213`	`237`	`{`
`214`	`238`	`var key2 = key.Replace("Stackify.", string.Empty);`
`215`	`239`	`var stackifyJson = _configuration.GetSection(key2);`
`216`	`240`	`v = stackifyJson.Value;`
`217`		`- if (string.IsNullOrEmpty(v))`
	`241`	`+ section = "ConfigDirect";`
	`242`	`+`
	`243`	`+ if (string.IsNullOrWhiteSpace(v))`
`218`	`244`	`{`
`219`	`245`	`// Search in Retrace, but key will likely still be Stackify.name, not Retrace.name in the code`
`220`	`246`	`var retraceAppSettings = _configuration.GetSection("Retrace");`
`221`	`247`	`v = retraceAppSettings[key.Replace("Stackify.", string.Empty)];`
	`248`	`+ section = "ConfigRetrace";`
`222`	`249`	`}`
`223`	`250`	`}`
`224`	`251`	`}`
`225`	`252`	`#endif`
`226`	`253`
`227`	`254`	`#if NETFULL`
`228`		`- if (string.IsNullOrEmpty(v))`
`229`		`- {`
`230`		`- v = System.Configuration.ConfigurationManager.AppSettings[key];`
`231`		`- }`
	`255`	`+ if (string.IsNullOrWhiteSpace(v))`
	`256`	`+ {`
	`257`	`+ v = System.Configuration.ConfigurationManager.AppSettings[key];`
	`258`	`+ section = "AppSettings";`
	`259`	`+ }`
`232`	`260`	`#endif`
`233`	`261`
`234`		`- if (string.IsNullOrEmpty(v))`
`235`		`- {`
`236`		`- v = System.Environment.GetEnvironmentVariable(key);`
`237`		`- }`
	`262`	`+ if (string.IsNullOrWhiteSpace(v))`
	`263`	`+ {`
	`264`	`+ v = System.Environment.GetEnvironmentVariable(key);`
	`265`	`+ section = "Env";`
	`266`	`+ }`
`238`	`267`
`239`		`- if (string.IsNullOrEmpty(v))`
`240`		`- {`
`241`		`- v = System.Environment.GetEnvironmentVariable(key.ToUpperInvariant());`
`242`		`- }`
	`268`	`+ if (string.IsNullOrWhiteSpace(v))`
	`269`	`+ {`
	`270`	`+ v = System.Environment.GetEnvironmentVariable(key.ToUpperInvariant());`
	`271`	`+ section = "EnvUpper";`
	`272`	`+ }`
`243`	`273`
`244`		`- if (string.IsNullOrEmpty(v))`
`245`		`- {`
`246`		`- // Linux systems do not allow period in an environment variable name`
`247`		`- v = System.Environment.GetEnvironmentVariable(key.Replace('.', '_').ToUpperInvariant());`
`248`		`- }`
	`274`	`+ if (string.IsNullOrWhiteSpace(v))`
	`275`	`+ {`
	`276`	`+ // Linux systems do not allow period in an environment variable name`
	`277`	`+ v = System.Environment.GetEnvironmentVariable(key.Replace('.', '_').ToUpperInvariant());`
	`278`	`+ section = "EnvUpperLinux";`
	`279`	`+ }`
`249`	`280`
`250`		`- if (string.IsNullOrEmpty(v) && key.StartsWith("Stackify."))`
`251`		`- {`
`252`		`- v = System.Environment.GetEnvironmentVariable("RETRACE_" + key.Substring(9).Replace('.', '_').ToUpperInvariant());`
`253`		`- }`
	`281`	`+ if (string.IsNullOrWhiteSpace(v) && key.StartsWith("Stackify."))`
	`282`	`+ {`
	`283`	`+ v = System.Environment.GetEnvironmentVariable("RETRACE_" + key.Substring(9).Replace('.', '_').ToUpperInvariant());`
	`284`	`+ section = "EnvUpperLinuxRetrace";`
	`285`	`+ }`
	`286`	`+`
	`287`	`+ if (string.IsNullOrWhiteSpace(v) == false)`
	`288`	`+ {`
	`289`	`+ StackifyAPILogger.Log($"#Config - #Get - Section: {section} - Key: {key} - Value: {v ?? "Empty"}");`
	`290`	`+ }`
`254`	`291`	`}`
`255`	`292`	`}`
`256`		`- catch (Exception ex)`
	`293`	`+ catch (Exception ex)`
`257`	`294`	`{`
`258`		`- StackifyAPILogger.Log("#Config #Get failed", ex);`
	`295`	`+ StackifyAPILogger.Log("#Config - #Get - #Failed", ex);`
`259`	`296`	`}`
`260`	`297`	`finally`
`261`	`298`	`{`
`@@ -278,13 +315,11 @@ public static void ReadStackifyJSONConfig()`
`278`	`315`	`string jsonPath = string.Empty;`
`279`	`316`	`string json = string.Empty;`
`280`	`317`
`281`		`- ASPEnvironment = "Production";`
`282`		`-`
`283`		`- if (!String.IsNullOrEmpty(ASPEnvironment))`
	`318`	`+ if (!String.IsNullOrWhiteSpace(ASPEnvironment))`
`284`	`319`	`{`
`285`	`320`	`jsonPath = Path.Combine(baseDirectory, $"Stackify.{ASPEnvironment}.json");`
`286`	`321`	`}`
`287`		`- else if (!String.IsNullOrEmpty(DotnetEnvironment))`
	`322`	`+ else if (!String.IsNullOrWhiteSpace(DotnetEnvironment))`
`288`	`323`	`{`
`289`	`324`	`jsonPath = Path.Combine(baseDirectory, $"Stackify.{DotnetEnvironment}.json");`
`290`	`325`	`}`
`@@ -293,6 +328,7 @@ public static void ReadStackifyJSONConfig()`
`293`	`328`	`jsonPath = Path.Combine(baseDirectory, "Stackify.json");`
`294`	`329`	`}`
`295`	`330`
	`331`	`+ StackifyAPILogger.Log($"#Config #Json Load - Path: {jsonPath}");`
`296`	`332`	`if (File.Exists(jsonPath))`
`297`	`333`	`{`
`298`	`334`	`using (var fs = new FileStream(jsonPath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))`
`@@ -312,11 +348,11 @@ public static void ReadStackifyJSONConfig()`
`312`	`348`	`string iisBaseDirectory = System.Web.Hosting.HostingEnvironment.ApplicationPhysicalPath;`
`313`	`349`	`string iisJsonPath = string.Empty;`
`314`	`350`
`315`		`- if (!String.IsNullOrEmpty(ASPEnvironment))`
	`351`	`+ if (!String.IsNullOrWhiteSpace(ASPEnvironment))`
`316`	`352`	`{`
`317`	`353`	`iisJsonPath = Path.Combine(iisBaseDirectory, $"Stackify.{ASPEnvironment}.json");`
`318`	`354`	`}`
`319`		`- else if (!String.IsNullOrEmpty(DotnetEnvironment))`
	`355`	`+ else if (!String.IsNullOrWhiteSpace(DotnetEnvironment))`
`320`	`356`	`{`
`321`	`357`	`iisJsonPath = Path.Combine(iisBaseDirectory, $"Stackify.{DotnetEnvironment}.json");`
`322`	`358`	`}`
`@@ -325,6 +361,7 @@ public static void ReadStackifyJSONConfig()`
`325`	`361`	`iisJsonPath = Path.Combine(iisBaseDirectory, "Stackify.json");`
`326`	`362`	`}`
`327`	`363`
	`364`	`+ StackifyAPILogger.Log($"#Config #Json Load - Path: {iisJsonPath}");`
`328`	`365`	`if (File.Exists(iisJsonPath))`
`329`	`366`	`{`
`330`	`367`	`using (var fs = new FileStream(iisJsonPath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))`
`@@ -402,6 +439,7 @@ public static void SetStackifyObj(JObject obj)`
`402`	`439`	`AppName = TryGetValue(obj, "AppName") ?? AppName;`
`403`	`440`	`Environment = TryGetValue(obj, "Environment") ?? Environment;`
`404`	`441`	`ApiKey = TryGetValue(obj, "ApiKey") ?? ApiKey;`
	`442`	`+ StackifyAPILogger.Log($"#Config #Json #SetStackifyObj Load - AppName: {AppName} - Environment: {Environment} - ApiKey: {ApiKey}");`
`405`	`443`	`}`
`406`	`444`
`407`	`445`	`private static string TryGetValue(JToken jToken, string key)`
`@@ -424,6 +462,7 @@ private static string TryGetValue(JToken jToken, string key)`
`424`	`462`	`}`
`425`	`463`
`426`	`464`	`r = val.ToString();`
	`465`	`+ StackifyAPILogger.Log($"#Config #TryGetValue #Json Success - Key: {key} - Value: {r ?? "Empty"}");`
`427`	`466`	`}`
`428`	`467`	`catch (Exception ex)`
`429`	`468`	`{`
Original file line number	Diff line number	Diff line change
`@@ -34,16 +34,20 @@ public static StackifyLib.StackifyError NewStackifyError(this Exception ex)`
`34`	`34`	`#if NETCORE \|\| NETCOREX`
`35`	`35`	`public static void ConfigureStackifyLogging(this Microsoft.Extensions.Configuration.IConfiguration configuration)`
`36`	`36`	`{`
	`37`	`+ StackifyAPILogger.Log("#Extensions - ConfigureStackifyLogging - Initialize");`
`37`	`38`	`Config.SetConfiguration(configuration);`
`38`	`39`	`//tell it to load all the settings since we now have the config`
`39`	`40`	`Config.LoadSettings();`
	`41`	`+ StackifyAPILogger.Log("#Extensions - ConfigureStackifyLogging - Settings Loaded");`
`40`	`42`	`}`
`41`	`43`
`42`	`44`	`public static void ConfigureStackifyLib(this Microsoft.Extensions.Configuration.IConfiguration configuration)`
`43`	`45`	`{`
	`46`	`+ StackifyAPILogger.Log("#Extensions - ConfigureStackifyLib - Initialize");`
`44`	`47`	`Config.SetConfiguration(configuration);`
`45`	`48`	`//tell it to load all the settings since we now have the config`
`46`	`49`	`Config.LoadSettings();`
	`50`	`+ StackifyAPILogger.Log("#Extensions - ConfigureStackifyLib - Settings Loaded");`
`47`	`51`	`}`
`48`	`52`	`#endif`
`49`	`53`	`}`
Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,6 @@ public class StackifyAPILogger`
`19`	`19`
`20`	`20`	`static StackifyAPILogger()`
`21`	`21`	`{`
`22`		`- EvaluateLogEnabled();`
`23`	`22`	`}`
`24`	`23`
`25`	`24`	`public static bool LogEnabled`
`@@ -85,7 +84,7 @@ public static void Log(string message, Exception ex, bool logAnyways = false)`
`85`	`84`	`}`
`86`	`85`	`}`
`87`	`86`
`88`		`- private static void EvaluateLogEnabled()`
	`87`	`+ public static void EvaluateLogEnabled()`
`89`	`88`	`{`
`90`	`89`	`if (_logEnabled == null)`
`91`	`90`	`{`