Feature/store configuraton json idented (#328)

* messing around with benchmark.net.seems Ocelot adds about 2ms to a request..lets make this less? :) * #326 store json indented so it looks nice :P
2025-06-19 11:58:15 +08:00 · 2018-04-24 08:30:17 +01:00
parent 636d116491
commit 77211e9f16
14 changed files with 445 additions and 53 deletions
--- a/test/Ocelot.Benchmarks/AllTheThingsBenchmarks.cs
+++ b/test/Ocelot.Benchmarks/AllTheThingsBenchmarks.cs
@ -0,0 +1,157 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Columns;
+using BenchmarkDotNet.Configs;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Logging;
+using Newtonsoft.Json;
+using Ocelot.Configuration.File;
+using Ocelot.DownstreamRouteFinder.UrlMatcher;
+using Ocelot.Middleware;
+using Ocelot.DependencyInjection;
+using System.Net.Http;
+using System.Threading.Tasks;
+using BenchmarkDotNet.Attributes.Jobs;
+using BenchmarkDotNet.Diagnosers;
+using BenchmarkDotNet.Validators;
+
+namespace Ocelot.Benchmarks
+{
+    [Config(typeof(AllTheThingsBenchmarks))]
+    public class AllTheThingsBenchmarks : ManualConfig
+    {
+        private IWebHost _service;
+        private IWebHost _ocelot;
+        private HttpClient _httpClient;
+
+        public AllTheThingsBenchmarks()
+        {
+            Add(StatisticColumn.AllStatistics);
+            Add(MemoryDiagnoser.Default);
+            Add(BaselineValidator.FailOnError);
+        }
+
+        [GlobalSetup]
+        public void SetUp()
+        {
+            var configuration = new FileConfiguration
+            {
+                ReRoutes = new List<FileReRoute>
+                    {
+                        new FileReRoute
+                        {
+                            DownstreamPathTemplate = "/",
+                            DownstreamHostAndPorts = new List<FileHostAndPort>
+                            {
+                                new FileHostAndPort
+                                {
+                                    Host = "localhost",
+                                    Port = 51879,
+                                }
+                            },
+                            DownstreamScheme = "http",
+                            UpstreamPathTemplate = "/",
+                            UpstreamHttpMethod = new List<string> { "Get" },
+                        }
+                    }
+            };
+
+            GivenThereIsAServiceRunningOn("http://localhost:51879", "/", 201, string.Empty);
+            GivenThereIsAConfiguration(configuration);
+            GivenOcelotIsRunning("http://localhost:5000");
+
+            _httpClient = new HttpClient();
+        }
+
+        [Benchmark(Baseline = true)]
+        public async Task Baseline()
+        {
+            var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost:5000/");
+            var response = await _httpClient.SendAsync(request);
+            response.EnsureSuccessStatusCode();
+        }
+
+        // * Summary *
+        // BenchmarkDotNet=v0.10.13, OS=macOS 10.12.6 (16G1212) [Darwin 16.7.0]
+        // Intel Core i5-4278U CPU 2.60GHz (Haswell), 1 CPU, 4 logical cores and 2 physical cores
+        // .NET Core SDK=2.1.4
+        //   [Host]     : .NET Core 2.0.6 (CoreCLR 4.6.0.0, CoreFX 4.6.26212.01), 64bit RyuJIT
+        //   DefaultJob : .NET Core 2.0.6 (CoreCLR 4.6.0.0, CoreFX 4.6.26212.01), 64bit RyuJIT
+
+        //    Method |     Mean |     Error |    StdDev |    StdErr |      Min |       Q1 |   Median |       Q3 |      Max |  Op/s | Scaled |   Gen 0 |  Gen 1 | Allocated |
+        // --------- |---------:|----------:|----------:|----------:|---------:|---------:|---------:|---------:|---------:|------:|-------:|--------:|-------:|----------:|
+        //  Baseline | 2.102 ms | 0.0292 ms | 0.0273 ms | 0.0070 ms | 2.063 ms | 2.080 ms | 2.093 ms | 2.122 ms | 2.152 ms | 475.8 |   1.00 | 31.2500 | 3.9063 |   1.63 KB |
+
+        private void GivenOcelotIsRunning(string url)
+        {
+            _ocelot = new WebHostBuilder()
+                .UseKestrel()
+                .UseUrls(url)
+                .UseContentRoot(Directory.GetCurrentDirectory())
+                .ConfigureAppConfiguration((hostingContext, config) =>
+                {
+                    config
+                        .SetBasePath(hostingContext.HostingEnvironment.ContentRootPath)
+                        .AddJsonFile("appsettings.json", true, true)
+                        .AddJsonFile($"appsettings.{hostingContext.HostingEnvironment.EnvironmentName}.json", true, true)
+                        .AddJsonFile("ocelot.json")
+                        .AddEnvironmentVariables();
+                })
+                .ConfigureServices(s => {
+                    s.AddOcelot();
+                })
+                .ConfigureLogging((hostingContext, logging) =>
+                {
+                    logging.AddConfiguration(hostingContext.Configuration.GetSection("Logging"));
+                })
+                .UseIISIntegration()
+                .Configure(app =>
+                {
+                    app.UseOcelot().Wait();
+                })
+                .Build();
+
+            _ocelot.Start();
+        }
+
+        public void GivenThereIsAConfiguration(FileConfiguration fileConfiguration)
+        {
+            var configurationPath = Path.Combine(AppContext.BaseDirectory, "ocelot.json");;
+
+            var jsonConfiguration = JsonConvert.SerializeObject(fileConfiguration);
+
+            if (File.Exists(configurationPath))
+            {
+                File.Delete(configurationPath);
+            }
+
+            File.WriteAllText(configurationPath, jsonConfiguration);
+        }
+        
+        private void GivenThereIsAServiceRunningOn(string baseUrl, string basePath, int statusCode, string responseBody)
+        {
+            _service = new WebHostBuilder()
+                .UseUrls(baseUrl)
+                .UseKestrel()
+                .UseContentRoot(Directory.GetCurrentDirectory())
+                .UseIISIntegration()
+                .Configure(app =>
+                {
+                    app.UsePathBase(basePath);
+                    app.Run(async context =>
+                    {   
+                        context.Response.StatusCode = statusCode;
+                        await context.Response.WriteAsync(responseBody);
+                    });
+                })
+                .Build();
+
+            _service.Start();
+        }
+    }
+}
--- a/test/Ocelot.Benchmarks/ExceptionHandlerMiddlewareBenchmarks.cs
+++ b/test/Ocelot.Benchmarks/ExceptionHandlerMiddlewareBenchmarks.cs
@ -0,0 +1,69 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Columns;
+using BenchmarkDotNet.Configs;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Logging;
+using Newtonsoft.Json;
+using Ocelot.Configuration.File;
+using Ocelot.DownstreamRouteFinder.UrlMatcher;
+using Ocelot.Middleware;
+using Ocelot.DependencyInjection;
+using System.Net.Http;
+using System.Threading.Tasks;
+using BenchmarkDotNet.Attributes.Jobs;
+using Ocelot.Configuration.Repository;
+using Ocelot.Infrastructure.RequestData;
+using Ocelot.Logging;
+using Ocelot.Errors.Middleware;
+using Microsoft.Extensions.DependencyInjection;
+using BenchmarkDotNet.Diagnosers;
+using BenchmarkDotNet.Validators;
+
+namespace Ocelot.Benchmarks
+{
+    [SimpleJob(launchCount: 1, warmupCount: 2, targetCount: 5)]
+    [Config(typeof(ExceptionHandlerMiddlewareBenchmarks))]
+    public class ExceptionHandlerMiddlewareBenchmarks : ManualConfig
+    {
+        private ExceptionHandlerMiddleware _middleware;
+        private DownstreamContext _downstreamContext;
+        private OcelotRequestDelegate _next;
+
+        public ExceptionHandlerMiddlewareBenchmarks()
+        {
+            Add(StatisticColumn.AllStatistics);
+            Add(MemoryDiagnoser.Default);
+            Add(BaselineValidator.FailOnError);
+        }
+
+        [GlobalSetup]
+        public void SetUp()
+        {
+            var serviceCollection = new ServiceCollection();
+            var config = new ConfigurationRoot(new List<IConfigurationProvider>());
+            var builder = new OcelotBuilder(serviceCollection, config);
+            var services = serviceCollection.BuildServiceProvider();
+            var loggerFactory = services.GetService<IOcelotLoggerFactory>();
+            var configRepo = services.GetService<IInternalConfigurationRepository>();
+            var repo = services.GetService<IRequestScopedDataRepository>();
+            _next = async context => {
+                await Task.CompletedTask;
+                throw new Exception("BOOM");
+            };
+            _middleware = new ExceptionHandlerMiddleware(_next, loggerFactory, configRepo, repo);
+            _downstreamContext = new DownstreamContext(new DefaultHttpContext());
+        }
+
+        [Benchmark(Baseline = true)]
+        public async Task Baseline()
+        {
+            await _middleware.Invoke(_downstreamContext);
+        }
+    }
+}
--- a/test/Ocelot.Benchmarks/Program.cs
+++ b/test/Ocelot.Benchmarks/Program.cs
@ -7,7 +7,9 @@ namespace Ocelot.Benchmarks
        public static void Main(string[] args)
        {
            var switcher = new BenchmarkSwitcher(new[] {
-                   typeof(UrlPathToUrlPathTemplateMatcherBenchmarks),
+                    typeof(UrlPathToUrlPathTemplateMatcherBenchmarks),
+                    typeof(AllTheThingsBenchmarks),
+                    typeof(ExceptionHandlerMiddlewareBenchmarks)
               });

            switcher.Run(args);
--- a/test/Ocelot.Benchmarks/UrlPathToUrlPathTemplateMatcherBenchmarks.cs
+++ b/test/Ocelot.Benchmarks/UrlPathToUrlPathTemplateMatcherBenchmarks.cs
@ -1,6 +1,9 @@
+using System;
 using BenchmarkDotNet.Attributes;
 using BenchmarkDotNet.Columns;
 using BenchmarkDotNet.Configs;
+using BenchmarkDotNet.Diagnosers;
+using BenchmarkDotNet.Validators;
 using Ocelot.DownstreamRouteFinder.UrlMatcher;

 namespace Ocelot.Benchmarks
@ -15,6 +18,8 @@ namespace Ocelot.Benchmarks
        public UrlPathToUrlPathTemplateMatcherBenchmarks()
        {
            Add(StatisticColumn.AllStatistics);
+            Add(MemoryDiagnoser.Default);
+            Add(BaselineValidator.FailOnError);
        }

        [GlobalSetup]
@ -25,16 +30,23 @@ namespace Ocelot.Benchmarks
            _downstreamUrlPathTemplate = "api/product/products/{productId}/variants/";
        }

