Comprehensive comparison for DevOps technology in Software Development applications

using System;
using System.Threading.Tasks;
using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Extensions.Http;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using Azure.Storage.Queues;
using Azure.Identity;
using Azure.Security.KeyVault.Secrets;
using System.Text.Json;
using System.ComponentModel.DataAnnotations;

namespace ProductCatalog.Api
{
    // DTO for product creation request
    public class CreateProductRequest
    {
        [Required]
        public string Name { get; set; }
        
        [Required]
        [Range(0.01, double.MaxValue)]
        public decimal Price { get; set; }
        
        public string Description { get; set; }
        
        [Required]
        public string Category { get; set; }
    }

    public class ProductApiFunction
    {
        private readonly ILogger<ProductApiFunction> _logger;
        private readonly SecretClient _secretClient;
        private const string QueueName = "product-processing-queue";

        public ProductApiFunction(ILogger<ProductApiFunction> logger)
        {
            _logger = logger;
            // Initialize Key Vault client with Managed Identity
            var keyVaultUrl = Environment.GetEnvironmentVariable("KEY_VAULT_URL");
            _secretClient = new SecretClient(new Uri(keyVaultUrl), new DefaultAzureCredential());
        }

        [FunctionName("CreateProduct")]
        public async Task<IActionResult> CreateProduct(
            [HttpTrigger(AuthorizationLevel.Function, "post", Route = "products")] HttpRequest req)
        {
            var correlationId = Guid.NewGuid().ToString();
            
            try
            {
                _logger.LogInformation($"[{correlationId}] Processing product creation request");

                // Parse and validate request body
                var requestBody = await new StreamReader(req.Body).ReadToEndAsync();
                var productRequest = JsonSerializer.Deserialize<CreateProductRequest>(requestBody,
                    new JsonSerializerOptions { PropertyNameCaseInsensitive = true });

                if (productRequest == null)
                {
                    return new BadRequestObjectResult(new { error = "Invalid request body" });
                }

                // Validate model
                var validationContext = new ValidationContext(productRequest);
                var validationResults = new System.Collections.Generic.List<ValidationResult>();
                if (!Validator.TryValidateObject(productRequest, validationContext, validationResults, true))
                {
                    return new BadRequestObjectResult(new { errors = validationResults });
                }

                // Retrieve storage connection string from Key Vault
                KeyVaultSecret storageSecret = await _secretClient.GetSecretAsync("StorageConnectionString");
                var connectionString = storageSecret.Value;

                // Create queue client and ensure queue exists
                var queueClient = new QueueClient(connectionString, QueueName);
                await queueClient.CreateIfNotExistsAsync();

                // Create message payload with metadata
                var messagePayload = new
                {
                    ProductId = Guid.NewGuid(),
                    productRequest.Name,
                    productRequest.Price,
                    productRequest.Description,
                    productRequest.Category,
                    CreatedAt = DateTime.UtcNow,
                    CorrelationId = correlationId
                };

                var messageJson = JsonSerializer.Serialize(messagePayload);
                var messageBytes = System.Text.Encoding.UTF8.GetBytes(messageJson);
                var base64Message = Convert.ToBase64String(messageBytes);

                // Send message to queue for async processing
                await queueClient.SendMessageAsync(base64Message);

                _logger.LogInformation($"[{correlationId}] Product queued successfully: {messagePayload.ProductId}");

                // Return accepted response with location header
                return new AcceptedResult(
                    $"/api/products/{messagePayload.ProductId}",
                    new
                    {
                        productId = messagePayload.ProductId,
                        status = "Processing",
                        correlationId = correlationId,
                        message = "Product creation request accepted and queued for processing"
                    });
            }
            catch (Azure.RequestFailedException ex) when (ex.Status == 404)
            {
                _logger.LogError(ex, $"[{correlationId}] Key Vault secret not found");
                return new StatusCodeResult(StatusCodes.Status500InternalServerError);
            }
            catch (JsonException ex)
            {
                _logger.LogWarning(ex, $"[{correlationId}] Invalid JSON in request body");
                return new BadRequestObjectResult(new { error = "Invalid JSON format" });
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, $"[{correlationId}] Unexpected error processing product creation");
                return new StatusCodeResult(StatusCodes.Status500InternalServerError);
            }
        }
    }
}