DynaScaleHangfire 1.0.23

DynaScaleHangfire

A dynamic scaling extension for Hangfire that provides real-time server and queue monitoring with dynamic worker count management.

Features

• Server & Queue Monitoring: Monitor individual servers and their queue configurations
• Real-time Worker Count Management: Update worker counts for specific server-queue combinations
• Bulk Operations: Apply worker count changes to all servers for a specific queue
• Server Status Tracking: Monitor server health and activity status
• Machine-based Grouping: Group servers by machine name for better organization
• RESTful API: Simple HTTP endpoints for server-queue management
• Web Dashboard Integration: Seamless integration with Hangfire dashboard
• Automatic Static Files: JavaScript files are automatically copied to build output

Installation

NuGet Package

dotnet add package DynaScaleHangfire

Manual Installation

1. Clone this repository
2. Build the project
3. Reference the built assembly in your project

Quick Start

1. Add Services

using Hangfire.DynaScale.Extensions;
using Hangfire.DynaScale.Models;

var builder = WebApplication.CreateBuilder(args);

// Add DynaScale services with custom options
builder.Services.AddHangfireDynaScale(new DynaScaleOptions
{
    MaxWorkerCount = 50,
    DefaultWorkerCount = 10
});

// Or use default options
builder.Services.AddHangfireDynaScale();

2. Configure Middleware

var app = builder.Build();

// Automatically creates wwwroot directory and adds static files middleware
app.UseHangfireDynaScaleWithStaticFiles();

3. Access Dashboard

Navigate to /dynamic-scaling to access the DynaScale dashboard.

Configuration

DynaScaleOptions

public sealed record DynaScaleOptions
{
    public int MaxWorkerCount { get; init; } = 100;
    public int DefaultWorkerCount { get; init; } = Environment.ProcessorCount * 5;
}

• MaxWorkerCount: Maximum number of workers that can be set for any queue (default: 100)
• DefaultWorkerCount: Default worker count for new servers (default: Environment.ProcessorCount * 5)

How It Works

DynaScaleHangfire uses Hangfire's monitoring APIs to provide real-time information about your Hangfire servers and their queue configurations. The system allows you to:

• View all active Hangfire servers grouped by machine name
• Monitor server health and activity status
• Modify worker counts for specific server-queue combinations
• Apply worker count changes to all servers for a specific queue
• Monitor queue performance and job processing

The web dashboard provides real-time monitoring of:

• Machine names (grouped servers)
• Queue configurations per server
• Current worker counts
• Server activity status
• Last heartbeat information

Automatic wwwroot Creation

This package automatically creates a wwwroot directory in your project if it doesn't exist when using UseHangfireDynaScaleWithStaticFiles(). This ensures that Hangfire's dashboard static files are properly served.

Project Structure

DynaScaleHangfire/
├── Controllers/
│   └── DynaScaleController.cs          # REST API endpoints
├── Extensions/
│   ├── ApplicationBuilderExtensions.cs # Middleware configuration
│   └── ServiceCollectionExtensions.cs  # DI configuration
├── Models/
│   └── HangfireSettings.cs            # Data models
├── Services/
│   ├── HangfireServerManager.cs       # Core monitoring logic
│   └── IHangfireServerManager.cs      # Service interface
├── build/
│   └── DynaScaleHangfire.targets      # MSBuild targets for file copying
└── wwwroot/
    └── js/
        └── dynamic-scaling.js         # Frontend JavaScript

API Endpoints

• GET /dynamic-scaling/servers - Get all server-queue configurations grouped by machine
• POST /dynamic-scaling/servers/{serverName}/queues/{queueName}/set-workers - Update worker count for a specific server-queue

Request Body for Set Workers

{
  "workerCount": 5,
  "applyToAllServers": false
}

• workerCount: The new worker count to set
• applyToAllServers: If true, applies the worker count to all servers for this queue

Data Models

ServerInfo

public sealed record ServerInfo
{
    public string ServerName { get; init; }        // Machine name
    public bool IsActive { get; init; }            // Server activity status
    public DateTime LastHeartbeat { get; init; }   // Last heartbeat time
    public List<QueueInfo> Queues { get; init; }   // Queue configurations
}

QueueInfo

public sealed record QueueInfo
{
    public string QueueName { get; init; }         // Queue name
    public int CurrentWorkerCount { get; init; }   // Current worker count
    public int MaxWorkerCount { get; init; }       // Maximum worker count
}

SetWorkersRequest

public sealed record SetWorkersRequest
{
    public int WorkerCount { get; init; }
    public bool ApplyToAllServers { get; init; }
}

Development

Prerequisites

• .NET 7.0 SDK or later
• Visual Studio 2022 or VS Code
• Hangfire storage provider (SQL Server, Redis, PostgreSQL, etc.)

Building

dotnet restore
dotnet build

Creating NuGet Package

dotnet pack -c Release

Contributing

1. Fork the repository
2. Create a feature branch (git checkout -b feature/amazing-feature)
3. Commit your changes (git commit -m 'Add some amazing feature')
4. Push to the branch (git push origin feature/amazing-feature)
5. Open a Pull Request

Contact

• Project Link: https://github.com/anilterzi/DynaScaleHangfire
• Issues: https://github.com/anilterzi/DynaScaleHangfire/issues

Acknowledgments

• Built on top of Hangfire
• Uses Hangfire's monitoring APIs for real-time data
• Community contributions and feedback