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 MockTelemetryInitializer());
DependencyTrackingTelemetryModule module = new DependencyTrackingTelemetryModule();
module.Initialize(configuration);
this.telemetryClient = new TelemetryClient(configuration);
var operationHolder = this.telemetryClient.StartOperation<DependencyTelemetry>("operationName");
this.telemetry = operationHolder.Telemetry;
this.webRequest = WebRequest.Create(new Uri("http://bing.com"));
this.sqlRequest = new SqlCommand("select * from table;");
}
private DependencyTrackingTelemetryModule CreateDependencyTrackingModule(
bool enableDiagnosticSource,
bool enableW3C,
bool enableRequestIdInW3CMode,
bool injectLegacyHeaders)
{
Activity.DefaultIdFormat = enableW3C ? ActivityIdFormat.W3C : ActivityIdFormat.Hierarchical;
Activity.ForceDefaultIdFormat = true;
var module = new DependencyTrackingTelemetryModule();
if (!enableDiagnosticSource)
{
module.DisableDiagnosticSourceInstrumentation = true;
}
module.EnableLegacyCorrelationHeadersInjection = injectLegacyHeaders;
module.EnableRequestIdHeaderInjectionInW3CMode = enableRequestIdInW3CMode;
module.Initialize(this.config);
Assert.AreEqual(enableDiagnosticSource, DependencyTableStore.IsDesktopHttpDiagnosticSourceActivated);
return(module);
}
private static DependencyTrackingTelemetryModule BuildDependencyTrackingTelemetryModule()
{
List <string> excludeComponentCorrelationHttpHeadersOnDomains = new List <string>
{
"core.windows.net",
"core.chinacloudapi.cn",
"core.cloudapi.de",
"core.usgovcloudapi.net",
"localhost",
"127.0.0.1"
};
DependencyTrackingTelemetryModule depModule = new DependencyTrackingTelemetryModule();
foreach (string excludeComponent in excludeComponentCorrelationHttpHeadersOnDomains)
{
depModule.ExcludeComponentCorrelationHttpHeadersOnDomains.Add(excludeComponent);
}
depModule.IncludeDiagnosticSourceActivities.Add("Microsoft.Azure.ServiceBus");
depModule.IncludeDiagnosticSourceActivities.Add("Microsoft.Azure.EventHubs");
return(depModule);
}
public async Task TestDependencyCollectionWithW3COnRequestIdOff()
{
using (var module = new DependencyTrackingTelemetryModule())
{
module.EnableRequestIdHeaderInjectionInW3CMode = false;
module.Initialize(this.config);
var parent = new Activity("parent")
.Start();
var url = new Uri(localhostUrl);
var request = new HttpRequestMessage(HttpMethod.Get, url);
using (new LocalServer(localhostUrl))
{
await new HttpClient().SendAsync(request);
}
// DiagnosticSource Response event is fired after SendAsync returns on netcoreapp1.*
// let's wait until dependency is collected
Assert.IsTrue(SpinWait.SpinUntil(() => this.sentTelemetry != null, TimeSpan.FromSeconds(1)));
this.ValidateTelemetryForDiagnosticSource(
item: this.sentTelemetry.Single(),
url: url,
request: request,
success: true,
resultCode: "200",
expectLegacyHeaders: false,
expectW3CHeaders: true,
expectRequestId: false,
responseExpected: true,
parentActivity: parent);
parent.Stop();
}
}
private static void SetupTelemetrics()
{
if (GlobalConfig.ErrorReporting)
{
Configuration = TelemetryConfiguration.CreateDefault();
Configuration.InstrumentationKey =
Encoding.ASCII.GetString(Convert.FromBase64String(GlobalConfig.AppInsightsKey));
var module = new DependencyTrackingTelemetryModule();
module.ExcludeComponentCorrelationHttpHeadersOnDomains.Add("core.windows.net");
module.IncludeDiagnosticSourceActivities.Add("Microsoft.Azure.ServiceBus");
module.IncludeDiagnosticSourceActivities.Add("Microsoft.Azure.EventHubs");
Configuration.TelemetryInitializers.Add(
new ApplicationInsightsInitializer(Configuration.InstrumentationKey));
Configuration.TelemetryInitializers.Add(new OperationCorrelationTelemetryInitializer());
Configuration.TelemetryInitializers.Add(new HttpDependenciesParsingTelemetryInitializer());
module.Initialize(Configuration);
AiContext = new TelemetryClient(Configuration);
}
}
public static TelemetryClient InitializeTelemetryClient(
IConfiguration config,
string cloudRoleName,
string cloudRoleInstance)
{
var telemetryConfig = TelemetryConfiguration.CreateDefault();
telemetryConfig.InstrumentationKey = config["APPINSIGHTS_INSTRUMENTATIONKEY"];
var insights = new TelemetryClient(telemetryConfig);
//insights.TrackTrace("Examples.Pipeline.MessageGenerator.Main");
var module = new DependencyTrackingTelemetryModule();
module.IncludeDiagnosticSourceActivities.Add("Microsoft.Azure.ServiceBus");
module.IncludeDiagnosticSourceActivities.Add("Microsoft.Azure.EventHubs");
module.Initialize(telemetryConfig);
telemetryConfig.TelemetryInitializers.Add(new OperationCorrelationTelemetryInitializer());
QuickPulseTelemetryProcessor processor = null;
telemetryConfig.TelemetryProcessorChainBuilder
.Use((next) =>
{
processor = new QuickPulseTelemetryProcessor(next);
return(processor);
})
.Build();
var QuickPulse = new QuickPulseTelemetryModule();
QuickPulse.Initialize(telemetryConfig);
QuickPulse.RegisterTelemetryProcessor(processor);
insights.Context.Cloud.RoleName = cloudRoleName;
insights.Context.Cloud.RoleInstance = cloudRoleInstance;
return(insights);
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app,
IWebHostEnvironment env,
IOptions <AppInsightsOptions> options,
TelemetryConfiguration configuration,
DependencyTrackingTelemetryModule module)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
app.UseHttpsRedirection();
app.UseRouting();
app.UseAuthorization();
app.UseEndpoints(endpoints =>
{
endpoints.MapControllers();
});
module.Initialize(configuration);
}
void SetUpTelemetryClient()
{
var module = new DependencyTrackingTelemetryModule();
// Currently it seems have a problem https://github.com/microsoft/ApplicationInsights-dotnet-server/issues/536
module.ExcludeComponentCorrelationHttpHeadersOnDomains.Add("core.windows.net");
module.ExcludeComponentCorrelationHttpHeadersOnDomains.Add("127.0.0.1");
TelemetryConfiguration config = TelemetryConfiguration.CreateDefault();
#pragma warning disable CS0618 // Type or member is obsolete
var telemetryInitializer = new DurableTaskCorrelationTelemetryInitializer();
#pragma warning restore CS0618 // Type or member is obsolete
// TODO It should be suppressed by DependencyTrackingTelemetryModule, however, it doesn't work currently.
// Once the bug is fixed, remove this settings.
telemetryInitializer.ExcludeComponentCorrelationHttpHeadersOnDomains.Add("127.0.0.1");
config.TelemetryInitializers.Add(telemetryInitializer);
config.InstrumentationKey = Environment.GetEnvironmentVariable("APPINSIGHTS_INSTRUMENTATIONKEY");
module.Initialize(config);
telemetryClient = new TelemetryClient(config);
}
private static void InitializeTelemetry()
{
var isDebugging = Debugger.IsAttached;
var config = TelemetryConfiguration.CreateDefault();
if (!isDebugging)
{
config.InstrumentationKey = "9fcef3c7-f401-41c7-9e91-1f6029c8dcc3";
}
var dependencyTracking = new DependencyTrackingTelemetryModule();
dependencyTracking.ExcludeComponentCorrelationHttpHeadersOnDomains.Add("core.windows.net");
dependencyTracking.Initialize(config);
config.TelemetryInitializers.Add(new HttpDependenciesParsingTelemetryInitializer());
var channel = new InMemoryChannel {
DeveloperMode = isDebugging
};
config.TelemetryChannel = channel;
s_telemetryClient = new TelemetryClient(config);
}
public static void Run()
{
TelemetryConfiguration configuration = new TelemetryConfiguration();
configuration.InstrumentationKey = "fb8a0b03-235a-4b52-b491-307e9fd6b209";
// automatically track dependency calls
var dependencies = new DependencyTrackingTelemetryModule();
dependencies.Initialize(configuration);
// automatically correlate all telemetry data with request
configuration.TelemetryInitializers.Add(new OperationCorrelationTelemetryInitializer());
// set default properties for all telemetry items
configuration.TelemetryInitializers.Add(new DefaultTelemetryInitializer());
// send all event telemetry to a different iKey
configuration.TelemetryInitializers.Add(new BusinessTelemetryInitializer());
// configure all telemetry to be sent to a single node
configuration.TelemetryInitializers.Add(new NodeNameTelemetryInitializer());
// initialize price calculation logic
var state = new _State();
state.Initialize();
// enable sampling
configuration.TelemetryProcessorChainBuilder
// this telemetry processor will be executed first for all telemetry items to calculate the size and # of items
.Use((next) => { return(new PriceCalculatorTelemetryProcessor(next, state.Collected)); })
// this telemetry processor will be execuyted ONLY when telemetry is sampled in
.Use((next) => { return(new PriceCalculatorTelemetryProcessor(next, state.Sent)); })
.Build();
TelemetryClient client = new TelemetryClient(configuration);
var iterations = 0;
// configure metrics collection
MetricManager metricManager = new MetricManager(client);
var itemsProcessed = metricManager.CreateMetric("Iterations");
var processingFailed = metricManager.CreateMetric("Failed processing");
var processingSize = metricManager.CreateMetric("Processing size");
while (!state.IsTerminated)
{
iterations++;
using (var operaiton = client.StartOperation <RequestTelemetry>("Process item"))
{
client.TrackEvent("test");
client.TrackTrace("Something happened", SeverityLevel.Information);
try
{
HttpClient http = new HttpClient();
var task = http.GetStringAsync("http://bing.com");
task.Wait();
// metrics aggregation. Metrics are aggregated and sent once per minute
itemsProcessed.Track(1);
processingSize.Track(task.Result.Length);
processingFailed.Track(0);
// raw metric telemetry. Each call represents a document.
client.TrackMetric("[RAW] Response size", task.Result.Length);
}
catch (Exception exc)
{
// raw metric telemetry
client.TrackMetric("[RAW] Successful responses", 0);
// metrics aggregation:
processingFailed.Track(1);
client.TrackException(exc);
operaiton.Telemetry.Success = false;
}
finally
{
client.TrackMetric("[RAW] Iterations", 1);
itemsProcessed.Track(1);
}
// client.StopOperation(operaiton);
// Console.WriteLine($"Iteration {iterations}. Elapesed time: {operaiton.Telemetry.Duration}");
}
}
// send all metrics before exiting the program
metricManager.Flush();
Console.WriteLine($"Program sent 100K of telemetry in {iterations} iterations!");
Console.ReadLine();
}
/// <summary>
/// Adds Application Insights services into service collection.
/// </summary>
/// <param name="services">The <see cref="IServiceCollection"/> instance.</param>
/// <param name="options">The action used to configure the options.</param>
/// <returns>
/// The <see cref="IServiceCollection"/>.
/// </returns>
public static IServiceCollection AddApplicationInsightsTelemetry(this IServiceCollection services)
{
if (!IsApplicationInsightsAdded(services))
{
services.TryAddSingleton <IHttpContextAccessor, HttpContextAccessor>();
services.AddSingleton <ITelemetryInitializer, AzureWebAppRoleEnvironmentTelemetryInitializer>();
services.AddSingleton <ITelemetryInitializer, DomainNameRoleInstanceTelemetryInitializer>();
services.AddSingleton <ITelemetryInitializer, ComponentVersionTelemetryInitializer>();
services.AddSingleton <ITelemetryInitializer, ClientIpHeaderTelemetryInitializer>();
services.AddSingleton <ITelemetryInitializer, OperationNameTelemetryInitializer>();
services.AddSingleton <ITelemetryInitializer, ApplicationInsights.AspNetCore.TelemetryInitializers.OperationCorrelationTelemetryInitializer>();
services.AddSingleton <ITelemetryInitializer, SyntheticTelemetryInitializer>();
services.AddSingleton <ITelemetryInitializer, WebSessionTelemetryInitializer>();
services.AddSingleton <ITelemetryInitializer, WebUserTelemetryInitializer>();
services.AddSingleton <ITelemetryInitializer, AspNetCoreEnvironmentTelemetryInitializer>();
services.AddSingleton <ITelemetryInitializer, HttpDependenciesParsingTelemetryInitializer>();
services.AddSingleton <ITelemetryModule, DependencyTrackingTelemetryModule>(provider => {
var module = new DependencyTrackingTelemetryModule();
var excludedDomains = module.ExcludeComponentCorrelationHttpHeadersOnDomains;
excludedDomains.Add("core.windows.net");
excludedDomains.Add("core.chinacloudapi.cn");
excludedDomains.Add("core.cloudapi.de");
excludedDomains.Add("core.usgovcloudapi.net");
excludedDomains.Add("localhost");
excludedDomains.Add("127.0.0.1");
var includedActivities = module.IncludeDiagnosticSourceActivities;
includedActivities.Add("Microsoft.Azure.EventHubs");
includedActivities.Add("Microsoft.Azure.ServiceBus");
return(module);
});
#if NET451 || NET46
services.AddSingleton <ITelemetryModule, PerformanceCollectorModule>();
#endif
services.AddSingleton <TelemetryConfiguration>(provider => provider.GetService <IOptions <TelemetryConfiguration> >().Value);
services.AddSingleton <ICorrelationIdLookupHelper>(provider => new CorrelationIdLookupHelper(() => provider.GetService <IOptions <TelemetryConfiguration> >().Value));
services.AddSingleton <TelemetryClient>();
services.AddSingleton <ApplicationInsightsInitializer, ApplicationInsightsInitializer>();
services.AddSingleton <IApplicationInsightDiagnosticListener, HostingDiagnosticListener>();
services.AddSingleton <IApplicationInsightDiagnosticListener, MvcDiagnosticsListener>();
// Using startup filter instead of starting DiagnosticListeners directly because
// AspNetCoreHostingDiagnosticListener injects TelemetryClient that injects TelemetryConfiguration
// that requires IOptions infrastructure to run and initialize
services.AddSingleton <IStartupFilter, ApplicationInsightsStartupFilter>();
services.AddSingleton <JavaScriptSnippet>();
services.AddSingleton <ApplicationInsightsLoggerEvents>();
services.AddOptions();
services.AddSingleton <IOptions <TelemetryConfiguration>, TelemetryConfigurationOptions>();
services.AddSingleton <IConfigureOptions <TelemetryConfiguration>, TelemetryConfigurationOptionsSetup>();
}
return(services);
}
public static async Task RunAsync(CancellationToken token)
{
// set Instrumentation Key
var configuration = new TelemetryConfiguration();
configuration.InstrumentationKey = "fb8a0b03-235a-4b52-b491-307e9fd6b209";
// automatically track dependency calls
var dependencies = new DependencyTrackingTelemetryModule();
dependencies.Initialize(configuration);
// automatically correlate all telemetry data with request
configuration.TelemetryInitializers.Add(new OperationCorrelationTelemetryInitializer());
// initialize state for the telemetry size calculation
var collectedItems = new ProcessedItems();
var sentItems = new ProcessedItems();
// build telemetry processing pipeline
configuration.TelemetryProcessorChainBuilder
// this telemetry processor will be executed first for all telemetry items to calculate the size and # of items
.Use((next) => { return(new SizeCalculatorTelemetryProcessor(next, collectedItems)); })
// this is a standard fixed sampling processor that will let only 10%
.Use((next) =>
{
return(new SamplingTelemetryProcessor(next)
{
IncludedTypes = "Dependency",
SamplingPercentage = 10,
});
})
// this is a standard adaptive sampling telemetry processor that will sample in/out any telemetry item it receives
.Use((next) =>
{
return(new AdaptiveSamplingTelemetryProcessor(next)
{
ExcludedTypes = "Event", // exclude custom events from being sampled
MaxTelemetryItemsPerSecond = 1, // default: 5 calls/sec
SamplingPercentageIncreaseTimeout = TimeSpan.FromSeconds(1), // default: 2 min
SamplingPercentageDecreaseTimeout = TimeSpan.FromSeconds(1), // default: 30 sec
EvaluationInterval = TimeSpan.FromSeconds(1), // default: 15 sec
InitialSamplingPercentage = 25, // default: 100%
});
})
// this telemetry processor will be execuyted ONLY when telemetry is sampled in
.Use((next) => { return(new SizeCalculatorTelemetryProcessor(next, sentItems)); })
.Build();
var client = new TelemetryClient(configuration);
// configure metrics collection
MetricManager metricManager = new MetricManager(client);
var reductionsize = metricManager.CreateMetric("Reduction Size");
var iteration = 0;
var http = new HttpClient();
while (!token.IsCancellationRequested)
{
iteration++;
using (var operation = client.StartOperation <RequestTelemetry>("Process item"))
{
client.TrackEvent("test", new Dictionary <string, string>()
{
{ "iteration", iteration.ToString() }
});
client.TrackTrace($"Iteration {iteration} happened", SeverityLevel.Information);
try
{
await http.GetStringAsync("http://bing.com");
}
catch (Exception exc)
{
client.TrackException(exc);
operation.Telemetry.Success = false;
}
client.StopOperation(operation);
Console.WriteLine($"Iteration {iteration}. Elapsed time: {operation.Telemetry.Duration}. Collected Telemetry: {collectedItems.Size}/{collectedItems.Count}. Sent Telemetry: {sentItems.Size}/{sentItems.Count}. Ratio: {1.0 * collectedItems.Size / sentItems.Size}");
reductionsize.Track(collectedItems.Size - sentItems.Size);
#pragma warning disable 0618
client.TrackMetric("[RAW] Reduction Size", collectedItems.Size - sentItems.Size);
#pragma warning restore 0618
}
}
}
public static async Task RunAsync(CancellationToken token)
{
// set Instrumentation Key
var configuration = new TelemetryConfiguration();
configuration.InstrumentationKey = "fb8a0b03-235a-4b52-b491-307e9fd6b209";
// automatically track dependency calls
var dependencies = new DependencyTrackingTelemetryModule();
dependencies.Initialize(configuration);
// automatically correlate all telemetry data with request
configuration.TelemetryInitializers.Add(new OperationCorrelationTelemetryInitializer());
// initialize state for the telemetry size calculation
var collectedItems = new ProcessedItems();
var sentItems = new ProcessedItems();
// enable sampling
configuration.TelemetryProcessorChainBuilder
// this telemetry processor will be executed first for all telemetry items to calculate the size and # of items
.Use((next) => { return(new SizeCalculatorTelemetryProcessor(next, collectedItems)); })
// exemplify dependency telemetry that is faster than 100 msec
.Use((next) => { return(new DependencyExampleTelemetryProcessor(next)); })
// sample all telemetry to 10%
.Use((next) =>
{
return(new SamplingTelemetryProcessor(next)
{
SamplingPercentage = 10,
});
})
// this telemetry processor will be execuyted ONLY when telemetry is sampled in
.Use((next) => { return(new SizeCalculatorTelemetryProcessor(next, sentItems)); })
.Build();
var client = new TelemetryClient(configuration);
var iteration = 0;
var http = new HttpClient();
while (!token.IsCancellationRequested)
{
using (var operation = client.StartOperation <RequestTelemetry>("Process item"))
{
client.TrackEvent("IterationStarted", properties: new Dictionary <string, string>()
{
{ "iteration", iteration.ToString() }
});
client.TrackTrace($"Iteration {iteration} started", SeverityLevel.Information);
try
{
await http.GetStringAsync("http://bing.com");
}
catch (Exception exc)
{
client.TrackException(exc);
operation.Telemetry.Success = false;
}
client.StopOperation(operation);
Console.WriteLine($"Iteration {iteration}. Elapsed time: {operation.Telemetry.Duration}. Collected Telemetry: {collectedItems.Size}/{collectedItems.Count}. Sent Telemetry: {sentItems.Size}/{sentItems.Count}. Ratio: {1.0 * collectedItems.Size / sentItems.Size}");
iteration++;
}
}
}
private static void RegisterApplicationInsightsTelemetryModules(TelemetryConfiguration configuration)
{
RegisterApplicationInsightsTelemetryModule(
new AppServicesHeartbeatTelemetryModule(),
configuration);
RegisterApplicationInsightsTelemetryModule(
new AzureInstanceMetadataTelemetryModule(),
configuration);
RegisterApplicationInsightsTelemetryModule(
new DeveloperModeWithDebuggerAttachedTelemetryModule(),
configuration);
RegisterApplicationInsightsTelemetryModule(
new UnhandledExceptionTelemetryModule(),
configuration);
RegisterApplicationInsightsTelemetryModule(
new UnobservedExceptionTelemetryModule(),
configuration);
var requestTrackingModule = new RequestTrackingTelemetryModule();
requestTrackingModule.Handlers.Add("Microsoft.VisualStudio.Web.PageInspector.Runtime.Tracing.RequestDataHttpHandler");
requestTrackingModule.Handlers.Add("System.Web.StaticFileHandler");
requestTrackingModule.Handlers.Add("System.Web.Handlers.AssemblyResourceLoader");
requestTrackingModule.Handlers.Add("System.Web.Optimization.BundleHandler");
requestTrackingModule.Handlers.Add("System.Web.Script.Services.ScriptHandlerFactory");
requestTrackingModule.Handlers.Add("System.Web.Handlers.TraceHandler");
requestTrackingModule.Handlers.Add("System.Web.Services.Discovery.DiscoveryRequestHandler");
requestTrackingModule.Handlers.Add("System.Web.HttpDebugHandler");
RegisterApplicationInsightsTelemetryModule(
requestTrackingModule,
configuration);
RegisterApplicationInsightsTelemetryModule(
new ExceptionTrackingTelemetryModule(),
configuration);
RegisterApplicationInsightsTelemetryModule(
new AspNetDiagnosticTelemetryModule(),
configuration);
var dependencyTrackingModule = new DependencyTrackingTelemetryModule();
dependencyTrackingModule.ExcludeComponentCorrelationHttpHeadersOnDomains.Add("core.windows.net");
dependencyTrackingModule.ExcludeComponentCorrelationHttpHeadersOnDomains.Add("core.chinacloudapi.cn");
dependencyTrackingModule.ExcludeComponentCorrelationHttpHeadersOnDomains.Add("core.cloudapi.de");
dependencyTrackingModule.ExcludeComponentCorrelationHttpHeadersOnDomains.Add("core.usgovcloudapi.net");
dependencyTrackingModule.IncludeDiagnosticSourceActivities.Add("Microsoft.Azure.EventHubs");
dependencyTrackingModule.IncludeDiagnosticSourceActivities.Add("Microsoft.Azure.ServiceBus");
RegisterApplicationInsightsTelemetryModule(
dependencyTrackingModule,
configuration);
RegisterApplicationInsightsTelemetryModule(
new PerformanceCollectorModule(),
configuration);
RegisterApplicationInsightsTelemetryModule(
new QuickPulseTelemetryModule(),
configuration);
}
public static IServiceCollection AddApplicationInsights(this IServiceCollection services)
{
services.TryAddSingleton <ISdkVersionProvider, WebJobsSdkVersionProvider>();
// Bind to the configuration section registered with
services.AddOptions <ApplicationInsightsLoggerOptions>()
.Configure <ILoggerProviderConfiguration <ApplicationInsightsLoggerProvider> >((options, config) =>
{
config.Configuration?.Bind(options);
});
services.AddSingleton <ITelemetryInitializer, HttpDependenciesParsingTelemetryInitializer>();
services.AddSingleton <ITelemetryInitializer, WebJobsRoleEnvironmentTelemetryInitializer>();
services.AddSingleton <ITelemetryInitializer, WebJobsSanitizingInitializer>();
services.AddSingleton <ITelemetryInitializer, WebJobsTelemetryInitializer>();
services.AddSingleton <ITelemetryModule, QuickPulseTelemetryModule>();
services.AddSingleton <ITelemetryModule>(provider =>
{
ApplicationInsightsLoggerOptions options = provider.GetService <IOptions <ApplicationInsightsLoggerOptions> >().Value;
if (options.EnablePerformanceCountersCollection)
{
return(new PerformanceCollectorModule());
}
return(NullTelemetryModule.Instance);
});
services.AddSingleton <IApplicationIdProvider, ApplicationInsightsApplicationIdProvider>();
services.AddSingleton <ITelemetryModule, DependencyTrackingTelemetryModule>(provider =>
{
var options = provider.GetService <IOptions <ApplicationInsightsLoggerOptions> >().Value;
var dependencyCollector = new DependencyTrackingTelemetryModule();
var excludedDomains = dependencyCollector.ExcludeComponentCorrelationHttpHeadersOnDomains;
excludedDomains.Add("core.windows.net");
excludedDomains.Add("core.chinacloudapi.cn");
excludedDomains.Add("core.cloudapi.de");
excludedDomains.Add("core.usgovcloudapi.net");
excludedDomains.Add("localhost");
excludedDomains.Add("127.0.0.1");
var includedActivities = dependencyCollector.IncludeDiagnosticSourceActivities;
includedActivities.Add("Microsoft.Azure.ServiceBus");
dependencyCollector.EnableW3CHeadersInjection = options.HttpAutoCollectionOptions.EnableW3CDistributedTracing;
return(dependencyCollector);
});
services.AddSingleton <ITelemetryModule>(provider =>
{
var options = provider.GetService <IOptions <ApplicationInsightsLoggerOptions> >().Value;
if (options.HttpAutoCollectionOptions.EnableHttpTriggerExtendedInfoCollection)
{
var appIdProvider = provider.GetService <IApplicationIdProvider>();
return(new RequestTrackingTelemetryModule(appIdProvider)
{
CollectionOptions = new RequestCollectionOptions
{
TrackExceptions = false, // webjobs/functions track exceptions themselves
EnableW3CDistributedTracing = options.HttpAutoCollectionOptions.EnableW3CDistributedTracing,
InjectResponseHeaders = options.HttpAutoCollectionOptions.EnableResponseHeaderInjection
}
});
}
return(NullTelemetryModule.Instance);
});
services.AddSingleton <ITelemetryModule, AppServicesHeartbeatTelemetryModule>();
services.AddSingleton <ITelemetryChannel, ServerTelemetryChannel>();
services.AddSingleton <TelemetryConfiguration>(provider =>
{
ApplicationInsightsLoggerOptions options = provider.GetService <IOptions <ApplicationInsightsLoggerOptions> >().Value;
LoggerFilterOptions filterOptions = CreateFilterOptions(provider.GetService <IOptions <LoggerFilterOptions> >().Value);
ITelemetryChannel channel = provider.GetService <ITelemetryChannel>();
TelemetryConfiguration config = TelemetryConfiguration.CreateDefault();
IApplicationIdProvider appIdProvider = provider.GetService <IApplicationIdProvider>();
ISdkVersionProvider sdkVersionProvider = provider.GetService <ISdkVersionProvider>();
// Because of https://github.com/Microsoft/ApplicationInsights-dotnet-server/issues/943
// we have to touch (and create) Active configuration before initializing telemetry modules
// Active configuration is used to report AppInsights heartbeats
// role environment telemetry initializer is needed to correlate heartbeats to particular host
var activeConfig = TelemetryConfiguration.Active;
if (!string.IsNullOrEmpty(options.InstrumentationKey) &&
string.IsNullOrEmpty(activeConfig.InstrumentationKey))
{
activeConfig.InstrumentationKey = options.InstrumentationKey;
}
if (!activeConfig.TelemetryInitializers.OfType <WebJobsRoleEnvironmentTelemetryInitializer>().Any())
{
activeConfig.TelemetryInitializers.Add(new WebJobsRoleEnvironmentTelemetryInitializer());
activeConfig.TelemetryInitializers.Add(new WebJobsTelemetryInitializer(sdkVersionProvider));
if (options.HttpAutoCollectionOptions.EnableW3CDistributedTracing)
{
// W3C distributed tracing is enabled by the feature flag inside ApplicationInsights SDK
// W3COperationCorrelationTelemetryInitializer will go away once W3C is implemented
// in the DiagnosticSource (.NET)
TelemetryConfiguration.Active.TelemetryInitializers.Add(new W3COperationCorrelationTelemetryInitializer());
}
}
SetupTelemetryConfiguration(
config,
options,
channel,
provider.GetServices <ITelemetryInitializer>(),
provider.GetServices <ITelemetryModule>(),
appIdProvider,
filterOptions);
return(config);
});
services.AddSingleton <TelemetryClient>(provider =>
{
TelemetryConfiguration configuration = provider.GetService <TelemetryConfiguration>();
TelemetryClient client = new TelemetryClient(configuration);
ISdkVersionProvider versionProvider = provider.GetService <ISdkVersionProvider>();
client.Context.GetInternalContext().SdkVersion = versionProvider?.GetSdkVersion();
return(client);
}
);
services.AddSingleton <ILoggerProvider, ApplicationInsightsLoggerProvider>();
return(services);
}
public static IHostBuilder CreateHostBuilder(string[] args)
{
return(Host.CreateDefaultBuilder(args)
.UseWindowsService()
.ConfigureAppConfiguration(cfg =>
{
cfg.SetBasePath(AppDomain.CurrentDomain.BaseDirectory);
})
.ConfigureLogging((context, builder) =>
{
builder.AddConsole();
builder.SetMinimumLevel(LogLevel.Trace);
})
.ConfigureServices((hostContext, services) =>
{
var hostConfig = hostContext.Configuration;
var module = new DependencyTrackingTelemetryModule();
module.IncludeDiagnosticSourceActivities.Add("MassTransit");
TelemetryConfiguration configuration = TelemetryConfiguration.CreateDefault();
configuration.InstrumentationKey = "<your instrumentation key>";
configuration.TelemetryInitializers.Add(new HttpDependenciesParsingTelemetryInitializer());
module.Initialize(configuration);
var loggerOptions = new ApplicationInsightsLoggerOptions();
var applicationInsightsLoggerProvider = new ApplicationInsightsLoggerProvider(Options.Create(configuration),
Options.Create(loggerOptions));
ILoggerFactory factory = new LoggerFactory();
factory.AddProvider(applicationInsightsLoggerProvider);
LogContext.ConfigureCurrentLogContext(factory);
services.AddMassTransit(x =>
{
x.AddConsumersFromNamespaceContaining <SubmitOrderConsumer>();
x.AddBus(context => Bus.Factory.CreateUsingAzureServiceBus(
configurator =>
{
var host =
configurator.Host(hostConfig["AzureServiceBusConnectionString"],
h => { });
configurator.ReceiveEndpoint("submit-order", e =>
{
e.Consumer <SubmitOrderConsumer>();
});
configurator.ReceiveEndpoint("order-observer", e =>
{
e.Consumer <OrderSubmittedConsumer>();
});
configurator.ReceiveEndpoint("order-state", e =>
{
var machine = new OrderStateMachine();
var repository = new InMemorySagaRepository <OrderState>();
e.StateMachineSaga(machine, repository);
EndpointConvention.Map <OrderProcessed>(e.InputAddress);
});
configurator.ReceiveEndpoint("execute-process-order", e =>
{
e.ExecuteActivityHost <ProcessOrderActivity, ProcessOrderArguments>();
EndpointConvention.Map <ProcessOrderArguments>(e.InputAddress);
});
}));
});
services.AddHostedService <WindowsService>();
}));
}
public static void Run()
{
TelemetryConfiguration configuration = new TelemetryConfiguration();
configuration.InstrumentationKey = "fb8a0b03-235a-4b52-b491-307e9fd6b209";
// automatically track dependency calls
var dependencies = new DependencyTrackingTelemetryModule();
dependencies.Initialize(configuration);
// automatically correlate all telemetry data with request
configuration.TelemetryInitializers.Add(new OperationCorrelationTelemetryInitializer());
//// initialize price calculation logic
var state = new _State();
state.Initialize();
// enable sampling
configuration.TelemetryProcessorChainBuilder
// this telemetry processor will be executed first for all telemetry items to calculate the size and # of items
.Use((next) => { return(new PriceCalculatorTelemetryProcessor(next, state.Collected)); })
// this is a standard fixed sampling processor that will let only 10%
.Use((next) =>
{
return(new SamplingTelemetryProcessor(next)
{
IncludedTypes = "Dependency",
SamplingPercentage = 10
});
})
// this is a standard adaptive sampling telemetry processor that will sample in/out any telemetry item it receives
.Use((next) =>
{
return(new AdaptiveSamplingTelemetryProcessor(next)
{
ExcludedTypes = "Event", // exclude custom events from being sampled
MaxTelemetryItemsPerSecond = 1, //default: 5 calls/sec
SamplingPercentageIncreaseTimeout = TimeSpan.FromSeconds(1), //default: 2 min
SamplingPercentageDecreaseTimeout = TimeSpan.FromSeconds(1), //default: 30 sec
EvaluationInterval = TimeSpan.FromSeconds(1), //default: 15 sec
InitialSamplingPercentage = 25 //default: 100%
});
})
// this telemetry processor will be execuyted ONLY when telemetry is sampled in
.Use((next) => { return(new PriceCalculatorTelemetryProcessor(next, state.Sent)); })
.Build();
TelemetryClient client = new TelemetryClient(configuration);
var iterations = 0;
while (!state.IsTerminated)
{
iterations++;
using (var operaiton = client.StartOperation <RequestTelemetry>("Process item"))
{
client.TrackEvent("test");
client.TrackTrace("Something happened", SeverityLevel.Information);
try
{
HttpClient http = new HttpClient();
var task = http.GetStringAsync("http://bing.com");
task.Wait();
}
catch (Exception exc)
{
client.TrackException(exc);
operaiton.Telemetry.Success = false;
}
//client.StopOperation(operaiton);
//Console.WriteLine($"Iteration {iterations}. Elapesed time: {operaiton.Telemetry.Duration}");
}
}
Console.WriteLine($"Program sent 100K of telemetry in {iterations} iterations!");
Console.ReadLine();
}
public static async Task RunAsync(CancellationToken token)
{
// set Instrumentation Key
var configuration = new TelemetryConfiguration();
configuration.InstrumentationKey = "fb8a0b03-235a-4b52-b491-307e9fd6b209";
// automatically track dependency calls
var dependencies = new DependencyTrackingTelemetryModule();
dependencies.Initialize(configuration);
// automatically correlate all telemetry data with request
configuration.TelemetryInitializers.Add(new OperationCorrelationTelemetryInitializer());
QuickPulseTelemetryProcessor processor = null;
// enable Live Metrics
configuration.TelemetryProcessorChainBuilder
// adding LiveMetrics telemetry processor
.Use((next) =>
{
processor = new QuickPulseTelemetryProcessor(next);
return(processor);
})
.Build();
var quickPulse = new QuickPulseTelemetryModule();
quickPulse.Initialize(configuration);
quickPulse.RegisterTelemetryProcessor(processor);
var client = new TelemetryClient(configuration);
var iteration = 0;
var http = new HttpClient();
var rnd = new Random();
while (!token.IsCancellationRequested)
{
iteration++;
using (var operation = client.StartOperation <RequestTelemetry>("Process item"))
{
client.TrackEvent("test", new Dictionary <string, string>()
{
{ "iteration", iteration.ToString() }
});
client.TrackTrace($"Iteration {iteration} happened", SeverityLevel.Information);
var status = rnd.Next() < rnd.Next();
try
{
if (status)
{
throw new Exception($"Failure during processing of iteration #{iteration}");
}
await http.GetStringAsync("http://bing.com");
}
catch (Exception exc)
{
client.TrackException(exc);
}
finally
{
client.StopOperation <RequestTelemetry>(operation);
operation.Telemetry.Success = status;
Console.WriteLine($"Iteration {iteration}. Elapsed time: {operation.Telemetry.Duration}. Success: {operation.Telemetry.Success}");
}
}
}
}
public async Task TestDependencyCollectionNoParentActivity()
{
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 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)));
var item = (DependencyTelemetry)sentTelemetry;
Assert.AreEqual(url, item.Data);
Assert.AreEqual(url.Host, item.Target);
Assert.AreEqual("GET " + url.AbsolutePath, item.Name);
Assert.IsTrue(item.Duration > TimeSpan.FromMilliseconds(0), "Duration has to be positive");
Assert.AreEqual(RemoteDependencyConstants.HTTP, item.Type, "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");
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('|' + item.Context.Operation.Id + '.'));
}
}
public static async Task Main(string[] args)
{
var isService = !(Debugger.IsAttached || args.Contains("--console"));
Log.Logger = new LoggerConfiguration()
.MinimumLevel.Debug()
.MinimumLevel.Override("Microsoft", LogEventLevel.Information)
.Enrich.FromLogContext()
.WriteTo.Console()
.CreateLogger();
var builder = new HostBuilder()
.ConfigureAppConfiguration((hostingContext, config) =>
{
config.AddJsonFile("appsettings.json", true);
config.AddEnvironmentVariables();
if (args != null)
{
config.AddCommandLine(args);
}
})
.ConfigureServices((hostContext, services) =>
{
_module = new DependencyTrackingTelemetryModule();
_module.IncludeDiagnosticSourceActivities.Add("MassTransit");
TelemetryConfiguration configuration = TelemetryConfiguration.CreateDefault();
configuration.InstrumentationKey = "6b4c6c82-3250-4170-97d3-245ee1449276";
configuration.TelemetryInitializers.Add(new HttpDependenciesParsingTelemetryInitializer());
_telemetryClient = new TelemetryClient(configuration);
services.TryAddSingleton(KebabCaseEndpointNameFormatter.Instance);
services.AddMassTransit(cfg =>
{
cfg.AddConsumersFromNamespaceContaining <ReadFileConsumer>();
cfg.UsingRabbitMq(ConfigureBus);
});
services.AddHostedService <MassTransitConsoleHostedService>();
})
.ConfigureLogging((hostingContext, logging) =>
{
logging.AddSerilog(dispose: true);
logging.AddConfiguration(hostingContext.Configuration.GetSection("Logging"));
logging.AddConsole();
});
;
if (isService)
{
await builder.UseWindowsService().Build().RunAsync();
}
else
{
await builder.RunConsoleAsync();
}
_module?.Dispose();
_telemetryClient?.Flush();
Log.CloseAndFlush();
}
/// <summary>
/// This method gets called by the runtime. Use this method to add services to the container.
/// </summary>
/// <param name="services">An instance of <see cref="IServiceCollection"/>.</param>
public void ConfigureServices(IServiceCollection services)
{
this.ConfigureServicesCommon(services);
_ = services.AddMvc();
_ = services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new OpenApiInfo {
Title = "NotificationService", Version = "v1"
});
});
ITelemetryInitializer[] itm = new ITelemetryInitializer[1];
var envInitializer = new EnvironmentInitializer
{
Service = this.Configuration[AIConstants.ServiceConfigName],
ServiceLine = this.Configuration[AIConstants.ServiceLineConfigName],
ServiceOffering = this.Configuration[AIConstants.ServiceOfferingConfigName],
ComponentId = this.Configuration[AIConstants.ComponentIdConfigName],
ComponentName = this.Configuration[AIConstants.ComponentNameConfigName],
EnvironmentName = this.Configuration[AIConstants.EnvironmentName],
IctoId = "IctoId",
};
itm[0] = envInitializer;
NotificationProviders.Common.Logger.LoggingConfiguration loggingConfiguration = new NotificationProviders.Common.Logger.LoggingConfiguration
{
IsTraceEnabled = true,
TraceLevel = (SeverityLevel)Enum.Parse(typeof(SeverityLevel), this.Configuration[ConfigConstants.AITraceLelelConfigKey]),
EnvironmentName = this.Configuration[AIConstants.EnvironmentName],
};
var tconfig = TelemetryConfiguration.CreateDefault();
tconfig.InstrumentationKey = this.Configuration[ConfigConstants.AIInsrumentationConfigKey];
DependencyTrackingTelemetryModule depModule = new DependencyTrackingTelemetryModule();
depModule.Initialize(tconfig);
RequestTrackingTelemetryModule requestTrackingTelemetryModule = new RequestTrackingTelemetryModule();
requestTrackingTelemetryModule.Initialize(tconfig);
_ = services.AddSingleton <NotificationProviders.Common.Logger.ILogger>(_ => new NotificationProviders.Common.Logger.AILogger(loggingConfiguration, tconfig, itm));
_ = services.AddScoped <IEmailManager, EmailManager>(s =>
new EmailManager(
this.Configuration,
s.GetService <IRepositoryFactory>(),
s.GetService <ILogger>(),
s.GetService <IMailTemplateManager>(),
s.GetService <ITemplateMerge>()))
.AddScoped <IEmailServiceManager, EmailServiceManager>(s =>
new EmailServiceManager(this.Configuration, s.GetService <IRepositoryFactory>(), s.GetService <ICloudStorageClient>(), s.GetService <ILogger>(),
s.GetService <INotificationProviderFactory>(), s.GetService <IEmailManager>()))
.AddScoped <ITemplateMerge, TemplateMerge>()
.AddSingleton <IEmailAccountManager, EmailAccountManager>()
.AddScoped <INotificationProviderFactory, NotificationProviderFactory>();
NotificationProviderType providerType = (NotificationProviderType)Enum.Parse(typeof(NotificationProviderType), this.Configuration[ConfigConstants.NotificationProviderType]);
if (NotificationProviderType.DirectSend == providerType)
{
this.ConfigureDirectSendServices(services);
}
else if (NotificationProviderType.SMTP == providerType)
{
this.ConfigureSMTPServices(services);
}
else
{
this.ConfigureGraphServices(services);
}
}
public static IServiceCollection AddApplicationInsights(this IServiceCollection services)
{
services.TryAddSingleton <ISdkVersionProvider, WebJobsSdkVersionProvider>();
// Bind to the configuration section registered with
services.AddOptions <ApplicationInsightsLoggerOptions>()
.Configure <ILoggerProviderConfiguration <ApplicationInsightsLoggerProvider> >((options, config) =>
{
config.Configuration?.Bind(options);
});
services.AddSingleton <ITelemetryInitializer, HttpDependenciesParsingTelemetryInitializer>();
services.AddSingleton <ITelemetryInitializer, WebJobsRoleEnvironmentTelemetryInitializer>();
services.AddSingleton <ITelemetryInitializer, WebJobsTelemetryInitializer>();
services.AddSingleton <ITelemetryInitializer, WebJobsSanitizingInitializer>();
services.AddSingleton <ITelemetryModule, QuickPulseTelemetryModule>();
services.AddSingleton <IApplicationIdProvider, ApplicationInsightsApplicationIdProvider>();
services.AddSingleton <ITelemetryModule, DependencyTrackingTelemetryModule>(provider =>
{
var dependencyCollector = new DependencyTrackingTelemetryModule();
var excludedDomains = dependencyCollector.ExcludeComponentCorrelationHttpHeadersOnDomains;
excludedDomains.Add("core.windows.net");
excludedDomains.Add("core.chinacloudapi.cn");
excludedDomains.Add("core.cloudapi.de");
excludedDomains.Add("core.usgovcloudapi.net");
excludedDomains.Add("localhost");
excludedDomains.Add("127.0.0.1");
var includedActivities = dependencyCollector.IncludeDiagnosticSourceActivities;
includedActivities.Add("Microsoft.Azure.ServiceBus");
return(dependencyCollector);
});
services.AddSingleton <ITelemetryModule, AppServicesHeartbeatTelemetryModule>();
services.AddSingleton <ITelemetryChannel, ServerTelemetryChannel>();
services.AddSingleton <TelemetryConfiguration>(provider =>
{
ApplicationInsightsLoggerOptions options = provider.GetService <IOptions <ApplicationInsightsLoggerOptions> >().Value;
LoggerFilterOptions filterOptions = CreateFilterOptions(provider.GetService <IOptions <LoggerFilterOptions> >().Value);
ITelemetryChannel channel = provider.GetService <ITelemetryChannel>();
TelemetryConfiguration config = TelemetryConfiguration.CreateDefault();
IApplicationIdProvider appIdProvider = provider.GetService <IApplicationIdProvider>();
// Because of https://github.com/Microsoft/ApplicationInsights-dotnet-server/issues/943
// we have to touch (and create) Active configuration before initializing telemetry modules
// Active configuration is used to report AppInsights heartbeats
// role environment telemetry initializer is needed to correlate heartbeats to particular host
var activeConfig = TelemetryConfiguration.Active;
if (!string.IsNullOrEmpty(options.InstrumentationKey) &&
string.IsNullOrEmpty(activeConfig.InstrumentationKey))
{
activeConfig.InstrumentationKey = options.InstrumentationKey;
}
if (!activeConfig.TelemetryInitializers.OfType <WebJobsRoleEnvironmentTelemetryInitializer>().Any())
{
activeConfig.TelemetryInitializers.Add(
new WebJobsRoleEnvironmentTelemetryInitializer());
}
SetupTelemetryConfiguration(
config,
options,
channel,
provider.GetServices <ITelemetryInitializer>(),
provider.GetServices <ITelemetryModule>(),
appIdProvider,
filterOptions);
return(config);
});
services.AddSingleton <TelemetryClient>(provider =>
{
TelemetryConfiguration configuration = provider.GetService <TelemetryConfiguration>();
TelemetryClient client = new TelemetryClient(configuration);
ISdkVersionProvider versionProvider = provider.GetService <ISdkVersionProvider>();
client.Context.GetInternalContext().SdkVersion = versionProvider?.GetSdkVersion();
return(client);
});
services.AddSingleton <ILoggerProvider, ApplicationInsightsLoggerProvider>();
return(services);
}
static void Main_backup(string[] args)
{
var state = new _State();
state.Initialize();
TelemetryConfiguration configuration = new TelemetryConfiguration();
configuration.InstrumentationKey = "fb8a0b03-235a-4b52-b491-307e9fd6b209";
var telemetryChannel = new ServerTelemetryChannel();
telemetryChannel.Initialize(configuration);
configuration.TelemetryChannel = telemetryChannel;
// data collection modules
var dependencies = new DependencyTrackingTelemetryModule();
dependencies.Initialize(configuration);
// telemetry initializers
configuration.TelemetryInitializers.Add(new AppVersionTelemetryInitializer());
configuration.TelemetryInitializers.Add(new DefaultTelemetryInitializer());
configuration.TelemetryInitializers.Add(new BusinessTelemetryInitializer());
configuration.TelemetryInitializers.Add(new NodeNameTelemetryInitializer());
configuration.TelemetryInitializers.Add(new OperationCorrelationTelemetryInitializer());
// telemetry processors
configuration.TelemetryProcessorChainBuilder
.Use((next) => { return(new PriceCalculatorTelemetryProcessor(next, state.Collected)); })
// .Use((next) => { return new MyTelemetryProcessor(next); })
// .Use((next) => { return new CleanAutoCollecctedTelemetryProcessor(next); })
// .Use((next) => { return new ExampleTelemetryProcessor(next); })
// send only 10% of all dependency data
.Use((next) =>
{
return(new SamplingTelemetryProcessor(next)
{
IncludedTypes = "Dependency",
SamplingPercentage = 10
});
})
// start sampling when load exceeds 2 events per second for all telemetry types except events
.Use((next) =>
{
return(new AdaptiveSamplingTelemetryProcessor(next)
{
ExcludedTypes = "Event",
MaxTelemetryItemsPerSecond = 2,
SamplingPercentageIncreaseTimeout = TimeSpan.FromSeconds(1),
SamplingPercentageDecreaseTimeout = TimeSpan.FromSeconds(1),
EvaluationInterval = TimeSpan.FromSeconds(1),
InitialSamplingPercentage = 25
});
})
.Use((next) => { return(new PriceCalculatorTelemetryProcessor(next, state.Sent)); })
.Build();
TelemetryClient client = new TelemetryClient(configuration);
var iterations = 0;
MetricManager metricManager = new MetricManager(client);
var itemsProcessed = metricManager.CreateMetric("Items processed");
var processingFailed = metricManager.CreateMetric("Failed processing");
var processingSize = metricManager.CreateMetric("Processing size");
while (!state.IsTerminated)
{
iterations++;
using (var operaiton = client.StartOperation <RequestTelemetry>("Process item"))
{
client.TrackEvent("test");
client.TrackTrace("Something happened");
try
{
HttpClient http = new HttpClient();
var task = http.GetStringAsync("http://bing.com");
task.Wait();
// metrics aggregation:
//itemsProcessed.Track(1);
//processingSize.Track(task.Result.Length);
//processingFailed.Track(0);
//client.TrackMetric("Response size", task.Result.Length);
//client.TrackMetric("Successful responses", 1);
}
catch (Exception exc)
{
//client.TrackMetric("Successful responses", 0);
//operaiton.Telemetry.Success = false;
// metrics aggregation:
//processingFailed.Track(1);
}
}
}
Console.WriteLine($"Program sent 1Mb of telemetry in {iterations} iterations!");
Console.ReadLine();
}
static async Task Main(string[] args)
{
var isService = !(Debugger.IsAttached || args.Contains("--console"));
Log.Logger = new LoggerConfiguration()
.MinimumLevel.Debug()
.MinimumLevel.Override("Microsoft", LogEventLevel.Information)
.Enrich.FromLogContext()
.WriteTo.Console()
.WriteTo.Seq("http://localhost:5341")
.CreateLogger();
var builder = new HostBuilder()
.ConfigureAppConfiguration((hostingContext, config) =>
{
config.AddJsonFile("appsettings.json", true);
config.AddEnvironmentVariables();
if (args != null)
{
config.AddCommandLine(args);
}
})
.ConfigureServices((hostContext, services) =>
{
_module = new DependencyTrackingTelemetryModule();
_module.IncludeDiagnosticSourceActivities.Add("MassTransit");
TelemetryConfiguration configuration = TelemetryConfiguration.CreateDefault();
configuration.InstrumentationKey = "0bd7dab0-5809-4ce5-b477-c89271124a54";
configuration.TelemetryInitializers.Add(new HttpDependenciesParsingTelemetryInitializer());
_telemetryClient = new TelemetryClient(configuration);
_module.Initialize(configuration);
services.AddScoped <AcceptOrderActivity>();
services.AddScoped <RoutingSlipBatchEventConsumer>();
services.TryAddSingleton(KebabCaseEndpointNameFormatter.Instance);
services.AddMassTransit(cfg =>
{
cfg.AddConsumersFromNamespaceContaining <SubmitOrderConsumer>();
cfg.AddActivitiesFromNamespaceContaining <AllocateInventoryActivity>();
cfg.AddSagaStateMachine <OrderStateMachine, OrderState>(typeof(OrderStateMachineDefinition))
.EntityFrameworkRepository(r =>
{
r.AddDbContext <DbContext, OrderStateDbContext>((provider, builder) =>
{
builder.UseSqlServer("Server=tcp:gertjvr.database.windows.net,1433;Initial Catalog=gertjvr;Persist Security Info=False;User ID=gertjvr;Password=Works4me!;MultipleActiveResultSets=False;Encrypt=True;TrustServerCertificate=False;Connection Timeout=30;", m =>
{
m.MigrationsAssembly(Assembly.GetExecutingAssembly().GetName().Name);
m.MigrationsHistoryTable($"__{nameof(OrderStateDbContext)}");
});
});
});
cfg.UsingAzureServiceBus(ConfigureBus);
cfg.AddRequestClient <AllocateInventory>();
});
services.AddHostedService <MassTransitConsoleHostedService>();
})
.ConfigureLogging((hostingContext, logging) =>
{
logging.AddSerilog(dispose: true);
logging.AddConfiguration(hostingContext.Configuration.GetSection("Logging"));
});
if (isService)
{
await builder.UseWindowsService().Build().RunAsync();
}
else
{
await builder.RunConsoleAsync();
}
_telemetryClient?.Flush();
_module?.Dispose();
Log.CloseAndFlush();
}
/// <summary>
/// This method gets called by the runtime. Use this method to add services to the container.
/// </summary>
/// <param name="services">An instance of <see cref="IServiceCollection"/>.</param>
public void ConfigureServices(IServiceCollection services)
{
this.ConfigureServicesCommon(services);
_ = services.AddMvc();
_ = services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new OpenApiInfo {
Title = "NotificationService", Version = "v1"
});
});
ITelemetryInitializer[] itm = new ITelemetryInitializer[1];
var envInitializer = new EnvironmentInitializer
{
Service = this.Configuration[Constants.ServiceConfigName],
ServiceLine = this.Configuration[Constants.ServiceLineConfigName],
ServiceOffering = this.Configuration[Constants.ServiceOfferingConfigName],
ComponentId = this.Configuration[Constants.ComponentIdConfigName],
ComponentName = this.Configuration[Constants.ComponentNameConfigName],
EnvironmentName = this.Configuration[Constants.EnvironmentName],
IctoId = "IctoId",
};
itm[0] = envInitializer;
NotificationProviders.Common.Logger.LoggingConfiguration loggingConfiguration = new NotificationProviders.Common.Logger.LoggingConfiguration
{
IsTraceEnabled = true,
TraceLevel = (SeverityLevel)Enum.Parse(typeof(SeverityLevel), this.Configuration["ApplicationInsights:TraceLevel"]),
EnvironmentName = this.Configuration[Constants.EnvironmentName],
};
var tconfig = TelemetryConfiguration.CreateDefault();
tconfig.InstrumentationKey = this.Configuration["ApplicationInsights:InstrumentationKey"];
DependencyTrackingTelemetryModule depModule = new DependencyTrackingTelemetryModule();
depModule.Initialize(tconfig);
RequestTrackingTelemetryModule requestTrackingTelemetryModule = new RequestTrackingTelemetryModule();
requestTrackingTelemetryModule.Initialize(tconfig);
_ = services.AddSingleton <NotificationProviders.Common.Logger.ILogger>(_ => new NotificationProviders.Common.Logger.AILogger(loggingConfiguration, tconfig, itm));
_ = services.AddSingleton <SendAccountConfiguration>(new SendAccountConfiguration()
{
DisplayName = this.Configuration["DirectSendSetting:DisplayName"],
});
if (int.TryParse(this.Configuration["DirectSendSetting:SmtpPort"], out int port))
{
_ = services.AddSingleton <ISmtpConfiguration>(new SmtpConfiguration()
{
SmtpPort = port,
SmtpServer = this.Configuration["DirectSendSetting:SmtpServer"]
});
}
_ = services.AddSingleton <ISmtpClientFactory, DSSmtpClientFactory>()
.AddSingleton <ISmtpClientPool, SmtpClientPool>()
.AddSingleton <IEmailService, DirectSendMailService>();
_ = services.AddScoped <INotificationReportManager, NotificationReportManager>()
.AddScoped <IEmailManager, EmailManager>(s =>
new EmailManager(
this.Configuration,
s.GetService <IRepositoryFactory>(),
s.GetService <ILogger>(),
s.GetService <IMailTemplateManager>(),
s.GetService <ITemplateMerge>()))
.AddScoped <IEmailServiceManager, EmailServiceManager>(s =>
new EmailServiceManager(this.Configuration, s.GetService <IRepositoryFactory>(), s.GetService <ICloudStorageClient>(), s.GetService <ILogger>(),
s.GetService <INotificationProviderFactory>(), s.GetService <IEmailManager>()))
.AddScoped <IRepositoryFactory, RepositoryFactory>()
.AddScoped <EmailNotificationRepository>()
.AddScoped <IEmailNotificationRepository, EmailNotificationRepository>(s => s.GetService <EmailNotificationRepository>())
.AddScoped <TableStorageEmailRepository>()
.AddScoped <IEmailNotificationRepository, TableStorageEmailRepository>(s => s.GetService <TableStorageEmailRepository>())
.AddScoped <ITableStorageClient, TableStorageClient>()
.AddScoped <IMailTemplateManager, MailTemplateManager>()
.AddScoped <IMailTemplateRepository, MailTemplateRepository>()
.AddScoped <IMailAttachmentRepository, MailAttachmentRepository>()
.AddScoped <ITemplateMerge, TemplateMerge>()
.AddSingleton <IEmailAccountManager, EmailAccountManager>()
.AddScoped <INotificationProviderFactory, NotificationProviderFactory>()
.AddScoped <DirectSendNotificationProvider>(s => new DirectSendNotificationProvider(this.Configuration, s.GetService <IEmailService>(), s.GetService <ILogger>(), s.GetService <IEmailManager>()))
.AddScoped <INotificationProvider, DirectSendNotificationProvider>()
.AddScoped <MSGraphNotificationProvider>(s => new MSGraphNotificationProvider(this.Configuration, s.GetService <IEmailAccountManager>(), s.GetService <ILogger>(),
Options.Create(this.Configuration.GetSection("MSGraphSetting").Get <MSGraphSetting>()), Options.Create(this.Configuration.GetSection("PollyRetrySetting").Get <RetrySetting>()),
s.GetService <ITokenHelper>(), s.GetService <IMSGraphProvider>(), s.GetService <IEmailManager>()))
.AddScoped <INotificationProvider, MSGraphNotificationProvider>();
}
public static IServiceCollection AddApplicationInsights(this IServiceCollection services)
{
// Bind to the configuration section registered with
services.AddOptions <ApplicationInsightsLoggerOptions>()
.Configure <ILoggerProviderConfiguration <ApplicationInsightsLoggerProvider> >((options, config) =>
{
config.Configuration?.Bind(options);
});
services.AddSingleton <ITelemetryInitializer, HttpDependenciesParsingTelemetryInitializer>();
services.AddSingleton <ITelemetryInitializer, WebJobsRoleEnvironmentTelemetryInitializer>();
services.AddSingleton <ITelemetryInitializer, WebJobsTelemetryInitializer>();
services.AddSingleton <ITelemetryInitializer, WebJobsSanitizingInitializer>();
services.AddSingleton <ITelemetryModule, QuickPulseTelemetryModule>();
services.AddSingleton <IApplicationIdProvider, ApplicationInsightsApplicationIdProvider>();
services.AddSingleton <ITelemetryModule, DependencyTrackingTelemetryModule>(provider =>
{
var dependencyCollector = new DependencyTrackingTelemetryModule();
var excludedDomains = dependencyCollector.ExcludeComponentCorrelationHttpHeadersOnDomains;
excludedDomains.Add("core.windows.net");
excludedDomains.Add("core.chinacloudapi.cn");
excludedDomains.Add("core.cloudapi.de");
excludedDomains.Add("core.usgovcloudapi.net");
excludedDomains.Add("localhost");
excludedDomains.Add("127.0.0.1");
var includedActivities = dependencyCollector.IncludeDiagnosticSourceActivities;
includedActivities.Add("Microsoft.Azure.ServiceBus");
return(dependencyCollector);
});
services.AddSingleton <ITelemetryModule, AppServicesHeartbeatTelemetryModule>();
services.AddSingleton <ITelemetryChannel, ServerTelemetryChannel>();
services.AddSingleton <TelemetryConfiguration>(provider =>
{
ApplicationInsightsLoggerOptions options = provider.GetService <IOptions <ApplicationInsightsLoggerOptions> >().Value;
LoggerFilterOptions filterOptions = CreateFilterOptions(provider.GetService <IOptions <LoggerFilterOptions> >().Value);
ITelemetryChannel channel = provider.GetService <ITelemetryChannel>();
TelemetryConfiguration config = TelemetryConfiguration.CreateDefault();
IApplicationIdProvider appIdProvider = provider.GetService <IApplicationIdProvider>();
SetupTelemetryConfiguration(
config,
options.InstrumentationKey,
options.SamplingSettings,
options.SnapshotConfiguration,
channel,
provider.GetServices <ITelemetryInitializer>(),
provider.GetServices <ITelemetryModule>(),
appIdProvider,
filterOptions);
return(config);
});
services.AddSingleton <TelemetryClient>(provider =>
{
TelemetryConfiguration configuration = provider.GetService <TelemetryConfiguration>();
TelemetryClient client = new TelemetryClient(configuration);
string assemblyVersion = GetAssemblyFileVersion(typeof(JobHost).Assembly);
client.Context.GetInternalContext().SdkVersion = $"webjobs: {assemblyVersion}";
return(client);
});
services.AddSingleton <ILoggerProvider, ApplicationInsightsLoggerProvider>();
return(services);
}
public static void Run()
{
TelemetryConfiguration configuration = new TelemetryConfiguration();
configuration.InstrumentationKey = "ad4a5cd4-9fb3-4e4e-9b9c-9f43e9939bfa";
// automatically track dependency calls
var dependencies = new DependencyTrackingTelemetryModule();
dependencies.Initialize(configuration);
// automatically correlate all telemetry data with request
configuration.TelemetryInitializers.Add(new OperationCorrelationTelemetryInitializer());
// initialize state for the telemetry size calculation
ProcessedItems CollectedItems = new ProcessedItems();
ProcessedItems SentItems = new ProcessedItems();
// build telemetry processing pipeline
configuration.TelemetryProcessorChainBuilder
// this telemetry processor will be executed first for all telemetry items to calculate the size and # of items
.Use((next) => { return(new SizeCalculatorTelemetryProcessor(next, CollectedItems)); })
// this is a standard fixed sampling processor that will let only 10%
.Use((next) =>
{
return(new SamplingTelemetryProcessor(next)
{
IncludedTypes = "Dependency",
SamplingPercentage = 10
});
})
// this is a standard adaptive sampling telemetry processor that will sample in/out any telemetry item it receives
.Use((next) =>
{
return(new AdaptiveSamplingTelemetryProcessor(next)
{
ExcludedTypes = "Event", // exclude custom events from being sampled
MaxTelemetryItemsPerSecond = 1, //default: 5 calls/sec
SamplingPercentageIncreaseTimeout = TimeSpan.FromSeconds(1), //default: 2 min
SamplingPercentageDecreaseTimeout = TimeSpan.FromSeconds(1), //default: 30 sec
EvaluationInterval = TimeSpan.FromSeconds(1), //default: 15 sec
InitialSamplingPercentage = 25 //default: 100%
});
})
// this telemetry processor will be execuyted ONLY when telemetry is sampled in
.Use((next) => { return(new SizeCalculatorTelemetryProcessor(next, SentItems)); })
.Build();
TelemetryClient client = new TelemetryClient(configuration);
var iteration = 0;
while (true)
{
using (var operaiton = client.StartOperation <RequestTelemetry>("Process item"))
{
client.TrackEvent("IterationStarted", new Dictionary <string, string>()
{
{ "iteration", iteration.ToString() }
});
client.TrackTrace($"Iteration {iteration} started", SeverityLevel.Information);
try
{
var task = (new HttpClient()).GetStringAsync("http://bing.com");
task.Wait();
}
catch (Exception exc)
{
client.TrackException(exc);
operaiton.Telemetry.Success = false;
}
client.StopOperation(operaiton);
Console.WriteLine($"Iteration {iteration}. Elapesed time: {operaiton.Telemetry.Duration}. Collected Telemetry: {CollectedItems.size}/{CollectedItems.count}. Sent Telemetry: {SentItems.size}/{SentItems.count}. Ratio: {1.0 * CollectedItems.size / SentItems.size}");
iteration++;
}
}
}
/// <summary>
/// This method gets called by the runtime. Use this method to add services to the container.
/// </summary>
/// <param name="services">An instance of <see cref="IServiceCollection"/>.</param>
public void ConfigureServicesCommon(IServiceCollection services)
{
_ = services.AddAuthorization(configure =>
{
configure.AddPolicy(Constants.AppNameAuthorizePolicy, policy =>
{
policy.Requirements.Add(new AppNameAuthorizeRequirement());
});
configure.AddPolicy(Constants.AppAudienceAuthorizePolicy, policy =>
{
policy.Requirements.Add(new AppAudienceAuthorizeRequirement());
});
});
_ = services.AddSingleton <IAuthorizationHandler, AppNameAuthorizePolicyHandler>(s => new AppNameAuthorizePolicyHandler(s.GetService <IHttpContextAccessor>(), this.Configuration));
_ = services.AddSingleton <IAuthorizationHandler, AppAudienceAuthorizePolicyHandler>(s => new AppAudienceAuthorizePolicyHandler(s.GetService <IHttpContextAccessor>(), this.Configuration));
_ = services.AddControllers();
_ = services.AddApplicationInsightsTelemetry();
_ = services.AddScoped(typeof(ValidateModelAttribute));
_ = services.AddOptions();
_ = services.Configure <MSGraphSetting>(this.Configuration.GetSection("MSGraphSetting"));
_ = services.Configure <MSGraphSetting>(s => s.ClientCredential = this.Configuration["MSGraphSettingClientCredential"]);
_ = services.Configure <MSGraphSetting>(s => s.ClientId = this.Configuration["MSGraphSettingClientId"]);
_ = services.Configure <CosmosDBSetting>(this.Configuration.GetSection("CosmosDB"));
_ = services.Configure <CosmosDBSetting>(s => s.Key = this.Configuration["CosmosDBKey"]);
_ = services.Configure <CosmosDBSetting>(s => s.Uri = this.Configuration["CosmosDBURI"]);
_ = services.Configure <StorageAccountSetting>(this.Configuration.GetSection("StorageAccount"));
_ = services.Configure <StorageAccountSetting>(s => s.ConnectionString = this.Configuration["StorageAccountConnectionString"]);
_ = services.Configure <UserTokenSetting>(this.Configuration.GetSection("UserTokenSetting"));
_ = services.Configure <RetrySetting>(this.Configuration.GetSection("RetrySetting"));
_ = services.AddSingleton <IConfiguration>(this.Configuration);
_ = services.AddSingleton <IEncryptionService, EncryptionService>();
_ = services.AddSingleton <IKeyEncryptionKey, CryptographyClient>(cc => new CryptographyClient(new Uri(this.Configuration["KeyVault:RSAKeyUri"]), new DefaultAzureCredential()));
_ = services.AddTransient <IHttpContextAccessor, HttpContextAccessor>()
.AddScoped <ICosmosLinqQuery, CustomCosmosLinqQuery>()
.AddSingleton <ICosmosDBQueryClient, CosmosDBQueryClient>()
.AddSingleton <ICloudStorageClient, CloudStorageClient>()
.AddScoped <ITokenHelper, TokenHelper>()
.AddHttpClient <IMSGraphProvider, MSGraphProvider>();
_ = services.AddHttpContextAccessor();
_ = services.AddAuthentication("Bearer").AddJwtBearer(options =>
{
options.Authority = this.Configuration["Authority"];
options.ClaimsIssuer = this.Configuration["BearerTokenAuthentication:Issuer"];
options.TokenValidationParameters = new Microsoft.IdentityModel.Tokens.TokenValidationParameters()
{
ValidateIssuer = true,
ValidAudiences = this.Configuration["BearerTokenAuthentication:ValidAudiences"].Split(Constants.SplitCharacter),
};
});
ITelemetryInitializer[] itm = new ITelemetryInitializer[1];
var envInitializer = new EnvironmentInitializer
{
Service = this.Configuration[Constants.ServiceConfigName],
ServiceLine = this.Configuration[Constants.ServiceLineConfigName],
ServiceOffering = this.Configuration[Constants.ServiceOfferingConfigName],
ComponentId = this.Configuration[Constants.ComponentIdConfigName],
ComponentName = this.Configuration[Constants.ComponentNameConfigName],
EnvironmentName = this.Configuration[Constants.EnvironmentName],
IctoId = "IctoId",
};
itm[0] = envInitializer;
LoggingConfiguration loggingConfiguration = new LoggingConfiguration
{
IsTraceEnabled = true,
TraceLevel = (SeverityLevel)Enum.Parse(typeof(SeverityLevel), this.Configuration["ApplicationInsights:TraceLevel"]),
EnvironmentName = this.Configuration[Constants.EnvironmentName],
};
var tconfig = TelemetryConfiguration.CreateDefault();
tconfig.InstrumentationKey = this.Configuration["ApplicationInsights:InstrumentationKey"];
DependencyTrackingTelemetryModule depModule = new DependencyTrackingTelemetryModule();
depModule.Initialize(tconfig);
RequestTrackingTelemetryModule requestTrackingTelemetryModule = new RequestTrackingTelemetryModule();
requestTrackingTelemetryModule.Initialize(tconfig);
_ = services.AddSingleton <ILogger>(_ => new AILogger(loggingConfiguration, tconfig, itm));
}
/// <inheritdoc/>
public override void Configure(IFunctionsHostBuilder builder)
{
var azureFuncConfig = builder?.Services?.BuildServiceProvider()?.GetService <IConfiguration>();
var configBuilder = new ConfigurationBuilder();
_ = configBuilder.AddConfiguration(azureFuncConfig);
var configFolder = Directory.GetParent(Assembly.GetExecutingAssembly().Location).Parent?.FullName;
_ = configBuilder.SetBasePath(configFolder);
_ = configBuilder.AddJsonFile("functionSettings.json");
_ = configBuilder.AddEnvironmentVariables();
var configuration = configBuilder.Build();
MaxDequeueCount = configuration.GetSection(ConfigConstants.MaxDequeueCountConfigKey);
AzureKeyVaultConfigurationOptions azureKeyVaultConfigurationOptions = new AzureKeyVaultConfigurationOptions(configuration[ConfigConstants.KeyVaultUrlConfigKey])
{
ReloadInterval = TimeSpan.FromSeconds(double.Parse(configuration[Constants.KeyVaultConfigRefreshDurationSeconds])),
};
_ = configBuilder.AddAzureKeyVault(azureKeyVaultConfigurationOptions);
configuration = configBuilder.Build();
_ = configBuilder.AddAzureAppConfiguration(options =>
{
var settings = options.Connect(configuration[ConfigConstants.AzureAppConfigConnectionstringConfigKey])
.Select(KeyFilter.Any, "Common").Select(KeyFilter.Any, "QueueProcessor");
_ = settings.ConfigureRefresh(refreshOptions =>
{
_ = refreshOptions.Register(key: configuration[ConfigConstants.ForceRefreshConfigKey], refreshAll: true, label: LabelFilter.Null);
});
});
configuration = configBuilder.Build();
ITelemetryInitializer[] itm = new ITelemetryInitializer[1];
var envInitializer = new EnvironmentInitializer
{
Service = configuration[AIConstants.ServiceConfigName],
ServiceLine = configuration[AIConstants.ServiceLineConfigName],
ServiceOffering = configuration[AIConstants.ServiceOfferingConfigName],
ComponentId = configuration[AIConstants.ComponentIdConfigName],
ComponentName = configuration[AIConstants.ComponentNameConfigName],
EnvironmentName = configuration[AIConstants.EnvironmentName],
IctoId = "IctoId",
};
itm[0] = envInitializer;
LoggingConfiguration loggingConfiguration = new LoggingConfiguration
{
IsTraceEnabled = true,
TraceLevel = (SeverityLevel)Enum.Parse(typeof(SeverityLevel), configuration[ConfigConstants.AITraceLelelConfigKey]),
EnvironmentName = configuration[AIConstants.EnvironmentName],
};
var tconfig = TelemetryConfiguration.CreateDefault();
tconfig.InstrumentationKey = configuration[ConfigConstants.AIInsrumentationConfigKey];
DependencyTrackingTelemetryModule depModule = new DependencyTrackingTelemetryModule();
depModule.Initialize(tconfig);
RequestTrackingTelemetryModule requestTrackingTelemetryModule = new RequestTrackingTelemetryModule();
requestTrackingTelemetryModule.Initialize(tconfig);
_ = builder.Services.AddSingleton <ILogger>(_ => new AILogger(loggingConfiguration, tconfig, itm));
StorageType storageType = (StorageType)Enum.Parse(typeof(StorageType), configuration?[ConfigConstants.StorageType]);
if (storageType == StorageType.DocumentDB)
{
_ = builder.Services.Configure <CosmosDBSetting>(configuration.GetSection(ConfigConstants.CosmosDBConfigSectionKey));
_ = builder.Services.Configure <CosmosDBSetting>(s => s.Key = configuration[ConfigConstants.CosmosDBKeyConfigKey]);
_ = builder.Services.Configure <CosmosDBSetting>(s => s.Uri = configuration[ConfigConstants.CosmosDBURIConfigKey]);
_ = builder.Services.AddScoped <ICosmosLinqQuery, CustomCosmosLinqQuery>();
_ = builder.Services.AddSingleton <ICosmosDBQueryClient, CosmosDBQueryClient>();
}
_ = builder.Services.Configure <StorageAccountSetting>(configuration.GetSection(ConfigConstants.StorageAccountConfigSectionKey));
_ = builder.Services.Configure <StorageAccountSetting>(s => s.ConnectionString = configuration[ConfigConstants.StorageAccountConnectionStringConfigKey]);
_ = builder.Services.AddSingleton <IConfiguration>(configuration);
_ = builder.Services.AddScoped <IRepositoryFactory, RepositoryFactory>();
_ = builder.Services.AddScoped <EmailNotificationRepository>();
_ = builder.Services.AddScoped <IEmailNotificationRepository, EmailNotificationRepository>(s => s.GetService <EmailNotificationRepository>());
_ = builder.Services.AddScoped <TableStorageEmailRepository>();
_ = builder.Services.AddScoped <IEmailNotificationRepository, TableStorageEmailRepository>(s => s.GetService <TableStorageEmailRepository>());
_ = builder.Services.AddScoped <ITableStorageClient, TableStorageClient>();
_ = builder.Services.AddHttpClient <IHttpClientHelper, HttpClientHelper>();
}
static async Task Main(string[] args)
{
var isService = !(Debugger.IsAttached || args.Contains("--console"));
Log.Logger = new LoggerConfiguration()
.MinimumLevel.Debug()
.MinimumLevel.Override("Microsoft", LogEventLevel.Information)
.Enrich.FromLogContext()
.WriteTo.Console()
.CreateLogger();
var builder = new HostBuilder()
.ConfigureAppConfiguration((hostingContext, config) =>
{
config.AddJsonFile("appsettings.json", true);
config.AddEnvironmentVariables();
if (args != null)
{
config.AddCommandLine(args);
}
})
.ConfigureServices((hostContext, services) =>
{
_module = new DependencyTrackingTelemetryModule();
_module.IncludeDiagnosticSourceActivities.Add("MassTransit");
TelemetryConfiguration configuration = TelemetryConfiguration.CreateDefault();
configuration.InstrumentationKey = "6b4c6c82-3250-4170-97d3-245ee1449278";
configuration.TelemetryInitializers.Add(new HttpDependenciesParsingTelemetryInitializer());
_telemetryClient = new TelemetryClient(configuration);
_module.Initialize(configuration);
services.AddScoped <AcceptOrderActivity>();
services.AddScoped <RoutingSlipBatchEventConsumer>();
services.TryAddSingleton(KebabCaseEndpointNameFormatter.Instance);
services.AddMassTransit(cfg =>
{
cfg.AddConsumersFromNamespaceContaining <SubmitOrderConsumer>();
cfg.AddActivitiesFromNamespaceContaining <AllocateInventoryActivity>();
cfg.AddSagaStateMachine <OrderStateMachine, OrderState>(typeof(OrderStateMachineDefinition))
.MongoDbRepository(r =>
{
r.Connection = "mongodb://127.0.0.1";
r.DatabaseName = "orders";
});
cfg.AddBus(ConfigureBus);
cfg.AddRequestClient <AllocateInventory>();
});
services.AddHostedService <MassTransitConsoleHostedService>();
})
.ConfigureLogging((hostingContext, logging) =>
{
logging.AddSerilog(dispose: true);
logging.AddConfiguration(hostingContext.Configuration.GetSection("Logging"));
});
if (isService)
{
await builder.UseWindowsService().Build().RunAsync();
}
else
{
await builder.RunConsoleAsync();
}
_telemetryClient?.Flush();
_module?.Dispose();
Log.CloseAndFlush();
}
/// <summary>
/// This method gets called by the runtime. Use this method to add services to the container.
/// </summary>
/// <param name="services">An instance of <see cref="IServiceCollection"/>.</param>
public void ConfigureServicesCommon(IServiceCollection services)
{
_ = services.AddAzureAppConfiguration();
_ = services.AddAuthorization(configure =>
{
configure.AddPolicy(ApplicationConstants.AppNameAuthorizePolicy, policy =>
{
policy.Requirements.Add(new AppNameAuthorizeRequirement());
});
configure.AddPolicy(ApplicationConstants.AppIdAuthorizePolicy, policy =>
{
policy.Requirements.Add(new AppIdAuthorizeRequirement());
});
});
_ = services.AddSingleton <IAuthorizationHandler, AppNameAuthorizePolicyHandler>(s => new AppNameAuthorizePolicyHandler(s.GetService <IHttpContextAccessor>(), this.Configuration));
_ = services.AddSingleton <IAuthorizationHandler, AppIdAuthorizePolicyHandler>(s => new AppIdAuthorizePolicyHandler(s.GetService <IHttpContextAccessor>(), this.Configuration));
_ = services.AddControllers();
_ = services.AddApplicationInsightsTelemetry();
_ = services.AddScoped(typeof(ValidateModelAttribute));
_ = services.AddOptions();
_ = services.Configure <StorageAccountSetting>(this.Configuration.GetSection(ConfigConstants.StorageAccountConfigSectionKey));
_ = services.Configure <StorageAccountSetting>(s => s.ConnectionString = this.Configuration[ConfigConstants.StorageAccountConnectionStringConfigKey]);
_ = services.Configure <UserTokenSetting>(this.Configuration.GetSection(ConfigConstants.UserTokenSettingConfigSectionKey));
_ = services.Configure <RetrySetting>(this.Configuration.GetSection(ConfigConstants.RetrySettingConfigSectionKey));
_ = services.AddSingleton <IConfiguration>(this.Configuration);
_ = services.AddSingleton <IEncryptionService, EncryptionService>();
_ = services.AddSingleton <IKeyEncryptionKey, CryptographyClient>(cc => new CryptographyClient(new Uri(this.Configuration[ConfigConstants.KeyVaultRSAUriConfigKey]), new DefaultAzureCredential()));
_ = services.AddTransient <IHttpContextAccessor, HttpContextAccessor>()
.AddSingleton <ICloudStorageClient, CloudStorageClient>()
.AddScoped <ITokenHelper, TokenHelper>()
.AddScoped <IRepositoryFactory, RepositoryFactory>()
.AddSingleton <IEmailAccountManager, EmailAccountManager>();
StorageType storageType = (StorageType)Enum.Parse(typeof(StorageType), this.Configuration?[ConfigConstants.StorageType]);
if (storageType == StorageType.DocumentDB)
{
this.ConfigureCosmosDB(services);
}
ConfigureStorageAccountServices(services);
_ = services.AddHttpContextAccessor();
_ = services.AddAuthentication(ApplicationConstants.BearerAuthenticationScheme).AddJwtBearer(options =>
{
options.Authority = this.Configuration[ConfigConstants.BearerTokenIssuerConfigKey];
options.ClaimsIssuer = this.Configuration[ConfigConstants.BearerTokenIssuerConfigKey];
options.TokenValidationParameters = new Microsoft.IdentityModel.Tokens.TokenValidationParameters()
{
ValidateIssuer = false,
ValidAudiences = this.Configuration[ConfigConstants.BearerTokenValidAudiencesConfigKey].Split(ApplicationConstants.SplitCharacter),
};
});
ITelemetryInitializer[] itm = new ITelemetryInitializer[1];
var envInitializer = new EnvironmentInitializer
{
Service = this.Configuration[AIConstants.ServiceConfigName],
ServiceLine = this.Configuration[AIConstants.ServiceLineConfigName],
ServiceOffering = this.Configuration[AIConstants.ServiceOfferingConfigName],
ComponentId = this.Configuration[AIConstants.ComponentIdConfigName],
ComponentName = this.Configuration[AIConstants.ComponentNameConfigName],
EnvironmentName = this.Configuration[AIConstants.EnvironmentName],
IctoId = "IctoId",
};
itm[0] = envInitializer;
LoggingConfiguration loggingConfiguration = new LoggingConfiguration
{
IsTraceEnabled = true,
TraceLevel = (SeverityLevel)Enum.Parse(typeof(SeverityLevel), this.Configuration[ConfigConstants.AITraceLelelConfigKey]),
EnvironmentName = this.Configuration[AIConstants.EnvironmentName],
};
#pragma warning disable CA2000 // Dispose objects before losing scope
var tconfig = TelemetryConfiguration.CreateDefault();
#pragma warning restore CA2000 // Dispose objects before losing scope
tconfig.InstrumentationKey = this.Configuration[ConfigConstants.AIInsrumentationConfigKey];
#pragma warning disable CA2000 // Dispose objects before losing scope
DependencyTrackingTelemetryModule depModule = new DependencyTrackingTelemetryModule();
#pragma warning restore CA2000 // Dispose objects before losing scope
depModule.Initialize(tconfig);
#pragma warning disable CA2000 // Dispose objects before losing scope
RequestTrackingTelemetryModule requestTrackingTelemetryModule = new RequestTrackingTelemetryModule();
#pragma warning restore CA2000 // Dispose objects before losing scope
requestTrackingTelemetryModule.Initialize(tconfig);
_ = services.AddSingleton <ILogger>(_ => new AILogger(loggingConfiguration, tconfig, itm));
}
