Merge the source code from aspnet/HttpClientFactory into this repo

Author: Nate McMaster

src/HttpClientFactory/Http/perf/Configs/CoreConfig.cs

@@ -0,0 +1,37 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using BenchmarkDotNet.Columns;
+using BenchmarkDotNet.Configs;
+using BenchmarkDotNet.Diagnosers;
+using BenchmarkDotNet.Engines;
+using BenchmarkDotNet.Jobs;
+using BenchmarkDotNet.Validators;
+
+namespace Microsoft.Extensions.Http.Performance
+{
+    public class CoreConfig : ManualConfig
+    {
+        public CoreConfig() 
+            : this(Job.Core
+                .WithRemoveOutliers(false)
+                .With(new GcMode() { Server = true })
+                .With(RunStrategy.Throughput)
+                .WithLaunchCount(3)
+                .WithWarmupCount(5)
+                .WithTargetCount(10))
+        {
+            Add(JitOptimizationsValidator.FailOnError);
+        }
+
+        public CoreConfig(Job job)
+        {
+            Add(DefaultConfig.Instance);
+
+            Add(MemoryDiagnoser.Default);
+            Add(StatisticColumn.OperationsPerSecond);
+
+            Add(job);
+        }
+    }
+}

src/HttpClientFactory/Http/perf/CreationOverheadBenchmark.cs

@@ -0,0 +1,77 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using System.Net.Http;
+using System.Net.Http.Headers;
+using System.Threading.Tasks;
+using BenchmarkDotNet.Attributes;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace Microsoft.Extensions.Http.Performance
+{
+    [ParameterizedJobConfig(typeof(CoreConfig))]
+    public class CreationOverheadBenchmark
+    {
+        private const int Iterations = 100;
+
+        public CreationOverheadBenchmark()
+        {
+            Handler = new FakeClientHandler();
+
+            var serviceCollection = new ServiceCollection();
+            serviceCollection.AddHttpClient("example", c =>
+            {
+                c.BaseAddress = new Uri("http://example.com/");
+                c.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
+            })
+            .ConfigurePrimaryHttpMessageHandler(() => Handler);
+
+            var services = serviceCollection.BuildServiceProvider();
+            Factory = services.GetRequiredService<IHttpClientFactory>();
+        }
+
+        public IHttpClientFactory Factory { get; }
+
+        public HttpMessageHandler Handler { get; }
+
+        [Benchmark(
+            Description = "use IHttpClientFactory", 
+            OperationsPerInvoke = Iterations)]
+        public async Task CreateClient()
+        {
+            for (var i = 0; i < Iterations; i++)
+            {
+                var client = Factory.CreateClient("example");
+
+                var response = await client.SendAsync(new HttpRequestMessage(HttpMethod.Get, "api/Products"));
+                response.EnsureSuccessStatusCode();
+            }
+        }
+
+        [Benchmark(
+            Description = "new HttpClient",
+            Baseline = true,
+            OperationsPerInvoke = Iterations)]
+        public async Task Baseline()
+        {
+            for (var i = 0; i < Iterations; i++)
+            {
+                var client = new HttpClient(Handler, disposeHandler: false)
+                {
+                    BaseAddress = new Uri("http://example.com/"),
+                    DefaultRequestHeaders =
+                    {
+                        Accept =
+                        {
+                            new MediaTypeWithQualityHeaderValue("application/json"),
+                        }
+                    },
+                };
+
+                var response = await client.SendAsync(new HttpRequestMessage(HttpMethod.Get, "api/Products"));
+                response.EnsureSuccessStatusCode();
+            }
+        }
+    }
+}

src/HttpClientFactory/Http/perf/FakeClientHandler.cs

@@ -0,0 +1,25 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using System.Net;
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Microsoft.Extensions.Http.Performance
+{
+    internal class FakeClientHandler : HttpMessageHandler
+    {
+        public TimeSpan Latency { get; set; } = TimeSpan.FromMilliseconds(10);
+
+        protected async override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
+        {
+            await Task.Yield();
+
+            var response = new HttpResponseMessage(HttpStatusCode.OK);
+            response.RequestMessage = request;
+            return response;
+        }
+    }
+}

src/HttpClientFactory/Http/perf/FakeLoggerProvider.cs

@@ -0,0 +1,46 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using Microsoft.Extensions.Logging;
+
+namespace Microsoft.Extensions.Http.Performance
+{
+    internal class FakeLoggerProvider : ILoggerProvider
+    {
+        public bool IsEnabled { get; set; }
+
+        public ILogger CreateLogger(string categoryName)
+        {
+            return new Logger(this);
+        }
+
+        public void Dispose()
+        {
+        }
+
+        private class Logger : ILogger
+        {
+            private FakeLoggerProvider _provider;
+
+            public Logger(FakeLoggerProvider provider)
+            {
+                _provider = provider;
+            }
+
+            public IDisposable BeginScope<TState>(TState state)
+            {
+                return null;
+            }
+
+            public bool IsEnabled(LogLevel logLevel)
+            {
+                return _provider.IsEnabled;
+            }
+
+            public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func<TState, Exception, string> formatter)
+            {
+            }
+        }
+    }
+}

src/HttpClientFactory/Http/perf/LoggingOverheadBenchmark.cs

