DEV Community: Satish Patil

🚀 RootAlert - Real-time Exception Tracking & Alerting for .NET on Slack & Teams

Satish Patil — Sat, 22 Mar 2025 13:54:26 +0000

🔍 Tired of missing critical exceptions in your .NET apps? Meet RootAlert – a lightweight, real-time error tracking library that captures unhandled exceptions, batches them intelligently, and alerts your team via Microsoft Teams and Slack.

🔥 Key Features

✅ Automatic exception handling via middleware

✅ Real-time alerts with batching to prevent spam

✅ Supports Microsoft Teams (Adaptive Cards) & Slack (Blocks & Sections)

✅ Configurable batch interval using TimeSpan

✅ Rich error logs including request details, headers, and stack traces

✅ Supports Redis & MSSQL for persistent storage

📦 Installation

Install RootAlert from NuGet:

 dotnet add package RootAlert

Or via Package Manager:

 Install-Package RootAlert

⚡ Quick Start

1️⃣ Configure RootAlert in `Program.cs`

using RootAlert.Config;
using RootAlert.Extensions;
using RootAlert.Storage;

var builder = WebApplication.CreateBuilder(args);

var rootAlertOptions = new List<RootAlertOption>
{
    new RootAlertOption { AlertMethod = AlertType.Teams, WebhookUrl = "https://your-teams-webhook-url" },
    new RootAlertOption { AlertMethod = AlertType.Slack, WebhookUrl = "https://your-slack-webhook-url" }
};

var rootAlertSetting = new RootAlertSetting
{
    BatchInterval = TimeSpan.FromSeconds(20),
    RootAlertOptions = rootAlertOptions,
};

builder.Services.AddRootAlert(rootAlertSetting);

var app = builder.Build();
app.UseMiddleware<ExceptionHandlingMiddleware>();
app.UseRootAlert();
app.UseRouting();
app.UseEndpoints(endpoints => { endpoints.MapControllers(); });
app.Run();

✅ Now, RootAlert will automatically capture all unhandled exceptions!

📡 Persistent Storage Options (Redis & MSSQL)

RootAlert supports external storage:

🔹 RootAlert.Redis → Stores logs in Redis
🔹 RootAlert.MSSQL → Stores logs in SQL Server

🛠 Using Redis for Storage

 dotnet add package RootAlert.Redis

using RootAlert.Redis;
var rootAlertSetting = new RootAlertSetting
{
    Storage = new RedisAlertStorage("127.0.0.1:6379"),
    BatchInterval = TimeSpan.FromSeconds(20),
    RootAlertOptions = rootAlertOptions,
};

✅ Ideal for distributed apps running on multiple servers!

🛠 Using MSSQL for Storage

 dotnet add package RootAlert.MSSQL

using RootAlert.MSSQL;
var rootAlertSetting = new RootAlertSetting
{
    Storage = new MSSQLAlertStorage("Server=myServer;Database=myDB;User Id=myUser;Password=myPassword;"),
    BatchInterval = TimeSpan.FromSeconds(20),
    RootAlertOptions = rootAlertOptions,
};

📌 SQL Table Schema for MSSQL:

CREATE TABLE RootAlertLogs (
    Id INT IDENTITY PRIMARY KEY,
    ExceptionMessage NVARCHAR(MAX) NOT NULL,
    StackTrace NVARCHAR(MAX) NULL,
    RequestUrl NVARCHAR(MAX) NULL,
    HttpMethod NVARCHAR(10) NULL,
    Headers NVARCHAR(MAX) NULL,
    CreatedAt DATETIME2 DEFAULT GETUTCDATE()
);

🔗 Microsoft Teams Integration

RootAlert supports Microsoft Teams via:
1️⃣ Incoming Webhooks (Connector) - Simple & Quick Setup.

2️⃣ Microsoft Teams Workflow API - Easier than Power Automate.

📌 Steps to Configure Teams Webhook:

Open Microsoft Teams, go to the desired channel.
Click “…” (More options) → Connectors.
Select “Incoming Webhook”, configure it, and copy the Webhook URL.
Add it to RootAlertOptions in your Program.cs.

📌 Using Microsoft Teams Workflow API:

Open Teams → “…” → Workflows → Select "Post to a channel when a webhook request is received" template.
Set up the webhook & use the URL in RootAlert.

🎥 Watch a step-by-step guide here:

💬 Slack Integration

