internal static IServiceCollection AddApplicationInsights()

in src/Microsoft.Azure.WebJobs.Logging.ApplicationInsights/Extensions/ApplicationInsightsServiceCollectionExtensions.cs [50:270]
172 lines of code
18 McCabe index (conditional complexity)

        internal static IServiceCollection AddApplicationInsights(this IServiceCollection services,
            Action<ApplicationInsightsLoggerOptions> loggerOptionsConfiguration,
            Action<TelemetryConfiguration> additionalTelemetryConfig)
        {
            services.TryAddSingleton<ISdkVersionProvider, WebJobsSdkVersionProvider>();
            services.TryAddSingleton<IRoleInstanceProvider, WebJobsRoleInstanceProvider>();

            // 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>(provider =>
            {
                ApplicationInsightsLoggerOptions options = provider.GetService<IOptions<ApplicationInsightsLoggerOptions>>().Value;
                if (options.HttpAutoCollectionOptions.EnableHttpTriggerExtendedInfoCollection)
                {
                    var httpContextAccessor = provider.GetService<IHttpContextAccessor>();
                    if (httpContextAccessor != null)
                    {
                        return new ClientIpHeaderTelemetryInitializer(httpContextAccessor);
                    }
                }

                return NullTelemetryInitializer.Instance;
            });

            services.AddSingleton<ITelemetryInitializer, WebJobsRoleEnvironmentTelemetryInitializer>();
            services.AddSingleton<ITelemetryInitializer, WebJobsTelemetryInitializer>();
            services.AddSingleton<ITelemetryInitializer, MetricSdkVersionTelemetryInitializer>();
            services.AddSingleton<QuickPulseInitializationScheduler>();
            services.AddSingleton<QuickPulseTelemetryModule>();

            services.AddSingleton<ITelemetryModule>(provider =>
            {
                ApplicationInsightsLoggerOptions options = provider.GetService<IOptions<ApplicationInsightsLoggerOptions>>().Value;
                if (options.EnableLiveMetrics)
                {
                    return provider.GetService<QuickPulseTelemetryModule>();
                }

                return NullTelemetryModule.Instance;
            });

            services.AddSingleton<ITelemetryModule>(provider =>
            {
                ApplicationInsightsLoggerOptions options = provider.GetService<IOptions<ApplicationInsightsLoggerOptions>>().Value;
                if (options.EnablePerformanceCountersCollection)
                {
                    return new PerformanceCollectorModule
                    {
                        // Disabling this can improve cold start times
                        EnableIISExpressPerformanceCounters = false
                    };
                }

                return NullTelemetryModule.Instance;
            });

            services.AddSingleton<ITelemetryModule>(provider =>
            {
                ApplicationInsightsLoggerOptions options = provider.GetService<IOptions<ApplicationInsightsLoggerOptions>>().Value;
                if (options.DiagnosticsEventListenerLogLevel != null)
                {
                    return new SelfDiagnosticsTelemetryModule((EventLevel)options.DiagnosticsEventListenerLogLevel);
                }

                return NullTelemetryModule.Instance;
            });

            services.AddSingleton<IApplicationIdProvider, ApplicationInsightsApplicationIdProvider>();

            services.AddSingleton<ITelemetryModule>(provider =>
            {
                var options = provider.GetService<IOptions<ApplicationInsightsLoggerOptions>>().Value;

                DependencyTrackingTelemetryModule dependencyCollector = null;
                if (options.EnableDependencyTracking)
                {
                    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");
                    includedActivities.Add("Microsoft.Azure.EventHubs");

                    if (options.DependencyTrackingOptions != null)
                    {
                        dependencyCollector.DisableRuntimeInstrumentation = options.DependencyTrackingOptions.DisableRuntimeInstrumentation;
                        dependencyCollector.DisableDiagnosticSourceInstrumentation = options.DependencyTrackingOptions.DisableDiagnosticSourceInstrumentation;
                        dependencyCollector.EnableLegacyCorrelationHeadersInjection = options.DependencyTrackingOptions.EnableLegacyCorrelationHeadersInjection;
                        dependencyCollector.EnableRequestIdHeaderInjectionInW3CMode = options.DependencyTrackingOptions.EnableRequestIdHeaderInjectionInW3CMode;
                        dependencyCollector.EnableSqlCommandTextInstrumentation = options.DependencyTrackingOptions.EnableSqlCommandTextInstrumentation;
                        dependencyCollector.SetComponentCorrelationHttpHeaders = options.DependencyTrackingOptions.SetComponentCorrelationHttpHeaders;
                        dependencyCollector.EnableAzureSdkTelemetryListener = options.DependencyTrackingOptions.EnableAzureSdkTelemetryListener;
                    }

                    return dependencyCollector;
                }

                return NullTelemetryModule.Instance;
            });

            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
                            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;

                Activity.DefaultIdFormat = options.HttpAutoCollectionOptions.EnableW3CDistributedTracing
                    ? ActivityIdFormat.W3C
                    : ActivityIdFormat.Hierarchical;
                Activity.ForceDefaultIdFormat = true;

                // If we do not want to filter LiveMetrics logs, we need to "late filter" using the 
                // custom filter options that were passed in during initialization.
                LoggerFilterOptions filterOptions = null;
                if (options.EnableLiveMetrics && !options.EnableLiveMetricsFilters)
                {
                    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>();
                IRoleInstanceProvider roleInstanceProvider = provider.GetService<IRoleInstanceProvider>();

                // 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;
                }

                // Set ConnectionString second because it takes precedence and
                // we don't want InstrumentationKey to overwrite the value
                // ConnectionString sets
                if (!string.IsNullOrEmpty(options.ConnectionString) &&
                    string.IsNullOrEmpty(activeConfig.ConnectionString))
                {
                    activeConfig.ConnectionString = options.ConnectionString;
                }

                if (!activeConfig.TelemetryInitializers.OfType<WebJobsRoleEnvironmentTelemetryInitializer>().Any())
                {
                    activeConfig.TelemetryInitializers.Add(new WebJobsRoleEnvironmentTelemetryInitializer());
                    activeConfig.TelemetryInitializers.Add(new WebJobsTelemetryInitializer(sdkVersionProvider, roleInstanceProvider, provider.GetService<IOptions<ApplicationInsightsLoggerOptions>>()));
                }

                SetupTelemetryConfiguration(
                    config,
                    options,
                    channel,
                    provider.GetServices<ITelemetryInitializer>(),
                    provider.GetServices<ITelemetryModule>(),
                    appIdProvider,
                    filterOptions,
                    roleInstanceProvider,
                    provider.GetService<QuickPulseInitializationScheduler>(),
                    additionalTelemetryConfig);

                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>();

            if (loggerOptionsConfiguration != null)
            {
                services.Configure<ApplicationInsightsLoggerOptions>(loggerOptionsConfiguration);
            }

            return services;
        }