Add App Services Heartbeat with environment variable monitor

CHANGELOG.md

@@ -9,7 +9,7 @@
   - `BuildInfoConfigComponentVersionTelemetryInitializer`
   - `DeveloperModeWithDebuggerAttachedTelemetryModule`
   - `UnobservedExceptionTelemetryModule`
-
+- [Add default heartbeat properties for Azure App Services (web apps).](https://github.com/Microsoft/ApplicationInsights-dotnet-server/issues/868)
 
 ## Version 2.6.0-beta2
 - [Added a max length restriction to values passed in through requests.](https://github.com/Microsoft/ApplicationInsights-dotnet-server/pull/810)

Src/Microsoft.ApplicationInsights.Web.sln

@@ -157,6 +157,7 @@ Global
 		Common\Common.projitems*{ea2d14aa-ae1e-4982-9326-11d4dcbb9529}*SharedItemsImports = 4
 		DependencyCollector\Shared\DependencyCollector.Shared.projitems*{ea2d14aa-ae1e-4982-9326-11d4dcbb9529}*SharedItemsImports = 4
 		TestFramework\Shared\TestFramework.Shared.projitems*{f05eb480-b209-47dd-90e3-1ddc47efc579}*SharedItemsImports = 4
+		WindowsServer\WindowsServer.Shared.Tests\WindowsServer.Shared.Tests.projitems*{f05eb480-b209-47dd-90e3-1ddc47efc579}*SharedItemsImports = 4
 		PerformanceCollector\Perf.Shared.Tests\Perf.Shared.Tests.projitems*{f254d4fb-428d-408e-8251-39bca7b4b5ce}*SharedItemsImports = 4
 		TestFramework\Shared\TestFramework.Shared.projitems*{f254d4fb-428d-408e-8251-39bca7b4b5ce}*SharedItemsImports = 4
 		TestFramework\Shared\TestFramework.Shared.projitems*{f71138bb-b3f8-4767-b394-857b0776038e}*SharedItemsImports = 4

Src/WindowsServer/WindowsServer.Net45.Tests/WindowsServer.Net45.Tests.csproj

@@ -100,6 +100,7 @@
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), 'Common.targets'))\Common.targets" />
   <Import Project="..\..\TestFramework\Shared\TestFramework.Shared.projitems" Label="Shared" />
+  <Import Project="..\WindowsServer.Shared.Tests\WindowsServer.Shared.Tests.projitems" Label="Shared" />
   <Import Project="..\..\..\..\packages\StyleCop.MSBuild.5.0.0\build\StyleCop.MSBuild.targets" Condition="Exists('..\..\..\..\packages\StyleCop.MSBuild.5.0.0\build\StyleCop.MSBuild.targets')" />
   <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
     <PropertyGroup>

Src/WindowsServer/WindowsServer.Nuget.Tests/TelemetryModulesTests.cs

@@ -65,7 +65,7 @@ public void InstallDoesNotInstallExtraModules()
 
             Type typeToFind = typeof(FirstChanceExceptionStatisticsTelemetryModule);
 
-            Assert.AreEqual(4, ConfigurationHelpers.GetTelemetryModules(configAfterTransform).Descendants().Count());
+            Assert.AreEqual(5, ConfigurationHelpers.GetTelemetryModules(configAfterTransform).Descendants().Count());
         }
 
         [TestMethod]

Src/WindowsServer/WindowsServer.Nuget/ApplicationInsights.config.install.xdt

@@ -7,6 +7,7 @@
   </TelemetryInitializers>
 
   <TelemetryModules xdt:Transform="InsertIfMissing">
+    <Add xdt:Transform="InsertIfMissing" xdt:Locator="Match(Type)" Type="Microsoft.ApplicationInsights.WindowsServer.AppServicesHeartbeatTelemetryModule, Microsoft.AI.WindowsServer" />
     <Add xdt:Transform="InsertIfMissing" xdt:Locator="Match(Type)" Type="Microsoft.ApplicationInsights.WindowsServer.AzureInstanceMetadataTelemetryModule, Microsoft.AI.WindowsServer">
       <!--
       Remove individual fields collected here by adding them to the ApplicationInsighs.HeartbeatProvider 

