/// <summary>
/// Initializes a new instance of the <see cref="ProfilerSqlProcessing"/> class.
/// </summary>
internal ProfilerSqlProcessing(TelemetryConfiguration configuration, string agentVersion, ObjectInstanceBasedOperationHolder telemetryTupleHolder)
{
if (configuration == null)
{
throw new ArgumentNullException("configuration");
}
if (telemetryTupleHolder == null)
{
throw new ArgumentNullException("telemetryHolder");
}
this.TelemetryTable = telemetryTupleHolder;
this.telemetryClient = new TelemetryClient(configuration);
// Since dependencySource is no longer set, sdk version is prepended with information which can identify whether RDD was collected by profiler/framework
// For directly using TrackDependency(), version will be simply what is set by core
string prefix = "rdd" + RddSource.Profiler + ":";
this.telemetryClient.Context.GetInternalContext().SdkVersion = SdkVersionUtils.GetSdkVersion(prefix);
if (!string.IsNullOrEmpty(agentVersion))
{
this.telemetryClient.Context.GetInternalContext().AgentVersion = agentVersion;
}
}
public static TelemetryClient Get()
{
lock (_instanceLock)
{
if (_activeConfig == null)
{
TelemetryConfiguration config = TelemetryConfiguration.Active;
config.InstrumentationKey = "1b3b7cd2-f058-4eb3-b153-a4425e95e20e";
#if DEBUG
config.TelemetryChannel.DeveloperMode = true;
#endif
config.ContextInitializers.Add(new ComponentContextInitializer());
config.ContextInitializers.Add(new DeviceContextInitializer());
config.ContextInitializers.Add(new UserSessionInitializer());
_activeConfig = config;
}
if (_instance == null)
{
var ret = new TelemetryClient(_activeConfig);
PopulateContext(ret);
_instance = ret;
}
return _instance;
}
}
public void IsEnabledReturnsTrueIfTelemetryTrackingIsEnabledInConfiguration()
{
var configuration = new TelemetryConfiguration { DisableTelemetry = false };
var client = new TelemetryClient(configuration);
Assert.True(client.IsEnabled());
}
public void simpleTelemetry()
{
Microsoft.ApplicationInsights.Extensibility.TelemetryConfiguration configuration = Microsoft.ApplicationInsights.Extensibility.TelemetryConfiguration.CreateDefault();
var telemetryClient = new TelemetryClient(configuration);
telemetryClient.TrackTrace("CashIn - Error");
}
/// <summary>
/// Initializes a new instance of the <see cref="ProfilerHttpProcessing"/> class.
/// </summary>
public ProfilerHttpProcessing(TelemetryConfiguration configuration, string agentVersion, ObjectInstanceBasedOperationHolder telemetryTupleHolder, bool setCorrelationHeaders, ICollection<string> correlationDomainExclusionList)
{
if (configuration == null)
{
throw new ArgumentNullException("configuration");
}
if (telemetryTupleHolder == null)
{
throw new ArgumentNullException("telemetryTupleHolder");
}
if (correlationDomainExclusionList == null)
{
throw new ArgumentNullException("correlationDomainExclusionList");
}
this.applicationInsightsUrlFilter = new ApplicationInsightsUrlFilter(configuration);
this.TelemetryTable = telemetryTupleHolder;
this.telemetryClient = new TelemetryClient(configuration);
this.correlationDomainExclusionList = correlationDomainExclusionList;
this.setCorrelationHeaders = setCorrelationHeaders;
// Since dependencySource is no longer set, sdk version is prepended with information which can identify whether RDD was collected by profiler/framework
// For directly using TrackDependency(), version will be simply what is set by core
string prefix = "rdd" + RddSource.Profiler + ":";
this.telemetryClient.Context.GetInternalContext().SdkVersion = SdkVersionUtils.GetSdkVersion(prefix);
if (!string.IsNullOrEmpty(agentVersion))
{
this.telemetryClient.Context.GetInternalContext().AgentVersion = agentVersion;
}
}
public static void SnippetWillIncludeInstrumentationKeyAsSubstring()
{
string unittestkey = "unittestkey";
var telemetryConfiguration = new TelemetryConfiguration { InstrumentationKey = unittestkey };
var snippet = new JavaScriptSnippet(telemetryConfiguration);
Assert.Contains("'" + unittestkey + "'", snippet.FullScript.ToString());
}
public void TestHttpRequestsWithQueryStringAreCollected()
{
ITelemetry sentTelemetry = null;
var channel = new StubTelemetryChannel { OnSend = telemetry => sentTelemetry = telemetry };
var config = new TelemetryConfiguration
{
InstrumentationKey = IKey,
TelemetryChannel = channel
};
using (var module = new DependencyTrackingTelemetryModule())
{
module.Initialize(config);
const string Url = "http://www.bing.com/search?q=1";
new HttpWebRequestUtils().ExecuteAsyncHttpRequest(Url, HttpMethod.Get);
while (sentTelemetry == null)
{
Thread.Sleep(100);
}
Assert.IsNotNull(sentTelemetry, "Get requests are not monitored with RDD Event Source.");
var item = (DependencyTelemetry)sentTelemetry;
Assert.AreEqual(Url, item.Name, "Reported Url must be " + Url);
Assert.IsTrue(item.Duration > TimeSpan.FromMilliseconds(0), "Duration has to be positive");
Assert.AreEqual("Http", item.DependencyKind, "HttpAny has to be dependency kind as it includes http and azure calls");
Assert.IsTrue(
DateTime.UtcNow.Subtract(item.Timestamp.UtcDateTime).TotalMilliseconds < TimeSpan.FromMinutes(1).TotalMilliseconds, "timestamp < now");
Assert.IsTrue(
item.Timestamp.Subtract(DateTime.UtcNow).TotalMilliseconds > -TimeSpan.FromMinutes(1).TotalMilliseconds, "now - 1 min < timestamp");
}
}
private TelemetryConfiguration CreateStubTelemetryConfiguration()
{
TelemetryConfiguration configuration = new TelemetryConfiguration();
configuration.TelemetryChannel = new StubTelemetryChannel { EndpointAddress = "https://endpointaddress" };
configuration.InstrumentationKey = Guid.NewGuid().ToString();
return configuration;
}
public RequestTrackingMiddleware(OwinMiddleware next, TelemetryConfiguration telemetryConfiguration)
: base(next)
{
_telemetryClient = telemetryConfiguration == null
? new TelemetryClient()
: new TelemetryClient(telemetryConfiguration);
}
/// <summary>
/// Initialize method is called after all configuration properties have been loaded from the configuration.
/// </summary>
public void Initialize(TelemetryConfiguration configuration)
{
// Temporary fix to make sure that we initialize module once.
// It should be removed when configuration reading logic is moved to Web SDK.
if (!this.isInitialized)
{
lock (this.lockObject)
{
if (!this.isInitialized)
{
try
{
this.telemetryConfiguration = configuration;
// Net40 only supports runtime instrumentation
// Net45 supports either but not both to avoid duplication
this.InitializeForRuntimeInstrumentationOrFramework();
}
catch (Exception exc)
{
DependencyCollectorEventSource.Log.RemoteDependencyModuleError(exc.ToInvariantString(), Environment.Version.ToString());
}
this.isInitialized = true;
}
}
}
}
public void InitializingEmptyConfigurationAddsCoreSdkDefaultComponents()
{
var configuration = new TelemetryConfiguration();
TelemetryConfigurationFactory.Instance.Initialize(configuration);
Assert.AreEqual(2, configuration.TelemetryInitializers.Count);
Assert.IsInstanceOfType(configuration.TelemetryChannel, typeof(InMemoryChannel));
}
public WcfInterceptor(TelemetryConfiguration configuration, ContractFilter filter)
{
if ( configuration == null )
throw new ArgumentNullException("configuration");
this.configuration = configuration;
this.contractFilter = filter;
}
/// <summary>
/// Gives the opportunity for this telemetry module to initialize configuration object that is passed to it.
/// </summary>
/// <param name="configuration">Configuration object.</param>
public void Initialize(TelemetryConfiguration configuration)
{
if (!configuration.TelemetryChannel.DeveloperMode.HasValue && IsDebuggerAttached())
{
// Note that when debugger is not attached we are preserving default null value
configuration.TelemetryChannel.DeveloperMode = true;
}
}
public void TestInitialize()
{
this.configuration = new TelemetryConfiguration();
this.sendItems = new List<ITelemetry>();
this.configuration.TelemetryChannel = new StubTelemetryChannel { OnSend = item => this.sendItems.Add(item) };
this.configuration.InstrumentationKey = Guid.NewGuid().ToString();
this.httpProcessingFramework = new FrameworkHttpProcessing(this.configuration, new CacheBasedOperationHolder());
}
public void TestInitialize()
{
this.configuration = new TelemetryConfiguration();
this.sendItems = new List<ITelemetry>();
this.configuration.TelemetryChannel = new StubTelemetryChannel { OnSend = item => this.sendItems.Add(item) };
this.configuration.InstrumentationKey = Guid.NewGuid().ToString();
this.httpProcessingProfiler = new ProfilerHttpProcessing(this.configuration, null, new ObjectInstanceBasedOperationHolder());
this.ex = new Exception();
}
public void AddConfiguration(string deploymentId, string hostName, string clientId, IPAddress address)
{
//throw new NotImplementedException();
TelemetryConfiguration.Active.ContextInitializers.Add(new AppInInitializer(DeploymentId));
var tc = new TelemetryConfiguration();
Telemetry = new TelemetryClient();
Telemetry.InstrumentationKey = InstrumentationKey;
Initialized = true;
}
public void TestInitialize()
{
var configuration = new TelemetryConfiguration();
this.sendItems = new List<ITelemetry>();
configuration.TelemetryChannel = new StubTelemetryChannel { OnSend = item => this.sendItems.Add(item) };
configuration.InstrumentationKey = Guid.NewGuid().ToString();
this.telemetryClient = new TelemetryClient(configuration);
AsyncLocalHelpers.SaveOperationContext(null);
}
public void TestInitialize()
{
var configuration = new TelemetryConfiguration();
this.sendItems = new List<ITelemetry>();
configuration.TelemetryChannel = new StubTelemetryChannel { OnSend = item => this.sendItems.Add(item) };
configuration.InstrumentationKey = Guid.NewGuid().ToString();
this.telemetryClient = new TelemetryClient(configuration);
CallContext.FreeNamedDataSlot(CallContextHelpers.OperationContextSlotName);
}
private static void CopyConfiguration(TelemetryConfiguration source, TelemetryConfiguration target)
{
target.InstrumentationKey = source.InstrumentationKey;
foreach (var telemetryInitializer in source.TelemetryInitializers)
{
target.TelemetryInitializers.Add(telemetryInitializer);
}
}
public void TestInitialize()
{
var configuration = new TelemetryConfiguration();
this.sendItems = new List<ITelemetry>();
configuration.TelemetryChannel = new StubTelemetryChannel { OnSend = item => this.sendItems.Add(item) };
configuration.InstrumentationKey = Guid.NewGuid().ToString();
configuration.TelemetryInitializers.Add(new OperationCorrelationTelemetryInitializer());
this.telemetryClient = new TelemetryClient(configuration);
}
/// <summary>
/// Initializes a new instance of the <see cref="TelemetryClient" /> class. Send telemetry with the specified <paramref name="configuration"/>.
/// </summary>
/// <exception cref="ArgumentNullException">The <paramref name="configuration"/> is null.</exception>
public TelemetryClient(TelemetryConfiguration configuration)
{
if (configuration == null)
{
CoreEventSource.Log.TelemetryClientConstructorWithNoTelemetryConfiguration();
configuration = TelemetryConfiguration.Active;
}
this.configuration = configuration;
}
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 static TelemetryClient MockTelemetryClient(Action<ITelemetry> onSendCallback)
{
var telemetryChannel = new FakeTelemetryChannel { OnSend = onSendCallback };
var telemetryConfiguration = new TelemetryConfiguration();
telemetryConfiguration.InstrumentationKey = "REQUIRED";
telemetryConfiguration.TelemetryChannel = telemetryChannel;
return new TelemetryClient(telemetryConfiguration);
}
public void ChannelIsLazilyInitializedFromConfiguration()
{
var configuration = new TelemetryConfiguration();
TelemetryClient client = new TelemetryClient(configuration);
configuration.TelemetryChannel = new StubTelemetryChannel();
ITelemetryChannel clientChannel = client.Channel;
Assert.Same(configuration.TelemetryChannel, clientChannel);
}
public void InitializingTelemetryConfigurationWithoutAnIkey()
{
string profile = Configuration("<InstrumentationKey> </InstrumentationKey>");
PlatformSingleton.Current = new StubPlatform { OnReadConfigurationXml = () => { return profile; } };
var configuration = new TelemetryConfiguration();
TelemetryConfigurationFactory.Instance.Initialize(configuration);
Assert.IsTrue(string.IsNullOrEmpty(configuration.InstrumentationKey));
}
public void ContextIsLazilyInitializedFromConfigurationToDefferCosts()
{
var configuration = new TelemetryConfiguration();
TelemetryClient client = new TelemetryClient(configuration);
configuration.ContextInitializers.Add(new StubContextInitializer { OnInitialize = context => context.User.Id = "Test User Id" });
TelemetryContext clientContext = client.Context;
Assert.Equal("Test User Id", clientContext.User.Id);
}
public static IAppBuilder UseApplicationInsights(this IAppBuilder builder,
OperationIdContextMiddlewareConfiguration middlewareConfiguration = null,
TelemetryConfiguration telemetryConfiguration = null,
Func<IOwinRequest, IOwinResponse, bool> shouldTraceRequest = null)
{
builder.Use<OperationIdContextMiddleware>(middlewareConfiguration);
builder.Use<HttpRequestTrackingMiddleware>(telemetryConfiguration, shouldTraceRequest);
return builder;
}
public void AddConfiguration(string deploymentId, bool isSilo, string siloName, SiloAddress address, IPEndPoint gateway, string hostName)
{
SiloName = siloName;
DeploymentId = deploymentId;
HostName = hostName;
TelemetryConfiguration.Active.ContextInitializers.Add(new AppInInitializer(DeploymentId));
var tc = new TelemetryConfiguration();
Telemetry = new TelemetryClient();
Telemetry.InstrumentationKey = InstrumentationKey;
Initialized = true;
}
/// <summary>
/// Adds a sink that writes log events against Microsoft Application Insights using the provided <paramref name="configuration"/>.
/// </summary>
/// <param name="loggerConfiguration">The logger configuration.</param>
/// <param name="configuration">Required Application Insights configuration settings.</param>
/// <param name="restrictedToMinimumLevel">The minimum log event level required in order to write an event to the sink.</param>
/// <param name="formatProvider">Supplies culture-specific formatting information, or null.</param>
/// <returns>
/// Logger configuration, allowing configuration to continue.
/// </returns>
/// <exception cref="System.ArgumentNullException">
/// loggerConfiguration
/// or
/// configuration
/// </exception>
public static LoggerConfiguration ApplicationInsights(
this LoggerSinkConfiguration loggerConfiguration,
TelemetryConfiguration configuration,
LogEventLevel restrictedToMinimumLevel = LevelAlias.Minimum,
IFormatProvider formatProvider = null)
{
if (loggerConfiguration == null) throw new ArgumentNullException("loggerConfiguration");
if (configuration == null) throw new ArgumentNullException("configuration");
return loggerConfiguration.Sink(new ApplicationInsightsSink(CreateTelemetryClientFromConfiguration(configuration), formatProvider), restrictedToMinimumLevel);
}
public void InitializingTelemetryConfigurationWithAnIkey()
{
string expected = Guid.NewGuid().ToString();
string profile = Configuration("<InstrumentationKey>" + expected + "</InstrumentationKey>");
PlatformSingleton.Current = new StubPlatform { OnReadConfigurationXml = () => { return profile; } };
var configuration = new TelemetryConfiguration();
TelemetryConfigurationFactory.Instance.Initialize(configuration);
Assert.AreEqual(expected.ToString(), configuration.InstrumentationKey);
}
/// <summary>
/// Initializes a new instance of the <see cref="TelemetryClient" /> class. Send telemetry with the specified <paramref name="configuration"/>.
/// </summary>
/// <exception cref="ArgumentNullException">The <paramref name="configuration"/> is null.</exception>
public TelemetryClient(TelemetryConfiguration configuration)
{
if (configuration == null)
{
CoreEventSource.Log.TelemetryClientConstructorWithNoTelemetryConfiguration();
configuration = TelemetryConfiguration.Active;
}
this.configuration = configuration;
this.debugOutput = PlatformSingleton.Current.GetDebugOutput();
}
public void advancedTelemetry()
{
Microsoft.ApplicationInsights.Extensibility.TelemetryConfiguration configuration = Microsoft.ApplicationInsights.Extensibility.TelemetryConfiguration.CreateDefault();
var telemetryClient = new TelemetryClient(configuration);
telemetryClient.TrackTrace("Login - Critical issue",
Microsoft.ApplicationInsights.DataContracts.SeverityLevel.Critical,
new Dictionary <string, string> {
{ "username", "0610691306" },
{ "tier", "TR23435023403408" },
{ "channel", "M" }
});
}
public void TelemetryProcessorsCollectionIsReadOnly()
{
var configuration = new TelemetryConfiguration();
Assert.IsType <ReadOnlyCollection <ITelemetryProcessor> >(configuration.TelemetryProcessors);
}
/// <summary>
/// Returns the TelemetryProcessorChainBuilder which can build and populate TelemetryProcessors in the given config.
/// </summary>
/// <param name="configuration">Telemetry configuration for which the telemetry processor chain is to be setup.</param>
/// <returns>The constructed TelemetryProcessorChainBuilder.</returns>
public static TelemetryProcessorChainBuilder GetTelemetryProcessorChainBuilder(this TelemetryConfiguration configuration)
{
return(new TelemetryProcessorChainBuilder(configuration));
}
public void MetricPrcessorsReturnsThreadSafeList()
{
var configuration = new TelemetryConfiguration();
Assert.Equal(typeof(SnapshottingList <IMetricProcessor>), configuration.MetricProcessors.GetType());
}
public void Request_TelemetryRespectsDimLimitCloudRoleInstance()
{
List <ITelemetry> telemetrySentToChannel = new List <ITelemetry>();
Func <ITelemetryProcessor, AutocollectedMetricsExtractor> extractorFactory =
(nextProc) => {
var metricExtractor = new AutocollectedMetricsExtractor(nextProc);
metricExtractor.MaxRequestCloudRoleInstanceValuesToDiscover = 2;
return(metricExtractor);
};
TelemetryConfiguration telemetryConfig = CreateTelemetryConfigWithExtractor(telemetrySentToChannel, extractorFactory);
using (telemetryConfig)
{
TelemetryClient client = new TelemetryClient(telemetryConfig);
// Track 4 requests with 3 different values for RoleInstance - A B C D.
// As MaxRequestCloudRoleInstanceValuesToDiscover = 2, the first 2 values encountered (A,B)
// will be used as such at which the DimensionCap is hit.
// Newly incoming values (C,D) will be rolled into "DIMENSION-CAPPED"
client.TrackRequest(CreateRequestTelemetry(
TimeSpan.FromMilliseconds(100), "200", true, false, "RoleNameA", "RoleInstanceA"));
client.TrackRequest(CreateRequestTelemetry(
TimeSpan.FromMilliseconds(100), "200", true, false, "RoleNameA", "RoleInstanceB"));
client.TrackRequest(CreateRequestTelemetry(
TimeSpan.FromMilliseconds(100), "200", true, false, "RoleNameA", "RoleInstanceC"));
client.TrackRequest(CreateRequestTelemetry(
TimeSpan.FromMilliseconds(100), "200", true, false, "RoleNameA", "RoleInstanceD"));
}
// 4 requests + 3 metric
Assert.AreEqual(7, telemetrySentToChannel.Count);
AssertEx.IsType <RequestTelemetry>(telemetrySentToChannel[0]);
Assert.AreEqual("Req1", ((RequestTelemetry)telemetrySentToChannel[0]).Name);
Assert.AreEqual(true, ((RequestTelemetry)telemetrySentToChannel[0]).Properties.ContainsKey("_MS.ProcessedByMetricExtractors"));
Assert.AreEqual("(Name:'Requests', Ver:'1.1')",
((RequestTelemetry)telemetrySentToChannel[0]).Properties["_MS.ProcessedByMetricExtractors"]);
AssertEx.IsType <RequestTelemetry>(telemetrySentToChannel[1]);
Assert.AreEqual("Req1", ((RequestTelemetry)telemetrySentToChannel[1]).Name);
Assert.AreEqual(true, ((RequestTelemetry)telemetrySentToChannel[1]).Properties.ContainsKey("_MS.ProcessedByMetricExtractors"));
Assert.AreEqual("(Name:'Requests', Ver:'1.1')",
((RequestTelemetry)telemetrySentToChannel[1]).Properties["_MS.ProcessedByMetricExtractors"]);
AssertEx.IsType <RequestTelemetry>(telemetrySentToChannel[2]);
Assert.AreEqual("Req1", ((RequestTelemetry)telemetrySentToChannel[2]).Name);
Assert.AreEqual(true, ((RequestTelemetry)telemetrySentToChannel[2]).Properties.ContainsKey("_MS.ProcessedByMetricExtractors"));
Assert.AreEqual("(Name:'Requests', Ver:'1.1')",
((RequestTelemetry)telemetrySentToChannel[2]).Properties["_MS.ProcessedByMetricExtractors"]);
AssertEx.IsType <RequestTelemetry>(telemetrySentToChannel[3]);
Assert.AreEqual("Req1", ((RequestTelemetry)telemetrySentToChannel[3]).Name);
Assert.AreEqual(true, ((RequestTelemetry)telemetrySentToChannel[3]).Properties.ContainsKey("_MS.ProcessedByMetricExtractors"));
Assert.AreEqual("(Name:'Requests', Ver:'1.1')",
((RequestTelemetry)telemetrySentToChannel[3]).Properties["_MS.ProcessedByMetricExtractors"]);
for (int i = 4; i < 7; i++)
{
AssertEx.IsType <MetricTelemetry>(telemetrySentToChannel[i]);
var metricTel = telemetrySentToChannel[i] as MetricTelemetry;
// validate standard fields
Assert.IsTrue(metricTel.Properties.ContainsKey("_MS.AggregationIntervalMs"));
Assert.IsTrue(metricTel.Context.GlobalProperties.ContainsKey("_MS.IsAutocollected"));
Assert.AreEqual("True", metricTel.Context.GlobalProperties["_MS.IsAutocollected"]);
Assert.IsTrue(metricTel.Context.GlobalProperties.ContainsKey("_MS.MetricId"));
Assert.AreEqual("requests/duration", metricTel.Context.GlobalProperties["_MS.MetricId"]);
// validate dimensions exist
Assert.AreEqual(true, metricTel.Properties.ContainsKey("Request.Success"));
Assert.AreEqual(true, metricTel.Properties.ContainsKey("cloud/roleInstance"));
Assert.AreEqual(true, metricTel.Properties.ContainsKey("cloud/roleName"));
Assert.AreEqual(true, metricTel.Properties.ContainsKey("request/resultCode"));
Assert.AreEqual(true, metricTel.Properties.ContainsKey("request/performanceBucket"));
Assert.AreEqual(true, metricTel.Properties.ContainsKey("operation/synthetic"));
}
// We expect RoleInstanceA to be tracked correctly
var cloudRoleInstanceA = telemetrySentToChannel.Where(
(tel) => "Server response time".Equals((tel as MetricTelemetry)?.Name) &&
(tel as MetricTelemetry).Properties.Contains(new KeyValuePair <string, string>("cloud/roleInstance", "RoleInstanceA")));
Assert.IsTrue(cloudRoleInstanceA.Count() == 1);
// We expect RoleInstanceB to be tracked correctly
var cloudRoleInstanceB = telemetrySentToChannel.Where(
(tel) => "Server response time".Equals((tel as MetricTelemetry)?.Name) &&
(tel as MetricTelemetry).Properties.Contains(new KeyValuePair <string, string>("cloud/roleInstance", "RoleInstanceB")));
Assert.IsTrue(cloudRoleInstanceB.Count() == 1);
// We expect RoleInstanceC to be not present as a dimension, as dimension cap of 2 is already hit.
var cloudRoleInstanceC = telemetrySentToChannel.Where(
(tel) => "Server response time".Equals((tel as MetricTelemetry)?.Name) &&
(tel as MetricTelemetry).Properties.Contains(new KeyValuePair <string, string>("cloud/roleInstance", "RoleInstanceC")));
Assert.IsTrue(cloudRoleInstanceC.Count() == 0);
// We expect RoleInstanceD to be not present as a dimension, as dimension cap of 2 is already hit.
var cloudRoleInstanceD = telemetrySentToChannel.Where(
(tel) => "Server response time".Equals((tel as MetricTelemetry)?.Name) &&
(tel as MetricTelemetry).Properties.Contains(new KeyValuePair <string, string>("cloud/roleInstance", "RoleInstanceD")));
Assert.IsTrue(cloudRoleInstanceD.Count() == 0);
// We expect a DIMENSION-CAPPED series, which represents RoleInstanceC and RoleInstanceD
var dimCappedSeries = telemetrySentToChannel.Where(
(tel) => "Server response time".Equals((tel as MetricTelemetry)?.Name) &&
(tel as MetricTelemetry).Properties.Contains(new KeyValuePair <string, string>("cloud/roleInstance", "DIMENSION-CAPPED")));
Assert.IsTrue(dimCappedSeries.Count() == 1);
}
public void Request_CorrectlyExtractsMetric()
{
List <ITelemetry> telemetrySentToChannel = new List <ITelemetry>();
Func <ITelemetryProcessor, AutocollectedMetricsExtractor> extractorFactory = (nextProc) => new AutocollectedMetricsExtractor(nextProc);
// default set of dimensions with test values.
bool[] success = new bool[] { true, false };
bool[] synthetic = new bool[] { true, false };
string[] responseCode = new string[] { "200", "500", "401" };
string[] cloudRoleNames = new string[] { "RoleA", "RoleB" };
string[] cloudRoleInstances = new string[] { "RoleInstanceA", "RoleInstanceB" };
TelemetryConfiguration telemetryConfig = CreateTelemetryConfigWithExtractor(telemetrySentToChannel, extractorFactory);
using (telemetryConfig)
{
TelemetryClient client = new TelemetryClient(telemetryConfig);
List <RequestTelemetry> requests = new List <RequestTelemetry>();
// Produces telemetry with every combination of dimension values.
for (int i = 0; i < success.Length; i++)
{
for (int j = 0; j < responseCode.Length; j++)
{
for (int k = 0; k < cloudRoleNames.Length; k++)
{
for (int l = 0; l < cloudRoleInstances.Length; l++)
{
for (int m = 0; m < synthetic.Length; m++)
{
// For ease of validation 4 calls are tracked.
// with 100, 100. 600. 600.
// This will fall into 2 buckets <250msec, and 500ms-1sec
requests.Add(CreateRequestTelemetry(
TimeSpan.FromMilliseconds(100), responseCode[j], success[i], synthetic[m], cloudRoleNames[k], cloudRoleInstances[l]));
requests.Add(CreateRequestTelemetry(
TimeSpan.FromMilliseconds(100), responseCode[j], success[i], synthetic[m], cloudRoleNames[k], cloudRoleInstances[l]));
requests.Add(CreateRequestTelemetry(
TimeSpan.FromMilliseconds(600), responseCode[j], success[i], synthetic[m], cloudRoleNames[k], cloudRoleInstances[l]));
requests.Add(CreateRequestTelemetry(
TimeSpan.FromMilliseconds(600), responseCode[j], success[i], synthetic[m], cloudRoleNames[k], cloudRoleInstances[l]));
}
}
}
}
}
foreach (var req in requests)
{
client.TrackRequest(req);
}
// The # of iteration is 48 = 2 * 2 * 3 * 2 * 2
// success * synthetic * responseCode * RoleName * RoleInstance
// 4 Track calls are made in every iteration,
// hence 48 * 4 requests gives 192 total requests
Assert.AreEqual(192, telemetrySentToChannel.Count);
// The total # of timeseries is 96
// 2 * 2 * 3 * 2 * 2 * 2 = 96
// success * synthetic * responseCode * RoleName * RoleInstance * DurationBucket
// Duration bucket is auto calculated, hence not included in iteration count.
// The above did not include Metrics as they are sent upon dispose only.
} // dispose occurs here, and hence metrics get flushed out.
// 2 * 2 * 3 * 2 * 2 * 2 = 96
// success * synthetic * responseCode * RoleName * RoleInstance * DurationBucket
int totalTimeSeries = 96;
// 288 = 192 requests + 96 metrics as there are 96 unique combination of dimension
Assert.AreEqual(288, telemetrySentToChannel.Count);
// These are pre-agg metric
var serverResponseMetric = telemetrySentToChannel.Where(
(tel) => "Server response time".Equals((tel as MetricTelemetry)?.Name));
Assert.AreEqual(totalTimeSeries, serverResponseMetric.Count());
foreach (var metric in serverResponseMetric)
{
var metricTel = metric as MetricTelemetry;
// validate standard fields
Assert.IsTrue(metricTel.Properties.ContainsKey("_MS.AggregationIntervalMs"));
Assert.IsTrue(metricTel.Context.GlobalProperties.ContainsKey("_MS.IsAutocollected"));
Assert.AreEqual("True", metricTel.Context.GlobalProperties["_MS.IsAutocollected"]);
Assert.IsTrue(metricTel.Context.GlobalProperties.ContainsKey("_MS.MetricId"));
Assert.AreEqual("requests/duration", metricTel.Context.GlobalProperties["_MS.MetricId"]);
// validate dimensions exist
Assert.AreEqual(true, metricTel.Properties.ContainsKey("Request.Success"));
Assert.AreEqual(true, metricTel.Properties.ContainsKey("cloud/roleInstance"));
Assert.AreEqual(true, metricTel.Properties.ContainsKey("cloud/roleName"));
Assert.AreEqual(true, metricTel.Properties.ContainsKey("request/resultCode"));
Assert.AreEqual(true, metricTel.Properties.ContainsKey("request/performanceBucket"));
Assert.AreEqual(true, metricTel.Properties.ContainsKey("operation/synthetic"));
}
// Validate success dimension
for (int i = 0; i < success.Length; i++)
{
var metricCollection = serverResponseMetric.Where(
(tel) => (tel as MetricTelemetry).Properties["Request.Success"] == success[i].ToString());
int expectedCount = totalTimeSeries / success.Length;
Assert.AreEqual(expectedCount, metricCollection.Count());
ValidateAllMetric(metricCollection);
}
// Validate synthetic dimension
for (int i = 0; i < synthetic.Length; i++)
{
var metricCollection = serverResponseMetric.Where(
(tel) => (tel as MetricTelemetry).Properties["operation/synthetic"] == synthetic[i].ToString());
int expectedCount = totalTimeSeries / synthetic.Length;
Assert.AreEqual(expectedCount, metricCollection.Count());
ValidateAllMetric(metricCollection);
}
// Validate RoleName dimesion
for (int i = 0; i < cloudRoleNames.Length; i++)
{
var metricCollection = serverResponseMetric.Where(
(tel) => (tel as MetricTelemetry).Properties["cloud/roleName"] == cloudRoleNames[i]);
int expectedCount = totalTimeSeries / cloudRoleNames.Length;
Assert.AreEqual(expectedCount, metricCollection.Count());
ValidateAllMetric(metricCollection);
}
// Validate RoleInstance dimension
for (int i = 0; i < cloudRoleInstances.Length; i++)
{
var metricCollection = serverResponseMetric.Where(
(tel) => (tel as MetricTelemetry).Properties["cloud/roleInstance"] == cloudRoleInstances[i]);
int expectedCount = totalTimeSeries / cloudRoleInstances.Length;
Assert.AreEqual(expectedCount, metricCollection.Count());
ValidateAllMetric(metricCollection);
}
// Validate ResponseCode dimension
for (int i = 0; i < responseCode.Length; i++)
{
var metricCollection = serverResponseMetric.Where(
(tel) => (tel as MetricTelemetry).Properties["request/resultCode"] == responseCode[i]);
int expectedCount = totalTimeSeries / responseCode.Length;
Assert.AreEqual(expectedCount, metricCollection.Count());
ValidateAllMetric(metricCollection);
}
// Validate Duration Bucket dimension
{
var metricCollectionBelow250 = serverResponseMetric.Where(
(tel) => (tel as MetricTelemetry).Properties["request/performanceBucket"] == "<250ms");
var metricCollection500mSecTo1Sec = serverResponseMetric.Where(
(tel) => (tel as MetricTelemetry).Properties["request/performanceBucket"] == "500ms-1sec");
int expectedCount = totalTimeSeries / 2;
Assert.AreEqual(expectedCount, metricCollectionBelow250.Count());
ValidateAllMetric(metricCollectionBelow250);
Assert.AreEqual(expectedCount, metricCollection500mSecTo1Sec.Count());
ValidateAllMetric(metricCollection500mSecTo1Sec);
}
}
public void InstrumentationKeyThrowsArgumentNullExceptionWhenNewValueIsNullToAvoidNullReferenceExceptionWhenAccessingPropertyValue()
{
var configuration = new TelemetryConfiguration();
Xunit.Assert.Throws <ArgumentNullException>(() => configuration.InstrumentationKey = null);
}
public void EnsureAllTelemetrySinkItemsAreSimilarAcrossSinks()
{
var configuration = new TelemetryConfiguration();
var commonChainBuilder = new TelemetryProcessorChainBuilder(configuration);
configuration.TelemetryProcessorChainBuilder = commonChainBuilder;
string jsonFromFirstChannel = null;
string jsonFromSecondChannel = null;
ITelemetryChannel firstTelemetryChannel = new StubTelemetryChannel
{
OnSend = telemetry =>
{
jsonFromFirstChannel = JsonConvert.SerializeObject(telemetry);
}
};
ITelemetryChannel secondTelemetryChannel = new StubTelemetryChannel
{
OnSend = telemetry =>
{
jsonFromSecondChannel = JsonConvert.SerializeObject(telemetry);
}
};
configuration.DefaultTelemetrySink.TelemetryChannel = firstTelemetryChannel;
configuration.TelemetrySinks.Add(new TelemetrySink(configuration, secondTelemetryChannel));
configuration.TelemetryProcessorChainBuilder.Build();
TelemetryClient telemetryClient = new TelemetryClient(configuration);
// Setup TelemetryContext in a way that it is filledup.
telemetryClient.Context.Operation.Id = "OpId";
telemetryClient.Context.Cloud.RoleName = "UnitTest";
telemetryClient.Context.Component.Version = "TestVersion";
telemetryClient.Context.Device.Id = "TestDeviceId";
telemetryClient.Context.Flags = 1234;
telemetryClient.Context.InstrumentationKey = Guid.Empty.ToString();
telemetryClient.Context.Location.Ip = "127.0.0.1";
telemetryClient.Context.Session.Id = "SessionId";
telemetryClient.Context.User.Id = "userId";
telemetryClient.TrackAvailability(
"Availability",
DateTimeOffset.Now,
TimeSpan.FromMilliseconds(200),
"Local",
true,
"Message",
new Dictionary <string, string>()
{
{ "Key", "Value" }
},
new Dictionary <string, double>()
{
{ "Dimension1", 0.9865 }
});
Assert.AreEqual(jsonFromFirstChannel, jsonFromSecondChannel);
telemetryClient.TrackDependency(
"HTTP",
"Target",
"Test",
"https://azure",
DateTimeOffset.Now,
TimeSpan.FromMilliseconds(100),
"200",
true);
Assert.AreEqual(jsonFromFirstChannel, jsonFromSecondChannel);
telemetryClient.TrackEvent(
"Event",
new Dictionary <string, string>()
{
{ "Key", "Value" }
},
new Dictionary <string, double>()
{
{ "Dimension1", 0.9865 }
});
Assert.AreEqual(jsonFromFirstChannel, jsonFromSecondChannel);
telemetryClient.TrackException(
new Exception("Test"),
new Dictionary <string, string>()
{
{ "Key", "Value" }
},
new Dictionary <string, double>()
{
{ "Dimension1", 0.9865 }
});
Assert.AreEqual(jsonFromFirstChannel, jsonFromSecondChannel);
telemetryClient.TrackMetric("Metric", 0.1, new Dictionary <string, string>()
{
{ "Key", "Value" }
});
Assert.AreEqual(jsonFromFirstChannel, jsonFromSecondChannel);
telemetryClient.TrackPageView("PageView");
Assert.AreEqual(jsonFromFirstChannel, jsonFromSecondChannel);
telemetryClient.TrackRequest(
new RequestTelemetry("GET https://azure.com", DateTimeOffset.Now, TimeSpan.FromMilliseconds(200), "200", true)
{
#pragma warning disable CS0618 // Type or member is obsolete. Using for testing all cases.
HttpMethod = "GET"
#pragma warning restore CS0618 // Type or member is obsolete. Using for testing all cases.
});
Assert.AreEqual(jsonFromFirstChannel, jsonFromSecondChannel);
telemetryClient.TrackTrace(
"Message",
SeverityLevel.Critical,
new Dictionary <string, string>()
{
{ "Key", "Value" }
});
Assert.AreEqual(jsonFromFirstChannel, jsonFromSecondChannel);
}
public void EnsureEventsAreNotDroppedByBroadcastProcessor()
{
var configuration = new TelemetryConfiguration();
var commonChainBuilder = new TelemetryProcessorChainBuilder(configuration);
configuration.TelemetryProcessorChainBuilder = commonChainBuilder;
ConcurrentBag <ITelemetry> itemsReceivedBySink1 = new ConcurrentBag <ITelemetry>();
ConcurrentBag <ITelemetry> itemsReceivedBySink2 = new ConcurrentBag <ITelemetry>();
ITelemetryChannel firstTelemetryChannel = new StubTelemetryChannel
{
OnSend = telemetry =>
{
itemsReceivedBySink1.Add(telemetry);
}
};
ITelemetryChannel secondTelemetryChannel = new StubTelemetryChannel
{
OnSend = telemetry =>
{
itemsReceivedBySink2.Add(telemetry);
}
};
configuration.DefaultTelemetrySink.TelemetryChannel = firstTelemetryChannel;
configuration.TelemetrySinks.Add(new TelemetrySink(configuration, secondTelemetryChannel));
configuration.TelemetryProcessorChainBuilder.Build();
TelemetryClient telemetryClient = new TelemetryClient(configuration);
// Setup TelemetryContext in a way that it is filledup.
telemetryClient.Context.Operation.Id = "OpId";
telemetryClient.Context.Cloud.RoleName = "UnitTest";
telemetryClient.Context.Component.Version = "TestVersion";
telemetryClient.Context.Device.Id = "TestDeviceId";
telemetryClient.Context.Flags = 1234;
telemetryClient.Context.InstrumentationKey = Guid.Empty.ToString();
telemetryClient.Context.Location.Ip = "127.0.0.1";
telemetryClient.Context.Session.Id = "SessionId";
telemetryClient.Context.User.Id = "userId";
Parallel.ForEach(
new int[100],
new ParallelOptions
{
MaxDegreeOfParallelism = 100
},
(value) =>
{
telemetryClient.TrackAvailability(
"Availability",
DateTimeOffset.Now,
TimeSpan.FromMilliseconds(200),
"Local",
true,
"Message",
new Dictionary <string, string>()
{
{ "Key", "Value" }
},
new Dictionary <string, double>()
{
{ "Dimension1", 0.9865 }
});
telemetryClient.TrackDependency(
"HTTP",
"Target",
"Test",
"https://azure",
DateTimeOffset.Now,
TimeSpan.FromMilliseconds(100),
"200",
true);
telemetryClient.TrackEvent(
"Event",
new Dictionary <string, string>()
{
{ "Key", "Value" }
},
new Dictionary <string, double>()
{
{ "Dimension1", 0.9865 }
});
telemetryClient.TrackException(
new Exception("Test"),
new Dictionary <string, string>()
{
{ "Key", "Value" }
},
new Dictionary <string, double>()
{
{ "Dimension1", 0.9865 }
});
telemetryClient.TrackMetric("Metric", 0.1, new Dictionary <string, string>()
{
{ "Key", "Value" }
});
telemetryClient.TrackPageView("PageView");
telemetryClient.TrackRequest(
new RequestTelemetry("GET https://azure.com", DateTimeOffset.Now, TimeSpan.FromMilliseconds(200), "200", true)
{
#pragma warning disable CS0618 // Type or member is obsolete. Using for testing all cases.
HttpMethod = "GET"
#pragma warning restore CS0618 // Type or member is obsolete. Using for testing all cases.
});
telemetryClient.TrackTrace(
"Message",
SeverityLevel.Critical,
new Dictionary <string, string>()
{
{ "Key", "Value" }
});
});
Assert.AreEqual(itemsReceivedBySink1.Count, itemsReceivedBySink2.Count);
Assert.AreEqual(8 * 100, itemsReceivedBySink1.Count);
Assert.AreEqual(8 * 100, itemsReceivedBySink2.Count);
}
public void ConfigurationDisposesAllSinks()
{
var configuration = new TelemetryConfiguration();
var commonChainBuilder = new TelemetryProcessorChainBuilder(configuration);
configuration.TelemetryProcessorChainBuilder = commonChainBuilder;
var firstChannel = new StubTelemetryChannel();
bool firstChannelDisposed = false;
firstChannel.OnDispose = () => firstChannelDisposed = true;
configuration.DefaultTelemetrySink.TelemetryChannel = firstChannel;
var firstSinkChainBuilder = new TelemetryProcessorChainBuilder(configuration, configuration.DefaultTelemetrySink);
bool firstSinkTelemetryProcessorDisposed = false;
firstSinkChainBuilder.Use((next) =>
{
var firstSinkTelemetryProcessor = new StubTelemetryProcessor(next);
firstSinkTelemetryProcessor.OnDispose = () => firstSinkTelemetryProcessorDisposed = true;
return(firstSinkTelemetryProcessor);
});
configuration.DefaultTelemetrySink.TelemetryProcessorChainBuilder = firstSinkChainBuilder;
var secondChannel = new StubTelemetryChannel();
bool secondChannelDisposed = false;
secondChannel.OnDispose = () => secondChannelDisposed = true;
var secondSink = new TelemetrySink(configuration, secondChannel);
var secondSinkChainBuilder = new TelemetryProcessorChainBuilder(configuration, secondSink);
bool secondSinkTelemetryProcessorDisposed = false;
secondSinkChainBuilder.Use((next) =>
{
var secondSinkTelemetryProcessor = new StubTelemetryProcessor(next);
secondSinkTelemetryProcessor.OnDispose = () => secondSinkTelemetryProcessorDisposed = true;
return(secondSinkTelemetryProcessor);
});
secondSink.TelemetryProcessorChainBuilder = secondSinkChainBuilder;
configuration.TelemetrySinks.Add(secondSink);
var client = new TelemetryClient(configuration);
client.TrackTrace("t1");
configuration.Dispose();
// We expect the channels to not be disposed (because they were created externally to sinks), but the processors should be disposed.
Assert.IsTrue(firstSinkTelemetryProcessorDisposed);
Assert.IsTrue(secondSinkTelemetryProcessorDisposed);
Assert.IsFalse(firstChannelDisposed);
Assert.IsFalse(secondChannelDisposed);
// does not throw
try
{
client.TrackTrace("t2");
}
catch (Exception ex)
{
Assert.Fail(ex.ToString());
}
}
public void TelemetryInitializersReturnsThreadSafeList()
{
var configuration = new TelemetryConfiguration();
Assert.Equal(typeof(SnapshottingList <ITelemetryInitializer>), configuration.TelemetryInitializers.GetType());
}
public void DisableTelemetryIsFalseByDefault()
{
var configuration = new TelemetryConfiguration();
Assert.False(configuration.DisableTelemetry);
}
public void TelemetryChannelIsNullByDefaultToAvoidLockEscalation()
{
var configuration = new TelemetryConfiguration();
Assert.Null(configuration.TelemetryChannel);
}
public override void Initialize(TelemetryConfiguration configuration, TelemetryModules modules)
{
this.OnInitialize(configuration, modules);
}
public void MultipleSinkTelemetryProcessorsAreInvoked()
{
var configuration = new TelemetryConfiguration();
var commonChainBuilder = new TelemetryProcessorChainBuilder(configuration);
configuration.TelemetryProcessorChainBuilder = commonChainBuilder;
commonChainBuilder.Use((next) =>
{
var commonProcessor = new StubTelemetryProcessor(next);
commonProcessor.OnProcess = (telemetry) => telemetry.Context.Properties.Add("SeenByCommonProcessor", "true");
return(commonProcessor);
});
var firstChannelTelemetry = new List <ITelemetry>();
var firstChannel = new StubTelemetryChannel();
firstChannel.OnSend = (telemetry) => firstChannelTelemetry.Add(telemetry);
configuration.DefaultTelemetrySink.TelemetryChannel = firstChannel;
var firstSinkChainBuilder = new TelemetryProcessorChainBuilder(configuration, configuration.DefaultTelemetrySink);
firstSinkChainBuilder.Use((next) =>
{
var firstSinkTelemetryProcessor = new StubTelemetryProcessor(next);
firstSinkTelemetryProcessor.OnProcess = (telemetry) => telemetry.Context.Properties.Add("SeenByFirstSinkProcessor", "true");
return(firstSinkTelemetryProcessor);
});
configuration.DefaultTelemetrySink.TelemetryProcessorChainBuilder = firstSinkChainBuilder;
var secondChannelTelemetry = new List <ITelemetry>();
var secondChannel = new StubTelemetryChannel();
secondChannel.OnSend = (telemetry) => secondChannelTelemetry.Add(telemetry);
var secondSink = new TelemetrySink(configuration, secondChannel);
configuration.TelemetrySinks.Add(secondSink);
var secondSinkChainBuilder = new TelemetryProcessorChainBuilder(configuration, secondSink);
secondSinkChainBuilder.Use((next) =>
{
var secondSinkTelemetryProcessor = new StubTelemetryProcessor(next);
secondSinkTelemetryProcessor.OnProcess = (telemetry) => telemetry.Context.Properties.Add("SeenBySecondSinkProcessor", "true");
return(secondSinkTelemetryProcessor);
});
secondSink.TelemetryProcessorChainBuilder = secondSinkChainBuilder;
var client = new TelemetryClient(configuration);
client.TrackTrace("t1");
Assert.AreEqual(1, firstChannelTelemetry.Count);
Assert.IsTrue(firstChannelTelemetry[0].Context.Properties.ContainsKey("SeenByCommonProcessor"));
Assert.IsTrue(firstChannelTelemetry[0].Context.Properties.ContainsKey("SeenByFirstSinkProcessor"));
Assert.IsFalse(firstChannelTelemetry[0].Context.Properties.ContainsKey("SeenBySecondSinkProcessor"));
Assert.AreEqual(1, secondChannelTelemetry.Count);
Assert.IsTrue(secondChannelTelemetry[0].Context.Properties.ContainsKey("SeenByCommonProcessor"));
Assert.IsFalse(secondChannelTelemetry[0].Context.Properties.ContainsKey("SeenByFirstSinkProcessor"));
Assert.IsTrue(secondChannelTelemetry[0].Context.Properties.ContainsKey("SeenBySecondSinkProcessor"));
}
public void Request_TelemetryRespectsDimLimitResponseCode()
{
List <ITelemetry> telemetrySentToChannel = new List <ITelemetry>();
Func <ITelemetryProcessor, AutocollectedMetricsExtractor> extractorFactory =
(nextProc) => {
var metricExtractor = new AutocollectedMetricsExtractor(nextProc);
metricExtractor.MaxRequestResponseCodeValuesToDiscover = 0;
return(metricExtractor);
};
TelemetryConfiguration telemetryConfig = CreateTelemetryConfigWithExtractor(telemetrySentToChannel, extractorFactory);
using (telemetryConfig)
{
TelemetryClient client = new TelemetryClient(telemetryConfig);
// Track 3 requests with 3 different values for Result code - 200,201,202.
// As MaxRequestResponseCodeValuesToDiscover = 0, we expect all responde code to be rolled into Other
client.TrackRequest("Test Request 1", DateTimeOffset.Now, TimeSpan.FromMilliseconds(10), "200", success: true);
client.TrackRequest("Test Request 2", DateTimeOffset.Now, TimeSpan.FromMilliseconds(11), "201", success: true);
client.TrackRequest("Test Request 3", DateTimeOffset.Now, TimeSpan.FromMilliseconds(11), "202", success: true);
}
Assert.AreEqual(4, telemetrySentToChannel.Count);
AssertEx.IsType <RequestTelemetry>(telemetrySentToChannel[0]);
Assert.AreEqual("Test Request 1", ((RequestTelemetry)telemetrySentToChannel[0]).Name);
Assert.AreEqual(true, ((RequestTelemetry)telemetrySentToChannel[0]).Properties.ContainsKey("_MS.ProcessedByMetricExtractors"));
Assert.AreEqual("(Name:'Requests', Ver:'1.1')",
((RequestTelemetry)telemetrySentToChannel[0]).Properties["_MS.ProcessedByMetricExtractors"]);
AssertEx.IsType <RequestTelemetry>(telemetrySentToChannel[1]);
Assert.AreEqual("Test Request 2", ((RequestTelemetry)telemetrySentToChannel[1]).Name);
Assert.AreEqual(true, ((RequestTelemetry)telemetrySentToChannel[1]).Properties.ContainsKey("_MS.ProcessedByMetricExtractors"));
Assert.AreEqual("(Name:'Requests', Ver:'1.1')",
((RequestTelemetry)telemetrySentToChannel[1]).Properties["_MS.ProcessedByMetricExtractors"]);
AssertEx.IsType <RequestTelemetry>(telemetrySentToChannel[2]);
Assert.AreEqual("Test Request 3", ((RequestTelemetry)telemetrySentToChannel[2]).Name);
Assert.AreEqual(true, ((RequestTelemetry)telemetrySentToChannel[2]).Properties.ContainsKey("_MS.ProcessedByMetricExtractors"));
Assert.AreEqual("(Name:'Requests', Ver:'1.1')",
((RequestTelemetry)telemetrySentToChannel[2]).Properties["_MS.ProcessedByMetricExtractors"]);
AssertEx.IsType <MetricTelemetry>(telemetrySentToChannel[3]);
var metricTel = telemetrySentToChannel[3] as MetricTelemetry;
// validate standard fields
Assert.IsTrue(metricTel.Properties.ContainsKey("_MS.AggregationIntervalMs"));
Assert.IsTrue(metricTel.Context.GlobalProperties.ContainsKey("_MS.IsAutocollected"));
Assert.AreEqual("True", metricTel.Context.GlobalProperties["_MS.IsAutocollected"]);
Assert.IsTrue(metricTel.Context.GlobalProperties.ContainsKey("_MS.MetricId"));
Assert.AreEqual("requests/duration", metricTel.Context.GlobalProperties["_MS.MetricId"]);
// validate dimensions exist
Assert.AreEqual(true, metricTel.Properties.ContainsKey("Request.Success"));
Assert.AreEqual(true, metricTel.Properties.ContainsKey("cloud/roleInstance"));
Assert.AreEqual(true, metricTel.Properties.ContainsKey("cloud/roleName"));
Assert.AreEqual(true, metricTel.Properties.ContainsKey("request/resultCode"));
Assert.AreEqual(true, metricTel.Properties.ContainsKey("request/performanceBucket"));
Assert.AreEqual(true, metricTel.Properties.ContainsKey("operation/synthetic"));
var resultCodeDimension = metricTel.Properties["request/resultCode"];
// As MaxRequestResponseCodeValuesToDiscover = 0, we expect all responde code to be rolled into Other
Assert.AreEqual("Other", resultCodeDimension);
}
public void Dependency_CorrectlyExtractsMetric()
{
List <ITelemetry> telemetrySentToChannel = new List <ITelemetry>();
Func <ITelemetryProcessor, AutocollectedMetricsExtractor> extractorFactory = (nextProc) => new AutocollectedMetricsExtractor(nextProc);
// default set of dimensions with test values.
bool[] success = new bool[] { true, false };
bool[] synthetic = new bool[] { true, false };
string[] targets = new string[] { "TargetA", "TargetB", "TargetC" };
string[] types = new string[] { "TypeA", "TypeB", "TypeC" };
string[] cloudRoleNames = new string[] { "RoleA", "RoleB" };
string[] cloudRoleInstances = new string[] { "RoleInstanceA", "RoleInstanceB" };
TelemetryConfiguration telemetryConfig = CreateTelemetryConfigWithExtractor(telemetrySentToChannel, extractorFactory);
using (telemetryConfig)
{
TelemetryClient client = new TelemetryClient(telemetryConfig);
List <DependencyTelemetry> dependencies = new List <DependencyTelemetry>();
// Produces telemetry with every combination of dimension values.
for (int i = 0; i < success.Length; i++)
{
for (int j = 0; j < targets.Length; j++)
{
for (int k = 0; k < cloudRoleNames.Length; k++)
{
for (int l = 0; l < cloudRoleInstances.Length; l++)
{
for (int m = 0; m < synthetic.Length; m++)
{
for (int n = 0; n < types.Length; n++)
{
// For ease of validation 4 calls are tracked.
// with 100, 100. 600. 600.
// This will fall into 2 buckets <250msec, and 500ms-1sec
dependencies.Add(CreateDependencyTelemetry(
TimeSpan.FromMilliseconds(100), targets[j], types[n], success[i], synthetic[m], cloudRoleNames[k], cloudRoleInstances[l]));
dependencies.Add(CreateDependencyTelemetry(
TimeSpan.FromMilliseconds(100), targets[j], types[n], success[i], synthetic[m], cloudRoleNames[k], cloudRoleInstances[l]));
dependencies.Add(CreateDependencyTelemetry(
TimeSpan.FromMilliseconds(600), targets[j], types[n], success[i], synthetic[m], cloudRoleNames[k], cloudRoleInstances[l]));
dependencies.Add(CreateDependencyTelemetry(
TimeSpan.FromMilliseconds(600), targets[j], types[n], success[i], synthetic[m], cloudRoleNames[k], cloudRoleInstances[l]));
}
}
}
}
}
}
foreach (var dep in dependencies)
{
client.TrackDependency(dep);
}
// 2 * 2 * 3 * 3 * 2 * 2 = 144 iteration
// DurationBucket is not included in interation as its automatically extracted.
// 4 Track calls are made in every iteration,
// hence 144 * 4 dependencies gives 576 total dependencies
Assert.AreEqual(576, telemetrySentToChannel.Count);
// The above did not include Metrics as they are sent upon dispose only.
} // dispose occurs here, and hence metrics get flushed out.
// 2 * 2 * 3 * 3 * 2 * 2 * 2 = 288 timeseries
// success * synthetic * target * type * RoleName * RoleInstance *DurationBucket
int totalTimeSeries = 288;
// 864 = 576 requests + 288 metrics as there are 288 unique combination of dimension
Assert.AreEqual(864, telemetrySentToChannel.Count);
// These are pre-agg metric
var depDurationMetric = telemetrySentToChannel.Where(
(tel) => "Dependency duration".Equals((tel as MetricTelemetry)?.Name));
Assert.AreEqual(totalTimeSeries, depDurationMetric.Count());
foreach (var metric in depDurationMetric)
{
var metricTel = metric as MetricTelemetry;
// validate standard fields
Assert.IsTrue(metricTel.Properties.ContainsKey("_MS.AggregationIntervalMs"));
Assert.IsTrue(metricTel.Context.GlobalProperties.ContainsKey("_MS.IsAutocollected"));
Assert.AreEqual("True", metricTel.Context.GlobalProperties["_MS.IsAutocollected"]);
Assert.IsTrue(metricTel.Context.GlobalProperties.ContainsKey("_MS.MetricId"));
Assert.AreEqual("dependencies/duration", metricTel.Context.GlobalProperties["_MS.MetricId"]);
// validate dimensions exist
Assert.AreEqual(true, metricTel.Properties.ContainsKey("Dependency.Success"));
Assert.AreEqual(true, metricTel.Properties.ContainsKey("cloud/roleInstance"));
Assert.AreEqual(true, metricTel.Properties.ContainsKey("cloud/roleName"));
Assert.AreEqual(true, metricTel.Properties.ContainsKey("Dependency.Type"));
Assert.AreEqual(true, metricTel.Properties.ContainsKey("dependency/target"));
Assert.AreEqual(true, metricTel.Properties.ContainsKey("operation/synthetic"));
Assert.AreEqual(true, metricTel.Properties.ContainsKey("dependency/performanceBucket"));
}
// Validate success dimension
for (int i = 0; i < success.Length; i++)
{
var metricCollection = depDurationMetric.Where(
(tel) => (tel as MetricTelemetry).Properties["Dependency.Success"] == success[i].ToString());
int expectedCount = totalTimeSeries / success.Length;
Assert.AreEqual(expectedCount, metricCollection.Count());
ValidateAllMetric(metricCollection);
}
// Validate synthetic dimension
for (int i = 0; i < synthetic.Length; i++)
{
var metricCollection = depDurationMetric.Where(
(tel) => (tel as MetricTelemetry).Properties["operation/synthetic"] == synthetic[i].ToString());
int expectedCount = totalTimeSeries / synthetic.Length;
Assert.AreEqual(expectedCount, metricCollection.Count());
ValidateAllMetric(metricCollection);
}
// Validate RoleName dimesion
for (int i = 0; i < cloudRoleNames.Length; i++)
{
var metricCollection = depDurationMetric.Where(
(tel) => (tel as MetricTelemetry).Properties["cloud/roleName"] == cloudRoleNames[i]);
int expectedCount = totalTimeSeries / cloudRoleNames.Length;
Assert.AreEqual(expectedCount, metricCollection.Count());
ValidateAllMetric(metricCollection);
}
// Validate RoleInstance dimension
for (int i = 0; i < cloudRoleInstances.Length; i++)
{
var metricCollection = depDurationMetric.Where(
(tel) => (tel as MetricTelemetry).Properties["cloud/roleInstance"] == cloudRoleInstances[i]);
int expectedCount = totalTimeSeries / cloudRoleInstances.Length;
Assert.AreEqual(expectedCount, metricCollection.Count());
ValidateAllMetric(metricCollection);
}
// Validate Dep Type dimension
for (int i = 0; i < types.Length; i++)
{
var metricCollection = depDurationMetric.Where(
(tel) => (tel as MetricTelemetry).Properties["Dependency.Type"] == types[i]);
int expectedCount = totalTimeSeries / types.Length;
Assert.AreEqual(expectedCount, metricCollection.Count());
ValidateAllMetric(metricCollection);
}
// Validate Dep Target dimension
for (int i = 0; i < targets.Length; i++)
{
var metricCollection = depDurationMetric.Where(
(tel) => (tel as MetricTelemetry).Properties["dependency/target"] == targets[i]);
int expectedCount = totalTimeSeries / types.Length;
Assert.AreEqual(expectedCount, metricCollection.Count());
ValidateAllMetric(metricCollection);
}
// Validate Duration Bucket dimension
{
var metricCollectionBelow250 = depDurationMetric.Where(
(tel) => (tel as MetricTelemetry).Properties["dependency/performanceBucket"] == "<250ms");
var metricCollection500mSecTo1Sec = depDurationMetric.Where(
(tel) => (tel as MetricTelemetry).Properties["dependency/performanceBucket"] == "500ms-1sec");
int expectedCount = totalTimeSeries / 2;
Assert.AreEqual(expectedCount, metricCollectionBelow250.Count());
ValidateAllMetric(metricCollectionBelow250);
Assert.AreEqual(expectedCount, metricCollection500mSecTo1Sec.Count());
ValidateAllMetric(metricCollection500mSecTo1Sec);
}
}
public void Request_CorrectlyWorksWithResponseSuccess()
{
List <ITelemetry> telemetrySentToChannel = new List <ITelemetry>();
Func <ITelemetryProcessor, AutocollectedMetricsExtractor> extractorFactory = (nextProc) => new AutocollectedMetricsExtractor(nextProc);
TelemetryConfiguration telemetryConfig = CreateTelemetryConfigWithExtractor(telemetrySentToChannel, extractorFactory);
using (telemetryConfig)
{
TelemetryClient client = new TelemetryClient(telemetryConfig);
client.TrackRequest(new RequestTelemetry()
{
Name = "Test Request 1",
Timestamp = DateTimeOffset.Now,
Duration = TimeSpan.FromMilliseconds(5),
ResponseCode = "xxx",
Success = true
});
client.TrackRequest(new RequestTelemetry()
{
Name = "Test Request 2",
Timestamp = DateTimeOffset.Now,
Duration = TimeSpan.FromMilliseconds(10),
ResponseCode = "xxx",
Success = false
});
client.TrackRequest(new RequestTelemetry()
{
Name = "Test Request 3",
Timestamp = DateTimeOffset.Now,
Duration = TimeSpan.FromMilliseconds(15),
ResponseCode = "xxx",
Success = null
});
}
Assert.AreEqual(5, telemetrySentToChannel.Count);
var t = new SortedList <string, MetricTelemetry>();
Assert.IsNotNull(telemetrySentToChannel[3]);
AssertEx.IsType <MetricTelemetry>(telemetrySentToChannel[3]);
var m = (MetricTelemetry)telemetrySentToChannel[3];
t.Add(m.Properties["Request.Success"], m);
Assert.IsNotNull(telemetrySentToChannel[4]);
AssertEx.IsType <MetricTelemetry>(telemetrySentToChannel[4]);
m = (MetricTelemetry)telemetrySentToChannel[4];
t.Add(m.Properties["Request.Success"], m);
var metricF = t.Values[0];
var metricT = t.Values[1];
Assert.AreEqual("Server response time", metricT.Name);
Assert.AreEqual(2, metricT.Count);
Assert.AreEqual(15, metricT.Max);
Assert.AreEqual(5, metricT.Min);
Assert.AreEqual(20, metricT.Sum);
Assert.AreEqual(true, metricT.Properties.ContainsKey("Request.Success"));
Assert.AreEqual(Boolean.TrueString, metricT.Properties["Request.Success"]);
Assert.AreEqual("Server response time", metricF.Name);
Assert.AreEqual(1, metricF.Count);
Assert.AreEqual(10, metricF.Max);
Assert.AreEqual(10, metricF.Min);
Assert.AreEqual(10, metricF.Sum);
Assert.AreEqual(true, metricF.Properties.ContainsKey("Request.Success"));
Assert.AreEqual(Boolean.FalseString, metricF.Properties["Request.Success"]);
}
public void TelemetryInitializersReturnsAnEmptyListByDefaultToAvoidNullReferenceExceptionsInUserCode()
{
var configuration = new TelemetryConfiguration();
Assert.Equal(0, configuration.TelemetryInitializers.Count);
}
public void InstrumentationKeyIsEmptyStringByDefaultToAvoidNullReferenceExceptionWhenAccessingPropertyValue()
{
var configuration = new TelemetryConfiguration();
Assert.Equal(0, configuration.InstrumentationKey.Length);
}
