Hasim.Auditify 0.1.6

Auditify

A lightweight, pluggable audit-trail library for Entity Framework Core 8+.

Auditify automatically captures entity changes (Added / Modified / Deleted) in your EF Core DbContext and persists them as structured audit logs. It hooks in via an EF Core SaveChangesInterceptor, supports sensitive-data masking, and is wired up through the Hasim.Injectify module system.

🇬🇧 English

Overview

Auditify inspects the ChangeTracker right before SaveChanges runs and writes one AuditLog per audited entity, each with granular EntityChange records (property, old value, new value). Values of sensitive properties are masked.

Features

• ✅ Automatic audit logging — via an EF Core SaveChangesInterceptor (PersistingAuditInterceptor)
• ✅ Sensitive data masking — Password, Token, Secret, ApiKey, ConnectionString are masked by default (configurable)
• ✅ Structured logs — AuditLog + EntityChange (old/new values)
• ✅ Configurable — AuditifyOptions for fine-grained control
• ✅ DI-ready — registered through the Injectify AuditModule
• ✅ .NET 8 — built for the latest .NET

Installation

dotnet add package Hasim.Auditify

Quick Start

1. Register the Injectify module

AuditModule registers PersistingAuditInterceptor, IAuditService and the audit core services. Register it either explicitly or via auto-discovery:

// Explicit registration
builder.Services.AddInjectifyModules(builder.Configuration, new AuditModule());

// OR auto-discovery (scans app + referenced assemblies)
builder.InjectifyApplication();

2. Add the interceptor to your own DbContext

builder.Services.AddDbContext<YourDbContext>((sp, options) =>
    options.UseSqlServer(connectionString)
           .AddInterceptors(sp.GetRequiredService<PersistingAuditInterceptor>()));

3. Save — audit is created automatically

await dbContext.AddAsync(entity);
await dbContext.SaveChangesAsync(); // interceptor writes the audit log

Customize options

builder.Services.Configure<AuditifyOptions>(options =>
{
    options.SensitiveProperties = ["Password", "Token", "Secret", "ApiKey", "ConnectionString"];
    options.TrackIpAddress = true;
    options.TrackCorrelationId = true;
    options.AuditLogsTableName = "MyAuditLogs";
    options.EntityChangesTableName = "MyEntityChanges";
});

Testing

The test project uses PeasyPilot on .NET 8:

• PeasyPilot.Core for fluent assertions.
• PeasyPilot.Moq for mocks.
• PeasyPilot.XUnit and PeasyPilotTestBase for xUnit integration and test context.

The xUnit and Moq dependencies are supplied transitively by PeasyPilot packages.

Architecture

┌────────────────────────────────────────────┐
│             Your Application                │
├────────────────────────────────────────────┤
│  Auditify                                   │
│  ├── Core (AuditService, AuditChangeBuilder)│
│  ├── EF Core (PersistingAuditInterceptor)   │
│  ├── Configuration (AuditifyOptions)        │
│  └── DI (AuditModule via Injectify)         │
└────────────────────────────────────────────┘

Namespaces

Entity model

• AuditLog — one audit record per audited entity change: UserId, Action (Added/Modified/Deleted), EntityName, Timestamp, optional IpAddress / CorrelationId, and a collection of EntityChange.
• EntityChange — property-level detail: PropertyName, OldValue, NewValue.

Notes on ISoftDelete / IAuditableEntity

These abstractions are provided for soft-delete and timestamp patterns, but they are not applied automatically by the interceptor. Apply them in your own entity logic if needed.

🇫🇷 Français

Vue d'ensemble

Auditify capture automatiquement les modifications d'entités (Ajoutées / Modifiées / Supprimées) dans votre DbContext EF Core et les persiste sous forme de journaux d'audit structurés. Il s'intègre via un SaveChangesInterceptor EF Core, prend en charge le masquage des données sensibles et se câble via le système de modules Hasim.Injectify.

Fonctionnalités

• ✅ Journalisation automatique — via un SaveChangesInterceptor EF Core (PersistingAuditInterceptor)
• ✅ Masquage des données sensibles — Password, Token, Secret, ApiKey, ConnectionString sont masqués par défaut (configurable)
• ✅ Journaux structurés — AuditLog + EntityChange (ancienne/nouvelle valeur)
• ✅ Configurable — AuditifyOptions pour un contrôle fin
• ✅ Prêt pour l'injection de dépendances — enregistré via le AuditModule d'Injectify
• ✅ .NET 8 — construit pour la dernière version de .NET

Installation

dotnet add package Hasim.Auditify

Démarrage rapide

1. Enregistrer le module Injectify

AuditModule enregistre PersistingAuditInterceptor, IAuditService et les services d'audit. Enregistrez-le explicitement ou par auto-découverte :

// Enregistrement explicite
builder.Services.AddInjectifyModules(builder.Configuration, new AuditModule());

// OU auto-découverte (scanne les assemblys applicatifs et référencés)
builder.InjectifyApplication();

2. Ajouter l'intercepteur à votre propre DbContext

builder.Services.AddDbContext<VotreDbContext>((sp, options) =>
    options.UseSqlServer(connectionString)
           .AddInterceptors(sp.GetRequiredService<PersistingAuditInterceptor>()));

3. Enregistrez — l'audit est créé automatiquement

await dbContext.AddAsync(entity);
await dbContext.SaveChangesAsync(); // l'intercepteur écrit le journal d'audit

Personnaliser les options

builder.Services.Configure<AuditifyOptions>(options =>
{
    options.SensitiveProperties = ["Password", "Token", "Secret", "ApiKey", "ConnectionString"];
    options.TrackIpAddress = true;
    options.TrackCorrelationId = true;
    options.AuditLogsTableName = "MesLogsAudit";
    options.EntityChangesTableName = "MesModifications";
});

Tests

Le projet de tests utilise PeasyPilot sous .NET 8 :

• PeasyPilot.Core pour les assertions fluides.
• PeasyPilot.Moq pour les mocks.
• PeasyPilot.XUnit et PeasyPilotTestBase pour l'integration xUnit et le contexte de test.

Les dependances xUnit et Moq sont fournies transitivement par les packages PeasyPilot.

Modèle d'entités

• AuditLog — un enregistrement d'audit par entité auditable modifiée : UserId, Action (Added/Modified/Deleted), EntityName, Timestamp, IpAddress / CorrelationId optionnels, et une collection de EntityChange.
• EntityChange — détail au niveau propriété : PropertyName, OldValue, NewValue.

Notes sur ISoftDelete / IAuditableEntity

Ces abstractions sont fournies pour les patterns de soft delete et d'horodatage, mais elles ne sont pas appliquées automatiquement par l'intercepteur. Appliquez-les dans votre propre logique d'entité si nécessaire.

Licence

MIT — Copyright (c) 2026, NID BOUBKER Houssine

Built with ❤️ for the .NET ecosystem.