Полиглотные микросервисы на C# и .NET

// UserManagement Service (C#)
public class UserProfile
{
    public Guid Id { get; set; }
    public string Email { get; set; }
    public string HashedPassword { get; set; }
    public UserRole Role { get; set; }
    public DateTime CreatedAt { get; set; }
}
 
// Analytics Service (Python) - другой bounded context
class UserBehavior:
    def __init__(self, user_id, session_data, interaction_events):
        self.user_id = user_id
        self.session_data = session_data
        self.interaction_events = interaction_events

// Event в C# сервисе
public class OrderPlacedEvent
{
    public Guid OrderId { get; set; }
    public Guid UserId { get; set; }
    public decimal Amount { get; set; }
    public DateTime PlacedAt { get; set; }
    public List<OrderItem> Items { get; set; }
}
 
// Публикация события
await _messagePublisher.PublishAsync(new OrderPlacedEvent
{
    OrderId = order.Id,
    UserId = order.UserId,
    Amount = order.TotalAmount,
    PlacedAt = DateTime.UtcNow,
    Items = order.Items
});

[ApiController]
[Route("api/[controller]")]
public class OrdersController : ControllerBase
{
    private readonly IOrderService _orderService;
    private readonly IInventoryService _inventoryService; // Node.js service
    private readonly INotificationService _notificationService; // Python service
 
    [HttpPost]
    public async Task<IActionResult> CreateOrder([FromBody] CreateOrderRequest request)
    {
        // Проверка наличия товара через gRPC к Node.js сервису
        var availability = await _inventoryService.CheckAvailabilityAsync(request.Items);
        if (!availability.IsAvailable)
        {
            return BadRequest("Some items are not available");
        }
 
        // Создание заказа в C# сервисе
        var order = await _orderService.CreateOrderAsync(request);
 
        // Отправка уведомления через HTTP к Python сервису
        await _notificationService.SendOrderConfirmationAsync(order.Id, order.UserId);
 
        return Ok(order);
    }
}

// gRPC клиент для интеграции с Node.js сервисом
public class InventoryGrpcClient : IInventoryService
{
    private readonly InventoryService.InventoryServiceClient _client;
 
    public async Task<AvailabilityResponse> CheckAvailabilityAsync(
        IEnumerable<OrderItem> items)
    {
        var request = new CheckAvailabilityRequest();
        request.Items.AddRange(items.Select(item => new InventoryItem
        {
            ProductId = item.ProductId,
            Quantity = item.Quantity
        }));
 
        var response = await _client.CheckAvailabilityAsync(request);
        return new AvailabilityResponse
        {
            IsAvailable = response.IsAvailable,
            UnavailableItems = response.UnavailableItems.ToList()
        };
    }
}

public class OrderSaga
{
    private readonly IInventoryService _inventoryService;
    private readonly IPaymentService _paymentService;
    private readonly IOrderService _orderService;
    private readonly INotificationService _notificationService;
 
    public async Task<OrderResult> ProcessOrderAsync(CreateOrderCommand command)
    {
        var sagaId = Guid.NewGuid();
        var steps = new List<ISagaStep>();
 
        try
        {
            // Шаг 1: Резервирование товара
            var reservationStep = new ReserveInventoryStep(_inventoryService);
            await reservationStep.ExecuteAsync(command.Items);
            steps.Add(reservationStep);
 
            // Шаг 2: Создание заказа
            var orderStep = new CreateOrderStep(_orderService);
            var order = await orderStep.ExecuteAsync(command);
            steps.Add(orderStep);
 
            // Шаг 3: Обработка платежа
            var paymentStep = new ProcessPaymentStep(_paymentService);
            await paymentStep.ExecuteAsync(order.Id, command.PaymentDetails);
            steps.Add(paymentStep);
 
            // Шаг 4: Уведомление пользователя
            await _notificationService.SendOrderConfirmationAsync(order.Id, order.UserId);
 
            return order;
        }
        catch (Exception ex)
        {
            // Откат всех выполненных шагов
            foreach (var step in steps.Reverse())
            {
                await step.CompensateAsync();
            }
            throw;
        }
    }
}

public class DistributedLockService
{
    private readonly IDatabase _database;
    private readonly string _lockPrefix = "lock:";
 
    public async Task<bool> AcquireLockAsync(string resource, TimeSpan expiry, string lockId)
    {
        var key = _lockPrefix + resource;
        var acquired = await _database.StringSetAsync(key, lockId, expiry, When.NotExists);
        return acquired;
    }
 
    public async Task<bool> ReleaseLockAsync(string resource, string lockId)
    {
        var key = _lockPrefix + resource;
        const string script = @"
            if redis.call('GET', KEYS[1]) == ARGV[1] then
                return redis.call('DEL', KEYS[1])
            else
                return 0
            end";
        
        var result = await _database.ScriptEvaluateAsync(script, new RedisKey[] { key }, new RedisValue[] { lockId });
        return result.ToString() == "1";
    }
}

public class ErrorResponse
{
    public string Code { get; set; }
    public string Message { get; set; }
    public Dictionary<string, object> Details { get; set; }
    public string TraceId { get; set; }
 
    public static ErrorResponse ValidationError(string field, string message, string traceId)
    {
        return new ErrorResponse
        {
            Code = "VALIDATION_ERROR",
            Message = "Validation failed",
            Details = new Dictionary<string, object> { [field] = message },
            TraceId = traceId
        };
    }
}
 
[HttpPost]
public async Task<IActionResult> CreateUser([FromBody] CreateUserRequest request)
{
    try
    {
        var user = await _userService.CreateAsync(request);
        return Ok(user);
    }
    catch (ValidationException ex)
    {
        var traceId = HttpContext.TraceIdentifier;
        return BadRequest(ErrorResponse.ValidationError(ex.Field, ex.Message, traceId));
    }
    catch (ServiceUnavailableException)
    {
        return StatusCode(503, new ErrorResponse 
        { 
            Code = "SERVICE_UNAVAILABLE", 
            Message = "External service temporarily unavailable",
            TraceId = HttpContext.TraceIdentifier
        });
    }
}