@@ -0,0 +1,75 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using System.Net.Http;
+using System.Net.Http.Headers;
+using System.Threading.Tasks;
+using BenchmarkDotNet.Attributes;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+
+namespace Microsoft.Extensions.Http.Performance
+{
+    [ParameterizedJobConfig(typeof(CoreConfig))]
+    public class LoggingOverheadBenchmark
+    {
+        private const int Iterations = 100;
+
+        public LoggingOverheadBenchmark()
+        {
+            Handler = new FakeClientHandler();
+            LoggerProvider = new FakeLoggerProvider();
+
+            var serviceCollection = new ServiceCollection();
+            serviceCollection.AddLogging(b => b.AddProvider(LoggerProvider));
+            serviceCollection.AddHttpClient("example", c =>
+            {
+                c.BaseAddress = new Uri("http://example.com/");
+                c.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
+            })
+            .ConfigurePrimaryHttpMessageHandler(() => Handler);
+
+            var services = serviceCollection.BuildServiceProvider();
+            Factory = services.GetRequiredService<IHttpClientFactory>();
+        }
+
+        private IHttpClientFactory Factory { get; }
+
+        private HttpMessageHandler Handler { get; }
+
+        private FakeLoggerProvider LoggerProvider { get; }
+
+        [Benchmark(
+            Description = "logging on", 
+            OperationsPerInvoke = Iterations)]
+        public async Task LoggingOn()
+        {
+            LoggerProvider.IsEnabled = true;
+
+            for (var i = 0; i < Iterations; i++)
+            {
+                var client = Factory.CreateClient("example");
+
+                var response = await client.SendAsync(new HttpRequestMessage(HttpMethod.Get, "api/Products"));
+                response.EnsureSuccessStatusCode();
+            }
+        }
+
+        [Benchmark(
+            Description = "logging off",
+            OperationsPerInvoke = Iterations)]
+        public async Task LoggingOff()
+        {
+            LoggerProvider.IsEnabled = false;
+
+            for (var i = 0; i < Iterations; i++)
+            {
+                var client = Factory.CreateClient("example");
+
+                var response = await client.SendAsync(new HttpRequestMessage(HttpMethod.Get, "api/Products"));
+                response.EnsureSuccessStatusCode();
+            }
+        }
+    }
+}

src/HttpClientFactory/Http/perf/Microsoft.Extensions.Http.Performance.csproj

@@ -0,0 +1,23 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFrameworks>netcoreapp2.0;net461</TargetFrameworks>
+    <TargetFrameworks Condition=" '$(OS)' != 'Windows_NT' ">netcoreapp2.0</TargetFrameworks>
+    <OutputType>Exe</OutputType>
+    <ServerGarbageCollection>true</ServerGarbageCollection>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Include="$(SharedSourceRoot)BenchmarkRunner\**\*.cs" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Reference Include="Microsoft.Extensions.Http" />
+    <Reference Include="BenchmarkDotNet" />
+    <Reference Include="Microsoft.Extensions.DependencyInjection" />
+  </ItemGroup>
+
+</Project>
+

src/HttpClientFactory/Http/src/ActiveHandlerTrackingEntry.cs

@@ -0,0 +1,81 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using System.Diagnostics;
+using System.Threading;
+
+namespace Microsoft.Extensions.Http
+{
+    // Thread-safety: We treat this class as immutable except for the timer. Creating a new object
+    // for the 'expiry' pool simplifies the threading requirements significantly.
+    internal class ActiveHandlerTrackingEntry
+    {
+        private readonly object _lock;
+        private bool _timerInitialized;
+        private Timer _timer;
+        private TimerCallback _callback;
+
+        public ActiveHandlerTrackingEntry(string name, LifetimeTrackingHttpMessageHandler handler, TimeSpan lifetime)
+        {
+            Name = name;
+            Handler = handler;
+            Lifetime = lifetime;
+
+            _lock = new object();
+        }
+
+        public LifetimeTrackingHttpMessageHandler Handler { get; private set; }
+
+        public TimeSpan Lifetime { get; }
+
+        public string Name { get; }
+
+        public void StartExpiryTimer(TimerCallback callback)
+        {
+            if (Lifetime == Timeout.InfiniteTimeSpan)
+            {
+                return; // never expires.
+            }
+
+            if (Volatile.Read(ref _timerInitialized))
+            {
+                return;
+            }
+
+            StartExpiryTimerSlow(callback);
+        }
+
+        private void StartExpiryTimerSlow(TimerCallback callback)
+        {
+            Debug.Assert(Lifetime != Timeout.InfiniteTimeSpan);
+
+            lock (_lock)
+            {
+                if (Volatile.Read(ref _timerInitialized))
+                {
+                    return;
+                }
+
+                _callback = callback;
+                _timer = new Timer(Timer_Tick, null, Lifetime, Timeout.InfiniteTimeSpan);
+
+                Volatile.Write(ref _timerInitialized, true);
+            }
+        }
+
+        private void Timer_Tick(object state)
+        {
+            Debug.Assert(_callback != null);
+            Debug.Assert(_timer != null);
+
+            lock (_lock)
+            {
+                _timer.Dispose();
+                _timer = null;
+
+                _callback(this);
+            }
+        }
+    }
+}