AuditManager 1.0.0

AuditManager AuditManager is a comprehensive, storage-agnostic audit, session, and reporting library designed for use in enterprise applications—particularly in the insurance industry. It enables teams to record, store, and report on important system events (such as user actions, session activity, and compliance audits) regardless of the underlying data source. AuditManager supports multiple storage providers including SQL Server, Azure Blob Storage, Azure Cosmos DB, and Amazon S3.

Table of Contents Features Architecture Installation Getting Started Configuration Dependency Injection Setup Using the Core Services Audit Data Model AuditLog Field Descriptions Storage Providers SQL Server Azure Blob Storage Azure Cosmos DB Amazon S3 Performance & Optimization Examples Logging a Claim Request Retrieving Paginated Audit Logs Extensibility Contributing License

Features Audit Logging: Capture and store detailed audit logs for various user actions. Supports rich metadata such as user identifiers, action types, details, timestamps, IP addresses, and more.

Session Tracking: Track user sessions with features for start, update, and termination of sessions. Includes active session monitoring and session timeout management.

Reporting: Generate reports (in formats like PDF, CSV, Excel, JSON) based on the audit data. Built-in support for filtering, aggregation, and summarization.

Storage-Agnostic Design: Designed to work with multiple storage providers. Use your existing SQL Server, Azure Blob Storage, Cosmos DB, or Amazon S3—without changing the core library logic.

Performance Optimizations: Built-in pagination for large datasets, caching of blob listings, and configurable data retention policies to ensure performance at scale.

Extensibility: Easily extend or replace storage providers and add additional functionality as needed.

Architecture AuditManager is structured around a set of core abstractions and services:

Core Interfaces:

IAuditService: For logging and retrieving audit logs. ISessionService: For managing user sessions. IReportingService: For generating reports based on audit data. IAuditStorage: An abstraction for storage operations, with implementations for various providers.

Service Implementations: Each service (audit, session, reporting) depends on the IAuditStorage interface, making the library completely agnostic to the underlying storage solution.

Storage Implementations: Implementations include:

SqlAuditStorage (uses EF Core and AuditDbContext) BlobAuditStorage (uses Azure Blob Storage with advanced blob naming, metadata, caching, and retry logic) CosmosAuditStorage (a stub using Azure Cosmos DB with continuation tokens for pagination) S3AuditStorage (a stub using Amazon S3 for JSON-based storage)

Installation Install AuditManager via NuGet. In the Package Manager Console, run:

Install-Package AuditManager Ensure you also have any required dependencies for your chosen storage provider (e.g., AWSSDK.S3, Azure.Storage.Blobs, or Microsoft.Azure.Cosmos).

Getting Started Configuration AuditManager uses an AuditConfiguration class for generic settings that apply across storage providers:

public class AuditConfiguration { /// <summary> /// Unique identifier for the system or application. /// </summary> public Guid SystemId { get; set; }

/// <summary>
/// Human-friendly name for the system or application.
/// </summary>
public string SystemName { get; set; }

/// <summary>
/// Session timeout (in minutes).
/// </summary>
public int SessionTimeoutMinutes { get; set; } = 30;

/// <summary>
/// Audit data retention period (in days).
/// </summary>
public int AuditRetentionDays { get; set; } = 365;

// Optional: storage-specific properties (e.g., ConnectionString for SQL)
public string? ConnectionString { get; set; }

}

Dependency Injection Setup AuditManager provides extension methods to register its services using your desired storage provider. For example, to use SQL Server:

using AuditManager; using AuditManager.Configuration;

var auditConfig = new AuditConfiguration { SystemId = Guid.NewGuid(), SystemName = "InsuranceClaimsApp", ConnectionString = builder.Configuration.GetConnectionString("AuditDb"), SessionTimeoutMinutes = 30, AuditRetentionDays = 365 };

builder.Services.AddInsuranceAuditLibraryWithSql(auditConfig); To use Azure Blob Storage:

using AuditManager; using AuditManager.Configuration; using Azure.Storage.Blobs; using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.Caching.Memory;

var auditConfig = new AuditConfiguration { SystemId = Guid.NewGuid(), SystemName = "InsuranceClaimsApp", SessionTimeoutMinutes = 30, AuditRetentionDays = 365 };

var blobConnectionString = builder.Configuration.GetConnectionString("AuditBlobStorage"); var containerClient = new BlobContainerClient(blobConnectionString, "audit-container"); await containerClient.CreateIfNotExistsAsync();

// Register the library with Blob storage and memory cache. builder.Services.AddSingleton<IMemoryCache, MemoryCache>(); builder.Services.AddInsuranceAuditLibraryWithBlob(auditConfig, containerClient); Similar extension methods exist for Cosmos DB and S3.

Using the Core Services Once registered, you can inject and use the core services in your controllers or business services:

public class SomeController : ControllerBase { private readonly IAuditService _auditService; private readonly IReportingService _reportingService;

public SomeController(IAuditService auditService, IReportingService reportingService)
{
    _auditService = auditService;
    _reportingService = reportingService;
}

// ... endpoints that call _auditService.LogAuditActionAsync, etc.

}

Audit Data Model AuditLog The AuditLog class represents a single audit record:

public class AuditLog { public Guid Id { get; set; } public string UserId { get; set; } public AuditAction Action { get; set; } public string Resource { get; set; } public string Details { get; set; } public DateTime Timestamp { get; set; } = DateTime.UtcNow; public string IpAddress { get; set; } public string UserAgent { get; set; } public string Region { get; set; } public string CorrelationId { get; set; } public string Changes { get; set; } public string EntityType { get; set; } public string EntityId { get; set; } }

Field Descriptions Changes: Contains a detailed summary (e.g., a JSON diff) of modifications made during an operation. This is valuable for auditing and compliance purposes.

CorrelationId: A unique identifier that links together multiple related operations across systems. Useful in distributed/microservice environments to trace a transaction’s journey.

EntityType: Specifies the type of business entity affected (e.g., "Claim", "Order"). Helps in categorizing and filtering audit logs.

EntityId: The unique identifier for the specific instance of the entity involved in the operation. When combined with EntityType, it allows quick identification of the affected record.

Storage Providers AuditManager supports multiple storage providers through implementations of the IAuditStorage interface.

SQL Server Implementation: Uses Entity Framework Core with AuditDbContext in the Data folder. Configuration: Requires a ConnectionString provided in the AuditConfiguration. Extension Method: AddInsuranceAuditLibraryWithSql

Azure Blob Storage Implementation: Uses BlobAuditStorage, which saves each audit log as a JSON file under a virtual folder (e.g., "auditlogs/"). Advanced Features: Blob Naming: Timestamps are embedded in blob names for easy filtering. Caching: Uses IMemoryCache to cache blob listings. Error Handling: Implements retry logic for transient errors. Extension Method: AddInsuranceAuditLibraryWithBlob

Azure Cosmos DB Implementation: Provides a stub (CosmosAuditStorage) that uses continuation tokens for pagination. Configuration: Requires endpoint, key, database, and container identifiers. Extension Method: AddInsuranceAuditLibraryWithCosmos

Amazon S3 Implementation: Provides a stub (S3AuditStorage) that stores audit logs as JSON files in S3. Configuration: Requires an IAmazonS3 client and bucket name. Extension Method: AddInsuranceAuditLibraryWithS3 Performance & Optimization To handle large datasets and ensure responsiveness, AuditManager incorporates several performance optimizations:

Pagination: Methods like GetAuditLogsAsync accept pagination parameters (page number and page size) to limit data retrieval.

Blob Naming & Metadata: For Blob Storage, the blob name includes a timestamp, allowing efficient filtering without downloading every blob.

Caching: Blob listings are cached (using IMemoryCache) to reduce the number of listing calls.

Error Handling & Retry: Robust error handling and retry logic is implemented in blob download operations.

Data Retention: A cleanup job (AuditCleanupJob) can be scheduled to purge old audit logs based on a configurable retention period.

Examples Logging a Claim Request When a broker submits a claim request, you can log the action as follows:

public class ClaimService { private readonly IAuditService _auditService;

public ClaimService(IAuditService auditService)
{
    _auditService = auditService;
}

public async Task SubmitClaimAsync(string brokerId, string claimDetails, string claimId)
{
    string correlationId = Guid.NewGuid().ToString();

    var auditLog = new AuditLog
    {
        UserId = brokerId,
        Action = AuditAction.SubmitClaim,
        Resource = "ClaimRequest",
        Details = $"Broker {brokerId} submitted a claim request. Details: {claimDetails}",
        IpAddress = "192.168.1.100",
        UserAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64)...",
        Region = "North America",
        CorrelationId = correlationId,
        Changes = "{\"status\":\"Pending\"}",
        EntityType = "Claim",
        EntityId = claimId
    };

    await _auditService.LogAuditActionAsync(auditLog);

    // Continue with further claim processing...
}

} Retrieving Paginated Audit Logs A controller endpoint can retrieve paginated audit logs for an admin UI:

[ApiController] [Route("api/[controller]")] public class AuditLogsController : ControllerBase { private readonly IAuditStorage _auditStorage;

public AuditLogsController(IAuditStorage auditStorage)
{
    _auditStorage = auditStorage;
}

// GET api/auditlogs?startDate=2025-01-01&endDate=2025-01-31&pageNumber=1&pageSize=50
[HttpGet]
public async Task<IActionResult> GetAuditLogs(DateTime startDate, DateTime endDate, int pageNumber = 1, int pageSize = 50, string region = null)
{
    var logs = await _auditStorage.GetAuditLogsAsync(startDate, endDate, region, pageNumber, pageSize);
    return Ok(logs);
}

}

Extensibility AuditManager is designed for extensibility:

Custom Storage Providers: You can implement your own version of IAuditStorage for additional data sources.

Extended Audit Data: The audit data model can be extended or inherited to include more domain-specific properties.

Pluggable Report Generation: The reporting service can be integrated with specialized libraries (e.g., iTextSharp for PDF, EPPlus for Excel) if needed.

Contributing Contributions to AuditManager are welcome! Please follow the standard pull request process and include appropriate tests and documentation for any new features or changes.

License MIT License

This documentation provides a comprehensive overview of AuditManager, its features, configuration, usage examples, and extensibility options. Adjust the content as necessary to match your library’s specifics and target audience.