private async Task BuildWebHost()

in src/Cli/func/Actions/HostActions/StartHostAction.cs [191:270]
64 lines of code
9 McCabe index (conditional complexity)

        private async Task<IWebHost> BuildWebHost(ScriptApplicationHostOptions hostOptions, Uri listenAddress, Uri baseAddress, X509Certificate2 certificate)
        {
            LoggingFilterHelper loggingFilterHelper = new LoggingFilterHelper(_hostJsonConfig, VerboseLogging);
            if (GlobalCoreToolsSettings.CurrentWorkerRuntime == WorkerRuntime.Dotnet ||
                GlobalCoreToolsSettings.CurrentWorkerRuntime == WorkerRuntime.DotnetIsolated)
            {
                UserSecretsId = ProjectHelpers.GetUserSecretsId(hostOptions.ScriptPath, loggingFilterHelper, new LoggerFilterOptions());
            }

            IDictionary<string, string> settings = await GetConfigurationSettings(hostOptions.ScriptPath, baseAddress);
            settings.AddRange(LanguageWorkerHelper.GetWorkerConfiguration(LanguageWorkerSetting));
            _keyVaultReferencesManager.ResolveKeyVaultReferences(settings);
            UpdateEnvironmentVariables(settings);

            var defaultBuilder = Microsoft.AspNetCore.WebHost.CreateDefaultBuilder(Array.Empty<string>());

            if (UseHttps)
            {
                defaultBuilder
                .UseKestrel(options =>
                {
                    options.Listen(IPAddress.Any, listenAddress.Port, listenOptins =>
                    {
                        listenOptins.UseHttps(certificate);
                    });
                });
            }

            return defaultBuilder
                .ConfigureKestrel(o =>
                {
                    // Setting it to match the default RequestBodySize in host
                    o.Limits.MaxRequestBodySize = Constants.DefaultMaxRequestBodySize;
                })
                .UseSetting(WebHostDefaults.ApplicationKey, typeof(Startup).Assembly.GetName().Name)
                .UseUrls(listenAddress.ToString())
                .ConfigureAppConfiguration(configBuilder =>
                {
                    configBuilder.AddEnvironmentVariables();
                })
                .ConfigureLogging(loggingBuilder =>
                {
                    loggingBuilder.ClearProviders();
                    loggingBuilder.Services.AddSingleton<ILoggerProvider>(p =>
                    {
                        // Cache LoggerFilterOptions to be used by the logger to filter logs based on content
                        var filterOptions = p.GetService<IOptions<LoggerFilterOptions>>().Value;

                        // Set min level to SystemLogDefaultLogLevel.
                        filterOptions.MinLevel = loggingFilterHelper.SystemLogDefaultLogLevel;
                        return new ColoredConsoleLoggerProvider(loggingFilterHelper, filterOptions, JsonOutputFile);
                    });

                    // This is needed to filter system logs only for known categories
                    loggingBuilder.AddDefaultWebJobsFilters<ColoredConsoleLoggerProvider>(LogLevel.Trace);

                    loggingBuilder.AddFilter((category, logLevel) =>
                    {
                        // temporarily suppress shared memory warnings
                        var isSharedMemoryWarning = logLevel == LogLevel.Warning
                            && string.Equals(category, "Microsoft.Azure.WebJobs.Script.Workers.SharedMemoryDataTransfer.MemoryMappedFileAccessor");

                        // temporarily suppress AppInsights extension warnings
                        var isAppInsightsExtensionWarning = logLevel == LogLevel.Warning
                            && string.Equals(category, "Microsoft.Azure.WebJobs.Script.DependencyInjection.ScriptStartupTypeLocator");

                        return !isSharedMemoryWarning && !isAppInsightsExtensionWarning;
                    });
                })
                .ConfigureServices((context, services) =>
                {
                    services.AddSingleton<IStartup>(new Startup(context, hostOptions, CorsOrigins, CorsCredentials, EnableAuth, UserSecretsId, loggingFilterHelper, JsonOutputFile));

                    if (DotNetIsolatedDebug != null && DotNetIsolatedDebug.Value)
                    {
                        services.AddSingleton<IConfigureBuilder<IServiceCollection>>(_ => new DotNetIsolatedDebugConfigureBuilder());
                    }
                })
                .Build();
        }