Src/WindowsServer/WindowsServer.Nuget/ApplicationInsights.config.uninstall.xdt

@@ -8,6 +8,7 @@
   <TelemetryInitializers xdt:Transform="Remove" xdt:Locator="Condition(count(*)=0)"/>
 
   <TelemetryModules>
+    <Add xdt:Transform="Remove" xdt:Locator="Match(Type)" Type="Microsoft.ApplicationInsights.WindowsServer.AppServicesHeartbeatTelemetryModule, Microsoft.AI.WindowsServer" />
     <Add xdt:Transform="Remove" xdt:Locator="Match(Type)" Type="Microsoft.ApplicationInsights.WindowsServer.AzureInstanceMetadataTelemetryModule, Microsoft.AI.WindowsServer" />
     <Add xdt:Transform="Remove" xdt:Locator="Match(Type)" Type="Microsoft.ApplicationInsights.WindowsServer.DeveloperModeWithDebuggerAttachedTelemetryModule, Microsoft.AI.WindowsServer" />
     <Add xdt:Transform="Remove" xdt:Locator="Match(Type)" Type="Microsoft.ApplicationInsights.WindowsServer.UnhandledExceptionTelemetryModule, Microsoft.AI.WindowsServer" />

Src/WindowsServer/WindowsServer.Shared.Tests/AppServicesHeartbeatTelemetryModuleTests.cs

