quick pulse endpoint config improvements.

Src/PerformanceCollector/NetCore20.Tests/Perf-NetCore20.Tests/Perf-NetCore20.Tests.csproj

@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
   <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildProjectDirectory), 'Test.props'))\Test.props" />
   <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), NetCore.props))\NetCore.props" />
 
@@ -37,4 +37,6 @@
   </ItemGroup>
 
   <Import Project="..\..\Perf.Shared.Tests\Perf.Shared.Tests.projitems" Label="Shared" />
+
+  <Import Project="..\..\..\TestFramework\Shared\TestFramework.Shared.projitems" Label="Shared" />
 </Project>

Src/PerformanceCollector/Perf.Shared.Tests/QuickPulse/QuickPulseTelemetryModuleTests.cs

@@ -14,6 +14,7 @@
     using Microsoft.ApplicationInsights.Extensibility.PerfCounterCollector.Implementation.QuickPulse;
     using Microsoft.ApplicationInsights.Extensibility.PerfCounterCollector.Implementation.QuickPulse.Helpers;
     using Microsoft.ApplicationInsights.Extensibility.PerfCounterCollector.QuickPulse;
+    using Microsoft.ApplicationInsights.TestFramework;
     using Microsoft.ApplicationInsights.Web.Helpers;
     using Microsoft.VisualStudio.TestTools.UnitTesting;
 
@@ -120,18 +121,114 @@ public void QuickPulseTelemetryModuleInitializesServiceClientFromConfiguration()
         }
 
         [TestMethod]
