API Reference

API Reference

Complete reference of all public types in the DataVigil packages. Organized by assembly.

---

RzR.DataVigil.Abstractions

Contracts

IAuditable

namespace RzR.DataVigil.Abstractions.Contracts;

public interface IAuditable { }

Marker interface. Add to any entity that should participate in CUD auditing.

IAuditableEntity : IAuditable

public interface IAuditableEntity : IAuditable
{
    bool ShouldAudit(AuditAction action);
    IEnumerable<string> GetExcludedFields();
}

Granular control over which actions are audited and which fields are excluded.

IAuditableContext

public interface IAuditableContext
{
    IEnumerable<Type> GetExcludedEntityTypes();
}

Implement on DbContext to exclude entity types from auditing in that context.

---

Services

IAuditStore

namespace RzR.DataVigil.Abstractions.Services;

public interface IAuditStore
{
    Task<IResult> SaveAsync(AuditTransaction transaction, CancellationToken ct = default);

    Task<IResult<IEnumerable<AuditTransaction>>> QueryAsync(
        AuditTransactionQuery query,
        GdprRetrievalContext gdprRetrievalContext = null,
        CancellationToken ct = default);

    Task<IResult> AnonymizeByUserAsync(string userId, CancellationToken ct = default);

    Task<IResult> PurgeBeforeAsync(DateTimeOffset cutoff, CancellationToken ct = default);
}

IAuditUserResolver

public interface IAuditUserResolver
{
    IResult<AuditUserInfo> Resolve();
}

IAuditSourceResolver

public interface IAuditSourceResolver
{
    IResult<string> Resolve();
}

IAuditCorrelationProvider

public interface IAuditCorrelationProvider
{
    IResult<string> GetCorrelationId();
    IResult<string> GetTraceId();
}

IAuditScopeContext : IDisposable

public interface IAuditScopeContext : IDisposable
{
    IResult SetUser(AuditUserInfo userInfo);
    IResult<AuditUserInfo> GetCurrentUser();
}

---

Enums

AuditAction

namespace RzR.DataVigil.Abstractions.Enums;

public enum AuditAction
{
    Create = 1,
    Read = 2,
    Update = 3,
    Delete = 4
}

GdprFieldAction

public enum GdprFieldAction
{
    Exclude = 0,
    Mask = 1,
    Anonymize = 2,
    Hash = 3,
    Custom = 4
}

GdprStorageState

public enum GdprStorageState
{
    Original = 0,
    PartiallyProcessed = 1,
    FullyAnonymized = 2,
    Erased = 3
}

---

Models

AuditTransaction

namespace RzR.DataVigil.Abstractions.Models.Entries;

public class AuditTransaction
{
    public Guid Id { get; set; }
    public DateTimeOffset Timestamp { get; set; }
    public string UserId { get; set; }
    public string UserName { get; set; }
    public string IpAddress { get; set; }
    public string CorrelationId { get; set; }
    public string TraceId { get; set; }
    public string Source { get; set; }
    public GdprStorageState GdprState { get; set; }
    public IDictionary<string, string> Metadata { get; set; }
    public ICollection<AuditEntry> Entries { get; set; }
}

AuditEntry

public class AuditEntry
{
    public Guid Id { get; set; }
    public Guid TransactionId { get; set; }
    public AuditAction Action { get; set; }
    public string EntityName { get; set; }
    public string EntityId { get; set; }
    public string EntityTypeName { get; set; }
    public ICollection<AuditEntryProperty> Properties { get; set; }
}

AuditEntryProperty

public class AuditEntryProperty
{
    public string PropertyName { get; set; }
    public string PropertyType { get; set; }
    public string OldValue { get; set; }
    public string NewValue { get; set; }
}

AuditUserInfo

namespace RzR.DataVigil.Abstractions.Models.Identity;

public class AuditUserInfo
{
    public string UserId { get; set; }
    public string UserName { get; set; }
    public string IpAddress { get; set; }
    public IEnumerable<string> Roles { get; set; }
    public IDictionary<string, string> Claims { get; set; }
}

AuditTransactionQuery

namespace RzR.DataVigil.Abstractions.Models.Query;

public class AuditTransactionQuery
{
    public int Skip { get; set; } = 0;
    public int Take { get; set; } = 10;
}

GdprRetrievalContext

namespace RzR.DataVigil.Abstractions.Models.Gdpr;

public class GdprRetrievalContext
{
    public IEnumerable<string> UserRoles { get; set; }
    public IDictionary<string, string> UserClaims { get; set; }

    public bool CanAccess(FieldGdprRule rule);
}

FieldGdprRule

