public void MetricThreePropsCompare() { var channel = new StubTelemetryChannel(); var client = GetTestTelemetryClient(channel); bool stopSending = false; var delayTask = Task.Delay(10000).ContinueWith((t) => { stopSending = true; }); while (!stopSending) { double val = new Random().NextDouble() * 100; string city = val > 50 ? "Seattle" : "New York"; string currency = ((int)val % 2) == 0 ? "Dollar" : "Pound"; string animal = ((int)val % 2) == 0 ? "Bear" : "Drop Bear"; client.TrackMetric("simple", val); client.TrackAggregateMetric("agg", val, city, currency, animal); Thread.Sleep((int)val); } delayTask.Wait(); Task.Delay(6000).Wait(); channel.AssertSingleAndAggMetricsAreEqual(); }
public void TrackUsesInstrumentationKeyFromEnvironmentIfEmptyInCode() { PlatformSingleton.Current = new StubPlatform(); ITelemetry sentTelemetry = null; var channel = new StubTelemetryChannel { OnSend = telemetry => sentTelemetry = telemetry }; var configuration = new TelemetryConfiguration { TelemetryChannel = channel }; var client = new TelemetryClient(configuration); string expectedKey = Guid.NewGuid().ToString(); configuration.InstrumentationKey = Guid.NewGuid().ToString(); // Set in config Environment.SetEnvironmentVariable("APPINSIGHTS_INSTRUMENTATIONKEY", expectedKey); // Set via env. variable Assert.DoesNotThrow(() => client.TrackTrace("Test Message")); Assert.Equal(expectedKey, sentTelemetry.Context.InstrumentationKey); Environment.SetEnvironmentVariable("APPINSIGHTS_INSTRUMENTATIONKEY", null); PlatformSingleton.Current = null; }
public void TrackUsesInstrumentationKeyFromClientContextIfSetInCodeFirst() { ClearActiveTelemetryConfiguration(); PlatformSingleton.Current = new StubPlatform(); string message = "Test Message"; ITelemetry sentTelemetry = null; var channel = new StubTelemetryChannel { OnSend = telemetry => sentTelemetry = telemetry }; var configuration = new TelemetryConfiguration(string.Empty, channel); var client = new TelemetryClient(configuration); string environmentKey = Guid.NewGuid().ToString(); string expectedKey = Guid.NewGuid().ToString(); Environment.SetEnvironmentVariable("APPINSIGHTS_INSTRUMENTATIONKEY", environmentKey); // Set via the environment variable. client.Context.InstrumentationKey = expectedKey; Assert.DoesNotThrow(() => client.TrackTrace(message)); Assert.Equal(expectedKey, sentTelemetry.Context.InstrumentationKey); Environment.SetEnvironmentVariable("APPINSIGHTS_INSTRUMENTATIONKEY", null); PlatformSingleton.Current = null; }
public void ModuleKeepsIntervalSteadyWhenMetricsAreLongToCollect() { var sentItems = new List <ITelemetry>(); var channel = new StubTelemetryChannel() { OnSend = (item) => { sentItems.Add(item); } }; var config = new TelemetryConfiguration(); config.TelemetryChannel = channel; config.InstrumentationKey = "dummy"; var startTime = DateTimeOffset.Now; AggregateMetricsTelemetryModule module = new AggregateMetricsTelemetryModule(); module.FlushInterval = TimeSpan.FromSeconds(6); module.Initialize(config); var client = new TelemetryClient(config); client.Gauge("test", () => { Thread.Sleep(TimeSpan.FromSeconds(1)); return(10); }); Thread.Sleep(TimeSpan.FromSeconds(15)); Assert.AreEqual(2, sentItems.Count); var metric0 = (MetricTelemetry)sentItems[0]; var metric1 = (MetricTelemetry)sentItems[1]; var timeDelta = metric1.Timestamp - metric0.Timestamp - TimeSpan.FromSeconds(6); Assert.IsTrue(timeDelta.TotalMilliseconds < 50, "Actual: " + timeDelta); }
public void SinkProcessorsAreInvoked() { var configuration = new TelemetryConfiguration(); var sentTelemetry = new List <ITelemetry>(1); var channel = new StubTelemetryChannel(); channel.OnSend = (telemetry) => sentTelemetry.Add(telemetry); configuration.TelemetryChannel = channel; var chainBuilder = new TelemetryProcessorChainBuilder(configuration, configuration.DefaultTelemetrySink); configuration.DefaultTelemetrySink.TelemetryProcessorChainBuilder = chainBuilder; chainBuilder.Use((next) => { var first = new StubTelemetryProcessor(next); first.OnProcess = (telemetry) => telemetry.Context.Properties.Add("SeenByFirst", "true"); return(first); }); chainBuilder.Use((next) => { var second = new StubTelemetryProcessor(next); second.OnProcess = (telemetry) => telemetry.Context.Properties.Add("SeenBySecond", "true"); return(second); }); var client = new TelemetryClient(configuration); client.TrackTrace("t1"); Assert.IsFalse(configuration.TelemetryProcessors.OfType <StubTelemetryProcessor>().Any()); // Both processors belong to the sink, not to the common chain. Assert.AreEqual(1, sentTelemetry.Count); Assert.IsTrue(sentTelemetry[0].Context.Properties.ContainsKey("SeenByFirst")); Assert.IsTrue(sentTelemetry[0].Context.Properties.ContainsKey("SeenBySecond")); }
public static ITelimena GetCrackedTelimena(ICollection <ITelemetry> sentTelemetry, Guid telemetryKey, string userName, bool excludeStartingEvent = false) { var startupInfo = new TelimenaStartupInfo(telemetryKey, Helpers.TeliUri) { UserInfo = new TelimenaClient.Model.UserInfo() { UserIdentifier = userName } }; var telimena = TelimenaFactory.Construct(startupInfo); StubTelemetryChannel channel = new StubTelemetryChannel { OnSend = t => { EventTelemetry ev = t as EventTelemetry; if (excludeStartingEvent && ev?.Name == "TelimenaSessionStarted") { return; } sentTelemetry.Add(t); } }; TelemetryModule module = telimena.GetFieldValue <TelemetryModule>("telemetryModule"); SetStaticFieldValue(module, "isSessionStartedEventSent", false); TelemetryClient client = module.GetPropertyValue <TelemetryClient>("TelemetryClient"); var config = client.GetPropertyValue <TelemetryConfiguration>("TelemetryConfiguration"); config.SetPropertyValue("TelemetryChannel", channel); return(telimena); }
public void CommonTelemetryProcessorsAreInvoked() { var configuration = new TelemetryConfiguration(); var sentTelemetry = new List <ITelemetry>(1); var channel = new StubTelemetryChannel(); channel.OnSend = (telemetry) => sentTelemetry.Add(telemetry); configuration.TelemetryChannel = channel; var chainBuilder = new TelemetryProcessorChainBuilder(configuration); configuration.TelemetryProcessorChainBuilder = chainBuilder; chainBuilder.Use((next) => { var first = new StubTelemetryProcessor(next); first.OnProcess = (telemetry) => telemetry.Context.Properties.Add("SeenByFirst", "true"); return(first); }); chainBuilder.Use((next) => { var second = new StubTelemetryProcessor(next); second.OnProcess = (telemetry) => telemetry.Context.Properties.Add("SeenBySecond", "true"); return(second); }); var client = new TelemetryClient(configuration); client.TrackTrace("t1"); Assert.AreEqual(1, sentTelemetry.Count); Assert.IsTrue(sentTelemetry[0].Context.Properties.ContainsKey("SeenByFirst")); Assert.IsTrue(sentTelemetry[0].Context.Properties.ContainsKey("SeenBySecond")); }
public void TrackWritesTelemetryToDebugOutputIfIKeyEmpty() { ClearActiveTelemetryConfiguration(); string actualMessage = null; var debugOutput = new StubDebugOutput { OnWriteLine = message => { System.Diagnostics.Debug.WriteLine("1"); actualMessage = message; }, OnIsAttached = () => true, }; PlatformSingleton.Current = new StubPlatform { OnGetDebugOutput = () => debugOutput }; var channel = new StubTelemetryChannel { DeveloperMode = true }; var configuration = new TelemetryConfiguration(string.Empty, channel); var client = new TelemetryClient(configuration); client.Track(new StubTelemetry()); Assert.True(actualMessage.StartsWith("Application Insights Telemetry (unconfigured): ")); PlatformSingleton.Current = null; }
private TelemetryConfiguration CreateDefaultConfig(HttpContext fakeContext, string rootIdHeaderName = null, string parentIdHeaderName = null, string instrumentationKey = null) { var telemetryChannel = new StubTelemetryChannel() { EndpointAddress = "https://endpointaddress", OnSend = item => this.sentTelemetry.Enqueue(item) }; var configuration = new TelemetryConfiguration { TelemetryChannel = telemetryChannel, InstrumentationKey = TestInstrumentationKey1, ApplicationIdProvider = new MockApplicationIdProvider(TestInstrumentationKey1, TestApplicationId1) }; configuration.TelemetryInitializers.Add(new Extensibility.OperationCorrelationTelemetryInitializer()); var telemetryInitializer = new TestableOperationCorrelationTelemetryInitializer(fakeContext); if (rootIdHeaderName != null) { telemetryInitializer.RootOperationIdHeaderName = rootIdHeaderName; } if (parentIdHeaderName != null) { telemetryInitializer.ParentOperationIdHeaderName = parentIdHeaderName; } configuration.TelemetryInitializers.Add(telemetryInitializer); return(configuration); }
public void Initialize() { this.sentTelemetry = new List <DependencyTelemetry>(); this.channel = new StubTelemetryChannel { OnSend = telemetry => { // The correlation id lookup service also makes http call, just make sure we skip that DependencyTelemetry depTelemetry = telemetry as DependencyTelemetry; if (depTelemetry != null) { this.sentTelemetry.Add(depTelemetry); } }, EndpointAddress = FakeProfileApiEndpoint }; this.config = new TelemetryConfiguration { InstrumentationKey = IKey, TelemetryChannel = this.channel }; this.config.TelemetryInitializers.Add(new OperationCorrelationTelemetryInitializer()); }
public void SimpleTrackMetricCompare() { var channel = new StubTelemetryChannel(); var client = GetTestTelemetryClient(channel); bool stopSending = false; var delayTask = Task.Delay(10000).ContinueWith((t) => { stopSending = true; }); while (!stopSending) { double val = new Random().NextDouble() * 100; client.TrackMetric("simple", val); client.TrackAggregateMetric("agg", val); Thread.Sleep((int)val); } delayTask.Wait(); Task.Delay(6000).Wait(); channel.AssertSingleAndAggMetricsAreEqual(); }
public void SimpleModuleUsage() { var sentItems = new List <ITelemetry>(); var channel = new StubTelemetryChannel() { OnSend = (item) => { sentItems.Add(item); } }; var config = new TelemetryConfiguration(); config.TelemetryChannel = channel; config.InstrumentationKey = "dummy"; AggregateMetricsTelemetryModule module = new AggregateMetricsTelemetryModule(); module.FlushInterval = TimeSpan.FromSeconds(6); module.Initialize(config); var client = new TelemetryClient(config); client.Gauge("test", () => { return(10); }); Thread.Sleep(TimeSpan.FromSeconds(7)); Assert.AreEqual(1, sentItems.Count); var metric = (MetricTelemetry)sentItems[0]; Assert.AreEqual("test", metric.Name); Assert.AreEqual(10, metric.Value); }
public void TrackRespectsInstrumentaitonKeySetByTelemetryInitializer() { var sentTelemetry = new List <ITelemetry>(); var channel = new StubTelemetryChannel { OnSend = t => sentTelemetry.Add(t) }; // No instrumentation key set here. var configuration = new TelemetryConfiguration(string.Empty, channel); var initializedTelemetry = new List <ITelemetry>(); var telemetryInitializer = new StubTelemetryInitializer(); telemetryInitializer.OnInitialize = item => { item.Context.InstrumentationKey = "Foo"; initializedTelemetry.Add(item); }; configuration.TelemetryInitializers.Add(telemetryInitializer); var client = new TelemetryClient(configuration); var telemetry = new StubTelemetry(); client.Track(telemetry); Assert.Equal(1, sentTelemetry.Count); Assert.Equal(1, initializedTelemetry.Count); }
internal static TelemetryConfiguration CreateTelemetryConfigWithExtractor(IList <ITelemetry> telemetrySentToChannel, Func <ITelemetryProcessor, AutocollectedMetricsExtractor> extractorFactory) { ITelemetryChannel channel = new StubTelemetryChannel { OnSend = (t) => telemetrySentToChannel.Add(t) }; string iKey = Guid.NewGuid().ToString("D"); TelemetryConfiguration telemetryConfig = new TelemetryConfiguration(iKey, channel); var channelBuilder = new TelemetryProcessorChainBuilder(telemetryConfig); channelBuilder.Use(extractorFactory); channelBuilder.Build(); TelemetryProcessorChain processors = telemetryConfig.TelemetryProcessorChain; foreach (ITelemetryProcessor processor in processors.TelemetryProcessors) { ITelemetryModule m = processor as ITelemetryModule; if (m != null) { m.Initialize(telemetryConfig); } } return(telemetryConfig); }
public void ReplacingTelemetryChannelOnConfiguraitonReplacesItForDefaultSink() { var configuration = new TelemetryConfiguration(); var firstSentTelemetry = new List <ITelemetry>(1); var firstChannel = new StubTelemetryChannel(); firstChannel.OnSend = (telemetry) => firstSentTelemetry.Add(telemetry); configuration.TelemetryChannel = firstChannel; var client = new TelemetryClient(configuration); client.TrackTrace("t1"); Assert.AreEqual(1, firstSentTelemetry.Count); var secondSentTelemetry = new List <ITelemetry>(1); var secondChannel = new StubTelemetryChannel(); secondChannel.OnSend = (telemetry) => secondSentTelemetry.Add(telemetry); configuration.TelemetryChannel = secondChannel; client.TrackTrace("t1"); Assert.AreEqual(1, firstSentTelemetry.Count); Assert.AreEqual(1, secondSentTelemetry.Count); }
public void MetricTwoPropsCompare() { var channel = new StubTelemetryChannel(); var client = GetTestTelemetryClient(channel); bool stopSending = false; var delayTask = Task.Delay(10000).ContinueWith((t) => { stopSending = true; }); while (!stopSending) { double val = new Random().NextDouble() * 100; string city = val > 50 ? "Seattle" : "New York"; string currency = ((int)val % 2) == 0 ? "Dollar" : "Pound"; client.TrackMetric("simple", val); client.TrackAggregateMetric("agg", val, city, currency); Thread.Sleep((int)val); } delayTask.Wait(); Task.Delay(6000).Wait(); channel.AssertSingleAndAggMetricsAreEqual(); }
public void TrackWritesTelemetryToDebugOutputIfIKeyNotEmpty() { string actualMessage = null; var debugOutput = new StubDebugOutput { OnWriteLine = message => actualMessage = message, OnIsAttached = () => true, }; PlatformSingleton.Current = new StubPlatform { OnGetDebugOutput = () => debugOutput }; var channel = new StubTelemetryChannel { DeveloperMode = true }; var configuration = new TelemetryConfiguration { TelemetryChannel = channel, InstrumentationKey = "123" }; var client = new TelemetryClient(configuration); client.Track(new StubTelemetry()); Assert.True(actualMessage.StartsWith("Application Insights Telemetry: ")); PlatformSingleton.Current = null; }
public SessionTelemetryModuleTest() { this.platform = new StubPlatform { OnGetApplicationSettings = () => this.settings }; this.channel = new StubTelemetryChannel { OnSend = t => this.sentTelemetry.Add(t) }; this.configuration = new TelemetryConfiguration { TelemetryChannel = this.channel, InstrumentationKey = "Test Key" }; ServiceLocator.AddService<IApplicationService>(new ApplicationService()); TelemetryConfiguration.Active = configuration; HockeyClient.Current.AsInternal().IsTelemetryInitialized = true; }
public void TrackMethodDoesNotThrowWhenInstrumentationKeyIsEmptyAndNotSendingTheTelemetryItem() { var channel = new StubTelemetryChannel { ThrowError = true }; TelemetryConfiguration.Active = new TelemetryConfiguration(string.Empty, channel); Assert.DoesNotThrow(() => new TelemetryClient().Track(new StubTelemetry())); }
public async Task TestDependencyCollectionWithParentActivity() { ITelemetry sentTelemetry = null; var channel = new StubTelemetryChannel { OnSend = telemetry => { // The correlation id lookup service also makes http call, just make sure we skip that DependencyTelemetry depTelemetry = telemetry as DependencyTelemetry; if (depTelemetry != null && !depTelemetry.Data.StartsWith(FakeProfileApiEndpoint, StringComparison.OrdinalIgnoreCase)) { Assert.IsNull(sentTelemetry); sentTelemetry = telemetry; } }, EndpointAddress = FakeProfileApiEndpoint }; var config = new TelemetryConfiguration { InstrumentationKey = IKey, TelemetryChannel = channel }; config.TelemetryInitializers.Add(new OperationCorrelationTelemetryInitializer()); using (var module = new DependencyTrackingTelemetryModule()) { module.ProfileQueryEndpoint = FakeProfileApiEndpoint; module.Initialize(config); var parent = new Activity("parent").AddBaggage("k", "v").SetParentId("|guid.").Start(); var url = new Uri("http://bing.com"); var request = new HttpRequestMessage(HttpMethod.Get, url); await new HttpClient().SendAsync(request); // on netcoreapp1.0 DiagnosticSource event is fired asycronously, let's wait for it Assert.IsTrue(SpinWait.SpinUntil(() => sentTelemetry != null, TimeSpan.FromSeconds(1))); parent.Stop(); var item = (DependencyTelemetry)sentTelemetry; Assert.AreEqual("200", item.ResultCode); var requestId = item.Id; Assert.AreEqual(requestId, request.Headers.GetValues("Request-Id").Single()); Assert.AreEqual(requestId, request.Headers.GetValues("x-ms-request-id").Single()); Assert.IsTrue(requestId.StartsWith(parent.Id)); Assert.AreNotEqual(parent.Id, requestId); Assert.AreEqual("v", item.Context.Properties["k"]); Assert.AreEqual("k=v", request.Headers.GetValues("Correlation-Context").Single()); } }
public void NewTelemetryConfigurationWithChannelUsesSpecifiedChannel() { StubTelemetryChannel stubChannel = new StubTelemetryChannel(); TelemetryConfiguration config = new TelemetryConfiguration(string.Empty, stubChannel); Assert.Same(stubChannel, config.TelemetryChannel); FieldInfo shouldDisposeChannelField = typeof(TelemetryConfiguration).GetField("shouldDisposeChannel", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.GetField); Assert.False((bool)shouldDisposeChannelField.GetValue(config)); }
public void TelemetryChannelCanBeSetByUserToReplaceDefaultChannelForTesting() { var configuration = new TelemetryConfiguration(); var customChannel = new StubTelemetryChannel(); configuration.TelemetryChannel = customChannel; Assert.AreSame(customChannel, configuration.TelemetryChannel); }
private TelemetryClient InitializeTelemetryClient(ICollection <ITelemetry> sentTelemetry) { var channel = new StubTelemetryChannel { OnSend = t => sentTelemetry.Add(t) }; var telemetryConfiguration = new TelemetryConfiguration(Guid.NewGuid().ToString(), channel); var client = new TelemetryClient(telemetryConfiguration); return(client); }
public void ModuleWillKeepIntervalWithThreadsStarvation() { var sentItems = new List <ITelemetry>(); var channel = new StubTelemetryChannel() { OnSend = (item) => { sentItems.Add(item); } }; var config = new TelemetryConfiguration(); config.TelemetryChannel = channel; config.InstrumentationKey = "dummy"; AggregateMetricsTelemetryModule module = new AggregateMetricsTelemetryModule(); module.FlushInterval = TimeSpan.FromSeconds(6); module.Initialize(config); var startTime = DateTime.Now; var client = new TelemetryClient(config); client.Gauge("test", () => { return(10); }); int workerThread; int ioCompletionThread; ThreadPool.GetMaxThreads(out workerThread, out ioCompletionThread); try { ThreadPool.SetMaxThreads(10, 10); for (int i = 0; i < 50; i++) { new Task(() => { Debug.WriteLine("task started"); Thread.Sleep(TimeSpan.FromSeconds(10)); Debug.WriteLine("task finihed"); }).Start(); } Thread.Sleep(TimeSpan.FromSeconds(7)); Assert.AreEqual(1, sentItems.Count); var metric = (MetricTelemetry)sentItems[0]; Assert.AreEqual("test", metric.Name); Assert.AreEqual(10, metric.Value); Assert.IsTrue(metric.Timestamp.Subtract(startTime).Seconds <= 6, "Actual: " + metric.Timestamp.Subtract(startTime).Seconds); Assert.IsTrue(metric.Timestamp.Subtract(startTime).Seconds >= 5, "Actual: " + metric.Timestamp.Subtract(startTime).Seconds); } finally { ThreadPool.SetMaxThreads(workerThread, ioCompletionThread); } }
private static void Metrics_SpecifiedPipeline(TelemetryConfiguration telemetryPipeline) { telemetryPipeline.InstrumentationKey = Guid.NewGuid().ToString("D"); MetricManager manager1 = telemetryPipeline.GetMetricManager(); Assert.IsNotNull(manager1); MetricManager manager2 = telemetryPipeline.GetMetricManager(); Assert.IsNotNull(manager2); Assert.AreEqual(manager1, manager2); Assert.AreSame(manager1, manager2); Assert.IsTrue(Object.ReferenceEquals(manager1, manager2)); StubTelemetryChannel telemetryCollector = new StubTelemetryChannel(); telemetryPipeline.TelemetryChannel = telemetryCollector; Assert.AreSame(telemetryCollector, telemetryPipeline.TelemetryChannel); //CollectingTelemetryInitializer telemetryCollector = new CollectingTelemetryInitializer(); //defaultTelemetryPipeline.TelemetryInitializers.Add(coll); IMetricSeriesConfiguration seriesConfig = new MetricSeriesConfigurationForMeasurement(restrictToUInt32Values: false); manager1.CreateNewSeries("ns", "Metric A", seriesConfig).TrackValue(42); manager1.CreateNewSeries("ns", "Metric A", seriesConfig).TrackValue("18"); manager2.CreateNewSeries("ns", "Metric A", seriesConfig).TrackValue(10000); manager2.CreateNewSeries("ns", "Metric B", seriesConfig).TrackValue(-0.001); manager1.Flush(); Assert.AreEqual(4, telemetryCollector.TelemetryItems.Count); Assert.IsInstanceOfType(telemetryCollector.TelemetryItems[0], typeof(MetricTelemetry)); Assert.AreEqual("Metric B", ((MetricTelemetry)telemetryCollector.TelemetryItems[0]).Name); Assert.AreEqual(1, ((MetricTelemetry)telemetryCollector.TelemetryItems[0]).Count); Assert.AreEqual(-0.001, ((MetricTelemetry)telemetryCollector.TelemetryItems[0]).Sum); Assert.IsInstanceOfType(telemetryCollector.TelemetryItems[1], typeof(MetricTelemetry)); Assert.AreEqual("Metric A", ((MetricTelemetry)telemetryCollector.TelemetryItems[1]).Name); Assert.AreEqual(1, ((MetricTelemetry)telemetryCollector.TelemetryItems[1]).Count); Assert.AreEqual(10000, ((MetricTelemetry)telemetryCollector.TelemetryItems[1]).Sum); Assert.IsInstanceOfType(telemetryCollector.TelemetryItems[2], typeof(MetricTelemetry)); Assert.AreEqual("Metric A", ((MetricTelemetry)telemetryCollector.TelemetryItems[2]).Name); Assert.AreEqual(1, ((MetricTelemetry)telemetryCollector.TelemetryItems[2]).Count); Assert.AreEqual(18, ((MetricTelemetry)telemetryCollector.TelemetryItems[2]).Sum); Assert.IsInstanceOfType(telemetryCollector.TelemetryItems[3], typeof(MetricTelemetry)); Assert.AreEqual("Metric A", ((MetricTelemetry)telemetryCollector.TelemetryItems[3]).Name); Assert.AreEqual(1, ((MetricTelemetry)telemetryCollector.TelemetryItems[3]).Count); Assert.AreEqual(42, ((MetricTelemetry)telemetryCollector.TelemetryItems[3]).Sum); }
public void NewTelemetryConfigurationWithInstrumentationKeyAndChannelUsesSpecifiedKeyAndChannel() { string expectedKey = "expected"; StubTelemetryChannel stubChannel = new StubTelemetryChannel(); TelemetryConfiguration config = new TelemetryConfiguration(expectedKey, stubChannel); Assert.Equal(expectedKey, config.InstrumentationKey); Assert.Same(stubChannel, config.TelemetryChannel); FieldInfo shouldDisposeChannelField = typeof(TelemetryConfiguration).GetField("shouldDisposeChannel", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.GetField); Assert.False((bool)shouldDisposeChannelField.GetValue(config)); }
public void NewTelemetryConfigurationWithChannelUsesSpecifiedChannel() { StubTelemetryChannel stubChannel = new StubTelemetryChannel(); bool channelDisposed = false; stubChannel.OnDispose += () => { channelDisposed = true; }; TelemetryConfiguration config = new TelemetryConfiguration(string.Empty, stubChannel); Assert.AreSame(stubChannel, config.TelemetryChannel); config.Dispose(); Assert.IsFalse(channelDisposed); }
public void TrackDoesNotTryAddingDeveloperModeCustomPropertyWhenTelemetryDoesNotSupportCustomProperties() { var channel = new StubTelemetryChannel { DeveloperMode = true }; var configuration = new TelemetryConfiguration { TelemetryChannel = channel, InstrumentationKey = "Test Key" }; var client = new TelemetryClient(configuration); Assert.DoesNotThrow(() => client.Track(new SessionStateTelemetry())); }
public void TrackDoesNotTryAddingDeveloperModeCustomPropertyWhenTelemetryDoesNotSupportCustomProperties() { var channel = new StubTelemetryChannel { DeveloperMode = true }; var configuration = new TelemetryConfiguration("Test Key", channel); var client = new TelemetryClient(configuration); #pragma warning disable 618 Assert.DoesNotThrow(() => client.Track(new SessionStateTelemetry())); #pragma warning disable 618 }
private TelemetryClient InitializeTelemetryClient(List <ITelemetry> sentTelemetry) { var channel = new StubTelemetryChannel { OnSend = t => sentTelemetry.Add(t) }; var telemetryConfiguration = new TelemetryConfiguration { InstrumentationKey = Guid.NewGuid().ToString(), TelemetryChannel = channel }; var client = new TelemetryClient(telemetryConfiguration); return(client); }
public void TestInit() { this.sendItems = new List <ITelemetry>(); var stubTelemetryChannel = new StubTelemetryChannel { OnSend = item => this.sendItems.Add(item) }; this.configuration = new TelemetryConfiguration { InstrumentationKey = Guid.NewGuid().ToString(), TelemetryChannel = stubTelemetryChannel }; }
public void CommonTelemetryChannelIsDefaultSinkTelemetryChannel() { var configuration = new TelemetryConfiguration(); var c1 = new StubTelemetryChannel(); var c2 = new StubTelemetryChannel(); configuration.TelemetryChannel = c1; Assert.AreSame(c1, configuration.TelemetryChannel); configuration.DefaultTelemetrySink.TelemetryChannel = c2; Assert.AreSame(c2, configuration.TelemetryChannel); }
public void TestInitialize() { this.items = new List<ITelemetry>(); this.moduleChannel = new StubTelemetryChannel { OnSend = telemetry => this.items.Add(telemetry) }; TelemetryConfiguration.Active.TelemetryChannel = new StubTelemetryChannel { EndpointAddress = "http://test.com" }; TelemetryConfiguration.Active.InstrumentationKey = "MyKey"; TelemetryConfiguration.Active.TelemetryInitializers.Clear(); }
public void TestInitialize() { this.items = new List<ITelemetry>(); var moduleChannel = new StubTelemetryChannel { OnSend = telemetry => this.items.Add(telemetry), EndpointAddress = "http://test.com" }; this.moduleConfiguration = new TelemetryConfiguration { TelemetryChannel = moduleChannel, InstrumentationKey = "MyKey", }; }
public void TelemetryChannelCanBeSetByUserToReplaceDefaultChannelForTesting() { var configuration = new TelemetryConfiguration(); var customChannel = new StubTelemetryChannel(); configuration.TelemetryChannel = customChannel; Assert.Same(customChannel, configuration.TelemetryChannel); }
public void TestCleanup() { this.moduleChannel = null; this.items.Clear(); }
public void OnEndTracksRequest() { var sendItems = new List<ITelemetry>(); var stubTelemetryChannel = new StubTelemetryChannel { OnSend = item => sendItems.Add(item) }; var configuration = new TelemetryConfiguration { InstrumentationKey = Guid.NewGuid().ToString(), TelemetryChannel = stubTelemetryChannel }; var module = new RequestTrackingTelemetryModule(); module.Initialize(configuration); module.OnBeginRequest(null); module.OnEndRequest(null); Assert.Equal(1, sendItems.Count); }