public static void DoesNotAddQuickPulseProcessorToConfigurationIfExplicitlyControlledThroughParameter() { var exisitingProcessorCount = GetTelemetryProcessorsCountInConfiguration <QuickPulseTelemetryProcessor>(TelemetryConfiguration.Active); var serviceOptions = new ApplicationInsightsServiceOptions(); serviceOptions.EnableQuickPulseMetricStream = false; var services = CreateServicesAndAddApplicationinsightsTelemetry(null, "http://localhost:1234/v2/track/", serviceOptions, false); IServiceProvider serviceProvider = services.BuildServiceProvider(); var telemetryConfiguration = serviceProvider.GetRequiredService <TelemetryConfiguration>(); var updatedCount = GetTelemetryProcessorsCountInConfiguration <QuickPulseTelemetryProcessor>(telemetryConfiguration); Assert.Equal(updatedCount, exisitingProcessorCount); }
public static void AddsAddaptiveSamplingServiceToTheConfigurationInFullFrameworkWithServiceOptions() { var exisitingProcessorCount = GetTelemetryProcessorsCountInConfiguration <AdaptiveSamplingTelemetryProcessor>(TelemetryConfiguration.Active); var serviceOptions = new ApplicationInsightsServiceOptions(); serviceOptions.EnableAdaptiveSampling = true; var services = CreateServicesAndAddApplicationinsightsTelemetry(null, "http://localhost:1234/v2/track/", serviceOptions, false); IServiceProvider serviceProvider = services.BuildServiceProvider(); var telemetryConfiguration = serviceProvider.GetRequiredService <TelemetryConfiguration>(); var updatedCount = GetTelemetryProcessorsCountInConfiguration <AdaptiveSamplingTelemetryProcessor>(telemetryConfiguration); Assert.Equal(updatedCount, exisitingProcessorCount + 1); }
/// <summary> /// Initializes a new instance of the <see cref="T:TelemetryConfigurationOptionsSetup"/> class. /// </summary> public TelemetryConfigurationOptionsSetup( IServiceProvider serviceProvider, IOptions <ApplicationInsightsServiceOptions> applicationInsightsServiceOptions, IEnumerable <ITelemetryInitializer> initializers, IEnumerable <ITelemetryModule> modules, IEnumerable <ITelemetryProcessorFactory> telemetryProcessorFactories) { this.applicationInsightsServiceOptions = applicationInsightsServiceOptions.Value; this.initializers = initializers; this.modules = modules; this.telemetryProcessorFactories = telemetryProcessorFactories; this.telemetryChannel = serviceProvider.GetService <ITelemetryChannel>(); }
/// <summary> /// Read from configuration /// Config.json will look like this: /// <para> /// "ApplicationInsights": { /// "InstrumentationKey": "11111111-2222-3333-4444-555555555555" /// "TelemetryChannel": { /// EndpointAddress: "http://dc.services.visualstudio.com/v2/track", /// DeveloperMode: true /// } /// } /// </para> /// Values can also be read from environment variables to support azure web sites configuration: /// </summary> /// <param name="config">Configuration to read variables from.</param> /// <param name="serviceOptions">Telemetry configuration to populate.</param> internal static void AddTelemetryConfiguration(IConfiguration config, ApplicationInsightsServiceOptions serviceOptions) { string instrumentationKey = config[InstrumentationKeyForWebSites]; if (string.IsNullOrWhiteSpace(instrumentationKey)) { instrumentationKey = config[InstrumentationKeyFromConfig]; } if (!string.IsNullOrWhiteSpace(instrumentationKey)) { serviceOptions.InstrumentationKey = instrumentationKey; } string developerModeValue = config[DeveloperModeForWebSites]; if (string.IsNullOrWhiteSpace(developerModeValue)) { developerModeValue = config[DeveloperModeFromConfig]; } if (!string.IsNullOrWhiteSpace(developerModeValue)) { bool developerMode = false; if (bool.TryParse(developerModeValue, out developerMode)) { serviceOptions.DeveloperMode = developerMode; } } string endpointAddress = config[EndpointAddressForWebSites]; if (string.IsNullOrWhiteSpace(endpointAddress)) { endpointAddress = config[EndpointAddressFromConfig]; } if (!string.IsNullOrWhiteSpace(endpointAddress)) { serviceOptions.EndpointAddress = endpointAddress; } var version = config[VersionKeyFromConfig]; if (!string.IsNullOrWhiteSpace(version)) { serviceOptions.ApplicationVersion = version; } }
public static IServiceCollection AddDFCLogging(this IServiceCollection services, string instrumentationKey) { var applicationInsightsServiceOptions = new ApplicationInsightsServiceOptions { InstrumentationKey = instrumentationKey, }; services.AddApplicationInsightsTelemetry(applicationInsightsServiceOptions); services.AddScoped <ICorrelationIdProvider, RequestHeaderCorrelationIdProvider>(); services.AddScoped <ILogService, ApplicationInsightsLogService>(); return(services); }
/// <summary> /// Configure application Insights /// </summary> public static void ConfigureAI(this IServiceCollection services) { ApplicationInsightsServiceOptions aiOptions = new ApplicationInsightsServiceOptions { EnableDebugLogger = false }; services.AddSingleton <ITelemetryInitializer, CloudRoleInitializer>(); services.AddApplicationInsightsTelemetry(aiOptions); services.ConfigureTelemetryModule <Microsoft.ApplicationInsights.AspNetCore.RequestTrackingTelemetryModule> ((req, o) => req.CollectionOptions.TrackExceptions = false); services.AddSingleton <ITelemetryClientFactory, TelemetryClientFactory>(); }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { // Dependency Injection of 1OS(AI/1DS) modules ApplicationInsightsServiceOptions aiOptions = new ApplicationInsightsServiceOptions { EnableAdaptiveSampling = false, InstrumentationKey = "key", }; services.AddApplicationInsightsTelemetry(aiOptions); services.AddSingleton <ITelemetryInitializer, AdditionalQosPropertiesInitializer>(); services.AddControllers(); }
private void AddApplicationInsights(IServiceCollection services) { services.AddSingleton <ITelemetryInitializer>(new RequestBodyTelemetryInitializer(new HttpContextAccessor())); services.AddApplicationInsightsTelemetryProcessor <RequestBodyTelemetryFilter>(); services.AddApplicationInsightsTelemetryProcessor <UserTelemetryFilter>(); var options = new ApplicationInsightsServiceOptions { EnableAdaptiveSampling = false, InstrumentationKey = _configuration["ApplicationInsights:InstrumentationKey"] }; services.AddApplicationInsightsTelemetry(options); }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { services.AddControllersWithViews(); var aiOpts = new ApplicationInsightsServiceOptions { EnableHeartbeat = true }; services.AddApplicationInsightsTelemetry(aiOpts); services.AddApplicationInsightsKubernetesEnricher(); services.AddSingleton<ITelemetryInitializer, CloudRoleTelemetryInitializer>(); services.AddMvc(); }
public void ConfigureServices(IServiceCollection services) { var options = new ApplicationInsightsServiceOptions { InstrumentationKey = Configuration["ApplicationInsights:InstrumentationKey"] }; if (InDevelopmentMode) { options.DeveloperMode = true; } // Configure AppInsights based on appsettings.json file services.AddApplicationInsightsTelemetry(options); }
/// <summary> /// Read configuration from appSettings.json, appsettings.{env.EnvironmentName}.json, /// IConfiguation used in an application and EnvironmentVariables. /// Bind configuration to ApplicationInsightsServiceOptions. /// Values can also be read from environment variables to support azure web sites configuration. /// </summary> /// <param name="config">Configuration to read variables from.</param> /// <param name="serviceOptions">Telemetry configuration to populate.</param> internal static void AddTelemetryConfiguration( IConfiguration config, ApplicationInsightsServiceOptions serviceOptions) { try { #if NETSTANDARD2_0 || NET461 config.GetSection(ApplicationInsightsSectionFromConfig).Bind(serviceOptions); config.GetSection(TelemetryChannelSectionFromConfig).Bind(serviceOptions); #endif if (config.TryGetValue(primaryKey: ConnectionStringEnvironmentVariable, backupKey: ConnectionStringFromConfig, value: out string connectionStringValue)) { serviceOptions.ConnectionString = connectionStringValue; } if (config.TryGetValue(primaryKey: InstrumentationKeyForWebSites, backupKey: InstrumentationKeyFromConfig, value: out string instrumentationKey)) { serviceOptions.InstrumentationKey = instrumentationKey; } if (config.TryGetValue(primaryKey: DeveloperModeForWebSites, backupKey: DeveloperModeFromConfig, value: out string developerModeValue)) { if (bool.TryParse(developerModeValue, out bool developerMode)) { serviceOptions.DeveloperMode = developerMode; } } if (config.TryGetValue(primaryKey: EndpointAddressForWebSites, backupKey: EndpointAddressFromConfig, value: out string endpointAddress)) { serviceOptions.EndpointAddress = endpointAddress; } if (config.TryGetValue(primaryKey: VersionKeyFromConfig, value: out string version)) { serviceOptions.ApplicationVersion = version; } } catch (Exception ex) { #if AI_ASPNETCORE_WEB AspNetCoreEventSource.Instance.LogError(ex.ToInvariantString()); #else WorkerServiceEventSource.Instance.LogError(ex.ToInvariantString()); #endif } }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { var endpointAddress = new EndpointAddress(); services.AddSingleton <EndpointAddress>(endpointAddress); ApplicationInsightsServiceOptions applicationInsightsOptions = new ApplicationInsightsServiceOptions(); applicationInsightsOptions.AddAutoCollectedMetricExtractor = false; applicationInsightsOptions.DeveloperMode = true; applicationInsightsOptions.EndpointAddress = endpointAddress.ConnectionString; applicationInsightsOptions.InstrumentationKey = "foo"; services.AddApplicationInsightsTelemetry(applicationInsightsOptions); services.AddMvc(); }
public static IServiceCollection AddCustomLogger(this IServiceCollection services, IConfiguration configuration) { string instrumentationkey = configuration.GetValue <string>("Telemetry:InstrumentationKey"); var aiOptions = new ApplicationInsightsServiceOptions { InstrumentationKey = instrumentationkey, EnableAdaptiveSampling = false, EnableAppServicesHeartbeatTelemetryModule = true, EnablePerformanceCounterCollectionModule = true, EnableRequestTrackingTelemetryModule = true, EnableDependencyTrackingTelemetryModule = true }; services.AddApplicationInsightsTelemetry(aiOptions); return(services.AddScoped <ICustomLogger, AiLogger>()); }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { var aiOptions = new ApplicationInsightsServiceOptions(); // aiOptions.ConnectionString = "InstrumentationKey=457e0aaf-fd2a-4e37-8df1-18c95bb66ca3;IngestionEndpoint=https://westus-0.in.applicationinsights.azure.com/"; aiOptions.ConnectionString = "InstrumentationKey=37b3dc54-9164-46b5-9b59-2d690c6fb409;IngestionEndpoint=https://westus-0.in.applicationinsights.azure.com/"; aiOptions.EnableHeartbeat = false; aiOptions.EnablePerformanceCounterCollectionModule = false; services.AddApplicationInsightsTelemetry(aiOptions); services.AddControllers(); services.AddSwaggerGen(c => { c.SwaggerDoc("v1", new OpenApiInfo { Title = "standardmetricdemo", Version = "v1" }); }); }
protected override void ConfigureWebHost(IWebHostBuilder builder) { builder.ConfigureServices(services => { services.AddLogging(loggingBuilder => loggingBuilder.AddFilter <ApplicationInsightsLoggerProvider>("Microsoft.AspNetCore.DataProtection.KeyManagement.XmlKeyManager", LogLevel.None)); services.AddSingleton <ITelemetryChannel>(new StubChannel() { OnSend = (item) => this.sentItems.Add(item) }); var aiOptions = new ApplicationInsightsServiceOptions(); aiOptions.AddAutoCollectedMetricExtractor = false; aiOptions.EnableAdaptiveSampling = false; aiOptions.InstrumentationKey = "ikey"; services.AddApplicationInsightsTelemetry(aiOptions); }); }
public static IResult <IServiceCollection> AddTelemetry <TProcessor>( this IServiceCollection services, ApplicationInsightsServiceOptions options ) where TProcessor : ITelemetryProcessor { try { services.AddSingleton <ITelemetryInitializer, Initializer>(); services.AddApplicationInsightsTelemetry(options); services.AddApplicationInsightsTelemetryProcessor <TProcessor>(); return(services.ToSuccess()); } catch (Exception e) { return(e.Message.ToFailure <IServiceCollection>()); } }
/// <summary> /// Copy the properties from this <see cref="ApplicationInsightsServiceOptions"/> to a target instance. /// </summary> /// <param name="target">Target instance to copy properties to.</param> internal void CopyPropertiesTo(ApplicationInsightsServiceOptions target) { if (this.DeveloperMode != null) { target.DeveloperMode = this.DeveloperMode; } if (!string.IsNullOrEmpty(this.EndpointAddress)) { target.EndpointAddress = this.EndpointAddress; } if (!string.IsNullOrEmpty(this.InstrumentationKey)) { target.InstrumentationKey = this.InstrumentationKey; } if (!string.IsNullOrEmpty(this.ConnectionString)) { target.ConnectionString = this.ConnectionString; } target.ApplicationVersion = this.ApplicationVersion; target.EnableAdaptiveSampling = this.EnableAdaptiveSampling; target.EnableDebugLogger = this.EnableDebugLogger; target.EnableQuickPulseMetricStream = this.EnableQuickPulseMetricStream; target.EnableHeartbeat = this.EnableHeartbeat; target.AddAutoCollectedMetricExtractor = this.AddAutoCollectedMetricExtractor; target.EnablePerformanceCounterCollectionModule = this.EnablePerformanceCounterCollectionModule; target.EnableDependencyTrackingTelemetryModule = this.EnableDependencyTrackingTelemetryModule; target.EnableAppServicesHeartbeatTelemetryModule = this.EnableAppServicesHeartbeatTelemetryModule; target.EnableAzureInstanceMetadataTelemetryModule = this.EnableAzureInstanceMetadataTelemetryModule; target.EnableDiagnosticsTelemetryModule = this.EnableDiagnosticsTelemetryModule; #if NETSTANDARD2_0 target.EnableEventCounterCollectionModule = this.EnableEventCounterCollectionModule; #endif #if AI_ASPNETCORE_WEB target.EnableAuthenticationTrackingJavaScript = this.EnableAuthenticationTrackingJavaScript; target.EnableRequestTrackingTelemetryModule = this.EnableRequestTrackingTelemetryModule; target.EnableActiveTelemetryConfigurationSetup = this.EnableActiveTelemetryConfigurationSetup; #endif }
public static void AddMigrationToolServicesForUnitTests(this IServiceCollection context) { // Add Fake AI Endpoint var aiOptions = new ApplicationInsightsServiceOptions { EndpointAddress = "http://localhost:8888/v2/track" }; context.AddApplicationInsightsTelemetryWorkerService(aiOptions); context.AddSingleton <ITelemetryLogger, TelemetryClientAdapter>(); // Logging for Unit Tests var loggers = new LoggerConfiguration().MinimumLevel.Verbose().Enrich.FromLogContext(); loggers.WriteTo.Logger(logger => logger .WriteTo.Debug(restrictedToMinimumLevel: LogEventLevel.Verbose)); Log.Logger = loggers.CreateLogger(); Log.Logger.Information("Logger is initialized"); context.AddLogging(loggingBuilder => loggingBuilder.AddSerilog(dispose: true)); }
/// <summary> /// Adds Application Insights services into service collection. /// </summary> /// <param name="services">The <see cref="IServiceCollection"/> instance.</param> /// <param name="options">The options instance used to configure with.</param> /// <returns> /// The <see cref="IServiceCollection"/>. /// </returns> public static IServiceCollection AddApplicationInsightsTelemetry(this IServiceCollection services, ApplicationInsightsServiceOptions options) { services.AddApplicationInsightsTelemetry(); services.Configure((ApplicationInsightsServiceOptions o) => { o.ApplicationVersion = options.ApplicationVersion; o.DeveloperMode = options.DeveloperMode; o.EnableAdaptiveSampling = options.EnableAdaptiveSampling; o.EnableAuthenticationTrackingJavaScript = options.EnableAuthenticationTrackingJavaScript; o.EnableDebugLogger = options.EnableDebugLogger; o.EnableQuickPulseMetricStream = options.EnableQuickPulseMetricStream; o.EndpointAddress = options.EndpointAddress; o.InstrumentationKey = options.InstrumentationKey; o.EnableHeartbeat = options.EnableHeartbeat; o.AddAutoCollectedMetricExtractor = options.AddAutoCollectedMetricExtractor; }); return(services); }
protected override void ConfigureWebHost(IWebHostBuilder builder) { builder.ConfigureServices(services => { services.AddSingleton <ITelemetryChannel>(new StubChannel() { OnSend = (item) => this.sentItems.Add(item) }); var aiOptions = new ApplicationInsightsServiceOptions(); aiOptions.AddAutoCollectedMetricExtractor = false; aiOptions.EnableAdaptiveSampling = false; aiOptions.InstrumentationKey = "ikey"; services.AddApplicationInsightsTelemetry(aiOptions); // Build the service provider. var sp = services.BuildServiceProvider(); var tc = sp.GetRequiredService <TelemetryClient>(); }); }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { var mvcBuilder = services.AddControllersWithViews().AddNewtonsoftJson(options => { options.SerializerSettings.ContractResolver = new DefaultContractResolver(); options.SerializerSettings.DateTimeZoneHandling = DateTimeZoneHandling.Utc; }); #if DEBUG if (Env.IsDevelopment()) { mvcBuilder.AddRazorRuntimeCompilation(); } #endif var aiOptions = new ApplicationInsightsServiceOptions { EnableAdaptiveSampling = false }; services.AddApplicationInsightsTelemetry(aiOptions); services.AddDbContext <BunningsProductCatalogContext>(options => options.UseLazyLoadingProxies().UseSqlServer( Configuration.GetConnectionString("BunningsProductCatalogContext"))); services.AddMvcCore().AddNewtonsoftJson( options => options.SerializerSettings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore); services.AddAutoMapper(AppDomain.CurrentDomain.GetAssemblies()); services.AddScoped <IUnitOfWork, UnitOfWork>(); services.AddScoped <IRepositoryProvider, RepositoryProvider>(); services.AddSingleton <RepositoryFactories>(); services.AddScoped <IProductService, ProductService>(); services.AddScoped <ICompanyService, CompanyService>(); services.AddScoped <ICompanyProductService, CompanyProductService>(); services.AddScoped <ICompanyProductBarcodeService, CompanyProductBarcodeService>(); services.AddScoped <ISupplierService, SupplierService>(); services.AddScoped <ICsvService <ImportSupplierDto>, CsvService <ImportSupplierDto> >(); services.AddScoped <ICsvService <ImportCompanyProductDto>, CsvService <ImportCompanyProductDto> >(); services.AddScoped <ICsvService <ImportCompanyProductBarcodeDto>, CsvService <ImportCompanyProductBarcodeDto> >(); services.AddScoped <ICsvService <ProductCatalogDto>, CsvService <ProductCatalogDto> >(); }
private static ApplicationInsightsServiceOptions setTelemetryClientOptions(ApplicationInsightsServiceOptions aiOptions, string appInsightsKey) { aiOptions.InstrumentationKey = appInsightsKey; //aiOptions.InstrumentationKey = _configuration.GetValue<string>("ApplicationInsights_InstrumentationKey"); // Disables adaptive sampling. aiOptions.EnableAdaptiveSampling = false; // Collects Requests Telemetry aiOptions.EnableRequestTrackingTelemetryModule = true; // よくわからんけど有効 aiOptions.EnableEventCounterCollectionModule = true; // Collects Depdndency Telemetry aiOptions.EnableDependencyTrackingTelemetryModule = true; // Disables QuickPulse (Live Metrics stream). aiOptions.EnableQuickPulseMetricStream = false; return(aiOptions); }
private static void SetupAppInsights(IConfiguration configuration, IServiceCollection services) { ApplicationInsightsServiceOptions aiOptions = new ApplicationInsightsServiceOptions(); var appInsightsDependencyConfigValue = configuration.GetValue <bool>("ApplicationInsights:EnableDependencyTrackingTelemetryModule"); //dependency tracking is disabled by default as it is quite expensive aiOptions.EnableDependencyTrackingTelemetryModule = appInsightsDependencyConfigValue; //by default instrumentation key is taken from config //Alternatively, specify the instrumentation key in either of the following environment variables. //APPINSIGHTS_INSTRUMENTATIONKEY or ApplicationInsights:InstrumentationKey services.AddApplicationInsightsTelemetryWorkerService(aiOptions); var appInsightsAuthApiKey = configuration.GetValue <string>("ApplicationInsights:AuthenticationApiKey"); if (!string.IsNullOrWhiteSpace(appInsightsAuthApiKey)) { services.ConfigureTelemetryModule <QuickPulseTelemetryModule> ((module, o) => module.AuthenticationApiKey = appInsightsAuthApiKey); } }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { services.AddControllers(o => o.AllowEmptyInputInBodyModelBinding = true); services.AddRazorPages().AddRazorPagesOptions(options => options.Conventions.AllowAnonymousToPage("/")); services.AddAuthentication("BasicAuthentication").AddScheme <AuthenticationSchemeOptions, BasicAuthHandler>("BasicAuthentication", null); services.AddHttpClient(); var appInsightOptions = new ApplicationInsightsServiceOptions { DeveloperMode = true, EnableEventCounterCollectionModule = false, }; services.AddApplicationInsightsTelemetry(appInsightOptions); services.AddScoped <IGitHubClient, GitHubClient>(sp => { return(new GitHubClient(new ProductHeaderValue("Covid19-ita-Report-api")) { Credentials = new Credentials(Configuration.GetSection("GitHubConfig:GitHubApiKey").Value) }); }); services.AddSingleton <CosmosSerializer, CosmosCovidSerializer>(); services.AddSingleton <ICosmosClientFactory, CosmosClientFactory>(); services.AddSingleton <ICosmosServiceFactory, CosmosServiceFactory>(); services.AddScoped <IDataCollectorSerializer, JsonDataCollectorSerializer>(); services.AddScoped <IDataCollectorSerializer, CsvDataCollectorSerializer>(); services.AddScoped <IDataCollector, DataCollector>(); services.AddScoped <ICosmosRepository, CosmosRepository>(); services.AddTransient <DbConnection>(sp => new SqlConnection(Configuration.GetConnectionString("covidDb"))); // Register configurations services.Configure <CosmosRepositoryOptions>(o => o.Databases = Configuration.GetSection("cosmos:databases") .GetChildren().ToDictionary(d => d.Key, d => d.GetSection("containers") .GetChildren() .ToDictionary(c => c.Key, c => c.Value))); services.Configure <CosmosClientFactoryOptions>(Configuration.GetSection("cosmos")); services.Configure <GitHubConfig>(Configuration.GetSection("GitHubConfig")); }
public void TestRequestWithNonW3CCompatibleNonHierrachicalRequestIdHeader() { IWebHostBuilder Config(IWebHostBuilder builder) { return(builder.ConfigureServices(services => { var aiOptions = new ApplicationInsightsServiceOptions(); // disable Dependency tracking (i.e. header injection) aiOptions.EnableDependencyTrackingTelemetryModule = false; services.AddApplicationInsightsTelemetry(aiOptions); })); } using (var server = new InProcessServer(assemblyName, this.output, Config)) { const string RequestPath = "/api/values"; var expectedRequestTelemetry = new RequestTelemetry(); expectedRequestTelemetry.Name = "GET Values/Get"; expectedRequestTelemetry.ResponseCode = "200"; expectedRequestTelemetry.Success = true; expectedRequestTelemetry.Url = new Uri(server.BaseHost + RequestPath); var headers = new Dictionary <string, string> { // Request-ID Correlation Header { "Request-Id", "somerandomidnotinanyformat" }, { "Request-Context", "appId=value" }, { "Correlation-Context", "k1=v1,k2=v2" } }; var actualRequest = this.ValidateRequestWithHeaders(server, RequestPath, headers, expectedRequestTelemetry); Assert.NotEqual("noncompatible", actualRequest.tags["ai.operation.id"]); Assert.Contains("somerandomidnotinanyformat", actualRequest.tags["ai.operation.parentId"]); Assert.Equal("somerandomidnotinanyformat", actualRequest.data.baseData.properties["ai_legacyRootId"]); Assert.Equal("v1", actualRequest.data.baseData.properties["k1"]); Assert.Equal("v2", actualRequest.data.baseData.properties["k2"]); } }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { var appInsightsConnectionString = Environment.GetEnvironmentVariable(AppInsightsConnectionStringEnvironmentVariableName); if (!string.IsNullOrEmpty(appInsightsConnectionString)) { var options = new ApplicationInsightsServiceOptions { EnableAdaptiveSampling = false, EnablePerformanceCounterCollectionModule = false }; services.AddApplicationInsightsTelemetry(options); } services.AddAuthentication(CookieAuthenticationDefaults.AuthenticationScheme) .AddCookie(CookieAuthenticationDefaults.AuthenticationScheme, options => { options.LoginPath = "/login"; options.LogoutPath = "/logout"; }); services.AddAuthentication(options => { options.DefaultAuthenticateScheme = CookieAuthenticationDefaults.AuthenticationScheme; }); services.AddSingleton <IArticlesRepository, DiskArticlesRepository>(); services.AddScoped <IArticlesService, ArticlesService>(); services.AddSingleton <IArticleInfoRepository, DiskArticleInfoRepository>(); services.AddSingleton <ITagsRepository, DiskTagsRepository>(); services.AddSingleton <IPagesRepository, DiskPagesRepository>(); services.AddScoped <IPagesService, PagesService>(); services.AddSingleton <ISiteConfigurationRepository, DiskSiteConfigurationRepository>(); services.AddSingleton <IImagesRepository, DiskImagesRepository>(); services.AddRazorPages(); }
public void VerifyAddAIWorkerServiceRespectsAIOptions() { var services = new ServiceCollection(); // ACT var aiOptions = new ApplicationInsightsServiceOptions(); aiOptions.AddAutoCollectedMetricExtractor = false; aiOptions.EnableAdaptiveSampling = false; aiOptions.EnableQuickPulseMetricStream = false; aiOptions.InstrumentationKey = "keyfromaioption"; services.AddApplicationInsightsTelemetryWorkerService(aiOptions); // VALIDATE IServiceProvider serviceProvider = services.BuildServiceProvider(); var telemetryConfiguration = serviceProvider.GetRequiredService <TelemetryConfiguration>(); Assert.Equal("keyfromaioption", telemetryConfiguration.InstrumentationKey); Assert.DoesNotContain(telemetryConfiguration.DefaultTelemetrySink.TelemetryProcessors, proc => proc.GetType().Name.Contains("AutocollectedMetricsExtractor")); Assert.DoesNotContain(telemetryConfiguration.DefaultTelemetrySink.TelemetryProcessors, proc => proc.GetType().Name.Contains("AdaptiveSamplingTelemetryProcessor")); Assert.DoesNotContain(telemetryConfiguration.DefaultTelemetrySink.TelemetryProcessors, proc => proc.GetType().Name.Contains("QuickPulseTelemetryProcessor")); }
public void GivenCustomConfiguration_ThenUseCustomConfiguration() { // Arrange var configuration = new ConfigurationBuilder() .AddInMemoryCollection(new Dictionary <string, string> { { "ApplicationInsights:ApplicationVersion", "test-local" }, { "ApplicationInsights:EnableAdaptiveSampling", "False" }, { "ApplicationInsights:TelemetryChannel:DeveloperMode", "true" }, { "ApplicationInsights:InstrumentationKey", "instrumentation-key" } }) .Build(); // Act var webHost = WebHost .CreateDefaultBuilder() .UseStartup <ConfigurableStartup>() .UseConfiguration(configuration) .Build(); // Assert var configuredOptions = webHost.Services.GetService <IOptions <ApplicationInsightsServiceOptions> >(); Assert.NotNull(configuredOptions.Value); var expectedOptions = new ApplicationInsightsServiceOptions { EnableAdaptiveSampling = false, ApplicationVersion = "test-local", DeveloperMode = true, InstrumentationKey = "instrumentation-key" }; configuredOptions.Value.Should().BeEquivalentTo(expectedOptions); }
public void TestRequestWithNoCorrelationHeaders() { IWebHostBuilder Config(IWebHostBuilder builder) { return(builder.ConfigureServices(services => { var aiOptions = new ApplicationInsightsServiceOptions(); // disable Dependency tracking (i.e. header injection) aiOptions.EnableDependencyTrackingTelemetryModule = false; services.AddApplicationInsightsTelemetry(aiOptions); })); } using (var server = new InProcessServer(assemblyName, this.output, Config)) { const string RequestPath = "/api/values/1"; var expectedRequestTelemetry = new RequestTelemetry(); expectedRequestTelemetry.Name = "GET Values/Get [id]"; expectedRequestTelemetry.ResponseCode = "200"; expectedRequestTelemetry.Success = true; expectedRequestTelemetry.Url = new System.Uri(server.BaseHost + RequestPath); Dictionary <string, string> requestHeaders = new Dictionary <string, string>() { // No Request-ID, No TraceParent { "Request-Context", "appId=value" }, }; var item = this.ValidateBasicRequest(server, RequestPath, expectedRequestTelemetry); Assert.Equal(32, item.tags["ai.operation.id"].Length); Assert.True(Regex.Match(item.tags["ai.operation.id"], @"[a-z][0-9]").Success); Assert.False(item.tags.ContainsKey("ai.operation.parentId")); } }
public static void AppApplicationInsightsTelemetryFromApplicationInsightsServiceOptionsCopiesAllSettings() { ServiceCollection services = ApplicationInsightsExtensionsTests.GetServiceCollectionWithContextAccessor(); ApplicationInsightsServiceOptions options = new ApplicationInsightsServiceOptions() { ApplicationVersion = "test", DeveloperMode = true, EnableAdaptiveSampling = false, EnableAuthenticationTrackingJavaScript = false, EnableDebugLogger = true, EnableQuickPulseMetricStream = false, EndpointAddress = "http://test", EnableHeartbeat = false, InstrumentationKey = "test" }; services.AddApplicationInsightsTelemetry(options); ApplicationInsightsServiceOptions servicesOptions = null; services.Configure((ApplicationInsightsServiceOptions o) => { servicesOptions = o; }); IServiceProvider serviceProvider = services.BuildServiceProvider(); TelemetryConfiguration telemetryConfiguration = serviceProvider.GetTelemetryConfiguration(); Type optionsType = typeof(ApplicationInsightsServiceOptions); PropertyInfo[] properties = optionsType.GetProperties(BindingFlags.Public | BindingFlags.Instance); Assert.True(properties.Length > 0); foreach (PropertyInfo property in properties) { Assert.Equal(property.GetValue(options).ToString(), property.GetValue(servicesOptions).ToString()); } }