var circuitBreakerPolicy = Policy
    .Handle<HttpRequestException>()
    .Or<TaskCanceledException>()
    .CircuitBreakerAsync(
        handledEventsAllowedBeforeBreaking: 3,
        durationOfBreak: TimeSpan.FromSeconds(30),
        onBreak: (exception, duration) => 
        {
            _logger.LogWarning("Circuit breaker opened for {Duration}s due to {Exception}", 
                duration.TotalSeconds, exception.Message);
        },
        onReset: () => 
        {
            _logger.LogInformation("Circuit breaker reset");
        });
 
// Использование
var response = await circuitBreakerPolicy.ExecuteAsync(async () =>
{
    return await _httpClient.GetAsync($"api/inventory/{productId}");
});

public class MLModelClient
{
    private readonly HttpClient _httpClient;
    private readonly ILogger<MLModelClient> _logger;
 
    public async Task<PredictionResult> GetPredictionAsync(UserBehaviorData data)
    {
        // Преобразование C# объектов в формат, понятный Python
        var features = new
        {
            user_id = data.UserId,
            session_duration = data.SessionDuration.TotalMinutes,
            page_views = data.PageViews,
            click_events = data.ClickEvents.Select(e => new
            {
                element = e.Element,
                timestamp = e.Timestamp.ToUnixTimeMilliseconds(),
                coordinates = new { x = e.X, y = e.Y }
            }).ToArray(),
            // NumPy массив передаем как вложенный список
            feature_vector = data.Features.Select(f => f.Values).ToArray()
        };
 
        var json = JsonSerializer.Serialize(features, new JsonSerializerOptions
        {
            PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
            Converters = { new DoubleArrayJsonConverter() }
        });
 
        var content = new StringContent(json, Encoding.UTF8, "application/json");
        
        try
        {
            var response = await _httpClient.PostAsync("predict", content);
            response.EnsureSuccessStatusCode();
            
            var resultJson = await response.Content.ReadAsStringAsync();
            var result = JsonSerializer.Deserialize<PredictionResult>(resultJson);
            
            return result;
        }
        catch (HttpRequestException ex)
        {
            _logger.LogError(ex, "Failed to get prediction for user {UserId}", data.UserId);
            throw new MLServiceException("Prediction service unavailable", ex);
        }
    }
}
 
// Кастомный конвертер для корректной сериализации массивов
public class DoubleArrayJsonConverter : JsonConverter<double[][]>
{
    public override double[][]? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
    {
        // Реализация десериализации
        return JsonSerializer.Deserialize<double[][]>(ref reader);
    }
 
    public override void Write(Utf8JsonWriter writer, double[][] value, JsonSerializerOptions options)
    {
        writer.WriteStartArray();
        foreach (var array in value)
        {
            writer.WriteStartArray();
            foreach (var item in array)
            {
                writer.WriteNumberValue(item);
            }
            writer.WriteEndArray();
        }
        writer.WriteEndArray();
    }
}

public class JwtServiceAuthenticationHandler : AuthenticationHandler<JwtServiceAuthenticationOptions>
{
    private readonly ILogger<JwtServiceAuthenticationHandler> _logger;
 
    public JwtServiceAuthenticationHandler(IOptionsMonitor<JwtServiceAuthenticationOptions> options,
        ILoggerFactory logger, UrlEncoder encoder, ISystemClock clock)
        : base(options, logger, encoder, clock)
    {
        _logger = logger.CreateLogger<JwtServiceAuthenticationHandler>();
    }
 
    protected override Task<AuthenticateResult> HandleAuthenticateAsync()
    {
        if (!Request.Headers.ContainsKey("Authorization"))
        {
            return Task.FromResult(AuthenticateResult.Fail("Missing Authorization header"));
        }
 
        try
        {
            var authHeader = Request.Headers["Authorization"].FirstOrDefault();
            if (authHeader == null || !authHeader.StartsWith("Bearer "))
            {
                return Task.FromResult(AuthenticateResult.Fail("Invalid Authorization header format"));
            }
 
            var token = authHeader.Substring("Bearer ".Length).Trim();
            var tokenHandler = new JwtSecurityTokenHandler();
            
            var validationParameters = GetTokenValidationParameters();
            var principal = tokenHandler.ValidateToken(token, validationParameters, out var validatedToken);
 
            // Дополнительная валидация для межсервисных токенов
            if (validatedToken is JwtSecurityToken jwtToken)
            {
                var serviceClaim = jwtToken.Claims.FirstOrDefault(x => x.Type == "service_name");
                if (serviceClaim == null || !IsAuthorizedService(serviceClaim.Value))
                {
                    return Task.FromResult(AuthenticateResult.Fail("Unauthorized service"));
                }
            }
 
            var ticket = new AuthenticationTicket(principal, Options.DefaultScheme);
            return Task.FromResult(AuthenticateResult.Success(ticket));
        }
        catch (SecurityTokenException ex)
        {
            _logger.LogWarning(ex, "Token validation failed: {Message}", ex.Message);
            return Task.FromResult(AuthenticateResult.Fail(ex.Message));
        }
    }
 
    private TokenValidationParameters GetTokenValidationParameters()
    {
        return new TokenValidationParameters
        {
            ValidateIssuerSigningKey = true,
            IssuerSigningKey = new SymmetricSecurityKey(
                Encoding.UTF8.GetBytes(Options.SecretKey)),
            ValidateIssuer = true,
            ValidIssuer = Options.Issuer,
            ValidateAudience = true,
            ValidAudience = Options.Audience,
            ClockSkew = TimeSpan.FromMinutes(5),
            RequireExpirationTime = true,
            ValidateLifetime = true
        };
    }
 
