👁 Image
I-Synergy.Framework.AspNetCore.Monitoring 2026.10618.11733

I-Synergy Framework AspNetCore Monitoring

Real-time monitoring and communication infrastructure using SignalR for ASP.NET Core applications. This package provides SignalR hub integration, monitor services for publishing events, connection management, and group-based messaging for building real-time dashboards, notifications, and collaboration features.

👁 NuGet
👁 License
👁 .NET

Features

• SignalR hub integration with OpenIddict authentication
• Monitor service for publishing real-time events to groups
• Connection lifecycle management with automatic group assignment
• User and account-based groups for tenant isolation
• Generic event publishing with typed entity support
• Real-time notifications for connected/disconnected users
• Detailed error logging for debugging SignalR connections
• Scalable architecture supporting multiple concurrent connections

Installation

Install the package via NuGet:

dotnet add package I-Synergy.Framework.AspNetCore.Monitoring

Quick Start

1. Configure Monitoring Services

In your Program.cs:

using ISynergy.Framework.AspNetCore.Monitoring.Extensions;

var builder = WebApplication.CreateBuilder(args);

// Add monitoring with SignalR (specify your entity type)
builder.Services.AddMonitorSignalR<MonitorEvent>();

builder.Services.AddControllers();

var app = builder.Build();

// Map the monitor hub
app.MapHub<MonitorHub>("/hubs/monitor");

app.Run();

2. Using the Monitor Service

Publish events to connected clients:

using ISynergy.Framework.Monitoring.Abstractions.Services;
using Microsoft.AspNetCore.Mvc;

[ApiController]
[Route("api/[controller]")]
public class OrdersController : ControllerBase
{
 private readonly IMonitorService<OrderEvent> _monitorService;

 public OrdersController(IMonitorService<OrderEvent> monitorService)
 {
 _monitorService = monitorService;
 }

 [HttpPost]
 public async Task<IActionResult> CreateOrder([FromBody] CreateOrderRequest request)
 {
 var order = await CreateOrderAsync(request);

 // Publish event to all users in the account group
 await _monitorService.PublishAsync(
 channel: request.AccountId.ToString(),
 eventname: "OrderCreated",
 data: new OrderEvent
 {
 OrderId = order.Id,
 Status = "Created",
 CreatedAt = DateTime.UtcNow
 });

 return Ok(order);
 }

 [HttpPut("{id}")]
 public async Task<IActionResult> UpdateOrderStatus(
 int id,
 [FromBody] UpdateOrderStatusRequest request)
 {
 var order = await UpdateOrderAsync(id, request);

 // Notify users about status change
 await _monitorService.PublishAsync(
 channel: order.AccountId.ToString(),
 eventname: "OrderStatusChanged",
 data: new OrderEvent
 {
 OrderId = order.Id,
 Status = order.Status,
 UpdatedAt = DateTime.UtcNow
 });

 return Ok(order);
 }
}

public class OrderEvent
{
 public int OrderId { get; set; }
 public string Status { get; set; }
 public DateTime CreatedAt { get; set; }
 public DateTime? UpdatedAt { get; set; }
}

3. Client-Side Connection (JavaScript/TypeScript)

Connect to the SignalR hub from your frontend:

import * as signalR from "@microsoft/signalr";

// Configure connection with authentication
const connection = new signalR.HubConnectionBuilder()
 .withUrl("/hubs/monitor", {
 accessTokenFactory: () => getAuthToken()
 })
 .withAutomaticReconnect()
 .configureLogging(signalR.LogLevel.Information)
 .build();

// Listen for order events
connection.on("OrderCreated", (event) => {
 console.log("New order created:", event);
 updateOrdersList(event);
});

connection.on("OrderStatusChanged", (event) => {
 console.log("Order status changed:", event);
 updateOrderStatus(event);
});

// Listen for user connection events
connection.on("Connected", (message) => {
 console.log(`User connected: ${message.Data}`);
 updateOnlineUsers(message);
});

connection.on("Disconnected", (message) => {
 console.log(`User disconnected: ${message.Data}`);
 updateOnlineUsers(message);
});

// Start connection
async function startConnection() {
 try {
 await connection.start();
 console.log("SignalR Connected");
 } catch (err) {
 console.error("SignalR Connection Error:", err);
 setTimeout(startConnection, 5000);
 }
}

// Handle disconnections
connection.onclose(async () => {
 await startConnection();
});

// Get authentication token
function getAuthToken() {
 return localStorage.getItem("authToken");
}

// Start the connection
startConnection();