1️⃣ Go to Slack API & create a new Slack App.

2️⃣ Enable Incoming Webhooks under Features.

3️⃣ Click "Add New Webhook to Workspace" & select a channel.

4️⃣ Copy the Webhook URL & use it in RootAlertOptions.

✅ Structured Slack alerts using Blocks & Sections for clear error logs.

📊 Example Batched Error Summary Alert

🚨 Root Alert - Batched Error Summary

🔴 Error #1
Error Count: 3
📅 Timestamp: 03/22/2025 6:30:29 PM
🌐 Request URL: /getuser
📡 HTTP Method: GET
📩 Headers: Accept: application/json
----------------------------------------------------
⚠️ Exception Details
❗ Type: HttpRequestException
💬 Message: Weather API failed to respond
----------------------------------------------------
🔍 Stack Trace
   at WeatherService.GetWeatherData() in WeatherService.cs:line 45
   at RootAlertMiddleware.Invoke(HttpContext context)
----------------------------------------------------

🎯 Final Thoughts

RootAlert is open-source and designed for modern .NET applications to improve exception tracking and response time.

🚀 Give it a try & let me know your feedback!

🔗 NuGet: RootAlert

💻 GitHub Repo: RootAlert on GitHub

Have questions? Drop them in the comments below! 😊

RootAlert - Real-time Exception Tracking for .NET with Redis

Satish Patil — Thu, 13 Feb 2025 19:13:31 +0000

🚀 RootAlert - Real-time Exception Tracking for .NET

RootAlert is an open-source real-time error tracking and alerting library for .NET applications. It captures unhandled exceptions, batches them intelligently, and sends alerts to Microsoft Teams, Slack, and more.

🔥 Features

✅ Automatic exception tracking with minimal setup

✅ Batched alerts to prevent spam

✅ Microsoft Teams (Adaptive Cards) & Slack (Blocks & Sections) support

✅ Customizable batch interval using TimeSpan

✅ Supports Redis-based storage for persistence

✅ Rich error logs including request details, headers, and stack traces

📦 Installation

RootAlert is available on NuGet. Install it using:

 dotnet add package RootAlert --version 0.1.5

Or via Package Manager:

 Install-Package RootAlert -Version 0.1.5

⚡ Quick Start

1️⃣ Configure RootAlert in `Program.cs`

using RootAlert.Config;
using RootAlert.Extensions;

var builder = WebApplication.CreateBuilder(args);

var rootAlertOptions = new List<RootAlertOption>
{
    new RootAlertOption
    {
        AlertMethod = AlertType.Teams,
        WebhookUrl = "https://your-teams-webhook-url"
    },
    new RootAlertOption
    {
        AlertMethod = AlertType.Slack,
        WebhookUrl = "https://your-slack-webhook-url"
    }
};

var rootAlertSetting = new RootAlertSetting
{
    Storage = new RedisAlertStorage("127.0.0.1:6379"), // Redis storage
    BatchInterval = TimeSpan.FromSeconds(20),
    RootAlertOptions = rootAlertOptions,
};

builder.Services.AddRootAlert(rootAlertSetting);

var app = builder.Build();

// ✅ Handle exceptions first
app.UseMiddleware<ExceptionHandlingMiddleware>();

// ✅ Then, log errors with RootAlert
app.UseRootAlert();

app.UseRouting();
app.UseEndpoints(endpoints => { endpoints.MapControllers(); });

app.Run();

✅ RootAlert will now automatically capture all unhandled exceptions!

🚀 Redis Storage for Persistent Logging

By default, RootAlert batches errors in memory, meaning errors are lost if the application restarts. To ensure persistence, you can use Redis as storage.

1️⃣ Configure Redis Storage in `Program.cs`

Update your RootAlertSetting to use Redis:

var rootAlertSetting = new RootAlertSetting
{
    Storage = new RedisAlertStorage("127.0.0.1:6379"), // Use Redis storage
    BatchInterval = TimeSpan.FromSeconds(20),
    RootAlertOptions = rootAlertOptions,
};

2️⃣ Redis Benefits

✅ Persistence - Logs are stored even after an app restart.

✅ Scalability - Works across multiple instances of your app.

✅ Performance - Faster retrieval and processing of batched errors.

⚠️ Important Notes

❗ If an exception filter is added, RootAlert won't work.

Why? Exception filters handle errors before middleware gets a chance to process them. Since RootAlert works as middleware, it will never see the exception if a filter catches it first.

