Quilt4Net.Toolkit 0.7.9

Quilt4Net.Toolkit

Core library providing health checks, metrics, remote configuration, feature toggles, content management, and Application Insights integration for .NET applications.

Features can be configured and monitored using Quilt4Net Web.

Feature toggles and remote configuration

Manage configuration and feature flags remotely via Quilt4Net Web or with a Blazor component from Quilt4Net.Toolkit.Blazor.

Feature toggles are boolean values of remote configuration.

Get started

Install the NuGet package Quilt4Net.Toolkit and register the service.

builder.AddQuilt4NetRemoteConfiguration();

Add your API key from Quilt4Net Web in appsettings.json.

{
  "Quilt4Net": {
    "ApiKey": "YOUR_API_KEY_HERE"
  }
}

Feature toggles

Inject IFeatureToggleService to check boolean feature flags.

public class MyService
{
    private readonly IFeatureToggleService _featureToggle;

    public MyService(IFeatureToggleService featureToggle)
    {
        _featureToggle = featureToggle;
    }

    public async Task DoWorkAsync()
    {
        if (await _featureToggle.GetToggleAsync("new-feature", fallback: false))
        {
            // new feature logic
        }
    }
}

Remote configuration

Inject IRemoteConfigurationService for typed configuration values.

var maxRetries = await _configService.GetValueAsync("MaxRetries", fallback: 3);

RemoteConfigurationOptions

Configuration path: Quilt4Net:RemoteConfiguration

Content management

Manage multilingual content from Quilt4Net Web.

builder.AddQuilt4NetContent();

Inject IContentService to retrieve and manage content.

var (value, success) = await _contentService.GetContentAsync("welcome-message", "Hello!", languageKey, ContentFormat.String);

ContentOptions

Configuration path: Quilt4Net:Content

Health check client

Client for consuming health endpoints from a remote service that uses Quilt4Net Health API.

builder.AddQuilt4NetHealthClient(o =>
{
    o.HealthAddress = "https://my-service.example.com/api/Health/";
});

Inject IHealthClient to call remote health endpoints.

var health = await _healthClient.GetHealthAsync(cancellationToken);
var metrics = await _healthClient.GetMetricsAsync(cancellationToken);
var version = await _healthClient.GetVersionAsync(cancellationToken);

HealthClientOptions

Configuration path: Quilt4Net:HealthClient

Application Insights client

Client for querying Application Insights data (logs, metrics, exceptions).

builder.AddQuilt4NetApplicationInsightsClient();

ApplicationInsightsOptions

Configuration path: Quilt4Net:ApplicationInsights

Managed Identity

When the app runs in Azure (App Service, Container Apps, VMs, …) you can skip the client secret entirely and authenticate with the hosting identity:

{
  "Quilt4Net": {
    "ApplicationInsights": {
      "WorkspaceId": "your-workspace-id",
      "AuthMode": "ManagedIdentity"
    }
  }
}

Grant the App Service identity the Log Analytics Reader (or Monitoring Reader) role on the target workspace. Use a user-assigned MI by setting ClientId to the identity's client ID; leave it empty for system-assigned.

DefaultAzureCredential

Use DefaultAzureCredential to share a single configuration across local dev and Azure-hosted environments:

{
  "Quilt4Net": {
    "ApplicationInsights": {
      "WorkspaceId": "your-workspace-id",
      "AuthMode": "DefaultAzureCredential"
    }
  }
}

The chained credential probes (in order): environment variables → workload identity → Managed Identity → Visual Studio / VS Code account → Azure CLI (az login) → Azure PowerShell. The first that succeeds is used.

Typical setup:

• Local development: developer runs az login once. The toolkit picks up that token and queries the workspace directly — no service principal secret to copy into user-secrets.
• Azure: the App Service identity is used (same effect as ManagedIdentity). Grant it Log Analytics Reader as above.

TenantId and ClientId are forwarded as hints (filter to a specific tenant; prefer a specific user-assigned MI) — both can be left empty.

Trade-off: DefaultAzureCredential masks which underlying credential succeeded. If authentication fails, the error chain is less specific than the explicit modes. For diagnosis, switch to ClientSecret or ManagedIdentity to isolate the issue.

Universal telemetry identity

AddQuilt4NetLogging() configures OpenTelemetry resource attributes and registers two BaseProcessors — one for LogRecord, one for Activity — that copy a fixed set of identity attributes onto every per-record Properties bag. Works for all app types; the Azure Monitor exporter forwards the per-record attributes into customDimensions, where KQL can read them.

var builder = WebApplication.CreateBuilder(args);

builder.AddQuilt4NetLogging();

Five attributes attached to every AppTrace, AppException, AppRequest (and outbound AppDependency):

Override via callback or appsettings.json:

builder.AddQuilt4NetLogging(o =>
{
    o.ApplicationName = "florida-server";
    o.Version = "2.0.0";
    o.Environment = "Production";
    o.MonitorName = "florida";
});

{
  "Quilt4Net": {
    "Logging": {
      "ApplicationName": "florida-server",
      "Version": "2.0.0",
      "Environment": "Production",
      "MonitorName": "florida"
    }
  }
}

AddQuilt4NetLogging() returns a Quilt4NetLoggingBuilder that extension packages can chain off. Quilt4Net.Toolkit.Api adds .AddHttpRequestLogging() to enable HTTP request/response middleware including the X-Correlation-ID propagation scope:

builder.AddQuilt4NetLogging()
    .AddHttpRequestLogging();

When Quilt4Net.Toolkit.Api's CorrelationIdMiddleware is active, every ILogger call inside a request also picks up customDimensions["CorrelationId"] automatically — see the Api package README.

Measure extensions

Extension methods on ILogger to measure and log execution time.

// Measure synchronous work
_logger.Measure("ProcessOrder", () =>
{
    // work to measure
});

// Measure async work with result
var result = await _logger.MeasureAsync("FetchData", async () =>
{
    return await _repository.GetDataAsync();
});

// Log a count
_logger.Count("ItemsProcessed", items.Length);

Logging attributes

Control HTTP request/response logging on endpoints.

[Logging(RequestBody = true, ResponseBody = false)]
public async Task<IActionResult> StreamData() { ... }

[LoggingStream] // Shorthand for ResponseBody = false
public async Task<IActionResult> StreamEvents() { ... }

Configuration

All options can be set via code or appsettings.json. Code takes priority.

{
  "Quilt4Net": {
    "ApiKey": "YOUR_API_KEY_HERE",
    "HealthClient": {
      "HealthAddress": "https://my-service.example.com/api/Health/"
    },
    "ApplicationInsights": {
      "TenantId": "your-tenant-id",
      "WorkspaceId": "your-workspace-id",
      "ClientId": "your-client-id",
      "ClientSecret": "your-client-secret",
      "AuthMode": "ClientSecret"
    },
    "RemoteConfiguration": {
      "Ttl": "00:10:00"
    },
    "Content": {
      "Application": "MyApp"
    }
  }
}