Muscula.Csharp.Extensions.Logging.AspNetCore 2.0.2

Muscula.Csharp.Extensions.Logging.AspNetCore

Overview

Muscula.Csharp.Extensions.Logging.AspNetCore provides seamless integration with ASP.NET Core's built-in logging framework, allowing you to send logs to Muscula error monitoring service. This package implements ILoggerProvider and ILogger interfaces to work natively with Microsoft.Extensions.Logging.

Features

• Native ASP.NET Core Integration: Works seamlessly with ILogger<T> dependency injection
• Automatic Exception Tracking: Captures and formats exceptions with full stack trace details
• Structured Logging Support: Optional IMusculaStructuralLogger for enhanced structured data logging
• Log Level Mapping: Maps Microsoft.Extensions.Logging levels to Muscula severity levels
• Configuration Extensions: Simple configuration through ILoggingBuilder extensions
• Performance Optimized: Asynchronous batch processing minimizes impact on application performance

Installation

Install the package via NuGet:

dotnet add package Muscula.Csharp.Extensions.Logging.AspNetCore

Or via Package Manager:

Install-Package Muscula.Csharp.Extensions.Logging.AspNetCore

Quick Start

Configuration in Program.cs (.NET 6+)

var builder = WebApplication.CreateBuilder(args);

// Add Muscula logging
builder.Logging.AddMuscula(settingsBuilder =>
{
    settingsBuilder.UseLogId("YOUR_MUSCULA_LOG_ID");
    return settingsBuilder.Build();
});

var app = builder.Build();

Configuration in Startup.cs (.NET Core 3.1 - 5.0)

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddLogging(builder => builder.AddMuscula(
            settingsBuilder =>
            {
                settingsBuilder.UseLogId("YOUR_MUSCULA_LOG_ID");
                return settingsBuilder.Build();
            }));
        
        // Other service configurations
    }
}

Using the Logger

Inject ILogger<T> into your controllers or services:

[ApiController]
[Route("[controller]")]
public class WeatherController : ControllerBase
{
    private readonly ILogger<WeatherController> _logger;

    public WeatherController(ILogger<WeatherController> logger)
    {
        _logger = logger;
    }

    [HttpGet]
    public IActionResult Get()
    {
        _logger.LogInformation("Weather endpoint called");
        
        try
        {
            // Your logic here
            return Ok(data);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Failed to get weather data");
            return StatusCode(500);
        }
    }
}

Advanced Configuration

Enable Structured Logging

builder.Logging.AddMuscula(settingsBuilder =>
{
    settingsBuilder
        .UseLogId("YOUR_MUSCULA_LOG_ID")
        .UseStructuralLogger(true) // Enable IMusculaStructuralLogger
        .UseCustomEndpoint("https://custom.muscula.endpoint.com"); // Optional custom endpoint
    return settingsBuilder.Build();
});

Using Structured Logger

When structured logging is enabled, inject IMusculaStructuralLogger:

public class OrderService
{
    private readonly ILogger<OrderService> _logger;
    private readonly IMusculaStructuralLogger _structuralLogger;

    public OrderService(ILogger<OrderService> logger, IMusculaStructuralLogger structuralLogger)
    {
        _logger = logger;
        _structuralLogger = structuralLogger;
    }

    public async Task ProcessOrderAsync(Order order)
    {
        _structuralLogger.LogStructural(
            Severity.Info,
            message: $"Processing order {order.Id}",
            structuralData: new 
            {
                OrderId = order.Id,
                CustomerId = order.CustomerId,
                Total = order.Total,
                Items = order.Items.Count
            },
            className: nameof(OrderService)
        );

        try
        {
            // Process order
        }
        catch (Exception ex)
        {
            _structuralLogger.LogStructural(
                Severity.Error,
                message: "Order processing failed",
                exception: ex,
                structuralData: order,
                className: nameof(OrderService)
            );
            throw;
        }
    }
}

Log Level Mapping

The provider maps ASP.NET Core log levels to Muscula severity:

Logging with Custom Exception Data

Use MusculaException to include structured data with exceptions:

try
{
    // Your code
}
catch (Exception ex)
{
    var musculaEx = new MusculaException("Payment processing failed", ex)
    {
        StructuralData = new 
        {
            PaymentId = paymentId,
            Amount = amount,
            Currency = currency,
            Gateway = "Stripe"
        }
    };
    _logger.LogError(musculaEx, "Payment failed for order {OrderId}", orderId);
    throw musculaEx;
}

Configuration from appsettings.json

You can also configure Muscula settings from configuration:

{
  "Muscula": {
    "LogId": "YOUR_MUSCULA_LOG_ID",
    "Url": "https://api.muscula.com",
    "StructuralLogger": true
  }
}

builder.Logging.AddMuscula(settingsBuilder =>
{
    var musculaConfig = builder.Configuration.GetSection("Muscula");
    settingsBuilder
        .UseLogId(musculaConfig["LogId"])
        .UseCustomEndpoint(musculaConfig["Url"])
        .UseStructuralLogger(musculaConfig.GetValue<bool>("StructuralLogger"));
    return settingsBuilder.Build();
});

Requirements

• .NET 10.0 or higher
• ASP.NET Core shared framework (Microsoft.AspNetCore.App)
• Muscula.Csharp.Extensions.Logging package
• Active Muscula account with valid Log ID

Support

For issues and questions:

• Visit Muscula Documentation
• Create an issue in the GitHub repository

License

This project is licensed under the MIT License - see the LICENSE file for details.