@@ -0,0 +1,150 @@
+namespace Microsoft.ApplicationInsights.WindowsServer
+{
+    using System;
+    using System.Collections.Generic;
+    using System.IO;
+    using System.Net.Http;
+    using System.Runtime.Serialization.Json;
+    using System.Text;
+    using System.Threading;
+    using System.Threading.Tasks;
+    using Microsoft.ApplicationInsights.Extensibility;
+    using Microsoft.ApplicationInsights.WindowsServer.Implementation;
+    using Microsoft.ApplicationInsights.WindowsServer.Implementation.DataContracts;
+    using Microsoft.ApplicationInsights.WindowsServer.Mock;
+    using Microsoft.VisualStudio.TestTools.UnitTesting;
+    using Assert = Xunit.Assert;
+
+    [TestClass]
+    public class AppServicesHeartbeatTelemetryModuleTests
+    {
+        private HeartbeatProviderMock testHeartbeatPropertyManager;
+        private AppServicesHeartbeatTelemetryModule testAppServiceHbeatModule;
+        private Dictionary<string, string> testEnvironmentVariables;
+
+        [TestInitialize]
+        public void BeforeEachTestMethod()
+        {
+            this.testHeartbeatPropertyManager = new HeartbeatProviderMock();
+            this.testAppServiceHbeatModule = this.GetAppServiceHeartbeatModuleWithUniqueTestEnvVars(this.testHeartbeatPropertyManager);
+            this.testEnvironmentVariables = this.GetEnvVarsAssociatedToModule(this.testAppServiceHbeatModule);
+        }
+
+        [TestCleanup]
+        public void AfterEachTestMethod()
+        {
+            this.RemoveTestEnvVarsAssociatedToModule(this.testAppServiceHbeatModule);
+        }
+
+        [TestMethod]
+        public void InitializeIsWorking()
+        {
+            this.testAppServiceHbeatModule.Initialize(null);
+
+            foreach (var kvp in this.testAppServiceHbeatModule.WebHeartbeatPropertyNameEnvVarMap)
+            {
+                Assert.True(this.testHeartbeatPropertyManager.HbeatProps.ContainsKey(kvp.Key));
+                Assert.Equal(this.testHeartbeatPropertyManager.HbeatProps[kvp.Key], this.testEnvironmentVariables[kvp.Value]);
+            }
+        }
+
+        [TestMethod]
+        [Description("This test causes a delay and must be updated to be more deterministic.")]
+        [Owner("dekeeler")]
+        public void UpdateEnvVarsWorksWhenEnvironmentValuesChange()
+        {            
+            this.testAppServiceHbeatModule.Initialize(null);
+
+            // update each environment variable to have a different value
+            foreach (var envVarKvp in this.testEnvironmentVariables)
+            {
+                string newVal = string.Concat(envVarKvp.Value, "_1");
+                Environment.SetEnvironmentVariable(envVarKvp.Key, newVal);
+            }
+
+            // wait for the delay set into the monitor, plus one second to ensure we got updated
+            Task.Delay(
+                AppServiceEnvironmentVariableMonitor.Instance.MonitorInterval + TimeSpan.FromSeconds(1))
+                .ConfigureAwait(false).GetAwaiter().GetResult();
+
+            var updatedEnvVars = this.GetEnvVarsAssociatedToModule(this.testAppServiceHbeatModule);
+
+            foreach (var kvp in this.testAppServiceHbeatModule.WebHeartbeatPropertyNameEnvVarMap)
+            {
+                Assert.True(this.testHeartbeatPropertyManager.HbeatProps.ContainsKey(kvp.Key));
+                Assert.Equal(this.testHeartbeatPropertyManager.HbeatProps[kvp.Key], updatedEnvVars[kvp.Value]);
+            }
+        }
+
+        [TestMethod]
+        public void NoHeartbeatManagerAvailableDoesntThrow()
+        {
+            var appSrvHbeatModule = new AppServicesHeartbeatTelemetryModule();
+            var envVars = this.GetEnvVarsAssociatedToModule(appSrvHbeatModule);
+
+            try
+            {
+                appSrvHbeatModule.Initialize(null);
+            }
+            catch (Exception any)
+            {
+                Assert.False(any == null);
+            }
+        }
+
+        [TestMethod]
+        public void NoAppServicesEnvVarsWorksWithoutFailure()
+        {
+            // ensure all environment variables are set to nothing (remove them from the environment)
+            this.RemoveTestEnvVarsAssociatedToModule(this.testAppServiceHbeatModule);
+
+            this.testAppServiceHbeatModule.UpdateHeartbeatWithAppServiceEnvVarValues();
+            foreach (var kvp in this.testAppServiceHbeatModule.WebHeartbeatPropertyNameEnvVarMap)
+            {
+                Assert.Null(this.testHeartbeatPropertyManager.HbeatProps[kvp.Key]);
+            }
+        }
+
+        /// <summary>
+        /// Return a dictionary containing the expected environment variables for the AppServicesHeartbeat module. If
+        /// the environment does not contain a value for them, set the environment to have them.
+        /// </summary>
+        /// <returns>Dictionary with expected environment variable names as the key, current environment variable content as the value.</returns>
+        private Dictionary<string, string> GetEnvVarsAssociatedToModule(AppServicesHeartbeatTelemetryModule testAppServicesHeartbeatModule)
+        {
+            Dictionary<string, string> uniqueTestEnvironmentVariables = new Dictionary<string, string>();
+            foreach (var kvp in testAppServicesHeartbeatModule.WebHeartbeatPropertyNameEnvVarMap)
+            {
+                uniqueTestEnvironmentVariables.Add(kvp.Value, Environment.GetEnvironmentVariable(kvp.Value));
+                if (string.IsNullOrEmpty(uniqueTestEnvironmentVariables[kvp.Value]))
+                {
+                    Environment.SetEnvironmentVariable(kvp.Value, kvp.Key);
+                    uniqueTestEnvironmentVariables[kvp.Value] = kvp.Key;
+                }
+            }
+
+            return uniqueTestEnvironmentVariables;
+        }
+
+        private AppServicesHeartbeatTelemetryModule GetAppServiceHeartbeatModuleWithUniqueTestEnvVars(HeartbeatProviderMock heartbeatProvider)
+        {
+            var appServicesHbeatModule = new AppServicesHeartbeatTelemetryModule(heartbeatProvider);
+            string testSuffix = Guid.NewGuid().ToString();
+            for (int i = 0; i < appServicesHbeatModule.WebHeartbeatPropertyNameEnvVarMap.Length; ++i)
+            {
+                var kvp = appServicesHbeatModule.WebHeartbeatPropertyNameEnvVarMap[i];
+                appServicesHbeatModule.WebHeartbeatPropertyNameEnvVarMap[i] = new KeyValuePair<string, string>(kvp.Key, string.Concat(kvp.Value, "_", testSuffix));
+            }
+
+            return appServicesHbeatModule;
+        }
+
+        private void RemoveTestEnvVarsAssociatedToModule(AppServicesHeartbeatTelemetryModule appServicesHbeatModule)
+        {
+            foreach (var kvp in appServicesHbeatModule.WebHeartbeatPropertyNameEnvVarMap)
+            {
+                Environment.SetEnvironmentVariable(kvp.Value, string.Empty);
+            }
+        }
+    }
+}

