internal ApplicationInsightsConfiguration(
TelemetryConfiguration telemetryConfiguration,
DiagnosticsTelemetryModule diagnosticsTelemetryModule)
{
TelemetryConfiguration = telemetryConfiguration ?? throw new ArgumentNullException(nameof(telemetryConfiguration));
DiagnosticsTelemetryModule = diagnosticsTelemetryModule ?? throw new ArgumentNullException(nameof(diagnosticsTelemetryModule));
}
public void Initialize()
{
DiagnosticsTelemetryModule dm = new DiagnosticsTelemetryModule();
TelemetryModules.Instance.Modules.Add(dm);
publisher = new HeartbeatCustomizer();
}
public void ReturnsFalseForNullPropertyName()
{
// Arrange
var module = new DiagnosticsTelemetryModule();
// Act
var result = DiagnosticsTelemetryModuleExtensions.AddOrSetHeartbeatProperty(module, null, "value", true);
// Assert
Assert.False(result);
}
private static ApplicationInsightsConfiguration InitializeApplicationInsightsConfiguration(
string instrumentationKey,
TimeSpan?heartbeatInterval)
{
// Note: TelemetryConfiguration.Active is being deprecated
// https://github.com/microsoft/ApplicationInsights-dotnet/issues/1152
// We use TelemetryConfiguration.CreateDefault() as opposed to instantiating a new TelemetryConfiguration()
// to take into account the ApplicationInsights.config file (if detected).
var telemetryConfiguration = TelemetryConfiguration.CreateDefault();
if (!string.IsNullOrWhiteSpace(instrumentationKey))
{
telemetryConfiguration.InstrumentationKey = instrumentationKey;
}
telemetryConfiguration.TelemetryInitializers.Add(new TelemetryContextInitializer());
// Hook-up the TelemetryModules configured in applicationinsights.config into our own
// TelemetryConfiguration instance, as this doesn't happen automatically...
foreach (var telemetryModule in TelemetryModules.Instance.Modules)
{
telemetryModule.Initialize(telemetryConfiguration);
}
// Construct a TelemetryClient to emit traces so we can track and debug AI initialization.
var telemetryClient = new TelemetryClient(telemetryConfiguration);
telemetryClient.TrackTrace(
$"TelemetryConfiguration initialized using instrumentation key: {instrumentationKey ?? "EMPTY"}.",
SeverityLevel.Information);
var diagnosticsTelemetryModule = new DiagnosticsTelemetryModule();
// Configure heartbeat interval if specified.
// When not defined, the DiagnosticsTelemetryModule will use its internal defaults (heartbeat enabled, interval of 15 minutes).
var traceMessage = "DiagnosticsTelemetryModule initialized using default heartbeat interval.";
if (heartbeatInterval.HasValue)
{
diagnosticsTelemetryModule.HeartbeatInterval = heartbeatInterval.Value;
traceMessage = $"DiagnosticsTelemetryModule initialized using configured heartbeat interval: {heartbeatInterval.Value}.";
}
diagnosticsTelemetryModule.Initialize(telemetryConfiguration);
telemetryClient.TrackTrace(traceMessage, SeverityLevel.Information);
return(new ApplicationInsightsConfiguration(telemetryConfiguration, diagnosticsTelemetryModule));
}
public void ReturnsTrueAndAddsPayloadWhenNotAddedYet(string propertyName, string propertyValue, bool isHealthy)
{
// Arrange
var module = new DiagnosticsTelemetryModule();
// Act
var result = DiagnosticsTelemetryModuleExtensions.AddOrSetHeartbeatProperty(
module,
propertyName,
propertyValue,
isHealthy);
// Assert
Assert.True(result);
VerifyHeartbeatPropertyPayload(module, propertyName, propertyValue, isHealthy);
}
/// <summary>
/// Tries to add or set a heartbeat property.
/// </summary>
/// <param name="module">The <see cref="DiagnosticsTelemetryModule"/>.</param>
/// <param name="propertyName">Name of the heartbeat value to add.</param>
/// <param name="propertyValue">Current value of the heartbeat value to add.</param>
/// <param name="isHealthy">Flag indicating whether or not the property represents a healthy value.</param>
/// <returns><c>True</c> if the property was set; otherwise <c>False</c>.</returns>
public static bool AddOrSetHeartbeatProperty(
this DiagnosticsTelemetryModule module,
string propertyName,
string propertyValue,
bool isHealthy)
{
if (module == null)
{
throw new ArgumentNullException(nameof(module));
}
var propertySet = module.AddHeartbeatProperty(propertyName, propertyValue, isHealthy);
if (!propertySet)
{
return(module.SetHeartbeatProperty(propertyName, propertyValue, isHealthy));
}
return(propertySet);
}
private void VerifyHeartbeatPropertyPayload(
DiagnosticsTelemetryModule module,
string propertyName,
string propertyValue,
bool isHealthy)
{
// Verify payload settings using reflection
var heartbeatPropertyManager = typeof(DiagnosticsTelemetryModule)
.GetField("HeartbeatProvider", BindingFlags.NonPublic | BindingFlags.Instance)
.GetValue(module) as IHeartbeatPropertyManager;
var heartbeatProperties = heartbeatPropertyManager
.GetType()
.GetField("heartbeatProperties", BindingFlags.NonPublic | BindingFlags.Instance)
.GetValue(heartbeatPropertyManager); // returns ConcurrentDictionary<string, HeartbeatPropertyPayload>
var propertyNames = heartbeatProperties
.GetType()
.GetProperty("Keys", BindingFlags.Public | BindingFlags.Instance)
.GetValue(heartbeatProperties) as ICollection <string>;
Assert.Contains(propertyNames, i => i.Equals(propertyName));
var propertyPayload = heartbeatProperties
.GetType()
.GetProperty("Item", BindingFlags.Public | BindingFlags.Instance)
.GetValue(heartbeatProperties, new object[] { propertyName }); // returns internal type HeartbeatPropertyPayload
var payloadValue = propertyPayload
.GetType()
.GetProperty("PayloadValue", BindingFlags.Public | BindingFlags.Instance)
.GetValue(propertyPayload) as string;
var payloadIsHealthy = (bool)propertyPayload
.GetType()
.GetProperty("IsHealthy", BindingFlags.Public | BindingFlags.Instance)
.GetValue(propertyPayload);
Assert.Equal(propertyValue, payloadValue);
Assert.Equal(isHealthy, payloadIsHealthy);
}
/// <inheritdoc />
public void Configure(TelemetryConfiguration configuration)
{
try
{
if (this.applicationInsightsServiceOptions.InstrumentationKey != null)
{
configuration.InstrumentationKey = this.applicationInsightsServiceOptions.InstrumentationKey;
}
if (this.telemetryModuleConfigurators.Any())
{
foreach (ITelemetryModuleConfigurator telemetryModuleConfigurator in this.telemetryModuleConfigurators)
{
ITelemetryModule telemetryModule = this.modules.FirstOrDefault((module) => module.GetType() == telemetryModuleConfigurator.TelemetryModuleType);
if (telemetryModule != null)
{
telemetryModuleConfigurator.Configure(telemetryModule, this.applicationInsightsServiceOptions);
}
else
{
#if AI_ASPNETCORE_WEB
AspNetCoreEventSource.Instance.UnableToFindModuleToConfigure(telemetryModuleConfigurator.TelemetryModuleType.ToString());
#else
WorkerServiceEventSource.Instance.UnableToFindModuleToConfigure(telemetryModuleConfigurator.TelemetryModuleType.ToString());
#endif
}
}
}
if (this.telemetryProcessorFactories.Any())
{
foreach (ITelemetryProcessorFactory processorFactory in this.telemetryProcessorFactories)
{
configuration.DefaultTelemetrySink.TelemetryProcessorChainBuilder.Use(processorFactory.Create);
}
}
// Fallback to default channel (InMemoryChannel) created by base sdk if no channel is found in DI
configuration.TelemetryChannel = this.telemetryChannel ?? configuration.TelemetryChannel;
(configuration.TelemetryChannel as ITelemetryModule)?.Initialize(configuration);
this.AddAutoCollectedMetricExtractor(configuration);
this.AddQuickPulse(configuration);
this.AddSampling(configuration);
this.DisableHeartBeatIfConfigured();
configuration.DefaultTelemetrySink.TelemetryProcessorChainBuilder.Build();
configuration.TelemetryProcessorChainBuilder.Build();
if (this.applicationInsightsServiceOptions.DeveloperMode != null)
{
configuration.TelemetryChannel.DeveloperMode = this.applicationInsightsServiceOptions.DeveloperMode;
}
if (this.applicationInsightsServiceOptions.EndpointAddress != null)
{
configuration.TelemetryChannel.EndpointAddress = this.applicationInsightsServiceOptions.EndpointAddress;
}
// Need to set connection string before calling Initialize() on the Modules and Processors.
if (this.applicationInsightsServiceOptions.ConnectionString != null)
{
configuration.ConnectionString = this.applicationInsightsServiceOptions.ConnectionString;
}
foreach (ITelemetryInitializer initializer in this.initializers)
{
configuration.TelemetryInitializers.Add(initializer);
}
// Find the DiagnosticsTelemetryModule, this is needed to initialize AzureInstanceMetadataTelemetryModule and AppServicesHeartbeatTelemetryModule.
DiagnosticsTelemetryModule diagModule =
(this.applicationInsightsServiceOptions.EnableDiagnosticsTelemetryModule && this.applicationInsightsServiceOptions.EnableHeartbeat)
? this.modules.OfType <DiagnosticsTelemetryModule>().FirstOrDefault()
: null;
// Checks ApplicationInsightsServiceOptions and disable TelemetryModules if explicitly disabled.
foreach (ITelemetryModule module in this.modules)
{
// If any of the modules are disabled explicitly using aioptions,
// do not initialize them and dispose if disposable.
// The option of not adding a module to DI if disabled
// cannot be done to maintain backward compatibility.
// So this approach of adding all modules to DI, but selectively
// disable those modules which user has disabled is chosen.
if (module is DiagnosticsTelemetryModule)
{
if (!this.applicationInsightsServiceOptions.EnableDiagnosticsTelemetryModule)
{
DisposeIfDisposable(module);
continue;
}
}
// DependencyTrackingTelemetryModule
if (module is DependencyTrackingTelemetryModule)
{
if (!this.applicationInsightsServiceOptions.EnableDependencyTrackingTelemetryModule)
{
DisposeIfDisposable(module);
continue;
}
}
#if AI_ASPNETCORE_WEB
// RequestTrackingTelemetryModule
if (module is RequestTrackingTelemetryModule)
{
if (!this.applicationInsightsServiceOptions.EnableRequestTrackingTelemetryModule)
{
DisposeIfDisposable(module);
continue;
}
}
#endif
#if NETSTANDARD2_0
// EventCounterCollectionModule
if (module is EventCounterCollectionModule)
{
if (!this.applicationInsightsServiceOptions.EnableEventCounterCollectionModule)
{
DisposeIfDisposable(module);
continue;
}
}
#endif
// PerformanceCollectorModule
if (module is PerformanceCollectorModule)
{
if (!this.applicationInsightsServiceOptions.EnablePerformanceCounterCollectionModule)
{
DisposeIfDisposable(module);
continue;
}
}
// AppServicesHeartbeatTelemetryModule
if (module is AppServicesHeartbeatTelemetryModule appServicesHeartbeatTelemetryModule)
{
if (!this.applicationInsightsServiceOptions.EnableAppServicesHeartbeatTelemetryModule)
{
DisposeIfDisposable(module);
continue;
}
else if (diagModule != null)
{
// diagModule is set to Null above if (applicationInsightsServiceOptions.EnableDiagnosticsTelemetryModule || this.applicationInsightsServiceOptions.EnableHeartbeat) == false.
appServicesHeartbeatTelemetryModule.HeartbeatPropertyManager = diagModule;
}
}
// AzureInstanceMetadataTelemetryModule
if (module is AzureInstanceMetadataTelemetryModule azureInstanceMetadataTelemetryModule)
{
if (!this.applicationInsightsServiceOptions.EnableAzureInstanceMetadataTelemetryModule)
{
DisposeIfDisposable(module);
continue;
}
else if (diagModule != null)
{
// diagModule is set to Null above if (applicationInsightsServiceOptions.EnableDiagnosticsTelemetryModule || this.applicationInsightsServiceOptions.EnableHeartbeat) == false.
azureInstanceMetadataTelemetryModule.HeartbeatPropertyManager = diagModule;
}
}
// QuickPulseTelemetryModule
if (module is QuickPulseTelemetryModule)
{
if (!this.applicationInsightsServiceOptions.EnableQuickPulseMetricStream)
{
DisposeIfDisposable(module);
continue;
}
}
try
{
module.Initialize(configuration);
}
catch (Exception ex)
{
#if AI_ASPNETCORE_WEB
AspNetCoreEventSource.Instance.TelemetryModuleInitialziationSetupFailure(module.GetType().FullName, ex.ToInvariantString());
#else
WorkerServiceEventSource.Instance.TelemetryModuleInitialziationSetupFailure(module.GetType().FullName, ex.ToInvariantString());
#endif
}
}
foreach (ITelemetryProcessor processor in configuration.TelemetryProcessors)
{
ITelemetryModule module = processor as ITelemetryModule;
if (module != null)
{
module.Initialize(configuration);
}
}
// Microsoft.ApplicationInsights.DependencyCollector.DependencyTrackingTelemetryModule depends on this nullable configuration to support Correlation.
configuration.ApplicationIdProvider = this.applicationIdProvider;
#if AI_ASPNETCORE_WEB
AspNetCoreEventSource.Instance.LogInformational("Successfully configured TelemetryConfiguration.");
#else
WorkerServiceEventSource.Instance.LogInformational("Successfully configured TelemetryConfiguration.");
#endif
}
catch (Exception ex)
{
#if AI_ASPNETCORE_WEB
AspNetCoreEventSource.Instance.TelemetryConfigurationSetupFailure(ex.ToInvariantString());
#else
WorkerServiceEventSource.Instance.TelemetryConfigurationSetupFailure(ex.ToInvariantString());
#endif
}
}