    private bool IsAuthorizedService(string serviceName)
    {
        return Options.AuthorizedServices.Contains(serviceName);
    }
}

public class PythonApiClient
{
    private readonly HttpClient _httpClient;
    private readonly JsonSerializerOptions _jsonOptions;
 
    public PythonApiClient(HttpClient httpClient)
    {
        _httpClient = httpClient;
        _jsonOptions = new JsonSerializerOptions
        {
            PropertyNamingPolicy = new SnakeCaseNamingPolicy(),
            WriteIndented = false,
            DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull
        };
    }
 
    public async Task<MLResult> ProcessDataAsync(MLRequest request)
    {
        var json = JsonSerializer.Serialize(request, _jsonOptions);
        var content = new StringContent(json, Encoding.UTF8, "application/json");
        
        var response = await _httpClient.PostAsync("api/ml/process", content);
        
        if (!response.IsSuccessStatusCode)
        {
            var error = await response.Content.ReadAsStringAsync();
            throw new MLServiceException($"ML service returned {response.StatusCode}: {error}");
        }
        
        var resultJson = await response.Content.ReadAsStringAsync();
        return JsonSerializer.Deserialize<MLResult>(resultJson, _jsonOptions);
    }
}
 
public class SnakeCaseNamingPolicy : JsonNamingPolicy
{
    public override string ConvertName(string name)
    {
        return ToSnakeCase(name);
    }
 
    private static string ToSnakeCase(string text)
    {
        if (string.IsNullOrEmpty(text))
            return text;
 
        var builder = new StringBuilder(text.Length + Math.Min(2, text.Length / 5));
        var previousCategory = default(UnicodeCategory?);
 
        for (var currentIndex = 0; currentIndex < text.Length; currentIndex++)
        {
            var currentChar = text[currentIndex];
            if (currentChar == '_')
            {
                builder.Append('_');
                previousCategory = null;
                continue;
            }
 
            var currentCategory = char.GetUnicodeCategory(currentChar);
            switch (currentCategory)
            {
                case UnicodeCategory.UppercaseLetter:
                case UnicodeCategory.TitlecaseLetter:
                    if (previousCategory == UnicodeCategory.SpaceSeparator ||
                        previousCategory == UnicodeCategory.LowercaseLetter ||
                        previousCategory != UnicodeCategory.DecimalDigitNumber &&
                        previousCategory != null &&
                        currentIndex > 0 &&
                        currentIndex + 1 < text.Length &&
                        char.IsLower(text[currentIndex + 1]))
                    {
                        builder.Append('_');
                    }
 
                    currentChar = char.ToLower(currentChar);
                    break;
 
                case UnicodeCategory.LowercaseLetter:
                case UnicodeCategory.DecimalDigitNumber:
                    if (previousCategory == UnicodeCategory.SpaceSeparator)
                    {
                        builder.Append('_');
                    }
                    break;
 
                default:
                    if (previousCategory != null)
                    {
                        previousCategory = UnicodeCategory.SpaceSeparator;
                    }
                    continue;
            }
 
            builder.Append(currentChar);
            previousCategory = currentCategory;
        }
 
        return builder.ToString();
    }
}

public class HybridApiController : ControllerBase
{
    private readonly OrderGrpcService.OrderGrpcServiceClient _grpcClient;
    private readonly IMapper _mapper;
 
    [HttpPost("orders")]
    public async Task<IActionResult> CreateOrder([FromBody] CreateOrderRequest request)
    {
        try
        {
            // Конвертация REST модели в gRPC
            var grpcRequest = _mapper.Map<CreateOrderGrpcRequest>(request);
            grpcRequest.TraceId = HttpContext.TraceIdentifier;
            
            // Вызов gRPC сервиса
            var grpcResponse = await _grpcClient.CreateOrderAsync(grpcRequest);
            
            // Конвертация gRPC ответа обратно в REST
            var response = _mapper.Map<CreateOrderResponse>(grpcResponse);
            
            return Ok(response);
        }
        catch (RpcException ex) when (ex.StatusCode == StatusCode.InvalidArgument)
        {
            return BadRequest(new { error = ex.Status.Detail });
        }
        catch (RpcException ex) when (ex.StatusCode == StatusCode.NotFound)
        {
            return NotFound(new { error = "Order not found" });
        }
        catch (RpcException ex)
        {
            _logger.LogError(ex, "gRPC call failed with status {Status}", ex.StatusCode);
            return StatusCode(503, new { error = "Service temporarily unavailable" });
        }
    }
}
 
// AutoMapper профили для конвертации между REST и gRPC моделями
public class RestToGrpcProfile : Profile
{
    public RestToGrpcProfile()
    {
        CreateMap<CreateOrderRequest, CreateOrderGrpcRequest>()
            .ForMember(dest => dest.Items, opt => opt.MapFrom(src => src.Items))
            .ForMember(dest => dest.CustomerId, opt => opt.MapFrom(src => src.CustomerId));
        
        CreateMap<CreateOrderGrpcResponse, CreateOrderResponse>()
            .ForMember(dest => dest.OrderId, opt => opt.MapFrom(src => src.OrderId))
            .ForMember(dest => dest.Status, opt => opt.MapFrom(src => src.Status.ToString()));
    }
}

public class RabbitMQEventPublisher : IEventPublisher
{
    private readonly IConnection _connection;
    private readonly IModel _channel;
    private readonly ILogger<RabbitMQEventPublisher> _logger;
    private readonly string _exchangeName;
 
