Audit.SignalR 22.0.1

Audit.SignalR

SignalR Auditing Extension for Audit.NET library.

Automatically generates Audit Logs for ASP.NET SignalR or Asp Net Core SignalR invokations.

Audit.SignalR provides a configurable Hub Pipeline Module/Filter that intercepts the hub processing to generate an audit trail.

It generate logs for the following events:

Install

NuGet Package

To install the package run the following command on the Package Manager Console:

PM> Install-Package Audit.SignalR

SignalR Version

This library supports:

• ASP.NET SignalR
• ASP.NET Core SignalR

Usage - ASP.NET SignalR

On your ASP.NET startup logic, call the extension method AddAuditModule() defined on namespace Microsoft.AspNet.SignalR.GlobalHost.HubPipeline, to setup the audit pipeline. This must be called before IAppBuilder.MapSignalR().

This method provides a fluent API to configure the audit module.

For example:

using Audit.SignalR;
using Microsoft.AspNet.SignalR;
//...
public class Startup
{
    public void Configuration(IAppBuilder app)
    {
        GlobalHost.HubPipeline.AddAuditModule(config => config
            .IncludeHeaders()
            .Filters(f => f
                .IncludeOutgoingEvent(og => og.HubName == "myHub")
                .IncludeReconnectEvent(false));
        app.MapSignalR();
    }
}

This will create an AuditPipelineModule (that inherits from HubPipelineModule) and will add it to the hub pipeline.

Alternatively, you can create an instance of the module and add it to the pipeline, with the exact same effect:

using Audit.SignalR;
using Microsoft.AspNet.SignalR;
//...
var module = new AuditPipelineModule()
{
    IncludeHeaders = true,
    ReconnectEventsFilter = _ => false,
    OutgoingEventsFilter = og => og.HubName == "myHub"
};
GlobalHost.HubPipeline.AddModule(module);

Or create the module using the factory method AuditPipelineModule.Create() that provides the fluent API for the configuration:

var module = AuditPipelineModule.Create(config => config
    .IncludeHeaders()
    ...
);
GlobalHost.HubPipeline.AddModule(module);

Usage - ASP.NET Core SignalR

On your ASP.NET Core startup logic, call the extension method AddAuditFilter() defined on namespace Audit.SignalR when adding the SignalR service.

This method provides a fluent API to configure the audit filter.

For example:

using Audit.SignalR;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddSignalR(c =>
{
    c.AddAuditFilter(cfg => cfg
        .IncludeHeaders()
        .IncludeQueryString()
        .Filters(f => f
            .IncludeIncomingEvent(true)
            .IncludeConnectEvent(false)
            .IncludeDisconnectEvent(false))
    );
});

This will create an Audit HubFilter and add it to the hub pipeline.

Configuration

Settings

The following settings can be configured on the module/filter:

• AuditEventType: To indicate the event type to use on the audit event. (Default is the event name). Can contain the following placeholders:
  • {event}: replaced with the SignalR event name (Connect, Reconnect, Disconnect, Incoming, Outgoing, Error).
• IncludeHeaders: To indicate if the audit should include the request headers (Valid for events Connect, Reconnect, Disconnect, Incoming and Error). Default is false.
• IncludeQueryString: To indicate if the audit should include the request Query String (Valid for events Connect, Reconnect, Disconnect, Incoming and Error). Default is false.
• AuditDisabled: Set to true to disable the audit log generation (bypass). Default is false.
• CreationPolicy: To indicate the event creation policy to use. Default is NULL to use the globally configured creation policy.
• AuditDataProvider: To indicate the Audit Data Provider to use. Default is NULL to use the globally configured data provider.

Filter settings

The module allows to configure filtering of events. By default it will log all the events.

• IncomingEventsFilter: Allows to filter Incoming events (invoking server-side methods) with a custom function that given the incoming event info, returns true if the event should be logged and false otherwise.
• OutgoingEventsFilter: Allows to filter Outgoing events (invoking client-side methods).
• ConnectEventsFilter: Allows to filter Connect events.
• DisconnectEventsFilter: Allows to filter Disconnect events.
• ReconnectEventsFilter: Allows to filter Reconnect events.
• ErrorEventsFilter: Allows to filter Error events.

Extension Methods

You can access the current Audit Scope for the incoming event inside server-side methods, by calling the Hub extension method GetIncomingAuditScope() / GetAuditScope(), for example:

public class MyHub : Hub
{
    public int Send(string name, string message)
    {
        var scope = this.GetAuditScope();
        if (someCondition)
        {
            scope.Discard()
        }
        else
        {
            scope.SetCustomField("UserType", user.UserType);
        }

        //...
    }

The SignalR specific event information on the AuditScope can be accessed as follows:

var scope = this.GetIncomingAuditScope();
var signalrEventIncoming = scope.Event.GetSignalrEvent<SignalrEventIncoming>();

Event Output

To configure the output persistence mechanism please see Configuration and Data Providers sections.

Output

Audit.SignalR output includes:

• Execution time and duration (when applicable)
• Environment information such as user, machine, domain and locale.
• ConnectionId
• Hub name, Method name and Arguments
• Exception details
• HTTP request details (optional)

Output details

The following tables describes the Audit.SignalR output fields per event type:

• SignalrEventConnect

• SignalrEventDisconnect

• SignalrEventIncoming

• SignalrEventOutgoing

• SignalrEventError : SignalrEventConnect

Customization

Custom fields

You can add extra information as custom fields to the events by calling the method AddAuditCustomField on your Hub. For example:

public class MyHub : Hub
{
    public int Send(string name, string message)
    {
        this.AddCustomField("User", user);
    }

Another way to customize the output is by using global custom actions, please see custom actions for more information.