FaultLens supports any platform.

Current SDK status

Choose your integration path

Additional official SDKs will be prioritized using customer demand and ecosystem feedback. We do not commit to an SDK for every language or to specific delivery dates.

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.
• Send events to the ingestion host shown in your project settings, such as https://YOUR-WORKSPACE.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

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.

Custom integration (direct ingest)

Any platform that can make an authenticated HTTPS request can send the canonical event envelope directly — no official SDK required. This is a first-class integration option using the same backend contract. You own envelope construction, retries, redaction, and context collection.

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.1.1" },
            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"
    }
};

TypeScript / JavaScript, React, and Angular SDKs

The browser, Angular, and React packages are the official frontend SDKs for error monitoring and diagnostics context capture. The framework packages wrap the browser SDK with framework-friendly APIs. All three are released together as a synchronized 1.0.0 family.

npm install @faultlenshq/browser@1.0.0
npm install @faultlenshq/angular@1.0.0 @faultlenshq/browser@1.0.0
npm install @faultlenshq/react@1.0.0 @faultlenshq/browser@1.0.0 react react-dom

The wrapper packages pin a compatible @faultlenshq/browser through their peerDependencies, so installing the matching 1.0.0 pair resolves cleanly.

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.1.1" },
  "exception": {
    "type": "System.NullReferenceException",
    "message": "Object reference not set to an instance of an object."
  }
}

Business severity metadata (reserved tags)

FaultLens classifies severity from observed impact and never infers business criticality from routes, URLs, or stack traces. To mark an event as business-critical, send explicit metadata under reserved tags keys. The backend consumes exactly three: faultlens.capability, faultlens.criticality (critical | high | normal | low), and faultlens.operation — where operation may name a route, workflow, job, or command.

"tags": {
  "faultlens.capability": "checkout",
  "faultlens.criticality": "critical",
  "faultlens.operation": "payment-capture"
}

Response contract

Every business outcome returns HTTP 200 with a JSON body — inspect status rather than assuming success. status: 1 is Ingested (stored). status: 2 is Dropped (for example reasonCode: "billing_limit_exceeded" — accepted by the endpoint but not stored). status: 3 is Rejected. HTTP 401 means a missing or invalid X-API-Key or the wrong host; 429 and 5xx are retryable with backoff. Do not treat every HTTP 200 as accepted.