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

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

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

<!--category-- ASP.NET, Architecture, Systems Design, Async -->
<datetime class="hidden">2025-12-12T16:00</datetime>

В **[Частина 1](/blog/fire-and-dont-quite-forget-ephemeral-execution)** ми створили ефемерний виконання - обмежений МSK1 приватний МSK2 власний - очищуючи асинкові робочі потоки **[Частина 2](/blog/ephemeral-execution-library)** ми перетворили її на відновлювану бібліотеку з координаторами, ключеві трубиM SK1 і інтеграцією DI.

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

## NUGET!!!

Тепер це також є у mostlylucid.ephemerals Nuget пакеті [більше, ніж 20 переважно зрозумілийM SK1нефемеральні шаблони і МSK2атоми](https://www.nuget.org/packages?q=mostlylucid.ephemeral&includeComputedFrameworks=true&prerel=true&sortby=created-desc).

[![NuGet](https://img.shields.io/nuget/v/mostlylucid.ephemeral.svg)](https://www.nuget.org/packages/mostlylucid.ephemeral)
[![Ліцензія](https://img.shields.io/badge/license-Unlicense-blue.svg)](../../UNLICENSE)

## Źródлі

Полний код є в [mostlylucid.atoms - база GitHub](https://github.com/scottgal/mostlylucid.atoms)

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

| Файл МSK1 Замір МSK2
|------|---------|
| [Сигнали.cs](https://github.com/scottgal/mostlylucidweb/blob/main/Mostlylucid/Helpers/Ephemeral/Signals.cs) | `SignalEvent`, `SignalRetractedEvent`, `SignalPropagation`, `SignalConstraints`, `SignalSink`, `ISignalEmitter`, `AsyncSignalProcessor` |
| [Ефемерна операція.cs](https://github.com/scottgal/mostlylucidweb/blob/main/Mostlylucid/Helpers/Ephemeral/EphemeralOperation.cs) | Сигналове випромінювання та відхилення від операцій МSK1
| [ЕфемерніOptions.cs](https://github.com/scottgal/mostlylucidweb/blob/main/Mostlylucid/Helpers/Ephemeral/EphemeralOptions.cs) | СигналM SK1реактивна конфігурація (`CancelOnSignals`, `DeferOnSignals`, `OnSignal`, `OnSignalRetracted`) |
| [StringPatternMatcher.cs](https://github.com/scottgal/mostlylucidweb/blob/main/Mostlylucid/Helpers/Ephemeral/StringPatternMatcher.cs) | GlobM SK1поєднання шаблонів для обробки сигналу |
| [Сигнальний диспетчер.cs](https://github.com/scottgal/mostlylucidweb/blob/main/Mostlylucid/Helpers/Ephemeral/SignalDispatcher.cs) | Асинкельне маршрутизування сигналу з співпадінням шаблонів `*`, `?`, комаві перелікиM SK1 детермінативний порядок) |
| [Примери/SignalingHttpClient.cs](https://github.com/scottgal/mostlylucidweb/blob/main/Mostlylucid/Helpers/Ephemeral/Examples/SignalingHttpClient.cs) | пробний штраф - вивільнення сигналу для HTTP дзвінків МSK2
| [Ось приклади/AdaptiveTranslationService.cs](https://github.com/scottgal/mostlylucidweb/blob/main/Mostlylucid/Helpers/Ephemeral/Examples/AdaptiveTranslationService.cs) | Пристосовальне обмеження швидкості з сигналомM SK1на основі відхилення МSK2
| [Приклади/SignalBasedCircuitBreaker.cs](https://github.com/scottgal/mostlylucidweb/blob/main/Mostlylucid/Helpers/Ephemeral/Examples/SignalBasedCircuitBreaker.cs) | Окно для odczytу efeмерного сигналу з розривника схеми МSK1
| [Приклади/TelemetrySignalHandler.cs](https://github.com/scottgal/mostlylucidweb/blob/main/Mostlylucid/Helpers/Ephemeral/Examples/TelemetrySignalHandler.cs) | Асинхове оброблення сигналу з інтеграцією телеметрії

[TOC]

---


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

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

```csharp
// 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](https://github.com/scottgal/mostlylucidweb/blob/main/Mostlylucid/Helpers/Ephemeral/Signals.cs):

```csharp
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**

```csharp
public event Action RateLimited;

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

Проблеми:

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

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

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

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

```csharp
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

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

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

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

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

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

```csharp
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

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

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

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

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

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

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

```csharp
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`:

```csharp
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; }
}
```

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

```csharp
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](https://github.com/scottgal/mostlylucidweb/blob/main/Mostlylucid/Helpers/Ephemeral/Examples/SignalingHttpClient.cs) що демонструє цю модель:

```csharp
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

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

```csharp
// 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

```csharp
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

```csharp
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

```csharp
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;
    }
});
```

---


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

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

```csharp
// 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](https://github.com/scottgal/mostlylucidweb/blob/main/Mostlylucid/Helpers/Ephemeral/EphemeralOptions.cs):

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

```csharp
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](https://github.com/scottgal/mostlylucidweb/blob/main/Mostlylucid/Helpers/Ephemeral/Examples/AdaptiveTranslationService.cs):

```csharp
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`:

```csharp
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 Охрана здоров 'я

```csharp
[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](https://github.com/scottgal/mostlylucidweb/blob/main/Mostlylucid/Helpers/Ephemeral/Examples/SignalBasedCircuitBreaker.cs):

```csharp
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](https://github.com/scottgal/mostlylucidweb/blob/main/Mostlylucid/Helpers/Ephemeral/Signals.cs):

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

```csharp
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`:

```csharp
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](https://github.com/scottgal/mostlylucidweb/blob/main/Mostlylucid/Helpers/Ephemeral/Signals.cs):

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

```csharp
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; }
}
```

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

```csharp
// 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](https://github.com/scottgal/mostlylucidweb/blob/main/Mostlylucid/Helpers/Ephemeral/StringPatternMatcher.cs):

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

```csharp
// 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
    }
}
```

---


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

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

```csharp
// 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 вентилятор

```csharp
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

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

```csharp
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](https://github.com/scottgal/mostlylucidweb/blob/main/Mostlylucid/Helpers/Ephemeral/Examples/TelemetrySignalHandler.cs)

```csharp
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();
}
```

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

```csharp
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 Свідомість ... Забудьте.**

---


## Ліки

- [Частина 1: Огонь і ДонM SK1t *Досить* Забудьте](/blog/fire-and-dont-quite-forget-ephemeral-execution) - теорія і модель
- [Частина 2: Збудувати поновлювану ефемеральну бібліотеку для виконання](/blog/ephemeral-execution-library) - повне втілення
- [Стикмергія ( ВікіпедіяM SK1](https://en.wikipedia.org/wiki/Stigmergy) - опосередкова координація через зміну середовища
- [схема розривника](https://learn.microsoft.com/en-us/azure/architecture/patterns/circuit-breaker)
- [Реактивні розширення](https://github.com/dotnet/reactive)