perf: optimize authorization scoreline and workers

Tiku.Api/Configuration/ApplicationBuilderExtensions.cs

@@ -22,9 +22,11 @@ public static class ApplicationBuilderExtensions
         }
 
         app.UseSerilogRequestLogging(SerilogRequestLogging.ConfigureRequestLogging);
+        app.UseMiddleware<DatabaseRequestMetricsMiddleware>();
         app.UseMiddleware<ExceptionHandlingMiddleware>();
         app.UseForwardedHeaders();
         app.UseHttpsRedirection();
+        app.UseResponseCompression();
         app.UseDefaultFiles();
         app.UseStaticFiles();
         app.UseRouting();
@@ -37,6 +39,7 @@ public static class ApplicationBuilderExtensions
         app.UseMiddleware<CurrentPrincipalMiddleware>();
         app.UseAuthorization();
         app.UseMiddleware<SaasFeatureAccessMiddleware>();
+        app.UseOutputCache();
         app.MapControllers();
 
         return app;

Tiku.Api/Configuration/AuthenticationExtensions.cs

@@ -209,7 +209,11 @@ internal static class AuthenticationExtensions
         if (session is null)
         {
             context.Fail("Session, identity, membership, tenant or role state is no longer valid.");
+            return;
         }
+
+        context.HttpContext.RequestServices.GetRequiredService<IRequestSecurityState>()
+            .SetValidatedSession(session);
     }
 
     private static async Task WriteTenantConflictChallengeAsync(JwtBearerChallengeContext context)

Tiku.Api/Configuration/DependencyInjection.cs

@@ -3,6 +3,12 @@ using Tiku.Application;
 using Tiku.Infrastructure;
 using Tiku.Infrastructure.Messaging;
 using Tiku.Infrastructure.Security;
+using Tiku.Api.Caching;
+using Microsoft.AspNetCore.ResponseCompression;
+using System.IO.Compression;
+using Tiku.Api.Observability;
+using Tiku.Application.Tenancy;
+using Microsoft.Extensions.DependencyInjection.Extensions;
 
 namespace Tiku.Api.Configuration;
 
@@ -18,6 +24,9 @@ public static class DependencyInjection
 
         builder.Services.AddApiPresentation();
         builder.Services.AddHealthChecks();
+        builder.Services.AddApiObservability(builder.Configuration, builder.Environment);
+        builder.Services.AddSingleton<OutboxBacklogSnapshot>();
+        builder.Services.AddHostedService<OutboxBacklogMonitor>();
         builder.Services.AddApplication();
         builder.Services.AddNetworkConfiguration(builder.Configuration, builder.Environment);
         builder.Services.AddApiRateLimiting(builder.Configuration);
@@ -42,6 +51,31 @@ public static class DependencyInjection
             throw new InvalidOperationException(
                 "Redis is required in Production. Configure ConnectionStrings:Redis or REDIS_URL.");
         }
+
+        builder.Services.AddOutputCache(options =>
+        {
+            options.AddPolicy("TenantPublic", new TenantPublicOutputCachePolicy());
+            options.DefaultExpirationTimeSpan = TimeSpan.FromSeconds(60);
+        });
+        builder.Services.RemoveAll<ITenantPublicCacheInvalidator>();
+        builder.Services.AddSingleton<ITenantPublicCacheInvalidator, TenantPublicCacheInvalidator>();
+        if (builder.Environment.IsProduction() && !string.IsNullOrWhiteSpace(redisConnectionString))
+        {
+            builder.Services.AddStackExchangeRedisOutputCache(options =>
+            {
+                options.Configuration = redisConnectionString;
+                options.InstanceName = $"tiku:{builder.Environment.EnvironmentName.ToLowerInvariant()}:output:";
+            });
+        }
+        builder.Services.AddResponseCompression(options =>
+        {
+            options.EnableForHttps = true;
+            options.Providers.Add<BrotliCompressionProvider>();
+            options.Providers.Add<GzipCompressionProvider>();
+            options.MimeTypes = ResponseCompressionDefaults.MimeTypes.Concat(["application/json"]);
+        });
+        builder.Services.Configure<BrotliCompressionProviderOptions>(options => options.Level = CompressionLevel.Fastest);
+        builder.Services.Configure<GzipCompressionProviderOptions>(options => options.Level = CompressionLevel.Fastest);
         var messaging = builder.Configuration.GetSection("RabbitMq").Get<MessagingOptions>() ?? new MessagingOptions();
         builder.Services.AddOptions<MessagingOptions>()
             .Bind(builder.Configuration.GetSection("RabbitMq"))

Tiku.Api/Configuration/ObservabilityExtensions.cs

@@ -0,0 +1,46 @@
+using OpenTelemetry.Metrics;
+using OpenTelemetry.Resources;
+using OpenTelemetry.Trace;
+using Tiku.Infrastructure.Observability;
+
+namespace Tiku.Api.Configuration;
+
+internal static class ObservabilityExtensions
+{
+    internal static IServiceCollection AddApiObservability(
+        this IServiceCollection services,
+        IConfiguration configuration,
+        IHostEnvironment environment)
+    {
+        var endpoint = configuration["OpenTelemetry:OtlpEndpoint"];
+        var hasOtlpEndpoint = Uri.TryCreate(endpoint, UriKind.Absolute, out var endpointUri);
+
+        services.AddOpenTelemetry()
+            .ConfigureResource(resource => resource.AddService(
+                serviceName: environment.ApplicationName,
+                serviceVersion: typeof(ObservabilityExtensions).Assembly.GetName().Version?.ToString()))
+            .WithTracing(tracing => tracing
+                .AddAspNetCoreInstrumentation(options =>
+                    options.Filter = context => !context.Request.Path.StartsWithSegments("/api/health"))
+                .AddHttpClientInstrumentation()
+                .AddSource("Npgsql")
+                .ApplyIf(hasOtlpEndpoint, builder => builder.AddOtlpExporter(options => options.Endpoint = endpointUri!)))
+            .WithMetrics(metrics => metrics
+                .AddAspNetCoreInstrumentation()
+                .AddHttpClientInstrumentation()
+                .AddMeter(DatabasePerformanceTelemetry.MeterName, "Tiku.Security.Redis", "Tiku.Messaging", "Npgsql")
+                .ApplyIf(hasOtlpEndpoint, builder => builder.AddOtlpExporter(options => options.Endpoint = endpointUri!)));
+
+        return services;
+    }
+
+    private static TBuilder ApplyIf<TBuilder>(this TBuilder builder, bool condition, Action<TBuilder> configure)
+    {
+        if (condition)
+        {
+            configure(builder);
+        }
+
+        return builder;
+    }
+}