Ефемерні сигнали - Перетворення атомів у сенсорну мережу (Українська (Ukrainian))

Ефемерні сигнали - Перетворення атомів у сенсорну мережу

Friday, 12 December 2025

//

21 minute read

Невеликий примітив, який перетворює одночасну роботу на координовану адаптивну систему

"Ефемерні сигнали

В Частина 1 ми створили ефемерний виконання - обмежений МSK1 приватний МSK2 власний - очищуючи асинкові робочі потоки Частина 2 ми перетворили її на відновлювану бібліотеку з координаторами, ключеві трубиM SK1 і інтеграцією DI.

Ця стаття додає одну маленьку функцію, яка змінює все: сигнали.

NUGET!!!

Тепер це також є у mostlylucid.ephemerals Nuget пакеті більше, ніж 20 переважно зрозумілийM SK1нефемеральні шаблони і МSK2атоми.

NuGet Ліцензія

Źródлі

Полний код є в mostlylucid.atoms - база GitHub

Сигнальна інфраструктура живе в:

Файл МSK1 Замір МSK2
Сигнали.cs SignalEvent, SignalRetractedEvent, SignalPropagation, SignalConstraints, SignalSink, ISignalEmitter, AsyncSignalProcessor
Ефемерна операція.cs Сигналове випромінювання та відхилення від операцій МSK1
ЕфемерніOptions.cs СигналM SK1реактивна конфігурація (CancelOnSignals, DeferOnSignals, OnSignal, OnSignalRetracted)
StringPatternMatcher.cs GlobM SK1поєднання шаблонів для обробки сигналу
Сигнальний диспетчер.cs Асинкельне маршрутизування сигналу з співпадінням шаблонів *, ?, комаві перелікиM SK1 детермінативний порядок)
Примери/SignalingHttpClient.cs пробний штраф - вивільнення сигналу для HTTP дзвінків МSK2
Ось приклади/AdaptiveTranslationService.cs Пристосовальне обмеження швидкості з сигналомM SK1на основі відхилення МSK2
Приклади/SignalBasedCircuitBreaker.cs Окно для odczytу efeмерного сигналу з розривника схеми МSK1
Приклади/TelemetrySignalHandler.cs Асинхове оброблення сигналу з інтеграцією телеметрії

Проблема: Самотні атоми

Наші efeмерні координатори чудові у обробці інформації, але вони ізольовані. Кожен координатор знає про свої власні операції, але не знає, що відбувається в іншій частині системи.

// Translation coordinator has no idea that...
await translationCoordinator.EnqueueAsync(request);

// ...the API just hit a rate limit
// ...another service is experiencing backpressure
// ...a downstream dependency is slow

Ми могли б підключити explicit dependencies ,, але це створює з 'єднання. Що ми хочемо усвідомлення навколишнього середовища - координатори, які можуть відчувати навколишнє середовище без безпосереднього зв 'язку

Сигнали дають атомам виконання залишити сліди в їх оповільненому вікні.

  • " Цей API просто ставиться -limited МSK2
  • " Цей użytkownik не впорався
  • " Операція братів і сестер ще чекає на шлюзі

Координатори можуть змінювати свою поведінку на основі сигналів, які вони бачать у своєму вікні.


Рішення: Сигнали на операційні

Від Сигнали.cs:

public readonly record struct SignalEvent(
    string Signal,
    long OperationId,
    string? Key,
    DateTimeOffset Timestamp,
    SignalPropagation? Propagation = null)
{
    public int Depth => Propagation?.Depth ?? 0;
    public bool WouldCycle(string signal) => Propagation?.Contains(signal) == true;
    public bool Is(string name) => Signal == name;
    public bool StartsWith(string prefix) => Signal.StartsWith(prefix, StringComparison.Ordinal);
}

Операція може піднімати сигнали під час виконання. Ці сигнали живуть в efeмерному вікні поруч з операцієюM SK1 Коли операція застаріла, сигнали йдуть з неюMSC3

Це так. МСК0 - це воно. МSK1 - Ніяких брокерів повідомлень. М СК2 - Ніякої окремої інфраструктури. М АК3 - Тільки строки, прив 'язані до операцій.

Через те, що сигнали живуть всередині efeмерного вікна, вони успадковуються його гарантіями: 1) обмежена розміром 2) автоматичне старіння 3) нульовий життєвий цикл


Закони швидкого сигналу

Закон 1 - Сигнали ніколи не підштовхують виконання

Сигнал , сам по собі МSK1 не спричиняє виконання Він записує лише факти в efeмерному вікні. Нічого не відбувається, тому що видається сигнал.

