Honeybadger for .NET

Typical installation time: ~5 minutes

Hi there! You’ve found Honeybadger’s guide to .NET exception and error tracking. Once installed, Honeybadger will automatically report errors from your .NET or C# application.

Getting started

Source Code

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 will attempt to automatically figure out the ProjectRoot directory, which should be the root of your project or solution. A valid ProjectRoot directory will allow Honeybadger to classify stack frames as either application code or all other code (e.g. framework code) and hence provide better error reports.

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(configure =>
{
    configure.ApiKey = "PROJECT_API_KEY";
});

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

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

Note

You should probably set your API key through environment variables or use the Secrets Manager, instead of hardcoding it in the appsettings.json file.

You can read the official documentation for more information on how to do that in a .Net Core app.

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 honeybadger) =>
{
    honeybadger.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(configure =>
{
    configure.ApiKey = "PROJECT_API_KEY";
});
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();

Usage

Errors from the logger will be reported to Honeybadger:

app.MapGet("/notify", ([FromServices] ILogger<Program> logger) =>
{
      logger.LogError("hello from Honeybadger.Logger!");

      return "Log reported to Honeybadger. Check your dashboard!";
});

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

Send a test notification

Note

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.

You can send a test notification to Honeybadger to verify that the configuration is working. Add the following to your Program.cs file:

// ...
builder.AddHoneybadger();
// ...
var app = builder.Build();
var honeybadger = app.Services.GetRequiredService<IHoneybadgerClient>();
await honeybadger.NotifyAsync("Hello from .Net!");

Run the app. If the configuration is correctly set, you should see the notification in your Honeybadger dashboard.

Automatic error reporting

Automatic error reporting is enabled by default, but you can disable it by setting the ReportUnhandledExceptions property to false in HoneybadgerOptions:

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

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("PROJECT_API_KEY");
var honeybadger = new HoneybadgerClient(Options.Create(options));

3. Call notify to report to Honeybadger:

// fire and forget
honeybadger.Notify("hello from .Net !");
// or async
await honeybadger.NotifyAsync("hello from .Net !");

See example project in examples/Honeybadger.Console.

Supported .NET versions

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