Interlace 1.0.0

Interlace

Interlace is a .NET library that eliminates hand-written observability code. You annotate your service interfaces with attributes, and at compile time Interlace generates the spans, metrics, wide events, and audit trails that would otherwise take dozens of lines per method.

[Observed(Layer = ObservabilityLayer.Service)]
public interface IOrderService
{
    [Metric(Name = "orders_placed", Type = MetricType.Counter)]
    [Audited(EventType = "OrderPlaced", CaptureResult = true)]
    Task<Order> PlaceOrderAsync(
        [CorrelationId] string orderId,
        [SpanAttribute(Name = "order.sku")] string sku,
        int quantity,
        [Sensitive] string paymentToken,
        CancellationToken ct = default);
}

Your implementation stays pure business logic:

public sealed class OrderService(IOrderRepository repository, IPricingService pricing) : IOrderService
{
    public async Task<Order> PlaceOrderAsync(string orderId, string sku, int quantity, string paymentToken, CancellationToken ct)
    {
        decimal unitPrice = await pricing.GetPriceAsync(sku, ct);
        Order order = new(orderId, sku, quantity, unitPrice);
        return await repository.InsertAsync(order, ct);
    }
}

From this single interface, Interlace generates interceptors that emit spans, operation/success/failure counters, a duration histogram, the custom orders_placed counter, an OrderPlaced audit event, wide event logs, and correlation context — with paymentToken excluded from every signal.

<details> <summary>Table of Contents</summary>

• Requirements
• Getting Started
• Packages
• Attributes
• Documentation
• Contributing
• License

</details>

Requirements

• .NET 10 SDK or later (C# 14 required for interceptor support)
• An OpenTelemetry exporter package (e.g. OpenTelemetry.Exporter.Console for local development)

Getting Started

1. Add package references:

<ItemGroup>
  <PackageReference Include="Interlace" Version="1.0.0" />
  <PackageReference Include="Interlace.Analyzers" Version="1.0.0" PrivateAssets="all" />

  
  
  
</ItemGroup>

2. Add this to your .csproj or Directory.Build.props:

<PropertyGroup>
  <TelemetryAutoConfigureNamespace>true</TelemetryAutoConfigureNamespace>
</PropertyGroup>

This lets Interlace wire up the generated code automatically. See configuration for additional MSBuild properties.

3. Register runtime services in Program.cs:

using Interlace.Registration;

// Initializes the ActivitySource and Meter that generated interceptors use to emit spans and metrics.
// The names you choose here are how OpenTelemetry identifies which signals to collect —
// they must match what you pass to AddSource/AddMeter on the OTel side.
builder.Services.AddInterlace(options =>
{
    options.ActivitySourceName = "MyApp.Telemetry";
    options.MeterName = "MyApp.Telemetry";
});

// Optional: wire up OpenTelemetry exporters (uncomment the packages in step 1 first)
// builder.Services.AddOpenTelemetry()
//     .WithTracing(t => t.AddSource("MyApp.Telemetry").AddConsoleExporter())
//     .WithMetrics(m => m.AddMeter("MyApp.Telemetry").AddConsoleExporter());

4. Annotate your interfaces:

using Interlace.Annotations.Attributes;

[Observed(Layer = ObservabilityLayer.Service)]
public interface IOrderService
{
    Task PlaceOrderAsync(
        string orderId,
        [SpanAttribute(Name = "order.sku")] string sku,
        int quantity,
        CancellationToken ct = default);
}

Every call to IOrderService.PlaceOrderAsync through DI now gets a span, metrics, and wide events — regardless of which class implements it.

For a complete walkthrough see the getting started guide.

Packages

Attributes

Documentation

Contributing

See CONTRIBUTING.md for development setup, build commands, and testing instructions.

License

See LICENSE for details.