Закон 2 МSK1 Посилання є зрозумілим , локальний МSK3 і fakultаційним

Якщо координатор визначає OnSignal handler, він працює синхронно, коли видається сигнал M SK1 але тільки тому, що координатор вирішив його приєднати Emitters do not know or care. Викреслення всіх обладначів залишає ядро без змін.

Закон 3 МSK1 Сигнали локальні для атому

Сигнал прикріплений лише до атому, який його виробляв. Жоден сигнал ніколи не мутує чи аннотує інший атом. Не існує спільних записних автобусів.

Закон МSK0 - Сигнали прикріпленіM SK2Только факти

Виведення сигналу додає факту до історії атома Сигнали ніколи не обновляються чи перезаписуються. Приtraction видаляє лише власні сигнали emitenta’

Закон 5 МSK1 Сигнал має обмежену поверхню і час - Лімитований

Сигнали існують лише в повільненому вікні koordinatора’ Вони закінчуються автоматично, коли вікно застаріє. Нічого не залишиться, якщо ви не будуєте стійкості.

Закон МSK0 - Обстежники читаютьM SK2 Вони не пишуть

Коли координатор “ перевіряє сигнали на ключі K, він сканує

атоми в його вікні

і сигнали локальних для цих атомів Обсерватори ніколи не змінюють стан сигналу атома

Закон 7 МSK1 Припадок МSK2 Подібне поведінку - це шар , Не Primітив

Якщо ви хочете, щоб сигнали керували асинтичними робочими потоками, ви повинні використовуватиM SK1

Сигнальний диспетчер

АсинховийProcessor

або інші адаптери.

Це опціональні шари, збудовані на основі сигналів, не є частиною їх семантикиM SK1

Закон МSK0 - Ніяких перетинів МSK2 Атомна мутация під будь-якими обставинами

Жоден атом не може змінювати сигнали snapshot, estadoM SK1, , або метадані іншого атому. координація відбувається через:

  • сигнали

  • сприйняття

  • вікна

  • політики

Не через записи.

Закон МSK0 - Глобальні погляди приходять з-під МSK2 Ніколи не змінюється

З 'єднана поверхня SignalSink або зграя - може показати об' єднане зображення сигналів — але він завжди читається

Закон 10 МSK1 Виведення мандрівників дає одну і ту ж основну систему

Якщо всі обладначі (OnSignal, диспетчериM SK2 процесори ) відокремлені система залишається повністю правильною і передбачуваною. Сигнали все ще мають значення, тому що це факти.

Найкраще аналогія: ПейзажиМSK1 Не інструкції

Мероприяти як телефонний дзвінок

МСК0 Я МSK1 я зараз дзвоню вам МКС2 підійти і реагувати МСС3

Сигнал як сліди в снігу

" Я залишила сліди, МSK1 Якщо ви хочете знати, куди я пішла МSK2 погляньте, . Якщо вам не байдуже ' не зверніть на це уваги

Ось чому сигнали ніколи не розбиваються, ніколи не блокуютьсяM SK1 і ніколи не взаємодіють з контрольним потоком, якщо ви вибирати для опитування.

Що це видаляє

Різниця має значення, тому що сигнали eliminують

Проблема МSK1 Небезпеку мають події МSK2 Сигнали уникати
Подключення МSK1 видавець МSK2 абоненти Ніхто ХМSK4
Залежність від часу МSK1 Потрібна безпосередня реакція МSK2 Об 'єднання , підбір, коли він готовий
Ручки зворотнього зв 'язку
Семантика впорядкування
Гарантії доставки МSK1 Доставляти МSK2 обходитися Без dostawи СМС4 просто існувати СМС5
Поширення помилки Порушення оператора поширюються
Загрози реінтернації МSK1 Поширені МSK2 Неможливі
Каскадовані невдачі Один обладнатель не вдач МSK2 розрив ланцюга МSK3 Ніхто не здатен розбити ланчу \

Швидка порівняння

Функція МSK1 Событки МSK2 Сигнали
МSK0 Складання Сильне МSK2 видавець → абоненти MSК4 МСК5 Ніхто MSК6
Планування МSK1 Непосереднє МSK2 Об 'єктивне
Доставка МSK1 Гарантована МSK2 спробований Жодна доставка
Реакція МSK1 Потрібна МSK2 Неопціональна
Перевантаження даних МSK1 Часто важкі МSK2 Невеликі метадані струн
Утримка МSK1 Нічого МSK2 Sliding LRUM SK3style window
Тривалість життя
Неможливі режими МSK1 Багато МSK2 Майже жодного

Різниця у коді

