Open telemetry

API/API.csproj

@@ -25,6 +25,11 @@
       <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="9.0.7" />
       <PackageReference Include="MimeTypeMapOfficial" Version="1.0.17" />
       <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="9.0.4" />
+      <PackageReference Include="Npgsql.OpenTelemetry" Version="9.0.3" />
+      <PackageReference Include="OpenTelemetry" Version="1.12.0" />
+      <PackageReference Include="OpenTelemetry.Exporter.OpenTelemetryProtocol" Version="1.12.0" />
+      <PackageReference Include="OpenTelemetry.Instrumentation.AspNetCore" Version="1.12.0" />
+      <PackageReference Include="OpenTelemetry.Instrumentation.Http" Version="1.12.0" />
       <PackageReference Include="Serilog" Version="4.3.0" />
       <PackageReference Include="Serilog.AspNetCore" Version="9.0.0" />
       <PackageReference Include="Serilog.Enrichers.Thread" Version="4.0.0" />
@@ -36,6 +41,7 @@
       <PackageReference Include="Serilog.Sinks.AspNetCore.App.SignalR" Version="1.2.2" />
       <PackageReference Include="Serilog.Sinks.Console" Version="6.0.0" />
       <PackageReference Include="Serilog.Sinks.File" Version="7.0.0" />
+      <PackageReference Include="SharpAbp.Abp.OpenTelemetry.Exporter.Prometheus.AspNetCore" Version="4.4.0" />
       <PackageReference Include="Swashbuckle.AspNetCore" Version="9.0.3" />
       <PackageReference Include="Swashbuckle.AspNetCore.Filters" Version="9.0.0" />
       <PackageReference Include="System.IO.Abstractions" Version="22.0.15" />

API/Controllers/ClientController.cs

@@ -52,6 +52,18 @@ public async Task<IActionResult> CreateClient(ClientDto dto)
         return Ok();
     }
 
+    /// <summary>
+    /// Create several clients at once
+    /// </summary>
+    /// <param name="dtos"></param>
+    /// <returns></returns>
+    [HttpPost("create-bulk")]
+    public async Task<ActionResult> CreateClientBulk(IList<ClientDto> dtos)
+    {
+        await clientService.CreateClients(dtos);
+        return Ok();
+    }
+
     /// <summary>
     /// Update an existing client
     /// </summary>

API/Data/Repositories/ProductRepository.cs

@@ -1,6 +1,5 @@
 using API.DTOs;
 using API.Entities;
-using API.Entities.Enums;
 using API.Extensions;
 using AutoMapper;
 using AutoMapper.QueryableExtensions;
