Ефемерні сигнали - Перетворення атомів у сенсорну мережу
Невеликий примітив, який перетворює одночасну роботу на координовану адаптивну систему
"Ефемерні сигнали
В Частина 1 ми створили ефемерний виконання - обмежений МSK1 приватний МSK2 власний - очищуючи асинкові робочі потоки Частина 2 ми перетворили її на відновлювану бібліотеку з координаторами, ключеві трубиM SK1 і інтеграцією DI.
Ця стаття додає одну маленьку функцію, яка змінює все: сигнали.
NUGET!!!
Тепер це також є у mostlylucid.ephemerals Nuget пакеті більше, ніж 20 переважно зрозумілийM SK1нефемеральні шаблони і МSK2атоми.
Ź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- Справді, якщо повернемося черезRetractMatchingPattern- 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
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 Свідомість ... Забудьте.
Ліки
- Частина 1: Огонь і ДонM SK1t Досить Забудьте - теорія і модель
- Частина 2: Збудувати поновлювану ефемеральну бібліотеку для виконання - повне втілення
- Стикмергія ( ВікіпедіяM SK1 - опосередкова координація через зміну середовища
- схема розривника
- Реактивні розширення