4. Client-Side Connection (.NET Client)

Connect from a .NET application:

using Microsoft.AspNetCore.SignalR.Client;

public class MonitorClient : IAsyncDisposable
{
 private readonly HubConnection _connection;

 public MonitorClient(string hubUrl, string accessToken)
 {
 _connection = new HubConnectionBuilder()
 .WithUrl(hubUrl, options =>
 {
 options.AccessTokenProvider = () => Task.FromResult(accessToken);
 })
 .WithAutomaticReconnect()
 .Build();

 // Register event handlers
 _connection.On<OrderEvent>("OrderCreated", OnOrderCreated);
 _connection.On<OrderEvent>("OrderStatusChanged", OnOrderStatusChanged);
 _connection.On<HubMessage<string>>("Connected", OnUserConnected);
 _connection.On<HubMessage<string>>("Disconnected", OnUserDisconnected);
 }

 public async Task StartAsync()
 {
 await _connection.StartAsync();
 }

 private void OnOrderCreated(OrderEvent orderEvent)
 {
 Console.WriteLine($"Order created: {orderEvent.OrderId}");
 }

 private void OnOrderStatusChanged(OrderEvent orderEvent)
 {
 Console.WriteLine($"Order {orderEvent.OrderId} status: {orderEvent.Status}");
 }

 private void OnUserConnected(HubMessage<string> message)
 {
 Console.WriteLine($"User connected: {message.Data}");
 }

 private void OnUserDisconnected(HubMessage<string> message)
 {
 Console.WriteLine($"User disconnected: {message.Data}");
 }

 public async ValueTask DisposeAsync()
 {
 if (_connection != null)
 {
 await _connection.DisposeAsync();
 }
 }
}

// Usage
var client = new MonitorClient("https://api.example.com/hubs/monitor", authToken);
await client.StartAsync();

Core Components

Hubs

ISynergy.Framework.AspNetCore.Monitoring.Hubs/
└── MonitorHub # SignalR hub with authentication

Services

ISynergy.Framework.AspNetCore.Monitoring.Services/
└── MonitorService<TEntity> # Publish events to hub groups

Extensions

ISynergy.Framework.AspNetCore.Monitoring.Extensions/
├── ServiceCollectionExtensions # DI configuration
├── HostApplicationBuilderExtensions # Builder configuration
└── ApplicationBuilderExtensions # Middleware configuration

Advanced Features

Publishing to Specific Users

The MonitorHub automatically creates groups based on user ID and account ID:

using ISynergy.Framework.Monitoring.Abstractions.Services;

public class NotificationService
{
 private readonly IMonitorService<NotificationEvent> _monitorService;

 public NotificationService(IMonitorService<NotificationEvent> monitorService)
 {
 _monitorService = monitorService;
 }

 public async Task SendToUserAsync(string userId, NotificationEvent notification)
 {
 // Send to specific user's group
 await _monitorService.PublishAsync(
 channel: userId,
 eventname: "Notification",
 data: notification);
 }

 public async Task SendToAccountAsync(Guid accountId, NotificationEvent notification)
 {
 // Send to all users in an account
 await _monitorService.PublishAsync(
 channel: accountId.ToString(),
 eventname: "Notification",
 data: notification);
 }

 public async Task BroadcastAsync(NotificationEvent notification)
 {
 // Send to all connected users
 await _monitorService.PublishAsync(
 channel: "all",
 eventname: "Notification",
 data: notification);
 }
}

Custom Event Types

Define strongly-typed events for different scenarios:

// Base event
public abstract class MonitorEvent
{
 public string EventId { get; set; } = Guid.NewGuid().ToString();
 public DateTime Timestamp { get; set; } = DateTime.UtcNow;
}

// Specific event types
public class OrderEvent : MonitorEvent
{
 public int OrderId { get; set; }
 public string Status { get; set; }
 public decimal Amount { get; set; }
}

public class InventoryEvent : MonitorEvent
{
 public int ProductId { get; set; }
 public int Quantity { get; set; }
 public string Action { get; set; } // Added, Removed, Updated
}

public class UserActivityEvent : MonitorEvent
{
 public string UserId { get; set; }
 public string Action { get; set; }
 public string Resource { get; set; }
}

// Register multiple monitor services
builder.Services.AddMonitorSignalR<OrderEvent>();
builder.Services.AddSingleton<IMonitorService<InventoryEvent>, MonitorService<InventoryEvent>>();
builder.Services.AddSingleton<IMonitorService<UserActivityEvent>, MonitorService<UserActivityEvent>>();