✅ Solution: Ensure RootAlert is added after any existing exception-handling middleware.

If your application has a global exception-handling middleware, register RootAlert after it to ensure exceptions are logged correctly.

app.UseMiddleware<ExceptionHandlingMiddleware>(); // Your existing middleware
app.UseRootAlert(); // Register RootAlert after the exception middleware

🏆 Microsoft Teams Integration

RootAlert supports Microsoft Teams via Adaptive Cards for structured error logging.

🔹 How to Get a Teams Webhook URL

RootAlert supports Microsoft Teams integration via:

Incoming Webhooks (Connector) – Simple and quick setup. (Will be deprecated)
Microsoft Teams Workflow API – Easier than Power Automate, with a built-in Webhook template.

🔹 Option 1: Using an Incoming Webhook (Connector)

This method is the easiest way to receive error alerts in a Teams channel.

📌 Steps to Get a Teams Webhook URL

Open Microsoft Teams and go to the desired channel.
Click "…" (More options) → Connectors.
Find "Incoming Webhook" and click "Configure".
Name it RootAlert Notifications and click Create.
Copy the Webhook URL and use it in RootAlertOptions.

🔹 Option 2: Using Microsoft Teams Workflow API (via Webhook Template)

This method is even easier than Power Automate and uses a built-in workflow to receive data via Webhook.
🎥 Watch this video for a step-by-step guide:

🔗 YouTube Link: https://www.youtube.com/watch?v=jHTU_jUnswY

📌 Steps to Configure Teams Workflow API

Open Microsoft Teams and Go to Workflows
- Click on “…” (More options) → Workflows. --> Create
Select "Post to a channel when a webhook request is received" Template
- Search for "Post to a channel when a webhook request is received" and select the ready-made template.
- Click Next to proceed.
Choose Team and Channel
- Select the Team where you want to post alerts.
- Choose the Channel where notifications should appear.

🔹 Example Teams Alert (Adaptive Card)

RootAlert sends alerts as rich Adaptive Cards:

Copy the Webhook URL
- After selecting the Team and Channel, Teams will generate a Webhook URL.
- Copy this URL and use it in your RootAlert settings.

🚨 Example Error Alert

RootAlert captures rich error details including request details, headers, and stack traces:

🆔 Error ID: abc123
⏳ Timestamp: 02/05/2025 4:02:41 AM
----------------------------------------------------
🌐 REQUEST DETAILS
🔗 URL: /weatherforecast
📡 HTTP Method: GET
----------------------------------------------------
📩 REQUEST HEADERS
📝 User-Agent: Mozilla/5.0
----------------------------------------------------
⚠️ EXCEPTION DETAILS
❗ Type: DivideByZeroException
💬 Message: Attempted to divide by zero.
----------------------------------------------------
🔍 STACK TRACE
   at Program.Main() in Program.cs:line 54
   at RootAlertMiddleware.Invoke()
----------------------------------------------------

🛠 Roadmap

🔹 Database Storage - Store logs in SQL, Redis, or NoSQL

🔹 Email Alerts - Send exception reports via SMTP

🔹 Log Severity Filtering - Send only critical errors

📜 License

RootAlert is open-source and available under the MIT License.

💡 Contributing

🚀 Contributions are welcome! Feel free to submit pull requests or feature requests on GitHub.

🔗 Connect with Us

📧 Email: satsvelke@gmail.com

🐦 Twitter: @satsvelke

RootAlert: Real-time Exception Tracking & Alerts for .NET!

Satish Patil — Thu, 06 Feb 2025 19:18:44 +0000

🚀 RootAlert: Real-time Exception Tracking & Alerts for .NET!

RootAlert is a powerful, lightweight real-time error tracking and alerting library for .NET applications. Whether you're building a small API or a large-scale enterprise system, RootAlert helps you monitor unhandled exceptions and get instant alerts in Microsoft Teams, Slack, and (soon) Email!

🔥 Why Use RootAlert?

✅ Automatically capture unhandled exceptions via middleware.

✅ Batch alerts to prevent spam while still getting timely notifications.

✅ Multi-service alerting – Send error notifications to Teams, Slack, and Email.

✅ Customizable batch intervals – Choose when to receive grouped alerts.

✅ Rich error logs with request details, headers, and stack traces.

📦 Installation & Setup