    public RabbitMQEventPublisher(RabbitMQConfig config, ILogger<RabbitMQEventPublisher> logger)
    {
        var factory = new ConnectionFactory()
        {
            HostName = config.HostName,
            UserName = config.UserName,
            Password = config.Password,
            VirtualHost = config.VirtualHost,
            AutomaticRecoveryEnabled = true,
            NetworkRecoveryInterval = TimeSpan.FromSeconds(10)
        };
 
        _connection = factory.CreateConnection();
        _channel = _connection.CreateModel();
        _exchangeName = config.ExchangeName;
        _logger = logger;
 
        // Объявляем exchange для надежности
        _channel.ExchangeDeclare(_exchangeName, ExchangeType.Topic, durable: true);
    }
 
    public async Task PublishAsync<T>(T @event, string routingKey) where T : class
    {
        try
        {
            var message = JsonSerializer.Serialize(@event, new JsonSerializerOptions
            {
                PropertyNamingPolicy = JsonNamingPolicy.CamelCase
            });
 
            var body = Encoding.UTF8.GetBytes(message);
            var properties = _channel.CreateBasicProperties();
            
            properties.Persistent = true;
            properties.MessageId = Guid.NewGuid().ToString();
            properties.Timestamp = new AmqpTimestamp(DateTimeOffset.UtcNow.ToUnixTimeSeconds());
            properties.ContentType = "application/json";
            properties.Type = typeof(T).Name;
 
            _channel.BasicPublish(
                exchange: _exchangeName,
                routingKey: routingKey,
                basicProperties: properties,
                body: body);
 
            _logger.LogDebug("Published event {EventType} with routing key {RoutingKey}", 
                typeof(T).Name, routingKey);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Failed to publish event {EventType}", typeof(T).Name);
            throw;
        }
    }
}
 
// Consumer для обработки событий
public class RabbitMQEventConsumer : BackgroundService
{
    private readonly IConnection _connection;
    private readonly IModel _channel;
    private readonly IServiceProvider _serviceProvider;
    private readonly ILogger<RabbitMQEventConsumer> _logger;
 
    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        var consumer = new EventingBasicConsumer(_channel);
        
        consumer.Received += async (model, ea) =>
        {
            try
            {
                var body = ea.Body.ToArray();
                var message = Encoding.UTF8.GetString(body);
                var eventType = ea.BasicProperties.Type;
 
                using var scope = _serviceProvider.CreateScope();
                var handler = GetEventHandler(eventType, scope.ServiceProvider);
                
                if (handler != null)
                {
                    await handler.HandleAsync(message, ea.BasicProperties);
                    _channel.BasicAck(ea.DeliveryTag, false);
                }
                else
                {
                    _logger.LogWarning("No handler found for event type {EventType}", eventType);
                    _channel.BasicNack(ea.DeliveryTag, false, false);
                }
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error processing message");
                _channel.BasicNack(ea.DeliveryTag, false, true);
            }
        };
 
        _channel.BasicConsume(queue: "order-service-queue", autoAck: false, consumer: consumer);
        
        while (!stoppingToken.IsCancellationRequested)
        {
            await Task.Delay(1000, stoppingToken);
        }
    }
}

public class KafkaEventPublisher : IEventPublisher
{
    private readonly IProducer<string, string> _producer;
    private readonly ILogger<KafkaEventPublisher> _logger;
    
    public KafkaEventPublisher(KafkaConfig config, ILogger<KafkaEventPublisher> logger)
    {
        var producerConfig = new ProducerConfig
        {
            BootstrapServers = config.BootstrapServers,
            Acks = Acks.All,
            Retries = 3,
            RetryBackoffMs = 1000,
            MessageTimeoutMs = 30000,
            EnableIdempotence = true
        };
        
        _producer = new ProducerBuilder<string, string>(producerConfig).Build();
        _logger = logger;
    }
 
    public async Task PublishAsync<T>(T @event, string partitionKey) where T : class
    {
        try
        {
            var topicName = GetTopicName<T>();
            var message = JsonSerializer.Serialize(@event);
            
            var kafkaMessage = new Message<string, string>
            {
                Key = partitionKey,
                Value = message,
                Headers = new Headers
                {
                    { "event-type", Encoding.UTF8.GetBytes(typeof(T).Name) },
                    { "timestamp", Encoding.UTF8.GetBytes(DateTimeOffset.UtcNow.ToString("O")) }
                }
            };
 
            var result = await _producer.ProduceAsync(topicName, kafkaMessage);
            
            _logger.LogDebug("Message delivered to partition {Partition} at offset {Offset}",
                result.Partition.Value, result.Offset.Value);
        }
        catch (ProduceException<string, string> ex)
        {
            _logger.LogError(ex, "Failed to deliver message to Kafka: {Reason}", ex.Error.Reason);
            throw;
        }
    }
}

public class OptimizedDataTransfer
{
    private static readonly JsonSerializerOptions JsonOptions = new()
    {
        PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
        DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
        WriteIndented = false
    };
 
    // Для debugging и простых сценариев используем JSON
    public async Task<T> SendJsonAsync<T>(T data, string endpoint)
    {
        var json = JsonSerializer.Serialize(data, JsonOptions);
        var content = new StringContent(json, Encoding.UTF8, "application/json");
        
        // Компрессия для больших объектов
        if (json.Length > 1024)
        {
            var compressed = await CompressAsync(json);
            content = new StringContent(Convert.ToBase64String(compressed), 
                Encoding.UTF8, "application/json+gzip");
        }
        
        var response = await _httpClient.PostAsync(endpoint, content);
        var responseJson = await response.Content.ReadAsStringAsync();
        
        return JsonSerializer.Deserialize<T>(responseJson, JsonOptions);
    }
 