-        [Benchmark]
-        public void Benchmark1()
+        [Benchmark(Baseline = true)]
+        public void Baseline()
        {
            _urlPathMatcher.Match(_downstreamUrlPath, _downstreamUrlPathTemplate);
        }

-        [Benchmark]
-        public void Benchmark2()
-        {
-            _urlPathMatcher.Match(_downstreamUrlPath, _downstreamUrlPathTemplate);
-        }
+        // * Summary *
+
+        // BenchmarkDotNet=v0.10.13, OS=macOS 10.12.6 (16G1212) [Darwin 16.7.0]
+        // Intel Core i5-4278U CPU 2.60GHz (Haswell), 1 CPU, 4 logical cores and 2 physical cores
+        // .NET Core SDK=2.1.4
+        //   [Host]     : .NET Core 2.0.6 (CoreCLR 4.6.0.0, CoreFX 4.6.26212.01), 64bit RyuJIT
+        //   DefaultJob : .NET Core 2.0.6 (CoreCLR 4.6.0.0, CoreFX 4.6.26212.01), 64bit RyuJIT
+
+
+        //      Method |     Mean |     Error |    StdDev |    StdErr |      Min |       Q1 |   Median |       Q3 |      Max |      Op/s |
+        // ----------- |---------:|----------:|----------:|----------:|---------:|---------:|---------:|---------:|---------:|----------:|
+        //  Benchmark1 | 3.133 us | 0.0492 us | 0.0460 us | 0.0119 us | 3.082 us | 3.100 us | 3.122 us | 3.168 us | 3.233 us | 319,161.9 |
    }
 }