diff --git a/CHANGELOG.md b/CHANGELOG.md
index c7d3586ec..4dda1235f 100644
--- a/CHANGELOG.md
+++ b/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)
diff --git a/Src/Microsoft.ApplicationInsights.Web.sln b/Src/Microsoft.ApplicationInsights.Web.sln
index 4d24664a6..56e8155be 100644
--- a/Src/Microsoft.ApplicationInsights.Web.sln
+++ b/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
diff --git a/Src/WindowsServer/WindowsServer.Net45.Tests/WindowsServer.Net45.Tests.csproj b/Src/WindowsServer/WindowsServer.Net45.Tests/WindowsServer.Net45.Tests.csproj
index b2082c23a..818dff660 100644
--- a/Src/WindowsServer/WindowsServer.Net45.Tests/WindowsServer.Net45.Tests.csproj
+++ b/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>
diff --git a/Src/WindowsServer/WindowsServer.Nuget.Tests/TelemetryModulesTests.cs b/Src/WindowsServer/WindowsServer.Nuget.Tests/TelemetryModulesTests.cs
index 38ba17d4f..78fe1e3c1 100644
--- a/Src/WindowsServer/WindowsServer.Nuget.Tests/TelemetryModulesTests.cs
+++ b/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]
diff --git a/Src/WindowsServer/WindowsServer.Nuget/ApplicationInsights.config.install.xdt b/Src/WindowsServer/WindowsServer.Nuget/ApplicationInsights.config.install.xdt
index f92eaa999..68051450c 100644
--- a/Src/WindowsServer/WindowsServer.Nuget/ApplicationInsights.config.install.xdt
+++ b/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 
diff --git a/Src/WindowsServer/WindowsServer.Nuget/ApplicationInsights.config.uninstall.xdt b/Src/WindowsServer/WindowsServer.Nuget/ApplicationInsights.config.uninstall.xdt
index fd90ac3d0..afd12e09a 100644
--- a/Src/WindowsServer/WindowsServer.Nuget/ApplicationInsights.config.uninstall.xdt
+++ b/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" />
diff --git a/Src/WindowsServer/WindowsServer.Shared.Tests/AppServicesHeartbeatTelemetryModuleTests.cs b/Src/WindowsServer/WindowsServer.Shared.Tests/AppServicesHeartbeatTelemetryModuleTests.cs
new file mode 100644
index 000000000..e64a82534
--- /dev/null
+++ b/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);
+            }
+        }
+    }
+}
diff --git a/Src/WindowsServer/WindowsServer.Shared.Tests/AzureInstanceMetadataEndToEndTests.cs b/Src/WindowsServer/WindowsServer.Shared.Tests/AzureInstanceMetadataEndToEndTests.cs
index 897c2ca2c..148f50fee 100644
--- a/Src/WindowsServer/WindowsServer.Shared.Tests/AzureInstanceMetadataEndToEndTests.cs
+++ b/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";
diff --git a/Src/WindowsServer/WindowsServer.Shared.Tests/AzureWebAppRoleEnvironmentTelemetryInitializerTest.cs b/Src/WindowsServer/WindowsServer.Shared.Tests/AzureWebAppRoleEnvironmentTelemetryInitializerTest.cs
index 3b7a5e06f..cdfc7f7cc 100644
--- a/Src/WindowsServer/WindowsServer.Shared.Tests/AzureWebAppRoleEnvironmentTelemetryInitializerTest.cs
+++ b/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);
diff --git a/Src/WindowsServer/WindowsServer.Shared.Tests/EnvironmentVariableMonitorTests.cs b/Src/WindowsServer/WindowsServer.Shared.Tests/EnvironmentVariableMonitorTests.cs
new file mode 100644
index 000000000..590061192
--- /dev/null
+++ b/Src/WindowsServer/WindowsServer.Shared.Tests/EnvironmentVariableMonitorTests.cs
@@ -0,0 +1,127 @@
+namespace Microsoft.ApplicationInsights.WindowsServer
+{
+    using System;
+    using System.Collections.Generic;
+    using Microsoft.ApplicationInsights.WindowsServer.Implementation;
+    using Microsoft.ApplicationInsights.WindowsServer.Mock;
+    using Microsoft.VisualStudio.TestTools.UnitTesting;
+    using Assert = Xunit.Assert;
+
+    [TestClass]
+    public class EnvironmentVariableMonitorTests
+    {
+        private Dictionary<string, string> testEnvironmentVariables;
+        private MockEnvironmentVariableMonitor testEnvironmentMonitor;
+
+        [TestInitialize]
+        public void BeforeEachTest()
+        {
+            this.testEnvironmentVariables = this.GetCurrentAppServiceEnvironmentVariableValues();
+            this.testEnvironmentMonitor = new MockEnvironmentVariableMonitor(this.testEnvironmentVariables.Keys);
+        }
+
+        [TestCleanup]
+        public void AfterEachTest()
+        {
+            this.RemoveTestEnvironmentVariablesFromEnvironment(this.testEnvironmentVariables);
+        }
+
+        [TestMethod]
+        public void EnsureInstanceWorksAsIntended()
+        {
+            Assert.NotNull(AppServiceEnvironmentVariableMonitor.Instance);
+        }
+
+        [TestMethod]
+        public void EnsureEnvironmentVariablesAreCapturedImmediately()
+        {
+            foreach (var kvp in this.testEnvironmentVariables)
+            {
+                string cachedVal = string.Empty;
+                this.testEnvironmentMonitor.GetCurrentEnvironmentVariableValue(kvp.Key, ref cachedVal);
+                Assert.Equal(kvp.Value, cachedVal, StringComparer.Ordinal);
+            }
+        }
+
+        [TestMethod]
+        public void ConfirmUpdatedEnvironmentIsNotDetectedPriorToUpdate()
+        {
+            foreach (var kvp in this.testEnvironmentVariables)
+            {
+                string updatedValue = Guid.NewGuid().ToString();
+                Assert.NotEqual(kvp.Value, updatedValue, StringComparer.Ordinal);
+
+                Environment.SetEnvironmentVariable(kvp.Key, updatedValue);
+
+                string cachedValue = string.Empty;
+                this.testEnvironmentMonitor.GetCurrentEnvironmentVariableValue(kvp.Key, ref cachedValue);
+                Assert.Equal(kvp.Value, cachedValue, StringComparer.Ordinal);
+            }
+        }
+
+        [TestMethod]
+        public void ConfirmUpdatedEnvironmentIsDetectedPostUpdate()
+        {
+            var updatedVars = new Dictionary<string, string>();
+
+            foreach (var kvp in this.testEnvironmentVariables)
+            {
+                string updatedValue = Guid.NewGuid().ToString();
+                Assert.NotEqual(kvp.Value, updatedValue, StringComparer.Ordinal);
+
+                Environment.SetEnvironmentVariable(kvp.Key, updatedValue);
+                updatedVars.Add(kvp.Key, updatedValue);
+            }
+
+            this.testEnvironmentMonitor.PerformCheckForUpdatedVariables();
+            Assert.True(this.testEnvironmentMonitor.DetectedUpdatedVarValue);
+
+            foreach (var kvp in this.testEnvironmentVariables)
+            {
+                string cachedValue = string.Empty;
+                this.testEnvironmentMonitor.GetCurrentEnvironmentVariableValue(kvp.Key, ref cachedValue);
+
+                Assert.Equal(updatedVars[kvp.Key], cachedValue, StringComparer.Ordinal);
+                Assert.NotEqual(kvp.Value, cachedValue, StringComparer.Ordinal);
+            }
+        }
+
+        /// <summary>
+        /// Create a set of environment variables that mimics the default values used by
+        /// the AppServiceEnvVarMonitor, and a set of values for them. Each time this method
+        /// is called the names and values of the environment variables will be unique as a Guid
+        /// is used.
+        /// </summary>
+        /// <returns>Dictionary containing the environment variable names and their current values.</returns>
+        private Dictionary<string, string> GetCurrentAppServiceEnvironmentVariableValues()
+        {
+            int testValueCount = 0;
+            Dictionary<string, string> envVars = new Dictionary<string, string>();
+
+            string testVarSuffix = Guid.NewGuid().ToString();
+            foreach (string envVarName in AppServiceEnvironmentVariableMonitor.PreloadedMonitoredEnvironmentVariables)
+            {
+                string testVarName = string.Concat(envVarName, "_", testVarSuffix);
+                string testVarValue = $"{testValueCount}_Stand-inValue_{testVarSuffix}_{testValueCount}";
+                testValueCount++;
+                Environment.SetEnvironmentVariable(testVarName, testVarValue);
+
+                envVars.Add(testVarName, testVarValue);
+            }
+
+            return envVars;
+        }
+
+        /// <summary>
+        /// Clean up the test environment by removing each set environment variable in the given dictionary.
+        /// </summary>
+        /// <param name="envVars">Environment variables currently set for a test method run.</param>
+        private void RemoveTestEnvironmentVariablesFromEnvironment(Dictionary<string, string> envVars)
+        {
+            foreach (var kvp in envVars)
+            {
+                Environment.SetEnvironmentVariable(kvp.Key, string.Empty);
+            }
+        }
+    }
+}
diff --git a/Src/WindowsServer/WindowsServer.Shared.Tests/Mock/MockEnvironmentVariableMonitor.cs b/Src/WindowsServer/WindowsServer.Shared.Tests/Mock/MockEnvironmentVariableMonitor.cs
new file mode 100644
index 000000000..b04cd10f2
--- /dev/null
+++ b/Src/WindowsServer/WindowsServer.Shared.Tests/Mock/MockEnvironmentVariableMonitor.cs
@@ -0,0 +1,74 @@
+namespace Microsoft.ApplicationInsights.WindowsServer.Mock
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Linq;
+    using Microsoft.ApplicationInsights.WindowsServer.Implementation;
+
+    internal class MockEnvironmentVariableMonitor : EnvironmentVariableMonitor
+    {
+        public Dictionary<string, string> ExpectedEnvVars;
+        private List<string> updatedVars;
+        private bool hasBeenUpdated = false;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="MockEnvironmentVariableMonitor"/> class.
+        /// Create a mocked-up instance of the abstract class EnvironmentVariableMonitor, disabling any
+        /// timed updates to ensure unit tests are determinant. Testers must use 'PerformCheckForUpdatedVariables'
+        /// to simulate update timer calls.
+        /// </summary>
+        /// <param name="envVars">List of environment variables to check for updates during the test. Hint: Keep these random/testable as a unit.</param>
+        public MockEnvironmentVariableMonitor(IEnumerable<string> envVars) : base(envVars, TimeSpan.FromMilliseconds(-1))
+        {
+            this.isEnabled = false;
+            this.updatedVars = new List<string>();
+            this.ExpectedEnvVars = new Dictionary<string, string>();
+            foreach (string key in envVars)
+            {
+                this.ExpectedEnvVars.Add(key, Environment.GetEnvironmentVariable(key));
+            }
+        }
+
+        public bool DetectedUpdatedVarValue
+        {
+            get
+            {
+                var updatedStatus = this.hasBeenUpdated;
+                this.hasBeenUpdated = false;
+                return updatedStatus;
+            }
+
+            set => this.hasBeenUpdated = true;
+        }
+
+        public List<string> GetAndClearAllUpdatedEnvVars()
+        {
+            var updatedVars = new List<string>(this.updatedVars);
+            this.updatedVars.Clear();
+            return updatedVars;
+        }
+
+        public void PerformCheckForUpdatedVariables()
+        {
+            this.CheckVariablesIntermittent(null);
+        }
+
+        protected override void OnEnvironmentVariableUpdated()
+        {
+            this.DetectedUpdatedVarValue = true;
+            this.updatedVars.Clear();
+
+            var keys = this.ExpectedEnvVars.Keys.ToList();
+            foreach (string key in keys)
+            {
+                var had = this.ExpectedEnvVars[key];
+                var got = Environment.GetEnvironmentVariable(key);
+                if (!had.Equals(got, StringComparison.Ordinal))
+                {
+                    this.updatedVars.Add(key);
+                    this.ExpectedEnvVars[key] = got;
+                }
+            }
+        }
+    }
+}
diff --git a/Src/WindowsServer/WindowsServer.Shared.Tests/WindowsServer.Shared.Tests.projitems b/Src/WindowsServer/WindowsServer.Shared.Tests/WindowsServer.Shared.Tests.projitems
index a653567ac..adba80f66 100644
--- a/Src/WindowsServer/WindowsServer.Shared.Tests/WindowsServer.Shared.Tests.projitems
+++ b/Src/WindowsServer/WindowsServer.Shared.Tests/WindowsServer.Shared.Tests.projitems
@@ -9,6 +9,8 @@
     <Import_RootNamespace>Microsoft.ApplicationInsights.WindowsServer</Import_RootNamespace>
   </PropertyGroup>
   <ItemGroup>
