Honeybadger for .Net Apps

This is the .Net Honeybadger Notifier.

Supported .Net versions:

All modern .Net Core applications are supported, up to .Net 9.0.

Getting Started

Configuration

The Honeybadger Notifier can be configured using the HoneybadgerOptions class. Honeybadger can be configured by passing the options when registering the service, or through your appsettings.json file.

Honeybadger, by default, will not report errors in development environments. You can override the development environments by setting the DevelopmentEnvironments property in the options. Alternatively, you can set the ReportData property to true to report errors in all environments.

See below for examples on how to configure Honeybadger for different types of applications.

For .Net Core Web App

1. Install Honeybadger.DotNetCore from Nuget

   dotnet add package Honeybadger.DotNetCore
   

2. Register the Honeybadger Middleware:

   var builder = WebApplication.CreateBuilder(args);
   builder.AddHoneybadger(new HoneybadgerOptions("apiKey"));

   Or you can configure Honeybadger through your appsettings.json file, by adding a Honeybadger section:

   {
     "Honeybadger": {
       "ApiKey": "apiKey",
       "AppEnvironment": "Development",
       "ReportData": true 
     }
   }

   And simply call AddHoneybadger without any parameters:

    var builder = WebApplication.CreateBuilder(args);
    builder.AddHoneybadger();

Usage

You can access the Honeybadger Client using DI:

app.MapGet("/", ([FromServices] IHoneybadgerClient client) =>
{
    client.AddBreadcrumb("reached index route", "route", new Dictionary<string, object?>());
    
    return "Hello World!";
});

Any unhandled exceptions should be reported to Honeybadger automatically (unless ReportUnhandledExceptions is set to false):

app.MapGet("/debug", () =>
{
    throw new Exception("hello from .Net Core Web App!");
});

See example project in examples/Honeybadger.DotNetCoreWebApp.

As a custom logging provider

1. Install Honeybadger.Extensions.Logging from Nuget

   dotnet add package Honeybadger.Extensions.Logging
   

2. Register Honeybadger and additionally the custom logging provider:

   var builder = WebApplication.CreateBuilder(args);
   // or set the configuration in the appsettings.json file
   builder.AddHoneybadger(new HoneybadgerOptions("apiKey"));
   builder.Logging.AddHoneybadger();

   You should also configure the minimum log level as you would configure other log providers in .Net Core. The following would report only logged errors:

   {
     "Logging": {
       "Honeybadger": {
          "Default": "Error"
       }
     }
   }

   And simply call AddHoneybadger and Logging.AddHoneybadger without any parameters:

    var builder = WebApplication.CreateBuilder(args);
    builder.AddHoneybadger();
    builder.Logging.AddHoneybadger();

   Note: If you want to disable automatic reporting of unhandled exceptions, you can set the ReportUnhandledExceptions property to false in the HoneybadgerOptions:

   {
     "Honeybadger": {
       "ApiKey": "apiKey",
       "AppEnvironment": "Development",
       "ReportData": true,
       "ReportUnhandledExceptions": false
     }
   }

Usage

Errors from the logger will be reported to Honeybadger:

app.MapGet("/notify", ([FromServices] ILogger logger) =>
{
    logger.LogError("hello from Honeybadger.Logger!");
    
    return "Log reported to Honeybadger. Check your dashboard!";
});

See example project in examples/Honeybadger.DotNetCoreWebApp.Logger.

Using the SDK manually

1. Install the Honeybadger Nuget.

   dotnet add package Honeybadger
   

2. Initialize the Honeybadger Client:

   using Microsoft.Extensions.Options;
   
   var options = new HoneybadgerOptions("apiKey");
   var client = new HoneybadgerClient(Options.Create(options));

3. Call notify to report to Honeybadger:

   // blocking
   client.Notify("hello from .Net !");
   // or async
   await client.NotifyAsync("hello from .Net !");

See example project in examples/Honeybadger.Console.

Changelog

Changelog is automatically generated using Conventional Commits with versionize. Conventional Commits are enforced with a pre-commit git hook (using husky).

Contributing

1. Fork the repo.
2. Create a topic branch git checkout -b my_branch
3. Commit your changes git commit -am "chore: boom"
4. Write a test that verifies your changes
5. Push to your branch git push origin my_branch
6. Send a pull request
7. Make sure that CI checks are passing

Releasing

All packages are published on nuget.org with a Github Actions Worfklow. The workflow does the following:

• dotnet versionize - bump versions and generate changelog
• dotnet pack
• dotnet package push

Note: only users with write permissions can trigger this workflow (i.e. Collaborators).

TODO

• Publish README with basic info to setup core nuget
• Publish Honeybadger.DotNetCore with README
• Publish Honeybadger.Extensions.Logging with README
• Implement Error Grouping (custom fingerprint)
• Implement Error Tags
• Allow excluding errors (either with a BeforeNotify method or exception classes config)
• Implement Filter Keys (exclude sensitive keys)
• Implement Checkins
• Implement Collect User Feedback
• Create guide for Deployment Tracking
• Create integration guide in honeybadger-docs project

License

This Honeybadger repository and published packages are MIT licensed. See the MIT-LICENSE file in this repository for details.