public void CreateClientUsesLoggerToCreateLoggingHandler()
{
using StandaloneHttpClientFactory httpClientFactory = new StandaloneHttpClientFactory(NullLogger.Instance);
using HttpClient client = httpClientFactory.CreateClient();
HttpMessageHandler handler = GetHandler(client);
Assert.IsType <LoggingHttpMessageHandler>(GetHandler(client));
LoggingHttpMessageHandler loggingHandler = (LoggingHttpMessageHandler)handler;
Assert.IsType <SocketsHttpHandler>(loggingHandler.InnerHandler);
}
static void Main(string[] args)
{
var messageHandler = new LoggingHttpMessageHandler(new Log4NetAdapter(typeof(System.Net.Http.HttpClient).FullName))
{
EnableContentLogging = true
};
using (var httpClient = new System.Net.Http.HttpClient(messageHandler))
{
// omitted for brevity
}
}
public void CreateClientUsesLoggerToCreateLoggingHandler()
{
using (StandaloneHttpClientFactory httpClientFactory = new StandaloneHttpClientFactory(NullLogger.Instance))
{
using (HttpClient client = httpClientFactory.CreateClient())
{
HttpMessageHandler handler = GetHandler(client);
Assert.IsType <LoggingHttpMessageHandler>(handler);
LoggingHttpMessageHandler loggingHandler = (LoggingHttpMessageHandler)handler;
Assert.IsType <ServicePointHttpMessageHandler>(loggingHandler.InnerHandler);
}
}
}
protected override void SetupServiceManager(IServiceManager serviceManager)
{
serviceManager.RegisterDebugLoggerFactory();
serviceManager.RegisterResolver(
new HttpClientResolver()
.WithHttpMessageHandlerFactory((serviceProvider, categoryType) =>
{
var loggerType = typeof(ILogger <>).MakeGenericType(categoryType);
var logger = serviceProvider.GetService(loggerType).As <ILogger>();
var handler = new LoggingHttpMessageHandler(logger)
{
InnerHandler = new HttpClientHandler()
};
return(handler);
}));
serviceManager.RegisterOptionsManager();
}
public static void RegisterResolvers(IServiceManager serviceManager)
{
serviceManager.ThrowIfNull(nameof(serviceManager));
serviceManager.RegisterResolver(
new HttpClientResolver()
.WithHttpMessageHandlerFactory((serviceProvider, categoryType) =>
{
var loggerType = typeof(ILogger <>).MakeGenericType(categoryType);
var logger = serviceProvider.GetService(loggerType).As <ILogger>();
var handler = new LoggingHttpMessageHandler(logger)
{
InnerHandler = new HttpClientHandler()
};
return(handler);
}));
serviceManager.RegisterOptionsManager <ApplicationConfigurationOptionsManager>();
}
private static IServiceProvider ConfigureServices()
{
var configuration = BuildConfiguration();
var services = new ServiceCollection();
services.AddSingleton(configuration);
services.AddHttpClient("k8s");
services.AddLogging(configure => configure.AddConsole())
.Configure <LoggerFilterOptions>(configure => configure.MinLevel = LogLevel.Debug);
services.AddMetrics(builder => {
new MetricsReporterBuilder().Chain(builder.Report, configuration.GetSection("Metrics:Reporting"));
});
services.AddScoped <IKubernetes, Kubernetes>(provider => {
var factory = provider.GetRequiredService <ILoggerFactory>();
var logger = factory.CreateLogger <HttpClient>();
var loggingHandler = new LoggingHttpMessageHandler(logger);
var config = KubernetesClientConfiguration.IsInCluster() ? KubernetesClientConfiguration.InClusterConfig() : KubernetesClientConfiguration.BuildDefaultConfig();
return(new Kubernetes(config, loggingHandler));
});
services.AddScoped <IKubernetesService, KubernetesService>();
services.AddScoped <ISqlManagementService, SqlManagementService>();
services.AddScoped <SecretSourceRehydrator>();
services.AddScoped <DatabaseServerRehydrator>();
services.AddOperator <DatabaseResource, DatabaseOperator>();
services.AddOperator <DatabaseServerResource, DatabaseServerOperator>();
services.AddOperator <DeploymentScriptResource, DeploymentScriptOperator>();
services.AddOperator <CredentialsResource, CredentialsOperator>();
return(services.BuildServiceProvider());
}
private HttpClient CreateHttpClient()
{
var httpClientHandler = new HttpClientHandler();
HttpMessageHandler httpMessageHandler = httpClientHandler;
if (_httpOptions != null)
{
if (_httpOptions.Proxy != null)
{
httpClientHandler.Proxy = _httpOptions.Proxy;
}
if (_httpOptions.Cookies != null)
{
httpClientHandler.CookieContainer = _httpOptions.Cookies;
}
if (_httpOptions.ClientCertificates != null)
{
httpClientHandler.ClientCertificates.AddRange(_httpOptions.ClientCertificates);
}
if (_httpOptions.UseDefaultCredentials != null)
{
httpClientHandler.UseDefaultCredentials = _httpOptions.UseDefaultCredentials.Value;
}
if (_httpOptions.Credentials != null)
{
httpClientHandler.Credentials = _httpOptions.Credentials;
}
httpMessageHandler = httpClientHandler;
if (_httpOptions.HttpMessageHandler != null)
{
httpMessageHandler = _httpOptions.HttpMessageHandler(httpClientHandler);
if (httpMessageHandler == null)
{
throw new InvalidOperationException("Configured HttpMessageHandler did not return a value.");
}
}
}
// Wrap message handler in a logging handler last to ensure it is always present
httpMessageHandler = new LoggingHttpMessageHandler(httpMessageHandler, _loggerFactory);
var httpClient = new HttpClient(httpMessageHandler);
httpClient.Timeout = HttpClientTimeout;
// Start with the user agent header
httpClient.DefaultRequestHeaders.UserAgent.Add(Constants.UserAgentHeader);
if (_httpOptions != null)
{
// Apply any headers configured on the HttpOptions
if (_httpOptions.Headers != null)
{
foreach (var header in _httpOptions.Headers)
{
httpClient.DefaultRequestHeaders.Add(header.Key, header.Value);
}
}
// Apply the authorization header
if (_httpOptions.AccessTokenFactory != null)
{
httpClient.DefaultRequestHeaders.Add("Authorization", $"Bearer {_httpOptions.AccessTokenFactory()}");
}
}
return(httpClient);
}
private HttpClient CreateHttpClient()
{
var httpClientHandler = new HttpClientHandler();
HttpMessageHandler httpMessageHandler = httpClientHandler;
if (_httpOptions != null)
{
if (_httpOptions.Proxy != null)
{
httpClientHandler.Proxy = _httpOptions.Proxy;
}
if (_httpOptions.Cookies != null)
{
httpClientHandler.CookieContainer = _httpOptions.Cookies;
}
if (_httpOptions.ClientCertificates != null)
{
httpClientHandler.ClientCertificates.AddRange(_httpOptions.ClientCertificates);
}
if (_httpOptions.UseDefaultCredentials != null)
{
httpClientHandler.UseDefaultCredentials = _httpOptions.UseDefaultCredentials.Value;
}
if (_httpOptions.Credentials != null)
{
httpClientHandler.Credentials = _httpOptions.Credentials;
}
httpMessageHandler = httpClientHandler;
if (_httpOptions.HttpMessageHandlerFactory != null)
{
httpMessageHandler = _httpOptions.HttpMessageHandlerFactory(httpClientHandler);
if (httpMessageHandler == null)
{
throw new InvalidOperationException("Configured HttpMessageHandlerFactory did not return a value.");
}
}
// Apply the authorization header in a handler instead of a default header because it can change with each request
if (_httpOptions.AccessTokenFactory != null)
{
httpMessageHandler = new AccessTokenHttpMessageHandler(httpMessageHandler, _httpOptions.AccessTokenFactory);
}
}
// Wrap message handler after HttpMessageHandlerFactory to ensure not overriden
httpMessageHandler = new LoggingHttpMessageHandler(httpMessageHandler, _loggerFactory);
var httpClient = new HttpClient(httpMessageHandler);
httpClient.Timeout = HttpClientTimeout;
// Start with the user agent header
httpClient.DefaultRequestHeaders.UserAgent.Add(Constants.UserAgentHeader);
// Apply any headers configured on the HttpOptions
if (_httpOptions?.Headers != null)
{
foreach (var header in _httpOptions.Headers)
{
httpClient.DefaultRequestHeaders.Add(header.Key, header.Value);
}
}
httpClient.DefaultRequestHeaders.Remove("X-Requested-With");
// Tell auth middleware to 401 instead of redirecting
httpClient.DefaultRequestHeaders.Add("X-Requested-With", "XMLHttpRequest");
return(httpClient);
}