    // Для высокопроизводительных сценариев - MessagePack
    public async Task<T> SendMessagePackAsync<T>(T data, string endpoint)
    {
        var bytes = MessagePackSerializer.Serialize(data);
        var content = new ByteArrayContent(bytes);
        content.Headers.ContentType = new MediaTypeHeaderValue("application/msgpack");
        
        var response = await _httpClient.PostAsync(endpoint, content);
        var responseBytes = await response.Content.ReadAsByteArrayAsync();
        
        return MessagePackSerializer.Deserialize<T>(responseBytes);
    }
 
    private async Task<byte[]> CompressAsync(string text)
    {
        using var output = new MemoryStream();
        using var gzip = new GZipStream(output, CompressionLevel.Optimal);
        using var writer = new StreamWriter(gzip, Encoding.UTF8);
        
        await writer.WriteAsync(text);
        await writer.FlushAsync();
        
        return output.ToArray();
    }
}

// Настройка трассировки в C# сервисе
public class Startup
{
  public void ConfigureServices(IServiceCollection services)
  {
      services.AddOpenTelemetryTracing(builder =>
      {
          builder
              .SetSampler(new AlwaysOnSampler())
              .AddAspNetCoreInstrumentation(options =>
              {
                  options.RecordException = true;
                  options.EnableGrpcAspNetCoreSupport = true;
              })
              .AddHttpClientInstrumentation(options =>
              {
                  options.RecordException = true;
                  options.SetHttpFlavor = true;
              })
              .AddSqlClientInstrumentation(options =>
              {
                  options.RecordException = true;
                  options.SetDbStatementForText = true;
              })
              .AddJaegerExporter(options =>
              {
                  options.AgentHost = "jaeger";
                  options.AgentPort = 6831;
              });
      });
 
      services.AddScoped<ITraceContextAccessor, TraceContextAccessor>();
  }
}
 
// Сервис для работы с trace context
public class TraceContextAccessor : ITraceContextAccessor
{
  public string GetTraceId()
  {
      var activity = Activity.Current;
      return activity?.TraceId.ToString() ?? Guid.NewGuid().ToString();
  }
 
  public void AddBaggage(string key, string value)
  {
      Baggage.SetBaggage(key, value);
  }
 
  public void SetTag(string key, object value)
  {
      Activity.Current?.SetTag(key, value?.ToString());
  }
}
 
// Middleware для передачи контекста
public class TraceContextMiddleware
{
  private readonly RequestDelegate _next;
  private readonly ILogger<TraceContextMiddleware> _logger;
 
  public async Task InvokeAsync(HttpContext context)
  {
      // Извлекаем trace ID из заголовков или создаем новый
      var traceId = context.Request.Headers["X-Trace-Id"].FirstOrDefault() 
          ?? Activity.Current?.TraceId.ToString() 
          ?? Guid.NewGuid().ToString();
 
      // Добавляем trace ID в response headers для debugging
      context.Response.Headers.Add("X-Trace-Id", traceId);
      
      // Добавляем пользовательские теги
      Activity.Current?.SetTag("service.name", "api-gateway");
      Activity.Current?.SetTag("service.version", "1.2.3");
      Activity.Current?.SetTag("user.id", context.User?.FindFirst("sub")?.Value);
 
      using (_logger.BeginScope(new Dictionary<string, object>
      {
          ["TraceId"] = traceId,
          ["SpanId"] = Activity.Current?.SpanId.ToString()
      }))
      {
          await _next(context);
      }
  }
}

public class TracedHttpClient
{
  private readonly HttpClient _httpClient;
  private readonly ITraceContextAccessor _traceContext;
 
  public async Task<T> PostAsync<T>(string endpoint, object data)
  {
      using var activity = ActivitySource.StartActivity($"HTTP POST {endpoint}");
      
      activity?.SetTag("http.method", "POST");
      activity?.SetTag("http.url", endpoint);
      activity?.SetTag("component", "http-client");
 
      var request = new HttpRequestMessage(HttpMethod.Post, endpoint);
      
      // Передаем trace context в заголовках
      request.Headers.Add("X-Trace-Id", _traceContext.GetTraceId());
      request.Headers.Add("X-Parent-Span-Id", Activity.Current?.SpanId.ToString());
      
      var json = JsonSerializer.Serialize(data);
      request.Content = new StringContent(json, Encoding.UTF8, "application/json");
 
      try
      {
          var response = await _httpClient.SendAsync(request);
          activity?.SetTag("http.status_code", (int)response.StatusCode);
          
          if (!response.IsSuccessStatusCode)
          {
              activity?.SetStatus(ActivityStatusCode.Error, $"HTTP {response.StatusCode}");
          }
          
          var responseJson = await response.Content.ReadAsStringAsync();
          return JsonSerializer.Deserialize<T>(responseJson);
      }
      catch (Exception ex)
      {
          activity?.SetStatus(ActivityStatusCode.Error, ex.Message);
          activity?.SetTag("exception.type", ex.GetType().Name);
          activity?.SetTag("exception.message", ex.Message);
          throw;
      }
  }
}

public class PerformanceMetricsCollector
{
  private readonly IMetrics _metrics;
  private readonly ILogger<PerformanceMetricsCollector> _logger;
  
  private readonly Counter<long> _requestCounter;
  private readonly Histogram<double> _requestDuration;
  private readonly Histogram<double> _databaseQueryDuration;
  private readonly Counter<long> _errorCounter;
 
  public PerformanceMetricsCollector(IMeterProvider meterProvider)
  {
      var meter = meterProvider.GetMeter("ApiGateway");
      
      _requestCounter = meter.CreateCounter<long>(
          "http_requests_total",
          "requests", 
          "Total number of HTTP requests");
          
      _requestDuration = meter.CreateHistogram<double>(
          "http_request_duration_seconds",
          "seconds",
          "Duration of HTTP requests");
          
      _databaseQueryDuration = meter.CreateHistogram<double>(
          "database_query_duration_seconds",
          "seconds", 
          "Duration of database queries");
          
      _errorCounter = meter.CreateCounter<long>(
          "http_errors_total",
          "errors",
          "Total number of HTTP errors");
  }
 
