Mostlylucid.Ephemeral.Patterns.SignalLogWatcher 1.7.1

Mostlylucid.Ephemeral.Patterns.SignalLogWatcher

🚨🚨 WARNING 🚨🚨 - Though in the 1.x range of version THINGS WILL STILL BREAK. This is the lab for developing this concept when stabilized it'll becoe the first styloflow release 🚨🚨🚨

Watches a SignalSink for matching signals and triggers callbacks. Useful for error monitoring and alerting.

dotnet add package mostlylucid.ephemeral.patterns.signallogwatcher

Quick Start

using Mostlylucid.Ephemeral.Patterns.SignalLogWatcher;

var sink = new SignalSink();

await using var watcher = new SignalLogWatcher(
    sink,
    evt => Console.WriteLine($"Error: {evt.Signal}"),
    pattern: "error.*",
    pollInterval: TimeSpan.FromMilliseconds(100));

// When any signal matching "error.*" appears, the callback fires
// Automatically deduplicates to avoid repeated callbacks for same signal

All Options

new SignalLogWatcher(
    // Required: signal sink to watch
    sink: signalSink,

    // Required: callback when matching signal found
    onMatch: evt => HandleSignal(evt),

    // Glob pattern to match signals
    // Default: "error.*"
    pattern: "error.*",

    // How often to poll the sink
    // Default: 200ms
    pollInterval: TimeSpan.FromMilliseconds(200)
)

API Reference

// Constructor starts watching immediately
var watcher = new SignalLogWatcher(sink, callback, pattern, pollInterval);

// Dispose to stop watching
await watcher.DisposeAsync();

How It Works

SignalSink: [error.db] [info.request] [error.api] [error.api] [warn.memory]
                │                           │           │
                ▼                           ▼           │
            Callback                    Callback        │
                                                        ▼
                                                  (deduplicated)

Poll every 200ms:
  - Get all signals from sink
  - Match against pattern "error.*"
  - Fire callback for NEW matches only
  - Track seen signals to prevent duplicates

Example: Error Alerting

var sink = new SignalSink();

await using var watcher = new SignalLogWatcher(
    sink,
    async evt =>
    {
        await alertService.SendSlackAlert(
            $"Error detected: {evt.Signal}",
            $"Operation: {evt.OperationId}, Time: {evt.Timestamp}");
    },
    pattern: "error.*",
    pollInterval: TimeSpan.FromSeconds(1));

// All error signals trigger alerts
sink.Raise("error.database.connection");
sink.Raise("error.api.timeout");

Attribute-driven alert jobs

[EphemeralJobs(SignalPrefix = "error")]
public sealed class ErrorAlertJobs
{
    private readonly IAlertService _alerts;

    public ErrorAlertJobs(IAlertService alerts) => _alerts = alerts;

    [EphemeralJob(".*", Lane = "alerts", MaxConcurrency = 2)]
    public Task NotifyAsync(SignalEvent evt, CancellationToken ct)
    {
        return _alerts.SendAlertAsync(
            $"Captured {evt.Signal}",
            $"Op {evt.OperationId} @ {evt.Timestamp}",
            ct);
    }
}

var sink = new SignalSink();
await using var runner = new EphemeralSignalJobRunner(sink, new[] { new ErrorAlertJobs(alertService) });
sink.Raise("error.database.connection");

Handlers created from the attribute package see the same signal stream, but the wiring lives right next to the logic that responds to error.* patterns.

Example: Multiple Watchers

var sink = new SignalSink();

// Watch for errors
await using var errorWatcher = new SignalLogWatcher(
    sink,
    evt => logger.LogError("Error signal: {Signal}", evt.Signal),
    pattern: "error.*");

// Watch for performance issues
await using var perfWatcher = new SignalLogWatcher(
    sink,
    evt => metrics.RecordSlowOperation(evt.Signal),
    pattern: "perf.slow.*");

// Watch for security events
await using var securityWatcher = new SignalLogWatcher(
    sink,
    evt => securityLog.Record(evt),
    pattern: "security.*",
    pollInterval: TimeSpan.FromMilliseconds(50));  // Fast polling for security

Example: With Coordinator

var sink = new SignalSink();

await using var coordinator = new EphemeralWorkCoordinator<Request>(
    async (req, ct) =>
    {
        try
        {
            await ProcessRequest(req, ct);
        }
        catch (Exception ex)
        {
            sink.Raise($"error.request.{ex.GetType().Name}");
            throw;
        }
    },
    new EphemeralOptions { Signals = sink });

await using var watcher = new SignalLogWatcher(
    sink,
    evt => Console.WriteLine($"Request failed: {evt.Signal}"),
    pattern: "error.request.*");

// Process requests - errors automatically logged
foreach (var req in requests)
    await coordinator.EnqueueAsync(req);

Related Packages

License

Unlicense (public domain)