-        public void QuickPulseTelemetryModuleInitializesServiceClientFromDefault()
+        [TestCategory("QuickPulseEndpoint")]
+        public void QuickPulseTelemetryModuleInitializesServiceClient_FromCode_WithDefaults()
         {
             // ARRANGE
+            var configuration = new TelemetryConfiguration();
+            var expectedEndpoint = QuickPulseDefaults.ServiceEndpoint;
+
             var module = new QuickPulseTelemetryModule(null, null, null, null, null, null);
+            TelemetryModules.Instance.Modules.Add(module);
+            var processor = (IQuickPulseTelemetryProcessor)new QuickPulseTelemetryProcessor(new SimpleTelemetryProcessorSpy());
+            module.Initialize(configuration);
 
-            // ACT
-            // do not provide module configuration, force default service client
-            module.Initialize(new TelemetryConfiguration());
+            // ASSERT
+            Assert.IsInstanceOfType(module.ServiceClient, typeof(QuickPulseServiceClient));
+            Assert.AreEqual(expectedEndpoint, module.ServiceClient.ServiceUri, "module is invalid");
+            Assert.AreEqual(expectedEndpoint, processor.ServiceEndpoint, "processor is invalid");
+        }
+
+        [TestMethod]
+        [TestCategory("QuickPulseEndpoint")]
+        public void QuickPulseTelemetryModuleInitializesServiceClient_FromConfigFile_WithDefaults()
+        {
+            // ARRANGE
+            var configuration = new TelemetryConfiguration();
+            var expectedEndpoint = QuickPulseDefaults.ServiceEndpoint;
+
+            string configFileContents = TelemetryConfigurationFactoryHelper.BuildConfiguration(
+                module: @"<Add Type=""Microsoft.ApplicationInsights.Extensibility.PerfCounterCollector.QuickPulse.QuickPulseTelemetryModule, Microsoft.AI.PerfCounterCollector""/>",
+                processor: @"<Add Type=""Microsoft.ApplicationInsights.Extensibility.PerfCounterCollector.QuickPulse.QuickPulseTelemetryProcessor, Microsoft.AI.PerfCounterCollector""/>"
+                );
+            TelemetryConfigurationFactoryHelper.Initialize(configuration, TelemetryModules.Instance, configFileContents);
 
             // ASSERT
+            var module = TelemetryModules.Instance.Modules.OfType<QuickPulseTelemetryModule>().SingleOrDefault();
+            Assert.IsNotNull(module, "module was not initialized");
+
+            var processor = configuration.TelemetryProcessors.OfType<IQuickPulseTelemetryProcessor>().SingleOrDefault();
+            Assert.IsNotNull(processor, "processor was not initialized");
+
+            Assert.IsInstanceOfType(module.ServiceClient, typeof(QuickPulseServiceClient));
+            Assert.AreEqual(expectedEndpoint, module.ServiceClient.ServiceUri, "module is invalid");
+            Assert.AreEqual(expectedEndpoint, processor.ServiceEndpoint, "processor is invalid");
+        }
+
+        [TestMethod]
+        [TestCategory("QuickPulseEndpoint")]
+        public void QuickPulseTelemetryModuleInitializesServiceClient_FromCode_WithCustomEndpoint()
+        {
+            // ARRANGE
+            var configuration = new TelemetryConfiguration();
+            var expectedEndpoint = "https://127.0.0.1/QuickPulseService.svc";
+
+            var module = new QuickPulseTelemetryModule(null, null, null, null, null, null);
+            module.QuickPulseServiceEndpoint = expectedEndpoint;
+            TelemetryModules.Instance.Modules.Add(module);
+            var processor = (IQuickPulseTelemetryProcessor)new QuickPulseTelemetryProcessor(new SimpleTelemetryProcessorSpy());
+            module.Initialize(configuration);
+
+            // ASSERT
+            Assert.IsInstanceOfType(module.ServiceClient, typeof(QuickPulseServiceClient));
+            Assert.AreEqual(expectedEndpoint, module.ServiceClient.ServiceUri.AbsoluteUri, "module is invalid");
+            Assert.AreEqual(expectedEndpoint, processor.ServiceEndpoint.AbsoluteUri, "processor is invalid");
+        }
+
+        [TestMethod]
+        [TestCategory("QuickPulseEndpoint")]
+        public void QuickPulseTelemetryModuleInitializesServiceClient_FromCodeReversed_WithCustomEndpoint()
+        {
+            // ARRANGE
+            var configuration = new TelemetryConfiguration();
+            var expectedEndpoint = "https://127.0.0.1/QuickPulseService.svc";
+
+            var module = new QuickPulseTelemetryModule(null, null, null, null, null, null);
+            module.QuickPulseServiceEndpoint = expectedEndpoint;
+            module.Initialize(configuration);
+            TelemetryModules.Instance.Modules.Add(module);
+            var processor = (IQuickPulseTelemetryProcessor)new QuickPulseTelemetryProcessor(new SimpleTelemetryProcessorSpy());
+
+            // ASSERT
+            Assert.IsInstanceOfType(module.ServiceClient, typeof(QuickPulseServiceClient));
+            Assert.AreEqual(expectedEndpoint, module.ServiceClient.ServiceUri.AbsoluteUri, "module is invalid");
+            Assert.AreEqual(expectedEndpoint, processor.ServiceEndpoint.AbsoluteUri, "processor is invalid");
+        }
+
+        [TestMethod]
+        [TestCategory("QuickPulseEndpoint")]
+        public void QuickPulseTelemetryModuleInitializesServiceClient_FromConfigFile_WithCustomEndpoint()
+        {
+            // ARRANGE
+            var configuration = new TelemetryConfiguration();
+            var expectedEndpoint = "https://127.0.0.1/QuickPulseService.svc";
+
+            string configFileContents = TelemetryConfigurationFactoryHelper.BuildConfiguration(
+                module: @"<Add Type=""Microsoft.ApplicationInsights.Extensibility.PerfCounterCollector.QuickPulse.QuickPulseTelemetryModule, Microsoft.AI.PerfCounterCollector""><QuickPulseServiceEndpoint>https://127.0.0.1/QuickPulseService.svc</QuickPulseServiceEndpoint></Add>",
+                processor: @"<Add Type=""Microsoft.ApplicationInsights.Extensibility.PerfCounterCollector.QuickPulse.QuickPulseTelemetryProcessor, Microsoft.AI.PerfCounterCollector""/>"
+                );
+            TelemetryConfigurationFactoryHelper.Initialize(configuration, TelemetryModules.Instance, configFileContents);
+
+            // ASSERT
+            var module = TelemetryModules.Instance.Modules.OfType<QuickPulseTelemetryModule>().SingleOrDefault();
+            Assert.IsNotNull(module, "module was not initialized");
+
+            var processor = configuration.TelemetryProcessors.OfType<IQuickPulseTelemetryProcessor>().SingleOrDefault();
+            Assert.IsNotNull(processor, "processor was not initialized");
+
             Assert.IsInstanceOfType(module.ServiceClient, typeof(QuickPulseServiceClient));
-            Assert.AreEqual(QuickPulseDefaults.ServiceEndpoint, module.ServiceClient.ServiceUri);
+            Assert.AreEqual(expectedEndpoint, module.ServiceClient.ServiceUri.AbsoluteUri, "module is invalid");
+            Assert.AreEqual(expectedEndpoint, processor.ServiceEndpoint.AbsoluteUri, "processor is invalid");
         }
 
         [TestMethod]