RootAlert is available on NuGet:

 dotnet add package RootAlert --version 0.1.5

Or via Package Manager:

 Install-Package RootAlert -Version 0.1.5

1️⃣ Add RootAlert to Your .NET Project

In Program.cs, configure RootAlert with multiple alert destinations:

using RootAlert.Config;
using RootAlert.Extensions;

var builder = WebApplication.CreateBuilder(args);

var rootAlertOptions = new List<RootAlertOption>
{
    new RootAlertOption
    {
        AlertMethod = AlertType.Teams,
        WebhookUrl = "https://your-teams-webhook-url"
    },
    new RootAlertOption
    {
        AlertMethod = AlertType.Slack,
        WebhookUrl = "https://your-slack-webhook-url"
    }
};

var rootAlertSetting = new RootAlertSetting
{
    BatchInterval = TimeSpan.FromSeconds(20),
    RootAlertOptions = rootAlertOptions,
};


builder.Services.AddRootAlert(rootAlertSetting);

var app = builder.Build();

// ✅ Handle exceptions first
app.UseMiddleware<ExceptionHandlingMiddleware>();

// ✅ Then, log errors with RootAlert
app.UseRootAlert();

app.UseRouting();
app.UseEndpoints(endpoints => { endpoints.MapControllers(); });

app.Run();

✅ Now, RootAlert will capture all unhandled exceptions and send alerts to multiple services!

⚠️ Important Notes

❗ If an exception filter is added, RootAlert won't work.

Reason: Exception filters handle errors before middleware gets a chance to process them. Since RootAlert works as middleware, it will never see the exception if a filter catches it first.

✅ Solution: Ensure RootAlert is added after any existing exception-handling middleware.

If your application has a global exception-handling middleware, register RootAlert after it to ensure exceptions are logged correctly. Example:

app.UseMiddleware<ExceptionHandlingMiddleware>(); // Your existing middleware
app.UseRootAlert(); // Register RootAlert after the exception middleware

🏆 Microsoft Teams Integration

RootAlert supports Microsoft Teams integration via:

Incoming Webhooks (Connector) – Simple and quick setup. (Will be deprecated)
Microsoft Teams Workflow API – Easier than Power Automate, with a built-in Webhook template.

🔹 Option 1: Using an Incoming Webhook (Connector)

This method is the easiest way to receive error alerts in a Teams channel.

📌 Steps to Get a Teams Webhook URL

Open Microsoft Teams and go to the desired channel.
Click "…" (More options) → Connectors.
Find "Incoming Webhook" and click "Configure".
Name it RootAlert Notifications and click Create.
Copy the Webhook URL and use it in your RootAlert configuration.

🔹 Option 2: Using Microsoft Teams Workflow API (via Webhook Template)

This method is even easier than Power Automate and uses a built-in workflow to receive data via Webhook.

🎥 Watch this video for a step-by-step guide:

🔗 YouTube Link: https://www.youtube.com/watch?v=jHTU_jUnswY

📌 Steps to Configure Teams Workflow API

Open Microsoft Teams and Go to Workflows
- Click on “…” (More options) → Workflows. --> Create
Select "Post to a channel when a webhook request is received" Template
- Search for "Post to a channel when a webhook request is received" and select the ready-made template.
- Click Next to proceed.
Choose Team and Channel
- Select the Team where you want to post alerts.
- Choose the Channel where notifications should appear.
Copy the Webhook URL
- After selecting the Team and Channel, Teams will generate a Webhook URL.
- Copy this URL and use it in your RootAlert settings.

💬 Slack Integration

🔹 How to Set Up a Slack Webhook

Go to https://api.slack.com/apps.
Create a new Slack App → Enable Incoming Webhooks.
Click Add New Webhook to Workspace, choose a channel.
Copy the Webhook URL and paste it in RootAlertOptions.

🔹 Example Slack Alert (Blocks & Sections Format)

RootAlert formats messages beautifully in Slack:

🚨 Example Error Alert

This is how RootAlert captures errors and logs detailed request information:

🆔 Error ID: abc123
⏳ Timestamp: 02/05/2025 4:02:41 AM
----------------------------------------------------
🌐 REQUEST DETAILS
🔗 URL: /weatherforecast
📡 HTTP Method: GET
----------------------------------------------------
📩 REQUEST HEADERS
📝 User-Agent: Mozilla/5.0
----------------------------------------------------
⚠️ EXCEPTION DETAILS
❗ Type: DivideByZeroException
💬 Message: Attempted to divide by zero.
----------------------------------------------------
🔍 STACK TRACE
   at Program.Main() in Program.cs:line 54
   at RootAlertMiddleware.Invoke()
