RedisUI.Dashboard 2.2.1

RedisUI.Dashboard

A modern Redis UI for ASP.NET Core with enhanced features, built as a fork of RedisUI.

🔥 What’s New in RedisUI.Dashboard

This fork includes major improvements over the original RedisUI:

• ✅ Support for Redis data types: Stream, Sorted Set, Hash, List, Set, String.
• ✅ Error prevention: Null-safe resolution to prevent NullReferenceException.
• ✅ Monokai-highlighted JSON: Key values rendered as readable formatted JSON.
• ✅ UI and performance upgrades:
  • Redesigned layout and styles
  • SCAN cursor enhancements
  • Async parallel Redis key & stat resolution
• ✅ Middleware refactor: Clearer API with overloads instead of optional params.
• ✅ .NET 9 support: Added to TargetFrameworks.
• Extras

🚀 Installation

Install via NuGet:

dotnet add package RedisUI.Dashboard

🔧 Recent Enhancements by @frankyjquintero

This project has undergone several significant improvements to enhance functionality, robustness, and forward compatibility. Notable changes include:

• ✅ Support for additional Redis data types: Stream, Sorted Set, Hash, and more are now properly rendered, enabling a complete view of Redis contents regardless of type.
• ✅ Error prevention enhancements: Added null-safety guards and robust checks to prevent potential NullReferenceException issues identified via static analysis tools.
• ✅ Cleaner JSON handling: Redis key values are now intelligently parsed into JSON with Monokai syntax highlighting, making complex structures easier to inspect and debug.
• ✅ Improved UI stability and experience: Reorganized HTML layout with Bootstrap 5.3, cleaned JS logic, and improved key loading via cursor-based SCAN to support large datasets.
• ✅ Optimized performance: Implemented async parallel processing for Redis INFO and key type/value resolution, along with a singleton-managed ConnectionMultiplexer.
• ✅ Simplified middleware API: Refactored core middleware components (RedisUIMiddleware, RedisKeyValueResolver) and transitioned from optional parameters to clearer overloads for maintainability.
• ✅ Extended .NET support: Added multi-target support for .NET 6, 7, 8, and 9 for wider compatibility and future readiness.
• ✅ Authorization filters added: Introduced pluggable security options including Basic Auth, JWT Role, Claim-based, IP Whitelisting, and environment-based access control.
• ✅ Dashboard path customization: You can now configure the Redis UI path, enabling cleaner route separation (e.g., /redis-admin).
• ✅ Package metadata improvements: Updated NuGet packaging details (license, readme, tags, project URL) for better discoverability and transparency.
• ✅ Redis key explorer UI improvements: TreeView redesigned for flat mode, zebra-style list groups, expandable folders, delete buttons, and TTL/size display.

These improvements aim to modernize and stabilize the RedisUI integration, making it more production-ready and developer-friendly.

🔧 Custom JS and CSS for RedisUI Viewer

You can customize the appearance and behavior of the Redis UI by providing your own JavaScript and CSS files. This is useful if you want to use local versions of Bootstrap, syntax highlighters, or JSON viewers.

Example

app.UseRedisUI(new RedisUISettings
{
    CssLink = "/assets/css/bootstrap.min.css",
    JsLink = "/assets/js/bootstrap.bundle.min.js",
    HighlightTheme = "/assets/css/highlight-dark.css",
    HighlightJs = "/assets/js/highlight.min.js",
    HighlightJson = "/assets/js/json-viewer.js"
});

🔐 Dashboard Authorization Filters

You can protect the Redis dashboard endpoint using different types of authorization filters by configuring the CacheOptions:Dashboard section in your appsettings.json.

📆 Supported Authentication Modes

⚙️ Example Configuration (appsettings.json)

✅ Basic Auth

"CacheOptions": {
  "Provider": "Redis",
  "RedisConnection": "localhost:6379",
  "Dashboard": {
    "Enabled": true,
    "Path": "/redis-admin",
    "AuthenticationMode": "basic",
    "Username": "admin",
    "Password": "secret"
  }
}