  public IDisposable MeasureRequest(string endpoint, string method)
  {
      var stopwatch = Stopwatch.StartNew();
      var tags = new KeyValuePair<string, object>[]
      {
          new("endpoint", endpoint),
          new("method", method),
          new("service", "api-gateway")
      };
 
      _requestCounter.Add(1, tags);
 
      return new DisposableAction(() =>
      {
          stopwatch.Stop();
          var duration = stopwatch.Elapsed.TotalSeconds;
          _requestDuration.Record(duration, tags);
      });
  }
 
  public void RecordError(string endpoint, string errorType, int statusCode)
  {
      _errorCounter.Add(1, new KeyValuePair<string, object>[]
      {
          new("endpoint", endpoint),
          new("error_type", errorType),
          new("status_code", statusCode),
          new("service", "api-gateway")
      });
  }
}
 
// Middleware для автоматического сбора метрик
public class MetricsMiddleware
{
  private readonly RequestDelegate _next;
  private readonly PerformanceMetricsCollector _metrics;
 
  public async Task InvokeAsync(HttpContext context)
  {
      var endpoint = context.Request.Path.Value;
      var method = context.Request.Method;
 
      using var measurement = _metrics.MeasureRequest(endpoint, method);
      
      try
      {
          await _next(context);
          
          if (context.Response.StatusCode >= 400)
          {
              _metrics.RecordError(endpoint, "http_error", context.Response.StatusCode);
          }
      }
      catch (Exception ex)
      {
          _metrics.RecordError(endpoint, ex.GetType().Name, 500);
          throw;
      }
  }
}

public class PrometheusMetricsExporter : BackgroundService
{
  private readonly IServiceProvider _serviceProvider;
  private readonly ILogger<PrometheusMetricsExporter> _logger;
  private readonly MetricServer _metricServer;
 
  // Кастомные метрики для бизнес-логики
  private readonly Counter _ordersProcessed = Metrics
      .CreateCounter("orders_processed_total", 
          "Total number of processed orders",
          new[] { "status", "payment_method" });
 
  private readonly Histogram _orderProcessingTime = Metrics
      .CreateHistogram("order_processing_seconds",
          "Time spent processing orders",
          new[] { "order_type" });
 
  private readonly Gauge _activeConnections = Metrics
      .CreateGauge("active_connections_current",
          "Current number of active connections");
 
  public PrometheusMetricsExporter(IServiceProvider serviceProvider)
  {
      _serviceProvider = serviceProvider;
      _metricServer = new MetricServer(hostname: "*", port: 9090);
  }
 
  protected override async Task ExecuteAsync(CancellationToken stoppingToken)
  {
      _metricServer.Start();
      _logger.LogInformation("Prometheus metrics server started on port 9090");
 
      // Собираем системные метрики каждые 30 секунд
      while (!stoppingToken.IsCancellationRequested)
      {
          try
          {
              await UpdateSystemMetrics();
              await Task.Delay(30000, stoppingToken);
          }
          catch (Exception ex)
          {
              _logger.LogError(ex, "Error updating system metrics");
          }
      }
  }
 
  private async Task UpdateSystemMetrics()
  {
      using var scope = _serviceProvider.CreateScope();
      var dbContext = scope.ServiceProvider.GetService<ApplicationDbContext>();
 
      if (dbContext != null)
      {
          // Метрики базы данных
          var activeConnections = await GetActiveConnectionsCount(dbContext);
          _activeConnections.Set(activeConnections);
 
          // Метрики очередей
          var queueLength = await GetMessageQueueLength();
          Metrics.CreateGauge("message_queue_length", "Current message queue length")
              .Set(queueLength);
      }
  }
 
  public void RecordOrderProcessed(string status, string paymentMethod, TimeSpan processingTime, string orderType)
  {
      _ordersProcessed
          .WithLabels(status, paymentMethod)
          .Inc();
 
      _orderProcessingTime
          .WithLabels(orderType)
          .Observe(processingTime.TotalSeconds);
  }
}

public class StructuredLogger
{
  private readonly ILogger _logger;
  private readonly ITraceContextAccessor _traceContext;
 
  public void LogBusinessEvent(string eventType, object data, LogLevel level = LogLevel.Information)
  {
      var logEntry = new
      {
          Timestamp = DateTimeOffset.UtcNow,
          Level = level.ToString(),
          EventType = eventType,
          TraceId = _traceContext.GetTraceId(),
          SpanId = Activity.Current?.SpanId.ToString(),
          Service = "api-gateway",
          Version = Assembly.GetExecutingAssembly().GetName().Version?.ToString(),
          Data = data,
          Environment = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT"),
          MachineName = Environment.MachineName
      };
 
      _logger.Log(level, "{@LogEntry}", logEntry);
  }
 
  public void LogPerformanceEvent(string operation, TimeSpan duration, bool success, object? additionalData = null)
  {
      LogBusinessEvent("performance", new
      {
          Operation = operation,
          DurationMs = duration.TotalMilliseconds,
          Success = success,
          Additional = additionalData
      });
  }
 
  public void LogIntegrationCall(string targetService, string operation, TimeSpan duration, bool success, int? statusCode = null)
  {
      LogBusinessEvent("integration", new
      {
          TargetService = targetService,
          Operation = operation,
          DurationMs = duration.TotalMilliseconds,
          Success = success,
          StatusCode = statusCode
      });
  }
}

public class ConsulConfigurationProvider : ConfigurationProvider, IDisposable
{
  private readonly ConsulClient _consul;
  private readonly string _keyPrefix;
  private readonly Timer _refreshTimer;
 