Connection State Management

Track connection states in your hub:

using ISynergy.Framework.AspNetCore.Monitoring.Hubs;
using Microsoft.AspNetCore.SignalR;

public class CustomMonitorHub : MonitorHub
{
 private readonly IConnectionTracker _connectionTracker;

 public CustomMonitorHub(
 ILogger<CustomMonitorHub> logger,
 IConnectionTracker connectionTracker)
 : base(logger)
 {
 _connectionTracker = connectionTracker;
 }

 public override async Task OnConnectedAsync()
 {
 await base.OnConnectedAsync();

 var accountId = Context.User.GetAccountId();
 var userId = Context.User.GetUserId();

 // Track connection
 await _connectionTracker.AddConnectionAsync(
 Context.ConnectionId,
 userId,
 accountId);

 // Send current online users to the connected client
 var onlineUsers = await _connectionTracker.GetOnlineUsersAsync(accountId);
 await Clients.Caller.SendAsync("OnlineUsers", onlineUsers);
 }

 public override async Task OnDisconnectedAsync(Exception exception)
 {
 var accountId = Context.User.GetAccountId();
 var userId = Context.User.GetUserId();

 // Remove connection
 await _connectionTracker.RemoveConnectionAsync(
 Context.ConnectionId,
 userId,
 accountId);

 await base.OnDisconnectedAsync(exception);
 }
}

Real-Time Dashboard

Build a real-time monitoring dashboard:

// Backend service
public class DashboardService
{
 private readonly IMonitorService<DashboardMetric> _monitorService;
 private readonly IMetricsCollector _metricsCollector;
 private Timer _timer;

 public DashboardService(
 IMonitorService<DashboardMetric> monitorService,
 IMetricsCollector metricsCollector)
 {
 _monitorService = monitorService;
 _metricsCollector = metricsCollector;
 }

 public void StartMonitoring(Guid accountId)
 {
 _timer = new Timer(async _ =>
 {
 var metrics = await _metricsCollector.GetCurrentMetricsAsync();

 await _monitorService.PublishAsync(
 channel: accountId.ToString(),
 eventname: "DashboardUpdate",
 data: new DashboardMetric
 {
 ActiveUsers = metrics.ActiveUsers,
 OrdersPerHour = metrics.OrdersPerHour,
 Revenue = metrics.Revenue,
 ServerLoad = metrics.ServerLoad
 });
 }, null, TimeSpan.Zero, TimeSpan.FromSeconds(5));
 }
}

public class DashboardMetric
{
 public int ActiveUsers { get; set; }
 public int OrdersPerHour { get; set; }
 public decimal Revenue { get; set; }
 public double ServerLoad { get; set; }
}

Frontend (React example):

import { useEffect, useState } from 'react';
import * as signalR from '@microsoft/signalr';

interface DashboardMetric {
 activeUsers: number;
 ordersPerHour: number;
 revenue: number;
 serverLoad: number;
}

export function Dashboard() {
 const [metrics, setMetrics] = useState<DashboardMetric | null>(null);
 const [connection, setConnection] = useState<signalR.HubConnection | null>(null);

 useEffect(() => {
 const newConnection = new signalR.HubConnectionBuilder()
 .withUrl('/hubs/monitor', {
 accessTokenFactory: () => getAuthToken()
 })
 .withAutomaticReconnect()
 .build();

 newConnection.on('DashboardUpdate', (metric: DashboardMetric) => {
 setMetrics(metric);
 });

 newConnection.start()
 .then(() => console.log('Connected to monitoring hub'))
 .catch(err => console.error('Connection error:', err));

 setConnection(newConnection);

 return () => {
 newConnection.stop();
 };
 }, []);

 return (
 <div className="dashboard">
 <MetricCard
 title="Active Users"
 value={metrics?.activeUsers ?? 0}
 />
 <MetricCard
 title="Orders/Hour"
 value={metrics?.ordersPerHour ?? 0}
 />
 <MetricCard
 title="Revenue"
 value={`$${metrics?.revenue?.toFixed(2) ?? '0.00'}`}
 />
 <MetricCard
 title="Server Load"
 value={`${metrics?.serverLoad?.toFixed(1) ?? '0.0'}%`}
 />
 </div>
 );
}

Usage Examples

Real-Time Collaboration

Implement collaborative editing features:

public class DocumentService
{
 private readonly IMonitorService<DocumentChangeEvent> _monitorService;

 public DocumentService(IMonitorService<DocumentChangeEvent> monitorService)
 {
 _monitorService = monitorService;
 }