----------------------------------------------------

🔜 Coming Soon!

✔ Database Storage - Store logs in MSSQL and Postgres
For Redis ->> using storage with Redis
✔ Email Alerts via SMTP - Get notifications in your inbox.

✔ Severity Filtering - Customize alerts based on error level.

Implementing Distributed Caching with PostgreSQL in .NET: Sats.PostgresDistributedCache

Satish Patil — Tue, 28 Jan 2025 20:07:54 +0000

Introduction

In modern applications, caching is essential to improve performance, reduce latency, and decrease the load on databases. Traditional in-memory caches like Redis or Memcached are widely used, but what if you already have PostgreSQL as your data store and want to leverage it for distributed caching as well? Introducing Sats.PostgresDistributedCache, a custom distributed cache implementation that uses PostgreSQL as the backing store.

This article walks through how to set up Sats.PostgresDistributedCache, a lightweight, high-performance distributed cache using PostgreSQL, and how to integrate it into your .NET application.

Key Features of Sats.PostgresDistributedCache:

PostgreSQL as the Backing Store: Store cache entries in a PostgreSQL database, utilizing the power and reliability of PostgreSQL.
Expiration Support: Cache entries can have expiration times, after which they will be automatically removed.
Basic Caching Operations: Set, get, remove, and refresh cache entries using simple methods.
Integration with .NET: Easy integration into your .NET application with minimal configuration.

Why Use PostgreSQL for Distributed Caching?

Using PostgreSQL for caching has several advantages:

Familiarity: If you already use PostgreSQL in your project, adding caching support doesn’t require new infrastructure or technology.
Scalability: PostgreSQL can scale vertically and horizontally, and using it for caching allows you to consolidate your data store.
Persistence: Unlike in-memory caches, PostgreSQL ensures that cached data is stored persistently and can be recovered in case of server failures.

Installation and Setup

To get started, you’ll need to install the Sats.PostgresDistributedCache NuGet package in your .NET project. You can do this by running the following command:

dotnet add package Sats.PostgresDistributedCache --version 1.3.0

Alternatively, you can use the NuGet Package Manager in Visual Studio for a more graphical experience.

Configuring the Cache in .NET

After installing the package, add the following configuration in your Startup.cs or Program.cs:

public void ConfigureServices(IServiceCollection services)
{
    // Add PostgreSQL distributed cache with your connection string
    services.AddPostgresDistributedCache(options =>
    {
        options.ConnectionString = "Host=myserver;Port=5432;Database=mydb;Username=myuser;Password=mypassword";
    });

    // Add other services as needed
}

Now, you can inject the IPostgreSqlDistributedCache interface into any class and use it for caching.

How to Use the Cache

Once configured, you can use the cache like any other distributed cache. Here is an example of setting and getting cache values using Sats.PostgresDistributedCache:

public class MyService
{
    private readonly IPostgreSqlDistributedCache _distributedCache;

    public MyService(IPostgreSqlDistributedCache distributedCache)
    {
        _distributedCache = distributedCache;
    }

    public async Task<string> GetFromCacheAsync(string key)
    {
        var data = await _distributedCache.GetAsync(key);
        return data != null ? Encoding.UTF8.GetString(data) : null;
    }

    public async Task SetInCacheAsync(string key, string value)
    {
        var data = Encoding.UTF8.GetBytes(value);
        await _distributedCache.SetAsync(key, data, expiration: TimeSpan.FromMinutes(10));
    }

    public async Task RemoveFromCacheAsync(string key)
    {
        await _distributedCache.RemoveAsync(key);
    }

    public async Task RefreshCacheAsync(string key)
    {
        await _distributedCache.RefreshAsync(key);
    }

    public async Task<string?> GetStringFromCacheAsync(string key)
    {
        return await _distributedCache.GetStringAsync(key);
    }

    public async Task SetStringInCacheAsync(string key, string value, TimeSpan? expiration = null)
    {
        await _distributedCache.SetStringAsync(key, value, expiration);
    }
}

Cache Table Schema

The cache is stored in a PostgreSQL table named Cache, which can be created with the following schema:

CREATE TABLE IF NOT EXISTS public."Cache"
(
    "key" character varying(255) NOT NULL,
    "value" text NOT NULL,
    "expiration" timestamp with time zone,
    CONSTRAINT "PK_Cache" PRIMARY KEY ("key"),
    CONSTRAINT "UQ_Cache_Key" UNIQUE ("key")
);

Columns:

Key: A unique identifier for each cache entry.
Value: The cached data stored as text.
Expiration: The expiration timestamp for each cache entry.

Supported .NET Versions

This package supports the following .NET versions:

.NET 6.0
.NET 7.0
.NET 8.0
.NET 9.0

Ensure that your project is targeting one of these versions for compatibility with Sats.PostgresDistributedCache.

License

The Sats.PostgresDistributedCache package is licensed under the MIT License, allowing you to freely use, modify, and distribute it in your projects.

.Net Core API Project with Embedded React.js UI

Satish Patil — Mon, 28 Oct 2024 19:08:08 +0000

This is a sample .NET Core API project demonstrating how to serve an embedded React.js UI (built with Chakra UI) alongside API endpoints. The project shows how to integrate a front-end application as an embedded resource, allowing the UI to be accessed without a separate server.

Features
ASP.NET Core API for backend functionality.
Embedded React.js UI built with Chakra UI or whatever ui framework, served as static files.
Static File Handling with embedded resources, allowing seamless access to front-end assets.
Setup Instructions
Build the React App: Ensure the production build of your React app (located in the ui folder) is created:

cd ui
npm install
npm run build

This will create a build folder with the production-ready files. Move or rename this folder to ui, so it aligns with the project’s embedded resource setup.

Configure the Project: Open the .csproj file and make sure the ui folder is set as an embedded resource:

<ItemGroup>
    <EmbeddedResource Include="ui\**" />
</ItemGroup>

Run the Project: Go back to the project root and run the application:

dotnet run

The API and UI will be served on the specified port (default: http://localhost:5244).

Usage
Access the React UI at:

http://localhost:5244/ui/index.html

Project Structure
Program.cs: Configures API routes, static file handling, and embedded resources.
ui/: Contains the production build of the React.js app.
WeatherForecast.cs: Sample API endpoint to demonstrate data responses.
URL Rewrite Handling
The project uses a URL rewrite rule to handle references to assets directly. Requests for paths like /assets/... are automatically rewritten to /ui/assets/....

GIT Url
https://github.com/satsvelke/embedded_resource_api_dotnet_react.git

HTMLtoPdf for .net core 3.1 - Converts HTML content to PDF using chrome executable

Satish Patil — Sat, 02 Oct 2021 06:44:44 +0000

Note : Requires Chrome executable
Nuget Link -https://www.nuget.org/packages/Sats.Core.HTMLToPdf

          var url = @"d:\test.html";
          var chromePath = @"C:\Program Files\Google\Chrome\Application\chrome.exe";

    var output = new ChromeOptions().AddOptions(b =>
                        {
                            b.Headless();
                            b.DisableGPU();
                            b.WithoutHeader();

                        }).ToPdf(new ChromeDetails()
                        {
                            ChromePath = chromePath,
                            HtmlPath = url,
                            DeleteOutputFile = true, //optional
                           // OutputPath = @"d:\print.pdf" // (add if Environment.CurrentDirectory does not have access rights)
                        });


    File.WriteAllBytes(@"d:\print.pdf", output.FileDetails.File);

HTMLtoPdf - Converts HTML content to PDF using chrome executable

Satish Patil — Mon, 27 Sep 2021 05:28:17 +0000

Note : Requires Chrome executable

Nuget Link - https://www.nuget.org/packages/Sats.HTMLtoPdf

Github link - https://github.com/satsvelke/HTMLtoPdf

Usage

           var url = @"d:\Vaccination.html";
          var chromePath = @"C:\Program Files\Google\Chrome\Application\chrome.exe";

          // returns byte array of file 
          var pdf = new ChromeOptions().AddOptions(b =>
                                      {
                                          b.Headless();
                                          b.DisableGPU();
                                          b.WithoutHeader();

                                      }).Pdf(new ChromeDetails() { ChromePath = chromePath, HtmlPath = url
 OutputPath = @"d:\print.pdf" // optional (add if 
             Environment.CurrentDirectory does not have access rights)
         });

           File.WriteAllBytes(@"d:\print.pdf", pdf);