  public ConsulConfigurationProvider(string consulAddress, string keyPrefix)
  {
      _consul = new ConsulClient(config => config.Address = new Uri(consulAddress));
      _keyPrefix = keyPrefix;
      
      // Обновляем конфигурацию каждые 30 секунд
      _refreshTimer = new Timer(RefreshConfiguration, null, TimeSpan.Zero, TimeSpan.FromSeconds(30));
  }
 
  public override void Load()
  {
      try
      {
          var queryResult = _consul.KV.List(_keyPrefix).Result;
          if (queryResult.Response != null)
          {
              Data.Clear();
              foreach (var kvPair in queryResult.Response)
              {
                  var key = kvPair.Key.Substring(_keyPrefix.Length).Replace('/', ':');
                  var value = Encoding.UTF8.GetString(kvPair.Value ?? Array.Empty<byte>());
                  Data[key] = value;
              }
          }
      }
      catch (Exception ex)
      {
          // Log error but don't fail startup
          Console.WriteLine($"Failed to load configuration from Consul: {ex.Message}");
      }
  }
 
  private void RefreshConfiguration(object state)
  {
      Load();
      OnReload();
  }
}
 
// Регистрация в DI container
services.AddSingleton<IConfigurationProvider>(sp =>
    new ConsulConfigurationProvider("http://consul:8500", "microservices/api-gateway/"));

[ApiController]
[Route("api/[controller]")]
public class UnifiedOrderController : ControllerBase
{
    private readonly IOrderOrchestrator _orchestrator;
    private readonly IAuthenticationService _authService;
    private readonly ILogger<UnifiedOrderController> _logger;
    private readonly PerformanceMetricsCollector _metrics;
 
    [HttpPost("create")]
    [Authorize]
    public async Task<ActionResult<OrderResponse>> CreateOrder(
        [FromBody] CreateOrderRequest request)
    {
        using var performanceMeasurement = _metrics.MeasureRequest("create-order", "POST");
        using var activity = Activity.Current?.Source.StartActivity("CreateOrder");
 
        try
        {
            activity?.SetTag("user.id", User.GetUserId());
            activity?.SetTag("order.items.count", request.Items.Count);
 
            // Валидация через FluentValidation
            var validationResult = await _validator.ValidateAsync(request);
            if (!validationResult.IsValid)
            {
                return BadRequest(new ValidationErrorResponse(validationResult.Errors));
            }
 
            // Оркестрация создания заказа через Saga паттерн
            var command = new CreateOrderCommand
            {
                UserId = User.GetUserId(),
                Items = request.Items,
                ShippingAddress = request.ShippingAddress,
                PaymentMethod = request.PaymentMethod,
                TraceId = HttpContext.TraceIdentifier
            };
 
            var result = await _orchestrator.ProcessOrderAsync(command);
            
            _metrics.RecordOrderProcessed("success", request.PaymentMethod.Type, 
                performanceMeasurement.Elapsed, "standard");
 
            return Ok(new OrderResponse
            {
                OrderId = result.OrderId,
                Status = result.Status,
                EstimatedDelivery = result.EstimatedDelivery,
                TotalAmount = result.TotalAmount
            });
        }
        catch (InsufficientInventoryException ex)
        {
            _metrics.RecordError("create-order", "insufficient_inventory", 400);
            return BadRequest(new { error = "Some items are not available", details = ex.UnavailableItems });
        }
        catch (PaymentFailedException ex)
        {
            _metrics.RecordError("create-order", "payment_failed", 402);
            return StatusCode(402, new { error = "Payment failed", reason = ex.Reason });
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Unexpected error creating order for user {UserId}", User.GetUserId());
            _metrics.RecordError("create-order", "internal_error", 500);
            return StatusCode(500, new { error = "Internal server error" });
        }
    }
 
    [HttpGet("{orderId}/recommendations")]
    [Authorize]
    public async Task<ActionResult<RecommendationResponse>> GetRecommendations(Guid orderId)
    {
        using var activity = Activity.Current?.Source.StartActivity("GetRecommendations");
        
        try
        {
            // Параллельное получение данных из разных источников
            var orderTask = _orderService.GetOrderAsync(orderId);
            var userBehaviorTask = _analyticsService.GetUserBehaviorAsync(User.GetUserId());
            var inventoryTask = _inventoryService.GetAvailableProductsAsync();
 
            await Task.WhenAll(orderTask, userBehaviorTask, inventoryTask);
 
            var order = orderTask.Result;
            var behavior = userBehaviorTask.Result;
            var inventory = inventoryTask.Result;
 
            // Вызов ML сервиса для получения персональных рекомендаций
            var mlRequest = new MLRecommendationRequest
            {
                UserId = User.GetUserId(),
                OrderHistory = order.Items.Select(i => i.ProductId).ToList(),
                BehaviorData = behavior,
                AvailableProducts = inventory.Where(p => p.InStock).Select(p => p.Id).ToList()
            };
 
            var recommendations = await _mlService.GetRecommendationsAsync(mlRequest);
 
            return Ok(new RecommendationResponse
            {
                OrderId = orderId,
                RecommendedProducts = recommendations.Products,
                Confidence = recommendations.Confidence,
                ExplanationText = recommendations.Explanation
            });
        }
        catch (OrderNotFoundException)
        {
            return NotFound(new { error = "Order not found" });
        }
        catch (MLServiceUnavailableException)
        {
            // Fallback на простые рекомендации при недоступности ML сервиса
            var fallbackRecommendations = await _fallbackRecommendationService.GetBasicRecommendationsAsync(orderId);
            return Ok(fallbackRecommendations);
        }
    }
}
 