+    <Compile Include="$(MSBuildThisFileDirectory)AppServicesHeartbeatTelemetryModuleTests.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)EnvironmentVariableMonitorTests.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)AzureInstanceMetadataEndToEndTests.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)AzureWebAppRoleEnvironmentTelemetryInitializerTest.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)AzureInstanceMetadataTests.cs" />
@@ -17,6 +19,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)Mock\AzureInstanceMetadataRequestMock.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Mock\AzureInstanceMetadataServiceMock.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Mock\HeartbeatProviderMock.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)Mock\MockEnvironmentVariableMonitor.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Mock\NetPlatformHttpResponseTypesExtension.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)UnobservedExceptionTelemetryModuleTest.cs" />
   </ItemGroup>
diff --git a/Src/WindowsServer/WindowsServer.Shared/AppServicesHeartbeatTelemetryModule.cs b/Src/WindowsServer/WindowsServer.Shared/AppServicesHeartbeatTelemetryModule.cs
new file mode 100644
index 000000000..2fff4c8ca
--- /dev/null
+++ b/Src/WindowsServer/WindowsServer.Shared/AppServicesHeartbeatTelemetryModule.cs
@@ -0,0 +1,159 @@
+namespace Microsoft.ApplicationInsights.WindowsServer
+{
+    using System;
+    using System.Collections.Generic;
+    using Microsoft.ApplicationInsights.Extensibility;
+    using Microsoft.ApplicationInsights.Extensibility.Implementation;
+    using Microsoft.ApplicationInsights.Extensibility.Implementation.Tracing;
+    using Microsoft.ApplicationInsights.WindowsServer.Implementation;
+
+    /// <summary>
+    /// Provides default values for the heartbeat feature of Application Insights that
+    /// are specific to Azure App Services (Web Apps, Functions, etc...).
+    /// </summary>
+    public sealed class AppServicesHeartbeatTelemetryModule : ITelemetryModule, IDisposable
+    {
+        /// <summary>
+        /// Environment variables and the Application Insights heartbeat field names that accompany them.
+        /// </summary>
+        internal readonly KeyValuePair<string, string>[] WebHeartbeatPropertyNameEnvVarMap = new KeyValuePair<string, string>[]
+        {
+            new KeyValuePair<string, string>("appSrv_SiteName", "WEBSITE_SITE_NAME"),
+            new KeyValuePair<string, string>("appSrv_SlotName", "WEBSITE_SLOT_NAME"),
+            new KeyValuePair<string, string>("appSrv_wsStamp", "WEBSITE_HOME_STAMPNAME"),
+            new KeyValuePair<string, string>("appSrv_wsHost", "WEBSITE_HOSTNAME"),
+            new KeyValuePair<string, string>("appSrv_wsOwner", "WEBSITE_OWNER_NAME")
+        };
+
+        // Cache the heartbeat property manager across updates. Note that tests can also override the heartbeat manager.
+        internal IHeartbeatPropertyManager HeartbeatManager;
+
+        // Used to determine if we call Add or Set heartbeat properties in the case of updates.
+        private bool isInitialized = false;
+        
+        /// <summary>
+        /// Initializes a new instance of the<see cref="AppServicesHeartbeatTelemetryModule" /> class.
+        /// </summary>
+        public AppServicesHeartbeatTelemetryModule() : this(null)
+        {            
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AppServicesHeartbeatTelemetryModule" /> class. This is
+        /// internal, and allows for overriding the Heartbeat Property Manager to test this module with.
+        /// </summary>
+        /// <param name="hbeatPropManager">The heartbeat property manager to use when setting/updating env var values.</param>
+        internal AppServicesHeartbeatTelemetryModule(IHeartbeatPropertyManager hbeatPropManager)
+        {
+            this.HeartbeatManager = hbeatPropManager;
+        }
+
+        /// <summary>
+        /// Initialize the default heartbeat provider for Azure App Services. This module
+        /// looks for specific environment variables and sets them into the heartbeat 
+        /// properties for Application Insights, if they exist.
+        /// </summary>
+        /// <param name="configuration">Unused parameter.</param>
+        public void Initialize(TelemetryConfiguration configuration)
+        {
+            this.UpdateHeartbeatWithAppServiceEnvVarValues();
+            AppServiceEnvironmentVariableMonitor.Instance.MonitoredAppServiceEnvVarUpdatedEvent += this.UpdateHeartbeatWithAppServiceEnvVarValues;
+        }
+
+        /// <summary>
+        /// Signal the AppServicesHeartbeatTelemetryModule to update the values of the 
+        /// Environment variables we use in our heartbeat payload.
+        /// </summary>
+        public void UpdateHeartbeatWithAppServiceEnvVarValues()
+        {
+            try
+            {
+                var hbeatManager = this.GetHeartbeatPropertyManager();
+                if (hbeatManager != null)
+                {
+                    this.isInitialized = this.AddAppServiceEnvironmentVariablesToHeartbeat(hbeatManager, isUpdateOperation: this.isInitialized);
+                }
+            }
+            catch (Exception appSrvEnvVarHbeatFailure)
+            {
+                WindowsServerEventSource.Log.AppServiceHeartbeatPropertySettingFails(appSrvEnvVarHbeatFailure.ToInvariantString());
+            }
+        }
+
+        /// <summary>
+        /// Remove our event handler from the environment variable monitor.
+        /// </summary>
+        public void Dispose()
+        {
+            AppServiceEnvironmentVariableMonitor.Instance.MonitoredAppServiceEnvVarUpdatedEvent -= this.UpdateHeartbeatWithAppServiceEnvVarValues;
+        }
+
+        private bool AddAppServiceEnvironmentVariablesToHeartbeat(IHeartbeatPropertyManager hbeatManager, bool isUpdateOperation = false)
+        {
+            bool hasBeenUpdated = false;
+
+            if (hbeatManager == null)
+            {
+                WindowsServerEventSource.Log.AppServiceHeartbeatSetCalledWithNullManager();
+            }
+            else
+            {
+                foreach (var kvp in this.WebHeartbeatPropertyNameEnvVarMap)
+                {
+                    try
+                    {
+                        string hbeatKey = kvp.Key.ToString();
+                        string hbeatValue = string.Empty;
+                        AppServiceEnvironmentVariableMonitor.Instance.GetCurrentEnvironmentVariableValue(kvp.Value, ref hbeatValue);
+                        if (isUpdateOperation)
+                        {
+                            hbeatManager.SetHeartbeatProperty(hbeatKey, hbeatValue);
+                        }
+                        else
+                        {
+                            hbeatManager.AddHeartbeatProperty(hbeatKey, hbeatValue, true);
+                        }
+
+                        hasBeenUpdated = true;
+                    }
+                    catch (Exception heartbeatValueException)
+                    {
+                        WindowsServerEventSource.Log.AppServiceHeartbeatPropertyAquisitionFailed(kvp.Value, heartbeatValueException.ToInvariantString());
+                    }
+                }
+            }
+
+            return hasBeenUpdated;
+        }
+
+        private IHeartbeatPropertyManager GetHeartbeatPropertyManager()
+        {
+            if (this.HeartbeatManager == null)
+            {
+                var telemetryModules = TelemetryModules.Instance;
+
+                try
+                {
+                    foreach (var module in telemetryModules.Modules)
+                    {
+                        if (module is IHeartbeatPropertyManager hman)
+                        {
+                            this.HeartbeatManager = hman;
+                        }
+                    }
+                }
+                catch (Exception hearbeatManagerAccessException)
+                {
+                    WindowsServerEventSource.Log.AppServiceHeartbeatManagerAccessFailure(hearbeatManagerAccessException.ToInvariantString());
+                }
+
+                if (this.HeartbeatManager == null)
+                {
+                    WindowsServerEventSource.Log.AppServiceHeartbeatManagerNotAvailable();
+                }
+            }
+
+            return this.HeartbeatManager;
+        }
+    }
+}
\ No newline at end of file
diff --git a/Src/WindowsServer/WindowsServer.Shared/AzureWebAppRoleEnvironmentTelemetryInitializer.cs b/Src/WindowsServer/WindowsServer.Shared/AzureWebAppRoleEnvironmentTelemetryInitializer.cs
index c0b0e6324..0913b60c6 100644
--- a/Src/WindowsServer/WindowsServer.Shared/AzureWebAppRoleEnvironmentTelemetryInitializer.cs
+++ b/Src/WindowsServer/WindowsServer.Shared/AzureWebAppRoleEnvironmentTelemetryInitializer.cs
@@ -1,20 +1,21 @@
 namespace Microsoft.ApplicationInsights.WindowsServer
 {
     using System;
-    using System.Threading;
-
     using Microsoft.ApplicationInsights.Channel;
     using Microsoft.ApplicationInsights.Extensibility;
     using Microsoft.ApplicationInsights.Extensibility.Implementation;
     using Microsoft.ApplicationInsights.WindowsServer.Implementation;
-   
+
     /// <summary>
     /// A telemetry initializer that will gather Azure Web App Role Environment context information.
     /// </summary>
-    public class AzureWebAppRoleEnvironmentTelemetryInitializer : ITelemetryInitializer
+    public sealed class AzureWebAppRoleEnvironmentTelemetryInitializer : ITelemetryInitializer, IDisposable
     {
-        /// <summary>Azure Web App Hostname. This will include the deployment slot, but will be same across instances of same slot.</summary>
-        private const string WebAppHostNameEnvironmentVariable = "WEBSITE_HOSTNAME";
+        /// <summary>
+        /// Azure Web App Hostname. This will include the deployment slot, but will be 
+        /// same across instances of same slot. Marked as internal to support testing.
+        /// </summary>
+        internal string WebAppHostNameEnvironmentVariable = "WEBSITE_HOSTNAME";
 
         /// <summary>Predefined suffix for Azure Web App Hostname.</summary>
         private const string WebAppSuffix = ".azurewebsites.net";
@@ -22,33 +23,49 @@ public class AzureWebAppRoleEnvironmentTelemetryInitializer : ITelemetryInitiali
         private string nodeName;
         private string roleName;
 
+        private volatile bool updateEnvVars = true;
+
         /// <summary>
         /// Initializes a new instance of the <see cref="AzureWebAppRoleEnvironmentTelemetryInitializer" /> class.
         /// </summary>
         public AzureWebAppRoleEnvironmentTelemetryInitializer()
         {
             WindowsServerEventSource.Log.TelemetryInitializerLoaded(this.GetType().FullName);
+            AppServiceEnvironmentVariableMonitor.Instance.MonitoredAppServiceEnvVarUpdatedEvent += this.UpdateEnvironmentValues;
         }
 
         /// <summary>
-        /// Initializes <see cref="ITelemetry" /> device context.
+        /// Initializes <see cref="ITelemetry" /> role and node context information.
         /// </summary>
         /// <param name="telemetry">The telemetry to initialize.</param>
         public void Initialize(ITelemetry telemetry)
         {
+            if (this.updateEnvVars)
+            {
+                this.roleName = this.GetRoleName();
+                this.nodeName = this.GetNodeName();
+                this.updateEnvVars = false;
+            }
+
             if (string.IsNullOrEmpty(telemetry.Context.Cloud.RoleName))
             {
-                string name = LazyInitializer.EnsureInitialized(ref this.roleName, this.GetRoleName);
-                telemetry.Context.Cloud.RoleName = name;
+                telemetry.Context.Cloud.RoleName = this.roleName;
             }
 
             if (string.IsNullOrEmpty(telemetry.Context.GetInternalContext().NodeName))
             {
-                string name = LazyInitializer.EnsureInitialized(ref this.nodeName, this.GetNodeName);                
-                telemetry.Context.GetInternalContext().NodeName = name;
+                telemetry.Context.GetInternalContext().NodeName = this.nodeName;
             }
         }
 
+        /// <summary>
+        /// Remove our event handler from the environment variable monitor.
+        /// </summary>
+        public void Dispose()
+        {
+            AppServiceEnvironmentVariableMonitor.Instance.MonitoredAppServiceEnvVarUpdatedEvent -= this.UpdateEnvironmentValues;
+        }
+
         private string GetRoleName()
         {
             var result = this.GetNodeName();
@@ -62,7 +79,14 @@ private string GetRoleName()
 
         private string GetNodeName()
         {
-            return Environment.GetEnvironmentVariable(WebAppHostNameEnvironmentVariable) ?? string.Empty;
+            string nodeName = string.Empty;
+            AppServiceEnvironmentVariableMonitor.Instance.GetCurrentEnvironmentVariableValue(this.WebAppHostNameEnvironmentVariable, ref nodeName);
+            return nodeName ?? string.Empty;
+        }
+
+        private void UpdateEnvironmentValues()
+        {
+            this.updateEnvVars = true;
         }
     }
 }
diff --git a/Src/WindowsServer/WindowsServer.Shared/Implementation/AppServiceEnvironmentVariableMonitor.cs b/Src/WindowsServer/WindowsServer.Shared/Implementation/AppServiceEnvironmentVariableMonitor.cs
new file mode 100644
index 000000000..2212c6768
--- /dev/null
+++ b/Src/WindowsServer/WindowsServer.Shared/Implementation/AppServiceEnvironmentVariableMonitor.cs
@@ -0,0 +1,77 @@
+namespace Microsoft.ApplicationInsights.WindowsServer.Implementation
+{
+    using System;
+    using System.Collections.Generic;
+    using System.ComponentModel;
+
+    internal delegate void MonitoredAppServiceEnvVarUpdated();
+
+    /// <summary>
+    /// Utility to monitor the value of environment variables which may change 
+    /// during the run of an application. Checks the environment variables 
+    /// at regular set intervals.
+    /// </summary>
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    internal sealed class AppServiceEnvironmentVariableMonitor : EnvironmentVariableMonitor
+    {
+        // event raised whenever any of the environment variables being watched get updated
+        public MonitoredAppServiceEnvVarUpdated MonitoredAppServiceEnvVarUpdatedEvent;
+
+        // Default interval between environment variable checks
+        internal static readonly TimeSpan DefaultMonitorInterval = TimeSpan.FromSeconds(60);
+
+        // Default list of environment variables tracked by this monitor.
+        internal static IReadOnlyCollection<string> PreloadedMonitoredEnvironmentVariables = new string[]
+        {
+            "WEBSITE_SITE_NAME",
+            "WEBSITE_SLOT_NAME",
+            "WEBSITE_HOME_STAMPNAME",
+            "WEBSITE_HOSTNAME",
+            "WEBSITE_OWNER_NAME"
+        };
+
+        // singleton pattern, this is the one instance of this class allowed
+        private static readonly AppServiceEnvironmentVariableMonitor SingletonInstance = new AppServiceEnvironmentVariableMonitor();
+
+        /// <summary>
+        /// Prevents a default instance of the <see cref="AppServiceEnvironmentVariableMonitor" /> class from being created.
+        /// </summary>
+        private AppServiceEnvironmentVariableMonitor() : 
+            base(
+                AppServiceEnvironmentVariableMonitor.PreloadedMonitoredEnvironmentVariables, 
+                AppServiceEnvironmentVariableMonitor.DefaultMonitorInterval)
+        {
+            // check to ensure there is at least one known Azure App Service environment variable present
+            bool validateAppServiceEnvironment = false;
+            foreach (var environmentVariableName in AppServiceEnvironmentVariableMonitor.PreloadedMonitoredEnvironmentVariables)
+            {
+                string environmentVariableValue = string.Empty;
+                this.GetCurrentEnvironmentVariableValue(environmentVariableName, ref environmentVariableValue);
+                if (!string.IsNullOrEmpty(environmentVariableValue))
+                {
+                    validateAppServiceEnvironment = true;
+                    break;
+                }
+            }
+
+            // if not, disable this monitor
+            if (!validateAppServiceEnvironment)
+            {
+                this.isEnabled = false;
+            }
+        }
+
+        public static AppServiceEnvironmentVariableMonitor Instance => AppServiceEnvironmentVariableMonitor.SingletonInstance;
+
+        internal TimeSpan MonitorInterval
+        {
+            get => AppServiceEnvironmentVariableMonitor.Instance.checkInterval;
+            set => AppServiceEnvironmentVariableMonitor.Instance.checkInterval = value;
+        }
+
+        protected override void OnEnvironmentVariableUpdated()
+        {
+            this.MonitoredAppServiceEnvVarUpdatedEvent?.Invoke();
+        }
+    }
+}
diff --git a/Src/WindowsServer/WindowsServer.Shared/Implementation/EnvironmentVariableMonitor.cs b/Src/WindowsServer/WindowsServer.Shared/Implementation/EnvironmentVariableMonitor.cs
new file mode 100644
index 000000000..e03e7eae5
--- /dev/null
+++ b/Src/WindowsServer/WindowsServer.Shared/Implementation/EnvironmentVariableMonitor.cs
@@ -0,0 +1,134 @@
+namespace Microsoft.ApplicationInsights.WindowsServer.Implementation
+{
+    using System;
+    using System.Collections.Concurrent;
+    using System.Collections.Generic;
+    using System.Security;
+    using System.Threading;
+    using Microsoft.ApplicationInsights.Extensibility.Implementation.Tracing;
+
+    /// <summary>
+    /// Utility to monitor the value of environment variables which may change 
+    /// during the run of an application. Checks the environment variables 
+    /// intermittently.
+    /// </summary>
+    internal abstract class EnvironmentVariableMonitor : IDisposable
+    {
+        // Environment variables tracked by this monitor.
+        protected readonly ConcurrentDictionary<string, string> CheckedValues;
+
+        // help ensure no Timer problems by enforcing a minimum check interval
+        protected readonly TimeSpan MinimumCheckInterval = TimeSpan.FromSeconds(5);
+
+        // enabled flag primarily used during dispose
+        protected volatile bool isEnabled = true;
+
+        // how often we allow the code to re-check the environment
+        protected TimeSpan checkInterval;
+
+        // timer object that will periodically update the environment variables
+        private readonly Timer environmentCheckTimer;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="EnvironmentVariableMonitor" /> class.
+        /// </summary>
+        protected EnvironmentVariableMonitor(IEnumerable<string> envVars, TimeSpan checkInterval)
+        {
+            this.CheckedValues = new ConcurrentDictionary<string, string>();
+            this.checkInterval = checkInterval > this.MinimumCheckInterval ? checkInterval : this.MinimumCheckInterval;
+
+            foreach (string varName in envVars)
+            {
+                this.CheckedValues.TryAdd(varName, Environment.GetEnvironmentVariable(varName));
+            }
+
+            this.environmentCheckTimer = new Timer(this.CheckVariablesIntermittent, null, Timeout.Infinite, Timeout.Infinite);
+            this.environmentCheckTimer.Change(checkInterval, TimeSpan.FromMilliseconds(-1));
+        }
+
+        /// <summary>
+        /// Get the latest value assigned to an environment variable.
+        /// </summary>
+        /// <param name="envVarName">Name of the environment variable to acquire.</param>
+        /// <param name="value">Current cached value of the environment variable.</param>
+        public void GetCurrentEnvironmentVariableValue(string envVarName, ref string value)
+        {
+            value = this.CheckedValues.GetOrAdd(envVarName, (key) => { return Environment.GetEnvironmentVariable(key); });
+        }
+
+        public void Dispose()
+        {
+            this.isEnabled = false;
+
+            if (this.environmentCheckTimer != null)
+            {
+                try
+                {
+                    this.environmentCheckTimer.Dispose();
+                }
+                catch (Exception e)
+                {
+                    WindowsServerEventSource.Log.EnvironmentVarMonitorFailedDispose(e.ToInvariantString());
+                }
+            }
+        }
+
+        /// <summary>
+        /// Method to update subscribers whenever a change in the tracked environment variables is detected.
+        /// </summary>
+        protected abstract void OnEnvironmentVariableUpdated();
+
+        /// <summary>
+        /// Check and update the variables being tracked and if any updates are detected,
+        /// raise the OnEnvironmentVariableUpdated event. Restart the timer to check again
+        /// in the configured interval once complete.
+        /// </summary>
+        /// <param name="state">Variable left unused in this implementation of TimerCallback.</param>
+        protected void CheckVariablesIntermittent(object state)
+        {
+            try
+            {
+                bool shouldTriggerOnUpdate = false;
+
+                var iter = this.CheckedValues.GetEnumerator();
+                while (iter.MoveNext())
+                {
+                    var kvp = iter.Current;
+                    string envValue = string.Empty;
+
+                    try
+                    {
+                        envValue = Environment.GetEnvironmentVariable(kvp.Key);
+                    }
+                    catch (SecurityException e)
+                    {
+                        WindowsServerEventSource.Log.SecurityExceptionThrownAccessingEnvironmentVariable(kvp.Key, e.ToInvariantString());
+                        this.isEnabled = false;
+                        break;
+                    }
+
+                    if (envValue != null
+                        && !envValue.Equals(kvp.Value, StringComparison.Ordinal)
+                        && this.CheckedValues.TryUpdate(kvp.Key, envValue, kvp.Value))
+                    {
+                        shouldTriggerOnUpdate = true;
+                    }
+                }
+
+                if (shouldTriggerOnUpdate)
+                {
+                    this.OnEnvironmentVariableUpdated();
+                }
+
+                if (this.isEnabled)
+                {
+                    this.environmentCheckTimer.Change(this.checkInterval, TimeSpan.FromMilliseconds(-1));
+                }
+            }
+            catch (Exception e)
+            {
+                WindowsServerEventSource.Log.GeneralFailureOccursDuringCheckForEnvironmentVariables(e.ToInvariantString());
+            }
+        }
+    }
+}
diff --git a/Src/WindowsServer/WindowsServer.Shared/Implementation/WindowsServerEventSource.cs b/Src/WindowsServer/WindowsServer.Shared/Implementation/WindowsServerEventSource.cs
index b203a8cc8..1ac10221c 100644
--- a/Src/WindowsServer/WindowsServer.Shared/Implementation/WindowsServerEventSource.cs
+++ b/Src/WindowsServer/WindowsServer.Shared/Implementation/WindowsServerEventSource.cs
@@ -267,7 +267,7 @@ public void AzureInstanceMetadataFieldNameUnexpected(string unexpectedFieldName,
         [Event(
             28,
             Message = "Azure IMS returned field '{0}' with an invalid/unexpected value. Not adding this value to heartbeat properties.",
-            Level = EventLevel.Informational)]
+            Level = EventLevel.Warning)]
         public void AzureInstanceMetadataValueForFieldInvalid(string fieldWithInvalidValue, string applicationName = "Incorrect")
         {
             this.WriteEvent(
@@ -326,6 +326,94 @@ public void AzureInstanceMetadataFailureSettingDefaultPayload(string exception,
                 this.ApplicationName);
         }
 
+        [Event(33,
+            Message = "App Services Heartbeat Provider: Failed to obtain Azure App Services environment variable '{0}'. Exception raised: {1}",
+            Level = EventLevel.Warning)]
+        public void AppServiceHeartbeatPropertyAquisitionFailed(string envVarName, string exceptionStr, string appDomainName = "Incorrect")
+        {
+            this.WriteEvent(
+                33,
+                envVarName ?? "unknown",
+                exceptionStr ?? "unknown-exception",
+                this.ApplicationName);
+        }
+
+        [Event(34,
+            Message = "App Services Heartbeat Provider: Could not obtain the Heartbeat Manager instance during initialization. Exception raised: {0}",
+            Level = EventLevel.Warning)]
+        public void AppServiceHeartbeatManagerAccessFailure(string exceptionStr, string appDomainName = "Incorrect")
+        {
+            this.WriteEvent(
+                34,
+                exceptionStr ?? "unknown-exception",
+                this.ApplicationName);
+        }
+        
+        [Event(35,
+            Message = "App Services Heartbeat Provider: Accessing the Hearbeat Manager failed as it is not in the list of available modules.",
+            Level = EventLevel.Warning)]
+        public void AppServiceHeartbeatManagerNotAvailable(string appDomainName = "Incorrect")
+        {
+            this.WriteEvent(
+                35,
+                this.ApplicationName);
+        }
+
+        [Event(36,
+            Message = "App Services Heartbeat Provider: Failed to set Azure App Services heartbeat values. Exception encountered: {0}",
+            Level = EventLevel.Warning)]
+        public void AppServiceHeartbeatPropertySettingFails(string exceptionStr, string appDomainName = "Incorrect")
+        {
+            this.WriteEvent(
+                36,
+                exceptionStr ?? "unknown-exception",
+                this.ApplicationName);
+        }
+
+        [Event(37,
+            Message = "App Services Heartbeat Provider: Request to set heartbeat properties when the heartbeat property manager is null.",
+            Level = EventLevel.Warning)]
+        public void AppServiceHeartbeatSetCalledWithNullManager(string appDomainName = "Incorrect")
+        {
+            this.WriteEvent(
+                37,
+                this.ApplicationName);
+        }
+
+        [Event(38,
+            Message = "Error occured when disposing update interval timer within EnvironmentVariableMonitor. Exception: {0}",
+            Level = EventLevel.Warning)]
+        public void EnvironmentVarMonitorFailedDispose(string exceptionMsg, string appDomainName = "Incorrect")
+        {
+            this.WriteEvent(
+                38,
+                exceptionMsg ?? "unknown-exception",
+                this.ApplicationName);
+        }
+
+        [Event(39,
+            Message = "Security exception was thrown trying to read environment variable '{0}'. Disabling environment variable monitor to avoid future security exceptions. Exception: {1}",
+            Level = EventLevel.Warning)]
+        public void SecurityExceptionThrownAccessingEnvironmentVariable(string environmentVariableName, string exceptionMsg, string appDomainName = "Incorrect")
+        {
+            this.WriteEvent(
+                39,
+                environmentVariableName,
+                exceptionMsg ?? "unknown-exception",
+                this.ApplicationName);
+        }
+
+        [Event(40,
+            Message = "Error occurred when trying to update environment variables. Exception: {0}",
+            Level = EventLevel.Warning)]
+        public void GeneralFailureOccursDuringCheckForEnvironmentVariables(string exceptionMsg, string appDomainName = "Incorrect")
+        {
+            this.WriteEvent(
+                40,
+                exceptionMsg ?? "unknown-exception",
+                this.ApplicationName);
+        }
+
         [NonEvent]
         private string GetApplicationName()
         {
diff --git a/Src/WindowsServer/WindowsServer.Shared/WindowsServer.Shared.projitems b/Src/WindowsServer/WindowsServer.Shared/WindowsServer.Shared.projitems
index 5d1246adb..46c50da09 100644
--- a/Src/WindowsServer/WindowsServer.Shared/WindowsServer.Shared.projitems
+++ b/Src/WindowsServer/WindowsServer.Shared/WindowsServer.Shared.projitems
@@ -15,9 +15,12 @@
     <Compile Include="$(MSBuildThisFileDirectory)BuildInfoConfigComponentVersionTelemetryInitializer.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)DeveloperModeWithDebuggerAttachedTelemetryModule.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)DomainNameRoleInstanceTelemetryInitializer.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)AppServicesHeartbeatTelemetryModule.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)Implementation\AppServiceEnvironmentVariableMonitor.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Implementation\AzureComputeMetadataHeartbeatPropertyProvider.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Implementation\AzureMetadataRequestor.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Implementation\DataContracts\AzureInstanceComputeMetadata.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)Implementation\EnvironmentVariableMonitor.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Implementation\IAzureMetadataRequestor.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Implementation\WindowsServerEventSource.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)UnobservedExceptionTelemetryModule.cs" />