Version : 2.1

        var url = @"d:\test.html";
        var chromePath = @"C:\Program Files\Google\Chrome\Application\chrome.exe";

        var output = new ChromeOptions().AddOptions(b =>
                            {
                                b.Headless();
                                b.DisableGPU();
                                b.WithoutHeader();

                            }).ToPdf(new ChromeDetails()
                            {
                                ChromePath = chromePath,
                                HtmlPath = url,
                                DeleteOutputFile = true, //optional
                               // OutputPath = @"d:\print.pdf" // (add if Environment.CurrentDirectory does not have access rights)
                            });


        File.WriteAllBytes(@"d:\print.pdf", output.FileDetails.File);

output.FileDetails.File will have byte array of created pdf
output.ProcessDetails will have output details like errors

kick start project in .net 5

Satish Patil — Sun, 22 Nov 2020 07:38:18 +0000

https://github.com/satsvelke/Net-Core-API

DEV Community: Satish Patil

🚀 RootAlert - Real-time Exception Tracking & Alerting for .NET on Slack & Teams

🔥 Key Features

📦 Installation

⚡ Quick Start

1️⃣ Configure RootAlert in Program.cs

📡 Persistent Storage Options (Redis & MSSQL)

🛠 Using Redis for Storage

🛠 Using MSSQL for Storage

🔗 Microsoft Teams Integration

💬 Slack Integration

📊 Example Batched Error Summary Alert

🎯 Final Thoughts

RootAlert - Real-time Exception Tracking for .NET with Redis

🚀 RootAlert - Real-time Exception Tracking for .NET

🔥 Features

📦 Installation

⚡ Quick Start

1️⃣ Configure RootAlert in Program.cs

🚀 Redis Storage for Persistent Logging

** 1️⃣ Configure Redis Storage in Program.cs**

2️⃣ Redis Benefits

⚠️ Important Notes

❗ If an exception filter is added, RootAlert won't work.

✅ Solution: Ensure RootAlert is added after any existing exception-handling middleware.

🏆 Microsoft Teams Integration

🔹 How to Get a Teams Webhook URL

🔹 Option 1: Using an Incoming Webhook (Connector)

📌 Steps to Get a Teams Webhook URL

🔹 Option 2: Using Microsoft Teams Workflow API (via Webhook Template)

📌 Steps to Configure Teams Workflow API

🔹 Example Teams Alert (Adaptive Card)

🚨 Example Error Alert

🛠 Roadmap

📜 License

💡 Contributing

🔗 Connect with Us

RootAlert: Real-time Exception Tracking & Alerts for .NET!

🚀 RootAlert: Real-time Exception Tracking & Alerts for .NET!

🔥 Why Use RootAlert?

📦 Installation & Setup

1️⃣ Add RootAlert to Your .NET Project

⚠️ Important Notes

❗ If an exception filter is added, RootAlert won't work.

✅ Solution: Ensure RootAlert is added after any existing exception-handling middleware.

🏆 Microsoft Teams Integration

🔹 Option 1: Using an Incoming Webhook (Connector)

📌 Steps to Get a Teams Webhook URL

🔹 Option 2: Using Microsoft Teams Workflow API (via Webhook Template)

📌 Steps to Configure Teams Workflow API

💬 Slack Integration

🔹 How to Set Up a Slack Webhook

🔹 Example Slack Alert (Blocks & Sections Format)

🚨 Example Error Alert

🔜 Coming Soon!

Implementing Distributed Caching with PostgreSQL in .NET: Sats.PostgresDistributedCache

Key Features of Sats.PostgresDistributedCache:

Why Use PostgreSQL for Distributed Caching?

Installation and Setup

Configuring the Cache in .NET

How to Use the Cache

Cache Table Schema

Columns:

Supported .NET Versions

License

Links

.Net Core API Project with Embedded React.js UI

HTMLtoPdf for .net core 3.1 - Converts HTML content to PDF using chrome executable

HTMLtoPdf - Converts HTML content to PDF using chrome executable

Note : Requires Chrome executable

Nuget Link - https://www.nuget.org/packages/Sats.HTMLtoPdf

Github link - https://github.com/satsvelke/HTMLtoPdf

Usage

kick start project in .net 5

1️⃣ Configure RootAlert in `Program.cs`

1️⃣ Configure RootAlert in `Program.cs`

1️⃣ Configure Redis Storage in `Program.cs`