✅ Claim-based Authorization

"Dashboard": {
  "Enabled": true,
  "AuthenticationMode": "claim",
  "ClaimType": "role",
  "ClaimValue": "Admin"
}

✅ IP Whitelist

"Dashboard": {
  "Enabled": true,
  "AuthenticationMode": "ip",
  "AllowedIps": [ "127.0.0.1", "::1", "192.168.0.100" ]
}

✅ JWT Role Check

"Dashboard": {
  "Enabled": true,
  "AuthenticationMode": "jwt",
  "Role": "Administrator"
}

✅ Environment-based (Dev/Staging only)

"Dashboard": {
  "Enabled": true,
  "AuthenticationMode": "env"
}

🧩 Custom Filter Injection

If you want to plug in a fully custom implementation, you can manually assign your own IRedisAuthorizationFilter in Program.cs:

app.UseRedisUI(new RedisUISettings
{
    Path = "/redis-admin",
    AuthorizationFilter = new MyCustomRedisAuthFilter()
});

🌐 Authorization Filter Factory (Automatic Selection)

To make filter setup easier and based on configuration, you can use the built-in factory to instantiate the correct filter automatically:

public static class DashboardAuthorizationFactory
{
    public static IRedisAuthorizationFilter Create(CacheDashboardOptions options, IWebHostEnvironment env)
    {
        return options.AuthenticationMode?.ToLower() switch
        {
            "basic" => new DashboardBasicAuthorizationFilter(options.Username, options.Password),
            "jwt"   => new DashboardJwtAuthorizationFilter(options.Role),
            "claim" => new DashboardClaimAuthorizationFilter(options.ClaimType, options.ClaimValue),
            "ip"    => new DashboardIpWhitelistAuthorizationFilter(options.AllowedIps),
            "env"   => new DashboardEnvironmentAuthorizationFilter(env),
            _       => new DashboardBasicAuthorizationFilter(options.Username, options.Password)
        };
    }
}

Usage inside UseCacheDashboard extension:

public static IApplicationBuilder UseCacheDashboard(this IApplicationBuilder app, IConfiguration configuration)
{
    var options = configuration.GetSection("CacheOptions").Get<CacheOptions>();

    if (options is { Provider: "Redis", Dashboard.Enabled: true })
    {
        var env = app.ApplicationServices.GetRequiredService<IWebHostEnvironment>();

        app.UseRedisUI(new RedisUISettings
        {
            Path = options.Dashboard.Path,
            ConnectionString = options.RedisConnection,
            AuthorizationFilter = DashboardAuthorizationFactory.Create(options.Dashboard, env)
        });
    }

    return app;
}

Extra: Example mapping CacheOptions

using System.Globalization;

public class CacheOptions : IAppOptions
{
    public string Provider { get; set; } = "Redis";
    public string RedisConnection { get; set; } = string.Empty;
    public string SqlConnection { get; set; } = string.Empty;
    public string Prefix { get; set; } = string.Empty;
    public Dictionary<string, string> ExpirationTimes { get; set; } = new();
    public CacheDashboardOptions Dashboard { get; set; } = new();

    public TimeSpan GetExpiration(string key)
    {
        key = key.Replace(":", "__");
        return ExpirationTimes.TryGetValue(key, out var value) && 
               TimeSpan.TryParse(value, CultureInfo.InvariantCulture, out var timeSpan)
            ? timeSpan
            : TimeSpan.FromMinutes(30);
    }
}

public class CacheDashboardOptions
{
    public bool Enabled { get; set; } = false;
    public string Path { get; set; } = "/redis-admin";
    public string Role { get; set; } = "Admin";
    public string Username { get; set; } = "admin";
    public string Password { get; set; } = "secret";
    public string AuthenticationMode { get; set; } = "basic"; // basic, jwt, claim, ip, env
    public string ClaimType { get; set; } = string.Empty;
    public string ClaimValue { get; set; } = string.Empty;
    public List<string> AllowedIps { get; set; } = new();
}