// Оркестратор для координации работы разных сервисов
public class OrderOrchestrator : IOrderOrchestrator
{
    private readonly IInventoryService _inventoryService;
    private readonly IPaymentService _paymentService;
    private readonly IOrderRepository _orderRepository;
    private readonly INotificationService _notificationService;
    private readonly IEventPublisher _eventPublisher;
    private readonly IDistributedLockService _lockService;
    private readonly ILogger<OrderOrchestrator> _logger;
 
    public async Task<OrderResult> ProcessOrderAsync(CreateOrderCommand command)
    {
        // Используем распределенную блокировку для предотвращения race conditions
        var lockKey = $"user-order-{command.UserId}";
        var lockId = Guid.NewGuid().ToString();
        
        var lockAcquired = await _lockService.AcquireLockAsync(lockKey, TimeSpan.FromMinutes(2), lockId);
        if (!lockAcquired)
        {
            throw new ConcurrentOrderException("Another order is being processed for this user");
        }
 
        try
        {
            return await ProcessOrderWithSaga(command);
        }
        finally
        {
            await _lockService.ReleaseLockAsync(lockKey, lockId);
        }
    }
 
    private async Task<OrderResult> ProcessOrderWithSaga(CreateOrderCommand command)
    {
        var sagaId = Guid.NewGuid();
        var sagaContext = new SagaContext(sagaId, command.TraceId);
        var compensations = new Stack<Func<Task>>();
 
        try
        {
            // Шаг 1: Проверка и резервирование инвентаря
            _logger.LogInformation("Starting inventory reservation for saga {SagaId}", sagaId);
            
            var reservationResult = await _inventoryService.ReserveItemsAsync(
                command.Items, sagaContext);
                
            if (!reservationResult.Success)
            {
                throw new InsufficientInventoryException(reservationResult.UnavailableItems);
            }
            
            compensations.Push(() => _inventoryService.CancelReservationAsync(
                reservationResult.ReservationId, sagaContext));
 
            // Шаг 2: Создание заказа в базе данных
            _logger.LogInformation("Creating order record for saga {SagaId}", sagaId);
            
            var order = new Order
            {
                Id = Guid.NewGuid(),
                UserId = command.UserId,
                Items = command.Items,
                Status = OrderStatus.Pending,
                CreatedAt = DateTime.UtcNow,
                TraceId = command.TraceId
            };
 
            await _orderRepository.CreateAsync(order);
            compensations.Push(() => _orderRepository.DeleteAsync(order.Id));
 
            // Шаг 3: Обработка платежа
            _logger.LogInformation("Processing payment for saga {SagaId}", sagaId);
            
            var paymentResult = await _paymentService.ProcessPaymentAsync(new PaymentRequest
            {
                OrderId = order.Id,
                Amount = order.TotalAmount,
                PaymentMethod = command.PaymentMethod,
                SagaContext = sagaContext
            });
 
            if (!paymentResult.Success)
            {
                throw new PaymentFailedException(paymentResult.FailureReason);
            }
 
            compensations.Push(() => _paymentService.RefundPaymentAsync(
                paymentResult.TransactionId, sagaContext));
 
            // Шаг 4: Финализация заказа
            order.Status = OrderStatus.Confirmed;
            order.PaymentTransactionId = paymentResult.TransactionId;
            await _orderRepository.UpdateAsync(order);
 
            // Шаг 5: Публикация событий
            await _eventPublisher.PublishAsync(new OrderCreatedEvent
            {
                OrderId = order.Id,
                UserId = order.UserId,
                Items = order.Items,
                TotalAmount = order.TotalAmount,
                CreatedAt = order.CreatedAt,
                TraceId = command.TraceId
            }, "orders.created");
 
            // Асинхронное уведомление пользователя
            _ = Task.Run(async () =>
            {
                try
                {
                    await _notificationService.SendOrderConfirmationAsync(order.Id, order.UserId);
                }
                catch (Exception ex)
                {
                    _logger.LogError(ex, "Failed to send order confirmation for order {OrderId}", order.Id);
                    // Уведомления не критичны - не роняем транзакцию
                }
            });
 
            _logger.LogInformation("Order {OrderId} successfully created for user {UserId} in saga {SagaId}",
                order.Id, command.UserId, sagaId);
 
            return new OrderResult
            {
                OrderId = order.Id,
                Status = order.Status.ToString(),
                TotalAmount = order.TotalAmount,
                EstimatedDelivery = CalculateEstimatedDelivery(order)
            };
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Saga {SagaId} failed, executing compensations", sagaId);
 
            // Выполняем компенсирующие действия в обратном порядке
            while (compensations.Count > 0)
            {
                try
                {
                    var compensation = compensations.Pop();
                    await compensation();
                }
                catch (Exception compensationEx)
                {
                    _logger.LogError(compensationEx, "Compensation failed in saga {SagaId}", sagaId);
                    // Компенсация не удалась - нужна ручная проверка
                }
            }
 
            throw;
        }
    }
}

public class OrderCommandService
{
  private readonly IEventStore _eventStore;
  private readonly IEventPublisher _publisher;
 
  public async Task<CommandResult> HandleAsync(CreateOrderCommand command)
  {
      var orderId = Guid.NewGuid();
      var events = new List<IDomainEvent>();
 
      events.Add(new OrderInitiatedEvent(orderId, command.UserId, command.Items));
      
      await _eventStore.SaveEventsAsync(orderId, events, expectedVersion: -1);
      
      foreach (var @event in events)
      {
          await _publisher.PublishAsync(@event);
      }
 
      return CommandResult.Success(orderId);
  }
}
 
public class OrderProjectionService
{
  private readonly IDatabase _readDatabase;
 
  public async Task Handle(OrderInitiatedEvent @event)
  {
      var projection = new OrderProjection
      {
          Id = @event.OrderId,
          UserId = @event.UserId,
          Status = "Pending",
          CreatedAt = @event.Timestamp,
          Items = @event.Items
      };
 
      await _readDatabase.UpsertAsync(projection);
  }
}