public class FieldGdprRule
{
    public string FieldName { get; set; }
    public GdprFieldAction Action { get; set; }
    public Func<string, string> CustomTransformer { get; set; }
    public IEnumerable<string> AllowedRoles { get; set; }
    public IEnumerable<KeyValuePair<string, string>> AllowedClaims { get; set; }
}

---

RzR.DataVigil.Core

Extension methods (DI entry points)

namespace RzR.DataVigil.Core.Extensions;

public static class ServiceCollectionExtensions
{
    // Main entry point - always call first
    public static AuditTrailBuilder AddAuditTrail(
        this IServiceCollection services,
        Action<AuditTrailOptions> configure);

    // Background retention service
    public static IServiceCollection AddAuditRetentionService(
        this IServiceCollection services);
}

AuditPipeline

namespace RzR.DataVigil.Core.Pipeline;

public class AuditPipeline
{
    public Task<IResult> ProcessAsync(
        AuditTransaction transaction,
        CancellationToken ct = default);
}

AuditReadCollector

namespace RzR.DataVigil.Core.Pipeline;

public class AuditReadCollector
{
    public void Collect(AuditEntry entry);
    public Task FlushAsync(CancellationToken ct = default);
    public bool HasEntries { get; }
}

GdprProcessor

namespace RzR.DataVigil.Core.Gdpr;

public class GdprProcessor
{
    public (AuditEntry entry, bool applied, bool fullyAnonymized)
        ApplyStoragePolicies(AuditEntry entry);

    public AuditEntry ApplyRetrievalPolicies(
        AuditEntry entry,
        GdprRetrievalContext context);
}

---

RzR.DataVigil.EFCore

Extension methods

namespace RzR.DataVigil.EFCore.Extensions;

public static class ServiceCollectionExtensions
{
    public static IServiceCollection AddAuditTrailEfCore(
        this IServiceCollection services);
}

public static class DbContextOptionsExtensions
{
    public static DbContextOptionsBuilder AddAuditInterceptors(
        this DbContextOptionsBuilder builder,
        IServiceProvider serviceProvider);
}

AuditReadService

namespace RzR.DataVigil.EFCore.Services;

public class AuditReadService
{
    public Task LogReadAsync<TEntity>(
        DbContext context, TEntity entity,
        CancellationToken ct = default);

    public Task LogReadAsync<TEntity>(
        DbContext context, IEnumerable<TEntity> entities,
        CancellationToken ct = default);
}

---

RzR.DataVigil.AspNetCore

Extension methods

namespace RzR.DataVigil.AspNetCore.Extensions;

public static class ServiceCollectionExtensions
{
    public static IServiceCollection AddAuditTrailAspNetCore(
        this IServiceCollection services);
}

public static class ApplicationBuilderExtensions
{
    public static IApplicationBuilder UseAuditReadFlush(
        this IApplicationBuilder app);
}

---

Storage provider extension methods

SQL Server

namespace RzR.DataVigil.Storage.EfSqlServer.Extensions;

public static class StorageOptionsExtensions
{
    public static StorageOptions UseSqlServer(this StorageOptions options, string connectionString);
}

public static class ServiceCollectionExtensions
{
    public static IServiceCollection AddAuditTrailSqlServer(this IServiceCollection services);
}

public static class ServiceProviderExtensions
{
    public static void MigrateAuditSqlServerDb(this IServiceProvider serviceProvider);
}

PostgreSQL

namespace RzR.DataVigil.Storage.EfPostgreSql.Extensions;

public static class StorageOptionsExtensions
{
    public static StorageOptions UsePostgreSql(this StorageOptions options, string connectionString);
}

public static class ServiceCollectionExtensions
{
    public static IServiceCollection AddAuditTrailPostgreSqlServer(this IServiceCollection services);
}

public static class ServiceProviderExtensions
{
    public static void MigrateAuditPostgreSqlDb(this IServiceProvider serviceProvider);
}

MongoDB

namespace RzR.DataVigil.Storage.EfMongoDb.Extensions;

public static class StorageOptionsExtensions
{
    public static StorageOptions UseMongoDb(
        this StorageOptions options, string connectionString, string databaseName);
}

public static class ServiceCollectionExtensions
{
    public static IServiceCollection AddAuditTrailMongoDb(this IServiceCollection services);
}

public static class DbContextOptionsExtensions
{
    public static DbContextOptionsBuilder AddAuditReadInterceptor(
        this DbContextOptionsBuilder builder, IServiceProvider sp);
}

File

namespace RzR.DataVigil.Storage.File.Extensions;

public static class StorageOptionsExtensions
{
    public static StorageOptions UseFile(this StorageOptions options, string directoryPath);
}

public static class ServiceCollectionExtensions
{
    public static IServiceCollection AddAuditTrailFileStorage(this IServiceCollection services);
}