Extra: Example auto register Options:

public static IServiceCollection AddAllConfigurations(this IServiceCollection services, IConfiguration configuration)
{
    var assembly = typeof(IAppOptions).Assembly;

    var optionsTypes = assembly.GetTypes()
        .Where(t => typeof(IAppOptions).IsAssignableFrom(t) && t.IsClass && !t.IsAbstract);

    foreach (var type in optionsTypes)
    {
        var method = typeof(OptionsConfigurationServiceCollectionExtensions)
            .GetMethods(BindingFlags.Static | BindingFlags.Public)
            .First(m => m.Name == "Configure" && m.GetParameters().Length == 2)
            .MakeGenericMethod(type);

        method.Invoke(null, new object[] { services, configuration.GetSection(type.Name) });
    }

    return services;
}

These filters give you flexibility to secure your Redis UI in the way that best matches your application's security model.

UI

Server Statistics

👉 You can review the updated source and commits at github.com/frankyjquintero/RedisUI

Redis Integrated UI

Redis Integrated UI is a .NET project designed to simplify the integration of a Redis User Interface (UI) page into your web applications. With this project, users can easily incorporate a Redis UI page, enabling them to interact with Redis keys and view Redis server statistics seamlessly.

Features

• Integration Ease: Simplifies the process of integrating a Redis UI page into web applications.

• Redis Key Management: Provides functionality to interact with Redis keys conveniently.

• Server Statistics: Displays statistics related to the Redis server for monitoring and analysis purposes.

Getting Started

To integrate the Redis UI into your application, follow these steps:

• Install RedisUI from the NuGet Gallery.

PM> Install-Package RedisUI

• Add the middleware to your project.

using RedisUI;

app.UseRedisUI();

• Run your project and browse /redis path. easy peasy!

Settings

• The Path is "/redis" by default, set a new path.

app.UseRedisUI(new RedisUISettings
{
    Path = "/myredisui",
});

• The ConnectionString is "localhost" by default, set the connection string.

app.UseRedisUI(new RedisUISettings
{
    ConnectionString = "1.1.1.1:6379",
});

• Use ConfigurationOptions for detailed settings.

ConfigurationOptions options = new ConfigurationOptions
{
    EndPoints = { { "my-redis.cloud.redislabs.com", 6379 } },
    User = "default",  // use your Redis user. More info https://redis.io/docs/management/security/acl/
    Password = "secret", // use your Redis password
    Ssl = true,
    SslProtocols = System.Security.Authentication.SslProtocols.Tls12                
};

app.UseRedisUI(new RedisUISettings
{
    ConfigurationOptions = options
});

• The UI is using Bootstrap 5.3.2 version from CDN, you can get it from locally via setting properties below:

app.UseRedisUI(new RedisUISettings
{
    CssLink = "..\\mypath\\bootstrap.min.cs",
    JsLink = "..\\mypath\\bootstrap.js"
});

Authorization

You can limit access to Redis data in the production environment.

• Add a new authorization filter and implement IRedisAuthorizationFilter

using RedisUI;

public class MyAuthorizationFilter : IRedisAuthorizationFilter
{
    private readonly bool _isDevelopment;

    public MyAuthorizationFilter(bool isDevelopment)
    {
        _isDevelopment = isDevelopment;
    }

    public bool Authorize(HttpContext context)
    {
        return _isDevelopment || (context.User.Identity != null && context.User.Identity.IsAuthenticated);
    }
}

app.UseRedisUI(new RedisUISettings
{
    AuthorizationFilter = new MyAuthorizationFilter(app.Environment.IsDevelopment())
});

Contributing

Contributions are welcome! If you'd like to contribute to Redis Integrated UI, please follow these guidelines:

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

License

This project is licensed under the MIT License.

Contact

For any inquiries or support regarding Redis Integrated UI, feel free to contact the project maintainer:

• Email: emrahkondur@hotmail.com
• GitHub: ekondur