20. Monitoreo y Observabilidad de Servicios de IA

// Ejemplo de implementación
public class ExampleService
{
    private readonly Kernel _kernel;
    private readonly ILogger<ExampleService> _logger;

    public ExampleService(Kernel kernel, ILogger<ExampleService> logger)
    {
        _kernel = kernel;
        _logger = logger;
    }

    public async Task<string> ProcessAsync(string input)
    {
        try
        {
            _logger.LogInformation("Procesando input: {Input}", input);

            var function = _kernel.CreateFunctionFromPrompt(
                "Procesa: {{\}}");

            var result = await _kernel.InvokeAsync(function, new KernelArguments
            {
                ["input"] = input
            });

            return result.GetValue<string>() ?? string.Empty;
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error procesando input");
            throw;
        }
    }
}

builder.Services.AddScoped<ExampleService>();
builder.Services.AddLogging();

var service = serviceProvider.GetRequiredService<ExampleService>();
var result = await service.ProcessAsync("ejemplo");
Console.WriteLine(result);

public interface IServiceFactory
{
    ExampleService Create();
}

public class ServiceFactory : IServiceFactory
{
    private readonly IServiceProvider _serviceProvider;

    public ServiceFactory(IServiceProvider serviceProvider)
    {
        _serviceProvider = serviceProvider;
    }

    public ExampleService Create()
    {
        return _serviceProvider.GetRequiredService<ExampleService>();
    }
}

public interface IProcessingStrategy
{
    Task<string> ProcessAsync(string input);
}

public class StandardStrategy : IProcessingStrategy
{
    public async Task<string> ProcessAsync(string input)
    {
        // Implementación estándar
        return await Task.FromResult(input);
    }
}

public class AdvancedStrategy : IProcessingStrategy
{
    public async Task<string> ProcessAsync(string input)
    {
        // Implementación avanzada
        return await Task.FromResult(input.ToUpper());
    }
}

using Xunit;
using Moq;

public class ExampleServiceTests
{
    [Fact]
    public async Task ProcessAsync_WithValidInput_ReturnsResult()
    {
        // Arrange
        var mockKernel = new Mock<Kernel>();
        var mockLogger = new Mock<ILogger<ExampleService>>();
        var service = new ExampleService(mockKernel.Object, mockLogger.Object);

        // Act
        var result = await service.ProcessAsync("test");

        // Assert
        Assert.NotNull(result);
    }
}

[Collection("Integration")]
public class ExampleServiceIntegrationTests
{
    [Fact]
    public async Task ProcessAsync_EndToEnd_Success()
    {
        // Configurar servicio real
        var kernel = CreateRealKernel();
        var logger = NullLogger<ExampleService>.Instance;
        var service = new ExampleService(kernel, logger);

        // Ejecutar
        var result = await service.ProcessAsync("integration test");

        // Verificar
        Assert.NotEmpty(result);
    }

    private Kernel CreateRealKernel()
    {
        // Configuración real para tests de integración
        return Kernel.CreateBuilder().Build();
    }
}