Src/PerformanceCollector/Perf.Shared/IQuickPulseTelemetryProcessor.cs

@@ -9,5 +9,7 @@ internal interface IQuickPulseTelemetryProcessor
         void StartCollection(IQuickPulseDataAccumulatorManager accumulatorManager, Uri serviceEndpoint, TelemetryConfiguration configuration, bool disableFullTelemetryItems = false);
 
         void StopCollection();
+
+        Uri ServiceEndpoint { get; set; }
     }
 }

Src/PerformanceCollector/Perf.Shared/QuickPulseTelemetryModule.cs

@@ -375,6 +375,12 @@ private void InitializeServiceClient(TelemetryConfiguration configuration)
                 isWebApp,
                 processorCount ?? 0);
 
+            // TelemetryConfigurationFactory will initialize Modules after Processors. Need to update the processor with the correct service endpoint.
+            foreach (var processor in this.TelemetryProcessors)
+            {
+                processor.ServiceEndpoint = serviceEndpointUri;
+            }
+
             QuickPulseEventSource.Log.TroubleshootingMessageEvent(
                 string.Format(
                     CultureInfo.InvariantCulture,

Src/PerformanceCollector/Perf.Shared/QuickPulseTelemetryProcessor.cs

@@ -2,11 +2,9 @@
 {
     using System;
     using System.Collections.Generic;
-    using System.Diagnostics.CodeAnalysis;
     using System.Globalization;
     using System.Linq;
     using System.Threading;
-
     using Microsoft.ApplicationInsights.Channel;
     using Microsoft.ApplicationInsights.Common;
     using Microsoft.ApplicationInsights.Common.Internal;
@@ -49,6 +47,18 @@ public class QuickPulseTelemetryProcessor : ITelemetryProcessor, ITelemetryModul
 
         private IQuickPulseDataAccumulatorManager dataAccumulatorManager = null;
 
+        /// <summary>
+        /// Gets or sets an endpoint that is compared against telemetry to remove our requests from customer telemetry.
+        /// </summary>
+        /// <remarks>
+        /// This is set from the QuickPulseTelemetryModule. 
+        /// </remarks>
+        Uri IQuickPulseTelemetryProcessor.ServiceEndpoint
+        {
+            get { return this.serviceEndpoint; }
+            set { this.serviceEndpoint = value; }
+        }
+
         private Uri serviceEndpoint = QuickPulseDefaults.ServiceEndpoint;
 
         private TelemetryConfiguration config = null;
@@ -81,14 +91,9 @@ internal QuickPulseTelemetryProcessor(
             float? maxGlobalTelemetryQuota = null,
             float? initialGlobalTelemetryQuota = null)
         {
-            if (next == null)
-            {
-                throw new ArgumentNullException(nameof(next));
-            }
-
-            this.Register();
+            this.Next = next ?? throw new ArgumentNullException(nameof(next));
 
-            this.Next = next;
+            this.RegisterSelfWithQuickPulseTelemetryModule();
 
             this.globalQuotaTracker = new QuickPulseQuotaTracker(
                 timeProvider,
@@ -118,7 +123,7 @@ The configuration that is being passed into this method is the configuration tha
 
             this.EvaluateDisabledTrackingProperties = configuration.EvaluateExperimentalFeature(ExperimentalConstants.DeferRequestTrackingProperties);
 
-            this.Register();
+            this.RegisterSelfWithQuickPulseTelemetryModule();
         }
 
         void IQuickPulseTelemetryProcessor.StartCollection(
@@ -707,10 +712,15 @@ private void UpdateRequestAggregates(RequestTelemetry requestTelemetry)
             }
         }
 
-        private void Register()
+        private void RegisterSelfWithQuickPulseTelemetryModule()
         {
             var module = TelemetryModules.Instance.Modules.OfType<QuickPulseTelemetryModule>().SingleOrDefault();
-            module?.RegisterTelemetryProcessor(this);
+
+            if (module != null)
+            {
+                module.RegisterTelemetryProcessor(this);
+                this.serviceEndpoint = module.ServiceClient?.ServiceUri ?? QuickPulseDefaults.ServiceEndpoint;
+            }
         }
     }
 }

Src/TestFramework/Shared/TelemetryConfigurationFactoryHelper.cs

@@ -0,0 +1,96 @@
+namespace Microsoft.ApplicationInsights.TestFramework
+{
+    using System;
+    using System.Text;
+
+    using Microsoft.ApplicationInsights.Extensibility;
+    using Microsoft.ApplicationInsights.Extensibility.Implementation;
+
+    public static class TelemetryConfigurationFactoryHelper
+    {
+        /// <summary>
+        /// TelemetryConfigurationFactory is an internal class in the BaseSDK.
+        /// This method using reflection to access the Initialize method.
+        /// This enables E2E testing using a sample config file.
+        /// </summary>
+        public static void Initialize(TelemetryConfiguration configuration, TelemetryModules modules, string serializedConfiguration)
+        {
+            // get the assembly qualified name using known public type:
+            var typeName = typeof(Microsoft.ApplicationInsights.Extensibility.TelemetryConfiguration).AssemblyQualifiedName
+                .Replace(
+                    "Microsoft.ApplicationInsights.Extensibility.TelemetryConfiguration",
+                    "Microsoft.ApplicationInsights.Extensibility.Implementation.TelemetryConfigurationFactory");
+
+            var telemetryConfigurationFactoryT = Type.GetType(typeName);
+            if (telemetryConfigurationFactoryT == null)
+            {
+                throw new ArgumentException($"Microsoft.ApplicationInsights.Extensibility.Implementation.TelemetryConfigurationFactory type not found");
+            }
+
+            var telemetryConfigurationFactoryInstanceProperty = telemetryConfigurationFactoryT.GetProperty("Instance");
+            if (telemetryConfigurationFactoryInstanceProperty == null)
+            {
+                throw new ArgumentException($"Property 'Instance' not found in type {telemetryConfigurationFactoryT.FullName}");
+            }
+
+            var telemetryConfigurationFactoryInstance = telemetryConfigurationFactoryInstanceProperty.GetValue(null);
+            if (telemetryConfigurationFactoryInstance == null)
+            {
+                throw new ArgumentException($"Microsoft.ApplicationInsights.Extensibility.Implementation.TelemetryConfigurationFactory.Instance should not be null");
+            }
+
+            var initTypes = new[]
+                {
+                    typeof(Microsoft.ApplicationInsights.Extensibility.TelemetryConfiguration),
+                    typeof(Microsoft.ApplicationInsights.Extensibility.Implementation.TelemetryModules),
+                    typeof(string)
+                };
+            var initMethod = telemetryConfigurationFactoryInstance.GetType().GetMethod("Initialize", initTypes);
+            if (initMethod == null)
+            {
+                throw new ArgumentException($"Microsoft.ApplicationInsights.Extensibility.TelemetryConfiguration.Initialize method not found");
+            }
+
+            // initialize the AppInsights using config string:
+            _ = initMethod.Invoke(telemetryConfigurationFactoryInstance, new object[] { configuration, modules, serializedConfiguration });
+        }
+
+        /// <summary>
+        /// Build a configuration xml string representing the contents of a config file.
+        /// All parameters are optional, allowing you to configure only what is needed for a specific test.
+        /// </summary>
+        public static string BuildConfiguration(string ikey = null, string connectionString = null, string module = null, string processor = null)
+        {
+            var sb = new StringBuilder();
+            sb.AppendLine(@"<?xml version=""1.0"" encoding=""utf-8"" ?>");
+            sb.AppendLine(@"<ApplicationInsights xmlns=""http://schemas.microsoft.com/ApplicationInsights/2013/Settings"">");
+
+            if (ikey != null)
+            {
+                sb.AppendLine($"<InstrumentationKey>{ikey}</InstrumentationKey>");
+            }
+
+            if (connectionString != null)
+            {
+                sb.AppendLine($"<ConnectionString>{connectionString}</ConnectionString>");
+            }
+
+            if (module != null)
+            {
+                sb.AppendLine("<TelemetryModules>");
+                sb.AppendLine(module);
+                sb.AppendLine("</TelemetryModules>");
+            }
+
+            if (processor != null)
+            {
+                sb.AppendLine("<TelemetryProcessors>");
+                sb.AppendLine(processor);
+                sb.AppendLine("</TelemetryProcessors>");
+            }
+
+            sb.AppendLine("</ApplicationInsights>");
+            return sb.ToString();
+        }
+    }
+}

Src/TestFramework/Shared/TestFramework.Shared.projitems

@@ -19,6 +19,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)StubStream.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)StubTelemetryInitializer.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)TaskExceptionObserver.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)TelemetryConfigurationFactoryHelper.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)TestEventListener.cs" />
   </ItemGroup>
   <ItemGroup Condition=" '$(TargetFramework)' != 'netcoreapp1.0' ">