Src/WindowsServer/WindowsServer.Shared.Tests/AzureInstanceMetadataEndToEndTests.cs

@@ -80,10 +80,10 @@ public void AzureImsResponseTooLargeStopsCollection()
                     var testStuff = new char[AzureMetadataRequestor.AzureImsMaxResponseBufferSize + 1];
                     for (int i = 0; i < (AzureMetadataRequestor.AzureImsMaxResponseBufferSize + 1); ++i)
                     {
-                        testStuff[i] = (char)( (int)'a' + (i % 26) );
+                        testStuff[i] = (char)((int)'a' + (i % 26));
                     }
-                    tester.Publisher = new string(testStuff);
 
+                    tester.Publisher = new string(testStuff);
                     var jsonStream = this.GetTestMetadataStream(tester);
                     response.SetContentLength(3 * jsonStream.Length);
                     response.ContentType = "application/json";

Src/WindowsServer/WindowsServer.Shared.Tests/AzureWebAppRoleEnvironmentTelemetryInitializerTest.cs

@@ -21,77 +21,98 @@ public void AzureWebAppRoleEnvironmentTelemetryInitializerSetsRoleName()
         {
             var telemetryItem = new EventTelemetry();
 
-            Environment.SetEnvironmentVariable("WEBSITE_HOSTNAME", "TestRoleName.AzureWebSites.net");
+            var testVarName = "WEBSITE_" + Guid.NewGuid().ToString() + "_HOSTNAME";
+            Environment.SetEnvironmentVariable(testVarName, "TestRoleName.azurewebsites.net");
+
+            var initializer = new AzureWebAppRoleEnvironmentTelemetryInitializer()
+            {
+                WebAppHostNameEnvironmentVariable = testVarName
+            };
 
-            var initializer = new AzureWebAppRoleEnvironmentTelemetryInitializer();
             initializer.Initialize(telemetryItem);
 
             Assert.Equal("TestRoleName", telemetryItem.Context.Cloud.RoleName);            
-            Assert.Equal("TestRoleName.AzureWebSites.net", telemetryItem.Context.GetInternalContext().NodeName);
+            Assert.Equal("TestRoleName.azurewebsites.net", telemetryItem.Context.GetInternalContext().NodeName);
 
-            Environment.SetEnvironmentVariable("WEBSITE_HOSTNAME", null);
+            Environment.SetEnvironmentVariable(testVarName, null);
         }
 
         [TestMethod]
         public void AzureWebAppRoleEnvironmentTelemetryInitializerDoesNotOverrideRoleName()
         {
-            Environment.SetEnvironmentVariable("WEBSITE_HOSTNAME", "TestRoleName.azurewebsites.net");
+            var testVarName = "WEBSITE_" + Guid.NewGuid().ToString() + "_HOSTNAME";
+            Environment.SetEnvironmentVariable(testVarName, "TestRoleName.azurewebsites.net");
 
             var telemetryItem = new EventTelemetry();
             telemetryItem.Context.Cloud.RoleName = "Test";
 
-            var initializer = new AzureWebAppRoleEnvironmentTelemetryInitializer();
+            var initializer = new AzureWebAppRoleEnvironmentTelemetryInitializer()
+            {
+                WebAppHostNameEnvironmentVariable = testVarName
+            };
             initializer.Initialize(telemetryItem);
 
             Assert.Equal("Test", telemetryItem.Context.Cloud.RoleName);            
             Assert.Equal("TestRoleName.azurewebsites.net", telemetryItem.Context.GetInternalContext().NodeName);
 
-            Environment.SetEnvironmentVariable("WEBSITE_HOSTNAME", null);
+            Environment.SetEnvironmentVariable(testVarName, null);
         }
 
         [TestMethod]
         public void AzureWebAppRoleEnvironmentTelemetryInitializerDoesNotOverrideRoleInstance()
         {
-            Environment.SetEnvironmentVariable("WEBSITE_HOSTNAME", "TestRoleName.azurewebsites.net");
+            var testVarName = "WEBSITE_" + Guid.NewGuid().ToString() + "_HOSTNAME";
+            Environment.SetEnvironmentVariable(testVarName, "TestRoleName.azurewebsites.net");
 
             var telemetryItem = new EventTelemetry();
             telemetryItem.Context.Cloud.RoleInstance = "Test";
 
-            var initializer = new AzureWebAppRoleEnvironmentTelemetryInitializer();
+            var initializer = new AzureWebAppRoleEnvironmentTelemetryInitializer()
+            {
+                WebAppHostNameEnvironmentVariable = testVarName
+            };
             initializer.Initialize(telemetryItem);
 
             Assert.Equal("TestRoleName", telemetryItem.Context.Cloud.RoleName);
             Assert.Equal("Test", telemetryItem.Context.Cloud.RoleInstance);
             Assert.Equal("TestRoleName.azurewebsites.net", telemetryItem.Context.GetInternalContext().NodeName);
 
-            Environment.SetEnvironmentVariable("WEBSITE_HOSTNAME", null);
+            Environment.SetEnvironmentVariable(testVarName, null);
         }
 
         [TestMethod]
         public void AzureWebAppRoleEnvironmentTelemetryInitializerDoesNotOverrideNodeName()
         {
-            Environment.SetEnvironmentVariable("WEBSITE_HOSTNAME", "TestRoleName.azurewebsites.net");
-
+            var testVarName = "WEBSITE_" + Guid.NewGuid().ToString() + "_HOSTNAME";
+            Environment.SetEnvironmentVariable(testVarName, "TestRoleName.azurewebsites.net");
+
             var telemetryItem = new EventTelemetry();
             telemetryItem.Context.GetInternalContext().NodeName = "Test";
 
-            var initializer = new AzureWebAppRoleEnvironmentTelemetryInitializer();
+            var initializer = new AzureWebAppRoleEnvironmentTelemetryInitializer()
+            {
+                WebAppHostNameEnvironmentVariable = testVarName
+            };
             initializer.Initialize(telemetryItem);
 
             Assert.Equal("TestRoleName", telemetryItem.Context.Cloud.RoleName);            
             Assert.Equal("Test", telemetryItem.Context.GetInternalContext().NodeName);
 
-            Environment.SetEnvironmentVariable("WEBSITE_HOSTNAME", null);            
+            Environment.SetEnvironmentVariable(testVarName, null);
         }
 
         [TestMethod]
         public void AzureWebAppRoleEnvironmentTelemetryInitializerEmptyVariable()
         {
-            Environment.SetEnvironmentVariable("WEBSITE_HOSTNAME", null);
+            var testVarName = "WEBSITE_" + Guid.NewGuid().ToString() + "_HOSTNAME";
+            Environment.SetEnvironmentVariable(testVarName, null);
 
             var telemetryItem = new EventTelemetry();
 
-            var initializer = new AzureWebAppRoleEnvironmentTelemetryInitializer();
+            var initializer = new AzureWebAppRoleEnvironmentTelemetryInitializer()
+            {
+                WebAppHostNameEnvironmentVariable = testVarName
+            };
             initializer.Initialize(telemetryItem);
 
             Assert.Null(telemetryItem.Context.Cloud.RoleName);