 public async Task UpdateDocumentAsync(
 Guid documentId,
 string userId,
 DocumentChange change)
 {
 // Save the change
 await SaveChangeAsync(documentId, change);

 // Notify all users viewing this document
 await _monitorService.PublishAsync(
 channel: documentId.ToString(),
 eventname: "DocumentChanged",
 data: new DocumentChangeEvent
 {
 DocumentId = documentId,
 UserId = userId,
 Change = change,
 Timestamp = DateTime.UtcNow
 });
 }
}

// Client-side (TypeScript)
connection.on("DocumentChanged", (event) => {
 if (event.userId !== currentUserId) {
 // Apply changes from other users
 applyDocumentChange(event.change);
 }
});

Real-Time Notifications

Send instant notifications to users:

public class NotificationHub
{
 private readonly IMonitorService<Notification> _monitorService;

 public NotificationHub(IMonitorService<Notification> monitorService)
 {
 _monitorService = monitorService;
 }

 public async Task SendNotificationAsync(
 string userId,
 string title,
 string message,
 NotificationType type)
 {
 await _monitorService.PublishAsync(
 channel: userId,
 eventname: "Notification",
 data: new Notification
 {
 Title = title,
 Message = message,
 Type = type,
 Timestamp = DateTime.UtcNow
 });
 }
}

// Client-side
connection.on("Notification", (notification) => {
 showToast(notification.title, notification.message, notification.type);
});

Best Practices

Hub Design

• Keep hub methods focused and simple
• Use groups for efficient message routing
• Implement proper authentication and authorization
• Log connection events for monitoring
• Handle exceptions gracefully
• Limit message size to avoid performance issues

Scalability

• Use Azure SignalR Service for production scaling
• Implement backplane (Redis) for multi-server deployments
• Monitor hub performance and connection metrics
• Set connection limits based on server capacity
• Use distributed caching for connection state
• Consider message batching for high-frequency updates

Security

• Always require authentication for sensitive hubs
• Validate user permissions before sending messages
• Use groups to enforce tenant isolation
• Encrypt sensitive data in messages
• Implement rate limiting for hub methods
• Audit hub access and message patterns

Performance

• Minimize message payload size
• Batch frequent updates when possible
• Use compression for large messages
• Implement client-side throttling
• Cache frequently accessed data
• Monitor and optimize hub method execution time

Testing

Example unit tests for monitoring services:

using ISynergy.Framework.Monitoring.Abstractions.Services;
using Microsoft.AspNetCore.SignalR;
using Moq;
using Xunit;

public class MonitorServiceTests
{
 [Fact]
 public async Task PublishAsync_PublishesToCorrectGroup()
 {
 // Arrange
 var mockHubContext = new Mock<IHubContext<MonitorHub>>();
 var mockClients = new Mock<IHubClients>();
 var mockGroupClients = new Mock<IClientProxy>();

 mockHubContext.Setup(h => h.Clients).Returns(mockClients.Object);
 mockClients.Setup(c => c.Group(It.IsAny<string>())).Returns(mockGroupClients.Object);

 var service = new MonitorService<OrderEvent>(mockHubContext.Object);

 var orderEvent = new OrderEvent
 {
 OrderId = 123,
 Status = "Created"
 };

 // Act
 await service.PublishAsync("account-123", "OrderCreated", orderEvent);

 // Assert
 mockClients.Verify(c => c.Group("account-123"), Times.Once);
 mockGroupClients.Verify(
 c => c.SendCoreAsync(
 "OrderCreated",
 It.Is<object[]>(o => o[0] == orderEvent),
 default),
 Times.Once);
 }
}

Dependencies

• Microsoft.AspNetCore.SignalR - SignalR infrastructure
• Microsoft.AspNetCore.SignalR.Core - Core SignalR abstractions
• ISynergy.Framework.Core - Core framework utilities
• ISynergy.Framework.Monitoring.Abstractions - Monitoring abstractions
• ISynergy.Framework.MessageBus - Message bus models

Documentation

For more information about the I-Synergy Framework:

• Framework Documentation
• API Reference
• Sample Applications

Related Packages

• I-Synergy.Framework.Core - Core framework components
• I-Synergy.Framework.AspNetCore - Base ASP.NET Core integration
• I-Synergy.Framework.AspNetCore.Authentication - Authentication utilities
• I-Synergy.Framework.MessageBus - Message bus infrastructure
• I-Synergy.Framework.Monitoring.Abstractions - Monitoring contracts

Support

For issues, questions, or contributions, please visit the GitHub repository.