Підход до подій (классичнийM SK1

public event Action RateLimited;

try
{
    await CallApiAsync();
}
catch (RateLimitException)
{
    RateLimited?.Invoke(); // Makes someone else act right now
}

Проблеми:

  • Хто реагує?
  • У якому порядку?
  • Що робити, якщо два обладначі зіштовхуються?
  • Що робити, якщо оператор кидає?
  • Що, якщо це неправильний час?
  • Що робити, якщо викликатель не хоче такої поведінки?

Сигналовий підхід (ефемеральнийM SK1

try
{
    await CallApiAsync(ct);
}
catch (RateLimitException ex)
{
    op.Signal($"rate-limit:{ex.RetryAfterMs}ms");
    throw;
}

Тут нічого не відбувається МСК0 Пізніше МSK1 десь зовсім по-іншому

if (translator.HasSignal("rate-limit"))
{
    await Task.Delay(1000);   // Act when *we* choose
}

Примітки:

  • Немає прямого підключення
  • Ніяких неочікуваних дзвінків
  • Жодного стрибка для виконання
  • Ніяких зворотньих дзвінків
  • Ні krzyżа-незвичность потоку
  • Тільки тоді, коли ми запитати подивитися

Лінія "AhaM SK1

Kontrolа передачі подій. Контекст передачі сигналівM SK1

Це - весь ментальний модель у одній реченні.

Що насправді є сигналами

В залежності від вашого походження:

МSK0 Аудиторія визначення МSK2
Системні мисливці Стигмергічний субстрат для непрямої координації МSK1
Інженери Мягкі метадані, прикріплені до операцій у замкнутому слизному вікні
PL/ Конкуренційні нерви Непередбачувана МSK1 темпорна табличка, в парі з замкнутою семантикою співпадіння
Корпоративні користувачі поверхню в стані очистки, яку ви можете задати в будь-який момент

Сигнали - це сліди, що залишилися в об 'єднаній поверхні пам' яті. стикмергічний модель координації - одна й та сама система, яку використовують мурахи , одна і та сама панель, яку використовували в ранньому штучний інтелект


Як це порівнює з іншими підходами

Дослідження застосування / OpenTelemetry

using var activity = source.StartActivity("ProcessOrder");
activity?.SetTag("order.id", orderId);
activity?.SetTag("rate.limited", true);

Найкраще для: Расподібне відстежування по всіх службах , довге M SK2 довгострокове зберігання телеметрії МSK3 кореляційні идентификації .

Використовуйте телеметрію, коли: Потрібно відстежувати запити у різних службах , зберігати метрики для аналізу

Використовуйте efeмерні сигнали, коли: Потрібна реакція на реактивну координаціюM SK3 або не потрібна ' непотрібна телеметрична інфраструктура

Реактивні розширення (RxM SK1

var rateLimits = Observable.FromEventPattern<RateLimitEventArgs>(
    h => api.RateLimitHit += h,
    h => api.RateLimitHit -= h);

rateLimits
    .Throttle(TimeSpan.FromSeconds(1))
    .Subscribe(e => HandleRateLimit(e));

Найкраще для: Kompleksне оброблення подій , час МSK2 операцій на основі МSK3 поєднання кількох потоків подій

Використовуйте Rx коли: Вам потрібні складні часові пошуки.

Використовуйте efeмерні сигнали, коли: Ви хочете простіше голосування - на основі сенсорного зондування

Обіцянки MediatR

public class RateLimitNotification : INotification
{
    public int RetryAfterMs { get; init; }
}

await _mediator.Publish(new RateLimitNotification { RetryAfterMs = 5000 });

Найкраще для: Відокремлений уM SK1розробці подій з багатьма обладнателями.

Використовуйте MediatR коли: Ви хочете, щоб багато обладників реагували на одне й те ж подія синхронно

Використовуйте efeмерні сигнали, коли: Ви хочете відчути навколишнє середовище без прямого підпису , самосвідомлення МSK2 історія очистки M SK3 або інтеграція з обмеженим виконанням .

Розривник ланцюга Polly

var circuitBreaker = Policy
    .Handle<HttpRequestException>()
    .CircuitBreakerAsync(5, TimeSpan.FromSeconds(30));

Найкраще для: Здатність реагувати на особисті дзвінки з автоматичним управлінням станом

Використовуйте Поллі, коли: Потрібно на один МSK1реsiliентність дзвінків з автоматизованою половиною МSK2открита /зачинена транзиція

Використовуйте efeмерні сигнали, коли: Ви хочете, щоб навколишнє усвідомлення проживало впродовж багатьох операцій , на замовлення логіка схеми МSK2 або інтеграція з відстеженням руху M SK3

Об 'єднати їх: Використовуйте Polly всередині вашого робочого тіла

តារាង порівняння

Погляньмо на це МSK1 Самовідбору МSK2 Чиття Освітнє сприйняття
Відкрита телеметрія
Реактивні розширення
MediatR МSK1 МSK2
Маршрутний переломник Поллі МSK1 МSK2 \❌ МSK5 ❌ \ \ МSK8 \ Спілотно з МSK10 \ Спілом з МСК11
Ефемеральні сигнали МSK0 ✅ ♫ ♫ ♫

Піднімання і відхилення сигналів

Втілення операцій ISignalEmitter:

public interface ISignalEmitter
{
    // Emit signals
    void Emit(string signal);
    bool EmitCaused(string signal, SignalPropagation? cause);

    // Retract (remove) signals
    bool Retract(string signal);
    int RetractMatching(string pattern);
    bool HasSignal(string signal);

    long OperationId { get; }
    string? Key { get; }
}

Всередині робочого тіла:

await coordinator.ProcessAsync(async (item, op, ct) =>
{
    try
    {
        var result = await CallExternalApiAsync(item, ct);

        if (result.WasCached)
            op.Signal("cache-hit");

        if (result.Duration > TimeSpan.FromSeconds(2))
            op.Signal("slow-response");
    }
    catch (RateLimitException ex)
    {
        op.Signal("rate-limit");
        op.Signal($"rate-limit:{ex.RetryAfterMs}ms");
        throw;
    }
    catch (TimeoutException)
    {
        op.Signal("timeout");
        throw;
    }
});

Сигнали - просто стрічки. Використовуйте просте ім 'я M SK1"rate-limit") або структуровані назви МSK1"rate-limit:5000ms"). Фильтры візерунок використовують семантику glob (*, ?) і ті, що підтримують список ком ("error.*,timeout"). Matching deterministic and allocation -light via StringPatternMatcher.

Чудово-Приклад вичерпаного сигналу: HTTP дзвінки

Для дуже детальної спостереження, ви можете випромінювати сигнали на кожному етапі операціїM SK1 Бібліотека містить зразок СигналуванняHttpClient що демонструє цю модель:

using Mostlylucid.Helpers.Ephemeral.Examples;

// Inside your work body where you have access to the operation's emitter:
await coordinator.ProcessAsync(async (request, op, ct) =>
{
    var data = await SignalingHttpClient.DownloadWithSignalsAsync(
        httpClient,
        new HttpRequestMessage(HttpMethod.Get, request.Url),
        op,  // ISignalEmitter
        ct);

    // Process the downloaded data...
});

Це випромінює сигнали на кожному етапі:

Сигнал МSK1 Коли
stage.starting Перед тим, як почати запрошувати МSK1
progress:0 Початкова позначка прогресу
stage.request HTTP-запрос відправлен
stage.headers Отримали заголовки відповідей
stage.reading Почато читати тіло МSK1
progress:XX Процент прогресу МSK1 під час завантаження
stage.completed Закінчено завантаження МSK1

Тоді ви можете задати їх із співпадінням шаблонів:

// Find all stage transitions
var stages = coordinator.GetSignalsByPattern("stage.*");

// Check download progress
var progress = coordinator.GetSignalsByPattern("progress:*");

// Check if any download is still in progress
if (coordinator.HasSignalMatching("stage.reading") &&
    !coordinator.HasSignalMatching("stage.completed"))
{
    // Download in progress
}

Перетягування сигналів

Операції також можуть видалити власні сигнали. Це корисно для тимчасових станівM SK1

await coordinator.ProcessAsync(async (item, op, ct) =>
{
    // Mark as processing
    op.Emit("processing");

    try
    {
        await ProcessItemAsync(item, ct);

        // Success - retract the processing signal
        op.Retract("processing");
        op.Emit("completed");
    }
    catch (RetryableException)
    {
        // Keep processing signal, add retry info
        op.Emit("retrying");
    }
    catch (Exception)
    {
        // Remove all temporary signals
        op.RetractMatching("processing*");
        op.Emit("failed");
        throw;
    }
});

Відхилення від подій

Так само, як і викиди сигналу, можуть викликати зворотний дзвінокM SK1

var coordinator = new EphemeralWorkCoordinator<Request>(
    body,
    new EphemeralOptions
    {
        // Sync retraction handler
        OnSignalRetracted = evt =>
        {
            _metrics.DecrementGauge(evt.Signal);
            Console.WriteLine($"Signal {evt.Signal} retracted from op {evt.OperationId}");

            if (evt.WasPatternMatch)
                Console.WriteLine($"  (matched pattern: {evt.Pattern})");
        },

        // Async retraction handler
        OnSignalRetractedAsync = async (evt, ct) =>
        {
            await _telemetry.TrackRetraction(evt.Signal, evt.OperationId, ct);
        }
    });

І SignalRetractedEvent включно:

  • Signal - Назва зворотнього сигналу
  • OperationId - Операція, яка його відкинула
  • Key - Операція
  • Timestamp - Коли відбулося відхилення
  • WasPatternMatch - Справді, якщо повернемося через RetractMatching
  • Pattern - Pattern, який використовували

Реальний - Світовий приклад МSK1 Обновлення Limit Rate Recovery

await coordinator.ProcessAsync(async (request, op, ct) =>
{
    // Check if we already have a rate limit signal
    if (op.HasSignal("rate-limited"))
    {
        // We're in recovery mode
        await Task.Delay(1000, ct);
    }

    try
    {
        var response = await _api.SendAsync(request, ct);

        // Success! Remove any rate limit signal
        if (op.Retract("rate-limited"))
        {
            op.Emit("rate-limit-cleared");
        }
    }
    catch (RateLimitException ex)
    {
        op.Emit("rate-limited");
        op.Emit($"rate-limit:{ex.RetryAfterMs}ms");
        throw;
    }
});

Відчуття сигналів

Усі координатори забезпечують оптимізоване просування сигналу:

// Check if any recent operation hit a rate limit
if (coordinator.HasSignal("rate-limit"))
{
    await Task.Delay(1000);
}

// Count slow responses in the window
var slowCount = coordinator.CountSignals("slow-response");
if (slowCount > 10)
{
    await ThrottleAsync();
}

// Get signals by pattern
var httpErrors = coordinator.GetSignalsByPattern("http.error.*");

// Get signals since a time
var recentSignals = coordinator.GetSignalsSince(DateTimeOffset.UtcNow.AddMinutes(-1));

// Get signals for a specific key
var userSignals = coordinator.GetSignalsByKey("user-123");

Сигнель-Реактивне оброблення

Від ЕфемерніOptions.cs:

Координатори можуть автоматично реагувати на сигнали:

var coordinator = new EphemeralWorkCoordinator<Request>(
    body,
    new EphemeralOptions
    {
        // Cancel new work if these signals are present
        CancelOnSignals = new HashSet<string> { "system-overload", "circuit-open" },

        // Defer new work while these signals are present
        DeferOnSignals = new HashSet<string> { "rate-limit" },
        MaxDeferAttempts = 10,
        DeferCheckInterval = TimeSpan.FromMilliseconds(100)
    });

Коли сигнал в CancelOnSignals відкриється, нові деталі пропущені M SK1 підраховані як непотрібні ). Коли сигнал в DeferOnSignals з 'являється, нові речі чекають, поки сигнал не очиститьсяM SK1


Реальний - Світовий приклад МSK1 Ограничення адаптивної швидкості

Від Адаптивна служба перекладу.cs:

public class AdaptiveTranslationService : IAsyncDisposable
{
    private readonly EphemeralWorkCoordinator<TranslationRequest> _coordinator;
    private readonly ITranslationApi _translationApi;

    public AdaptiveTranslationService(ITranslationApi translationApi)
    {
        _translationApi = translationApi;

        _coordinator = new EphemeralWorkCoordinator<TranslationRequest>(
            ProcessTranslationAsync,
            new EphemeralOptions
            {
                MaxConcurrency = 8,
                MaxTrackedOperations = 100,

                // New work is deferred while any "rate-limit" or "rate-limit:*" signal is present
                DeferOnSignals = new HashSet<string> { "rate-limit", "rate-limit:*" },
                MaxDeferAttempts = 10,
                DeferCheckInterval = TimeSpan.FromMilliseconds(100)
            });
    }

    public async Task TranslateAsync(TranslationRequest request)
    {
        // Optional: extra politeness based on most recent retry-after
        var rateLimitSignals = _coordinator.GetSignalsByPattern("rate-limit:*");
        if (rateLimitSignals.Count > 0)
        {
            var latest = rateLimitSignals
                .OrderByDescending(s => s.Timestamp)
                .First()
                .Signal; // "rate-limit:5000ms"

            if (TryParseRetryAfter(latest, out var delay))
            {
                await Task.Delay(delay);
            }
        }

        await _coordinator.EnqueueAsync(request);
    }

    public static bool TryParseRetryAfter(string signal, out TimeSpan delay)
    {
        delay = default;
        var parts = signal.Split(':', 2);
        if (parts.Length != 2) return false;

        var payload = parts[1].Trim();
        if (!payload.EndsWith("ms", StringComparison.OrdinalIgnoreCase)) return false;

        var numPart = payload[..^2];
        if (!int.TryParse(numPart, out var ms) || ms < 0) return false;

        delay = TimeSpan.FromMilliseconds(ms);
        return true;
    }
}

Кожна інстанція цього сервісу автоматично відключається, коли зазнають обмеження тарифу. Немає спільного стануM SK1 Нема інформації, що проходить через . Просто читаємо ефемерне вікно.


Реальність МСК0 Світовий приклад МSK1 Крест - Усвідомлення koordinatora

Багато координаторів можуть відчувати один одного через спільний SignalSink:

public class OrderProcessingSystem
{
    private readonly SignalSink _sharedSignals = new(maxCapacity: 1000);

    private readonly EphemeralWorkCoordinator<Order> _orderProcessor;
    private readonly EphemeralWorkCoordinator<PaymentRequest> _paymentProcessor;

    public OrderProcessingSystem()
    {
        var options = new EphemeralOptions { Signals = _sharedSignals };

        _orderProcessor = new EphemeralWorkCoordinator<Order>(
            ProcessOrderAsync, options);

        _paymentProcessor = new EphemeralWorkCoordinator<PaymentRequest>(
            ProcessPaymentAsync, options);
    }

    public async Task ProcessOrderAsync(Order order)
    {
        // Check shared signals for payment gateway issues
        if (_sharedSignals.Detect("gateway-error"))
        {
            await _retryQueue.EnqueueAsync(order);
            return;
        }

        await _orderProcessor.EnqueueAsync(order);
    }
}

Реальність- Світовий прикладM SK1 Охрана здоров 'я

[HttpGet("/health/detailed")]
public IActionResult GetDetailedHealth()
{
    return Ok(new
    {
        translation = new
        {
            pending = _translationCoordinator.PendingCount,
            active = _translationCoordinator.ActiveCount,
            recentRateLimits = _translationCoordinator.CountSignals("rate-limit"),
            recentTimeouts = _translationCoordinator.CountSignals("timeout"),
            recentSuccess = _translationCoordinator.CountSignals("success"),
            hasErrors = _translationCoordinator.HasSignalMatching("error.*")
        },
        payment = new
        {
            pending = _paymentCoordinator.PendingCount,
            gatewayErrors = _paymentCoordinator.CountSignals("gateway-error"),
            declines = _paymentCoordinator.CountSignals("declined"),
            approvals = _paymentCoordinator.CountSignals("approved")
        }
    });
}

Немає ніякої метрикної бібліотеки. Просто запитуйте efeмерне вікно.


Реальний МСК0 Світовий приклад МSK1 Сигнал - Похилення схем на основі

Від СигнальнийBasedCircuitBreaker.cs:

public class SignalBasedCircuitBreaker
{
    private readonly string _failureSignal;
    private readonly int _threshold;
    private readonly TimeSpan _windowSize;

    public SignalBasedCircuitBreaker(
        string failureSignal = "failure",
        int threshold = 5,
        TimeSpan? windowSize = null)
    {
        _failureSignal = failureSignal;
        _threshold = threshold;
        _windowSize = windowSize ?? TimeSpan.FromSeconds(30);
    }

    public bool IsOpen<T>(EphemeralWorkCoordinator<T> coordinator)
    {
        var recentFailures = coordinator.GetSignalsSince(
            DateTimeOffset.UtcNow - _windowSize);

        return recentFailures.Count(s => s.Signal == _failureSignal) >= _threshold;
    }

    public int GetFailureCount<T>(EphemeralWorkCoordinator<T> coordinator)
    {
        var recentFailures = coordinator.GetSignalsSince(
            DateTimeOffset.UtcNow - _windowSize);

        return recentFailures.Count(s => s.Signal == _failureSignal);
    }
}

// Usage
var circuitBreaker = new SignalBasedCircuitBreaker("api-error", threshold: 3);

if (circuitBreaker.IsOpen(_coordinator))
{
    throw new CircuitOpenException("Too many recent API errors");
}

await _coordinator.EnqueueAsync(request);

Маршрутний розривник не має власного стану. - він просто читає ефемерне вікно


Сигнальні обмеження: Захищають нескінченні ланцюги

Від Сигнали.cs:

Коли сигнали можуть викликати інші сигнали, ви ризикуєте нескінченними ланцюгамиM SK1 SignalConstraints запобігає цьому:

var options = new EphemeralOptions
{
    SignalConstraints = new SignalConstraints
    {
        // Max propagation depth before blocking
        MaxDepth = 10,

        // Prevent A → B → A cycles
        BlockCycles = true,

        // Signals that end propagation chains
        TerminalSignals = new HashSet<string> { "completed", "failed", "resolved" },

        // Signals that emit but don't propagate
        LeafSignals = new HashSet<string> { "logged", "metric" },

        // Callback when a signal is blocked
        OnBlocked = (signal, reason) =>
        {
            _logger.LogWarning("Signal {Signal} blocked: {Reason}",
                signal.Signal, reason);
        }
    }
};

Пропагування сигналів

Прослідкувати причинно-наслідковий зв 'язок з EmitCaused:

public void HandleSignal(SignalEvent evt, ISignalEmitter emitter)
{
    if (evt.Is("order-placed"))
    {
        // This signal carries the propagation chain
        // Will be blocked if it would create a cycle
        emitter.EmitCaused("inventory-reserved", evt.Propagation);
    }
}

Проекційна ланцюга відслідковує шлях: order-placed → inventory-reserved → ...

Якщо inventory-reserved намагався випромінювати order-placed, він був би блокований


Глобальний сигналний простір

Від Сигнали.cs:

Для сигналів, які мають бути видимими між координаторами:

public sealed class SignalSink
{
    private readonly ConcurrentQueue<SignalEvent> _window;
    private readonly int _maxCapacity;
    private readonly TimeSpan _maxAge;

    public SignalSink(int maxCapacity = 1000, TimeSpan? maxAge = null);

    // Raise signals
    public void Raise(SignalEvent signal);
    public void Raise(string signal, string? key = null);

    // Sense signals
    public IReadOnlyList<SignalEvent> Sense();
    public IReadOnlyList<SignalEvent> Sense(Func<SignalEvent, bool> predicate);
    public bool Detect(string signalName);
    public bool Detect(Func<SignalEvent, bool> predicate);

    public int Count { get; }
}

Використовування:

// Create a shared sink
var sink = new SignalSink(maxCapacity: 1000, maxAge: TimeSpan.FromMinutes(2));

// Configure coordinators to use it
var options = new EphemeralOptions { Signals = sink };

// Or raise signals directly
sink.Raise("system-maintenance");

// Sense from anywhere
if (sink.Detect("system-maintenance"))
{
    await DeferWorkAsync();
}

Pattern Matching with StringPatternMatcher

Від StringPatternMatcher.cs:

Glob-поєднання стилю для обробки сигналуM SK1

// Exact match
coordinator.HasSignal("rate-limit");

// Wildcard patterns
coordinator.HasSignalMatching("http.*");           // http.timeout, http.error
coordinator.HasSignalMatching("error.*.critical"); // error.payment.critical
coordinator.HasSignalMatching("user-???-failed");  // user-123-failed

// Comma-separated patterns in CancelOnSignals/DeferOnSignals
new EphemeralOptions
{
    CancelOnSignals = new HashSet<string>
    {
        "system-overload, circuit-open",  // Either pattern
        "error.*"                          // Any error signal
    }
}

Конвенції про назву сигналів

Залишити сигнали простими і послідовними:

// Good - simple, categorical
op.Signal("success");
op.Signal("failure");
op.Signal("rate-limit");
op.Signal("timeout");
op.Signal("cache-hit");

// Good - structured for parsing
op.Signal("rate-limit:5000ms");
op.Signal("retry:attempt-3");
op.Signal("slow:2500ms");
op.Signal("http.error:429");

// Good - hierarchical for pattern matching
op.Signal("payment.declined");
op.Signal("payment.approved");
op.Signal("payment.gateway-error");

// Avoid - entity identification belongs in Key, not signals
op.Signal("user-123-rate-limited");  // Bad

// Instead
op.Key = "user-123";
op.Signal("rate-limit");

Рухування сигналом асинку

Синхронні обладначі сигналів (OnSignal) запускає операцію ' стрічку МSK2 підтримує їх швидко M SK3 для того, щоб зробити I/OM SK5 об 'єднану роботу MSC6 вентиляторні сигнали в асинк-путі з SignalDispatcher ( співпадіння візерунки , детермінативний порядок МSK2 або AsyncSignalProcessor.

СигналDispatcher вентилятор

await using var dispatcher = new SignalDispatcher(new EphemeralOptions
{
    MaxConcurrency = Environment.ProcessorCount,
    MaxConcurrencyPerKey = 1  // sequential per signal name by default
});

dispatcher.Register("error.*", evt => _alerts.SendAsync(evt.Signal));
dispatcher.Register("progress:*", evt => _metrics.Record(evt.Signal));

// In coordinator options, keep OnSignal cheap and enqueue
var coordinator = new EphemeralWorkCoordinator<Request>(
    body,
    new EphemeralOptions
    {
        OnSignal = dispatcher.Dispatch
    });

Patterns підтримують *, ?, і список кома ("error.*,timeout"). Усі handlerи, що відповідають за співпадіння, запускаються в порядку rejestracji на фоновому координаторі з кількома кнопками

АсинховийProcessor

Для автономної асинкальної обробки:

await using var processor = new AsyncSignalProcessor(
    async (signal, ct) =>
    {
        await _externalService.LogAsync(signal, ct);
    },
    maxConcurrency: 4,
    maxQueueSize: 1000);

// Enqueue signals (returns immediately)
processor.Enqueue(new SignalEvent(
    "rate-limit",
    operationId,
    key,
    DateTimeOffset.UtcNow));

Ось приклад оператора телеметрії

Це повний приклад об 'єднання асинкового обробки сигналів з інтеграцією телеметрії:

Источник: Оператор сигналів телеметрії.cs

public class TelemetrySignalHandler : IAsyncDisposable
{
    private readonly AsyncSignalProcessor _processor;
    private readonly ITelemetryClient _telemetry;

    public TelemetrySignalHandler(ITelemetryClient telemetry)
    {
        _telemetry = telemetry;
        _processor = new AsyncSignalProcessor(
            HandleSignalAsync,
            maxConcurrency: 8,
            maxQueueSize: 5000);
    }

    // Synchronous entry point - returns immediately
    public bool OnSignal(SignalEvent signal) => _processor.Enqueue(signal);

    private async Task HandleSignalAsync(SignalEvent signal, CancellationToken ct)
    {
        var properties = new Dictionary<string, string>
        {
            ["signal"] = signal.Signal,
            ["operationId"] = signal.OperationId.ToString(),
            ["key"] = signal.Key ?? "none"
        };

        await _telemetry.TrackEventAsync("EphemeralSignal", properties, ct);

        // Categorized tracking based on signal prefix
        if (signal.StartsWith("error"))
            await _telemetry.TrackExceptionAsync(signal.Signal, properties, ct);
        else if (signal.StartsWith("perf"))
            await _telemetry.TrackMetricAsync(signal.Signal, 1, ct);
    }

    // Expose stats for monitoring
    public int QueuedCount => _processor.QueuedCount;
    public long ProcessedCount => _processor.ProcessedCount;
    public long DroppedCount => _processor.DroppedCount;

    public async ValueTask DisposeAsync() => await _processor.DisposeAsync();
}

Спроводіть його до вашого координатора:

await using var telemetryHandler = new TelemetrySignalHandler(telemetryClient);

await using var coordinator = new EphemeralWorkCoordinator<Request>(
    ProcessAsync,
    new EphemeralOptions
    {
        OnSignal = signal => telemetryHandler.OnSignal(signal)
    });

Рухівник:

  • Ніколи не блокує операційний поток - OnSignal повертається негайно
  • Категорізує сигнали за допомогою префикса для різних типів телеметрії
  • Виявляє метрики ( заквасованаM SK1 перероблена , відкинута МSK3 для моніторингу здоров 'я
  • Пам 'ять - кидає старіші сигнали, якщо черга заповнюється

Чому це працює?

Сигнали сильні, тому що вони efeмерний:

МSK0 Недвижимость Дохід
Обмежена Чи може МSK1 не рости безмежно МSK2 старі сигнали старіють
Само očiszczenie Ніяких кодів для очистки не потрібно
Від 'єднані Вказівники не знаютьM SK1 не знаю про слухачів
Дослідження Будь-який код може відчути те, що відбувається зараз.
Особисто Ніяких даних про користувача - лише назви сигналів МSK2
Найшвидше OM SK1 розпізнавання з коротким -обертанням МSK3

Ефемерне вікно вже є для розв 'язання проблем. Сигнали просто дають йому семантичне значення


Завершення

Сигнали перетворюють ізольовані атоми виконання в сенсорна мережа. Кожен координатор може

  • Утворити сигнали про те, що він пережив
  • Свідомість сигнали з власної історії або спільних раковин
  • Відреагувати автоматично через CancelOnSignals і DeferOnSignals

Жодного брокера повідомлень. Жодної спільної ситуаціїM SK1 Жоден протоколу координації. Лише операції з метаданками, які природньо зруйнуються .

Атоми не спілкуються між собою безпосередньо, вони просто залишають сліди в efeмерному вікні, який інші можуть спостерігати.

Світло... СигнельM SK1 Свідомість ... Забудьте.


Ліки

Finding related posts...
logo

© 2026 Scott Galloway — Unlicense — All content and source code on this site is free to use, copy, modify, and sell.