@@ -71,31 +70,31 @@ public async Task<IList<ProductDto>> GetDtoByIds(IEnumerable<int> ids)
 
     public async Task<IList<Product>> GetAll(bool onlyEnabled = false)
     {
-        return await ctx.Products
-            .WhereIf(onlyEnabled, p => p.Enabled)
+        return await QueryableExtensions
+            .WhereIf(ctx.Products, onlyEnabled, p => p.Enabled)
             .ToListAsync();
     }
 
     public async Task<IList<ProductDto>> GetAllDto(bool onlyEnabled = false)
     {
-        return await ctx.Products
-            .WhereIf(onlyEnabled, p => p.Enabled)
+        return await QueryableExtensions
+            .WhereIf(ctx.Products, onlyEnabled, p => p.Enabled)
             .ProjectTo<ProductDto>(mapper.ConfigurationProvider)
             .ToListAsync();
     }
 
     public async Task<IList<ProductCategory>> GetAllCategories(bool onlyEnabled = false)
     {
-        return await ctx.ProductCategories
-            .WhereIf(onlyEnabled, p => p.Enabled)
+        return await QueryableExtensions
+            .WhereIf(ctx.ProductCategories, onlyEnabled, p => p.Enabled)
             .OrderBy(p => p.SortValue)
             .ToListAsync();
     }
 
     public async Task<IList<ProductCategoryDto>> GetAllCategoriesDtos(bool onlyEnabled = false)
     {
-        return await ctx.ProductCategories
-            .WhereIf(onlyEnabled, p => p.Enabled)
+        return await QueryableExtensions
+            .WhereIf(ctx.ProductCategories, onlyEnabled, p => p.Enabled)
             .OrderBy(p => p.SortValue)
             .ProjectTo<ProductCategoryDto>(mapper.ConfigurationProvider)
             .ToListAsync();

API/Extensions/ApplicationServiceExtensions.cs

@@ -39,7 +39,8 @@ public static void AddApplicationServices(this IServiceCollection services, ICon
 
     private static void AddPostgres(this IServiceCollection services, IConfiguration configuration)
     {
-        var pgConnectionString = configuration.GetConnectionString("Postgres");
+        var pgConnectionString = Environment.GetEnvironmentVariable("CONNECTION_STRING")
+                                 ?? configuration.GetConnectionString("Postgres");
 
         services.AddDbContextPool<DataContext>(options =>
         {

API/Entities/QueryableExtensions.cs → API/Extensions/QueryableExtensions.cs

@@ -1,6 +1,6 @@
 using System.Linq.Expressions;
 
-namespace API.Entities;
+namespace API.Extensions;
 
 public static class QueryableExtensions
 {

API/Helpers/Telemetry/OperationTracker.cs

@@ -0,0 +1,30 @@
+using System.Diagnostics;
+using System.Diagnostics.Metrics;
+
+namespace API.Helpers.Telemetry;
+
+public class OperationTracker: IDisposable
+{
+    private readonly Stopwatch _stopwatch;
+    private readonly Histogram<double> _histogram;
+    private readonly Dictionary<string, object?> _tags;
+    private bool _disposed;
+
+    internal OperationTracker(Histogram<double> histogram, string operationName, Dictionary<string, object?>? tags)
+    {
+        _histogram = histogram;
+        _tags = tags ?? [];
+        _stopwatch = Stopwatch.StartNew();
+
+        _tags["operation"] = operationName;
+    }
+
+    public void Dispose()
+    {
+        if (_disposed) return;
+
+        _stopwatch.Stop();
+        _histogram.Record(_stopwatch.Elapsed.TotalMilliseconds, _tags.ToArray());
+        _disposed = true;
+    }
+}

API/Helpers/Telemetry/TelemetryHelper.cs

@@ -0,0 +1,46 @@
+using System.Diagnostics;
+using System.Diagnostics.Metrics;
+using Flurl.Util;
+
+namespace API.Helpers.Telemetry;
+
+public static class TelemetryHelper
+{
+
+    private static readonly ActivitySource ActivitySource;
+    private static readonly Meter Meter;
+
+    private static readonly Histogram<double> MethodTiming;
+    private static readonly Counter<long> InvalidOperationCounts;
+
+    static TelemetryHelper()
+    {
+        var serviceName = BuildInfo.AppName;
+
+        ActivitySource = new ActivitySource(serviceName);
+        Meter = new Meter(serviceName);
+
+        MethodTiming = Meter.CreateHistogram<double>(
+            "method_timing_duration_ms",
+            "ms",
+            "Duration of specific method, see method tag"
+            );
+
+        InvalidOperationCounts = Meter.CreateCounter<long>(
+            "invalid_operations_counter",
+            "absolute",
+            "Amount of invalid operations performed by users");
+    }
+
+    public static OperationTracker TrackOperation(string operationName, Dictionary<string, object?>? tags = null)
+    {
+        return new OperationTracker(MethodTiming, operationName, tags);
+    }
+
+    public static void InvalidOperation(string operationName, Dictionary<string, object?>? tags = null)
+    {
+        tags ??= [];
+        tags.Add("operation", operationName);
+        InvalidOperationCounts.Add(1, tags.ToArray());
+    }
+}

API/Services/ClientService.cs

@@ -10,6 +10,7 @@ namespace API.Services;
 public interface IClientService
 {
     Task CreateClient(ClientDto dto);
+    Task CreateClients(IList<ClientDto> dtos);
     Task UpdateClient(ClientDto dto);
     Task DeleteClient(int id);
 }
@@ -18,6 +19,22 @@ public class ClientService(IUnitOfWork unitOfWork, ILogger<ClientService> logger
 {
 
     public async Task CreateClient(ClientDto dto)
+    {
+        await CreateClientFromDto(dto);
+        await unitOfWork.CommitAsync();
+    }
+
+    public async Task CreateClients(IList<ClientDto> dtos)
+    {
+        foreach (var dto in dtos)
+        {
+            await CreateClientFromDto(dto);
+        }
+
+        await unitOfWork.CommitAsync();
+    }
+
+    private async Task CreateClientFromDto(ClientDto dto)
     {
         if (!string.IsNullOrWhiteSpace(dto.CompanyNumber))
         {
@@ -39,7 +56,6 @@ public async Task CreateClient(ClientDto dto)
         };
 
         unitOfWork.ClientRepository.Add(client);
-        await unitOfWork.CommitAsync();
     }
 
     public async Task UpdateClient(ClientDto dto)

API/Services/DeliveryService.cs

@@ -7,6 +7,7 @@
 using API.Entities.Enums;
 using API.Exceptions;
 using API.Extensions;
+using API.Helpers.Telemetry;
 
 namespace API.Services;
 
@@ -31,6 +32,11 @@ public async Task<Delivery> CreateDelivery(int userId, DeliveryDto dto)
         var client = await unitOfWork.ClientRepository.GetClientById(dto.ClientId);
         if (client == null)
             throw new InOutException("errors.client-not-found");
+
+        using var tracker = TelemetryHelper.TrackOperation("create_client", new Dictionary<string, object?>
+        {
+            ["user_id"] = userId,
+        });
 
         var lines = dto.Lines.GroupBy(l => l.ProductId)
             .Select(g => new DeliveryLineDto
@@ -95,6 +101,11 @@ public async Task<Delivery> UpdateDelivery(ClaimsPrincipal actor, DeliveryDto dt
         var user = await userService.GetUser(actor);
         if (delivery.UserId != user.Id && !actor.IsInRole(PolicyConstants.CreateForOthers))
             throw new UnauthorizedAccessException();
+
+        using var tracker = TelemetryHelper.TrackOperation("update_client", new Dictionary<string, object?>
+        {
+            ["user_id"] = user.Id,
+        });
 
         delivery.Message = dto.Message;
 
@@ -205,6 +216,12 @@ public async Task TransitionDelivery(ClaimsPrincipal actor, int deliveryId, Deli
             throw new InOutException("errors.invalid-next-state");
 
         delivery.State = nextState;
+
+        if (delivery.State == DeliveryState.Cancelled)
+        {
+            // TODO: Refund stock
+        }
+
         await unitOfWork.CommitAsync();
     }
 

API/Services/LocalizationService.cs

@@ -1,5 +1,6 @@
 using System.Text.Json;
 using API.Data;
+using API.Helpers.Telemetry;
 using Microsoft.Extensions.Caching.Memory;
 
 namespace API.Services;
@@ -78,6 +79,11 @@ public LocalizationService(ILogger<LocalizationService> logger, IDirectoryServic
 
     public async Task<Dictionary<string, string>?> LoadLanguage(string languageCode)
     {
+        using var tracker = TelemetryHelper.TrackOperation("load_language", new Dictionary<string, object?>
+        {
+            ["language"] = languageCode,
+        });
+
         if (string.IsNullOrWhiteSpace(languageCode))
         {
             languageCode = DefaultLocale;
@@ -105,6 +111,12 @@ public LocalizationService(ILogger<LocalizationService> logger, IDirectoryServic
 
     public async Task<string> Get(string locale, string key, params object[] args)
     {
+        using var tracker = TelemetryHelper.TrackOperation("get_translations", new Dictionary<string, object?>
+        {
+            ["locale"] = locale,
+            ["key"] = key,
+        });
+
         var cacheKey = $"{locale}_{key}";
         if (!_memoryCache.TryGetValue(cacheKey, out string? translatedString))
         {

API/Services/StockService.cs

@@ -3,8 +3,8 @@
 using API.DTOs;
 using API.Entities;
 using API.Entities.Enums;
-using API.Extensions;
 using API.Helpers;
+using API.Helpers.Telemetry;
 
 namespace API.Services;
 
@@ -25,12 +25,18 @@ public class StockService(ILogger<StockService> logger, IUnitOfWork unitOfWork,
 
     public async Task<Result<IList<Stock>>> UpdateStockBulkAsync(User user, IList<UpdateStockDto> dtos) 
     {
-        if (dtos == null || !dtos.Any())
+        dtos = dtos.Where(dto => dto.Value != 0 || dto.Operation == StockOperation.Set).ToList();
+
+        if (!dtos.Any())
         {
             return Result<IList<Stock>>.Failure(await localization.Translate(user.Id, "stock-bulk-empty-list"));
         }
-
-        dtos = dtos.Where(dto => dto.Value != 0 || dto.Operation == StockOperation.Set).ToList();
+
+        using var tracker = TelemetryHelper.TrackOperation("bulk_stock_update", new Dictionary<string, object?>
+        {
+            ["user_id"] = user.Id,
+            ["update_operations"] = dtos.Count,
+        });
 
         return await unitOfWork.ExecuteWithRetryAsync(async () =>
         {

API/Startup.cs

@@ -8,8 +8,12 @@
 using API.Middleware;
 using Microsoft.AspNetCore.Http.Features;
 using Microsoft.AspNetCore.ResponseCompression;
+using Microsoft.Extensions.Primitives;
 using Microsoft.Net.Http.Headers;
 using Microsoft.OpenApi.Models;
+using Npgsql;
+using OpenTelemetry.Metrics;
+using OpenTelemetry.Resources;
 using Serilog;
 using Serilog.Events;
 
@@ -85,6 +89,16 @@ public void ConfigureServices(IServiceCollection services)
         });
         services.AddResponseCaching();
         // TODO: Rate limitter
+
+        services.AddOpenTelemetry()
+            .ConfigureResource(src => src
+                .AddService(BuildInfo.AppName))
+            .WithMetrics(metrics => metrics
+                .AddAspNetCoreInstrumentation()
+                .AddHttpClientInstrumentation()
+                .AddNpgsqlInstrumentation()
+                .AddMeter(BuildInfo.AppName)
+                .AddPrometheusExporter());
     }
 
     public void Configure(IApplicationBuilder app, IServiceProvider serviceProvider, IHostApplicationLifetime applicationLifetime)
@@ -158,12 +172,33 @@ public void Configure(IApplicationBuilder app, IServiceProvider serviceProvider,
                 ctx.Context.Response.Headers["X-Robots-Tag"] = "noindex,nofollow";
             }
         });
+
+
+
+        var apiKey = cfg.GetValue<string>("ApiKey");
+        app.Use(async (ctx, next) =>
+        {
+            if (ctx.Request.Path.StartsWithSegments("/metrics"))
+            {
+                if (!ctx.Request.Query.TryGetValue("api-key", out var key) ||
+                    key != apiKey || string.IsNullOrWhiteSpace(apiKey))
+                {
+                    ctx.Response.StatusCode = StatusCodes.Status401Unauthorized;
+                    await ctx.Response.WriteAsync("Unauthorized");
+                    return;
+                }
+            }
+
+            await next();
+        });
+
         app.UseEndpoints(endpoints =>
         {
             endpoints.MapControllers();
             //endpoints.MapHub<MessageHub>("hubs/messages");
             //endpoints.MapHub<LogHub>("hubs/logs");
             endpoints.MapFallbackToController("Index", "Fallback");
+            endpoints.MapPrometheusScrapingEndpoint();
         });
 
         applicationLifetime.ApplicationStarted.Register(() =>