Integrate FaultLens from .NET, browser, Angular, and React applications.

Current SDK status

Guide index

Start with the SDK or workflow guide closest to the application you are instrumenting. These pages are public, crawlable references for real integration tasks rather than a separate SEO directory.

Sample repositories

The fastest way to validate a FaultLens integration is to run a sample against your own tenant workspace. The sample repositories include realistic setup, local run instructions, and verification steps.

Prerequisites

Before integrating, make sure you have:

• An active FaultLens workspace with at least one project created.
• A project API key from Project Settings -> API Keys.
• Your ingest base URL, shown in the same project settings surface.
• For current staging and beta validation, use your tenant host directly, such as https://TENANT-SLUG.staging.faultlens.in.

.NET SDK

The recommended .NET path is the public NuGet package. Use it when you want the supported client surface for exception capture and delivery behavior.

dotnet add package FaultLens.SDK --version 0.1.0-beta.2

Initialize the client

var client = new FaultLensClient(
    new FaultLensOptions(
        apiKey: "YOUR_PROJECT_API_KEY",
        environment: "production",
        release: "1.0.0")
);

Capture exceptions

try
{
    throw new InvalidOperationException("Something broke");
}
catch (Exception ex)
{
    client.CaptureException(ex);
}

ASP.NET Core setup

If you are wiring FaultLens into an ASP.NET Core application, register the options and typed client early, then capture exceptions at the middleware or service layer where context is strongest.

appsettings.json

{
  "FaultLens": {
    "ApiKey": "fl_proj_your_key_here",
    "Environment": "production",
    "Release": "1.4.2",
    "BaseUrl": "https://api.faultlens.in"
  }
}

Program.cs

builder.Services.AddSingleton<FaultLensClient>(sp =>
{
    var config = sp.GetRequiredService<IConfiguration>();
    var apiKey = config["FaultLens:ApiKey"];
    var endpoint = new Uri(config["FaultLens:Endpoint"]!);

    return new FaultLensClient(new FaultLensOptions(
        apiKey: apiKey!,
        environment: config["FaultLens:Environment"] ?? "production",
        release: config["FaultLens:Release"],
        endpoint: endpoint,
        breadcrumbCapacity: 40));
});

builder.Services.AddSingleton<IFaultLensClient>(sp =>
    sp.GetRequiredService<FaultLensClient>());

Request context and tags

using (var scope = client.BeginRequest("GET", "/orders/{id}"))
{
    scope.SetRequestContext(
        url: "https://api.example.com/orders/123",
        referrer: null,
        userAgent: "sample-client");
    scope.SetUserId("user-123");
    scope.SetTag("feature", "checkout");

    client.AddStep("checkout", "Payment flow started");
    client.CaptureMessage("Checkout validation failed");
}

For a complete working ASP.NET Core setup, use the FaultLens .NET samples.

Direct ingest fallback

The direct ingest API is still useful when you need lower-level control, want to prototype a custom runtime, or are bridging a frontend/runtime before a higher-level SDK fits your application.

Minimal custom client shape

using System.Net.Http.Json;

public sealed class FaultLensClient
{
    private readonly HttpClient _http;

    public FaultLensClient(HttpClient http)
    {
        _http = http;
    }

    public async Task CaptureExceptionAsync(Exception ex, CancellationToken ct = default)
    {
        var payload = new
        {
            eventId = Guid.NewGuid().ToString(),
            timestamp = DateTimeOffset.UtcNow,
            environment = "production",
            platform = "dotnet",
            sdk = new { name = "faultlens-dotnet", version = "1.0.0" },
            exception = new
            {
                type = ex.GetType().FullName ?? ex.GetType().Name,
                message = ex.Message
            }
        };

        using var request = new HttpRequestMessage(HttpMethod.Post, "api/events/ingest")
        {
            Content = JsonContent.Create(payload)
        };

        request.Headers.Add("X-API-Key", "fl_proj_your_key_here");
        await _http.SendAsync(request, ct);
    }
}

Breadcrumbs

Breadcrumbs capture the trail leading into an exception. They help FaultLens show what happened just before a failure rather than only showing the final exception record.

Breadcrumb example

var breadcrumbs = new[]
{
    new
    {
        timestamp = DateTimeOffset.UtcNow,
        type = "log",
        level = "info",
        category = "order",
        message = "Order validation passed"
    },
    new
    {
        timestamp = DateTimeOffset.UtcNow,
        type = "http",
        level = "info",
        category = "payment",
        message = "Payment gateway responded OK"
    }
};

Browser, Angular, and React SDKs

The browser, Angular, and React packages are released beta integration surfaces for frontend error monitoring and diagnostics context capture. The framework packages wrap the browser SDK with framework-friendly APIs.

npm install @faultlenshq/browser@beta
npm install @faultlenshq/angular@beta @faultlenshq/browser@0.1.0-beta.3
npm install @faultlenshq/react@beta @faultlenshq/browser@0.1.0-beta.3

If you need help choosing between the browser SDK, Angular SDK, React SDK, or direct ingest API, contact support@faultlens.in. See also browser SDK setup and Angular integration or React integration.

For cloneable examples, use the FaultLens frontend samples.

Payload reference

Complete field reference for POST /api/events/ingest. Authentication is via X-API-Key: fl_proj_....

Minimal example payload

POST /api/events/ingest
X-API-Key: fl_proj_your_key_here
Content-Type: application/json

{
  "eventId": "a3f1c2d4-8b7e-4f3a-9c12-1d2e3f4a5b6c",
  "timestamp": "2026-04-01T10:42:00.000Z",
  "environment": "production",
  "platform": "dotnet",
  "release": "1.4.2",
  "sdk": { "name": "faultlens-dotnet", "version": "1.0.0" },
  "exception": {
    "type": "System.NullReferenceException",
    "message": "Object reference not set to an instance of an object."
  }
}