10. Event-Stream-Listener

Wird an den Veranstaltungskanal (Hafen 10020) und gibt Systemereignisse aus, wobei eine Filterung nach Schweregrad, Namensmuster und Ausschlüssen möglich ist. Nur-Lese-Modus – kein Sitzungsprofil, keine Befehle werden gesendet.

Was Sie lernen werden:

• Abonnieren Sie den Ereignisse WebSocket (Hafen 10020) als passiver Beobachter
• Parsen Ereignis-JSON — level, name, category, data, message
• Nach minimalem Schweregrad filtern
• Übereinstimmung und Ausschluss von Namen mit Platzhaltern
• Verwenden Sie dieses Tutorial, um den Regelkreis im Vergleich zu anderen Tutorials zu bewerten

Arbeitsablauf

1. CLI-Flags auswerten (--level, --name, --exclude, --no-hide-rate, --port).
2. Verbinden mit ws://localhost:10020 (der Veranstaltungskanal) – Es wird kein Sitzungsprofil gesendet, da es sich um einen schreibgeschützten Beobachter handelt.
3. Für jede eingehende Nachricht das Ereignis-JSON analysieren und Filter anwenden:
   • Lass los, wenn level liegt unterhalb der Mindestschwere.
   • Wenn --name Wenn Muster angegeben sind, werden diese verworfen, sofern keines davon übereinstimmt (entweder mit name allein oder category/name).
   • Falls --exclude Muster passt, verwerfen.
4. Erfolgreiche Ereignisse mit ihrer Stufe, ihrem qualifizierten Namen, einer optionalen Meldung und optional data Nutzlast.

Parameter

Flagge	Standard	Zweck
--port	10020	Anschluss für den Ereigniskanal
-l, --level	info	Mindestschweregrad – einer von info, notice, warning, error, critical, panic
-n, --name	(keine)	Nur Ereignisse anzeigen, die dem Muster entsprechen (Glob, wiederholbar)
-x, --exclude	(keine)	Ereignisse ausblenden, die dem Muster entsprechen (Glob, wiederholbar)
--no-hide-rate	false	Einfügen system-rate-report Ereignisse (standardmäßig ausgeblendet – sehr störend)

Den Regelkreis einer Vergleichsmessung unterziehen

Führen Sie ein beliebiges Tutorial (04-hello-floor, 05-position-control, 06-combined...) in einem Terminal aus, und den Ereignis-Listener mit --no-hide-rate in einem anderen. Das system-rate-report Das Ereignis umfasst die effektive Taktfrequenz des Geräts – vergleichen Sie die Python-, C++-nlohmann- und C++-Glaze-Varianten desselben Tutorials, um den Serialisierungs-Overhead bei einem Regelkreis mit ca. 4 kHz zu beobachten.

# Terminal 1 — pick a variant
./04-haply-inverse-hello-floor          # C++ nlohmann
./04-haply-inverse-hello-floor-glz      # C++ Glaze
python 04-haply-inverse-hello-floor.py  # Python

# Terminal 2 — watch the rate
./10-haply-inverse-events --no-hide-rate

Statusfelder gelesen

Jede eingehende Nachricht ist ein einzelnes Ereignis:

• level — Schweregrad der Zeichenfolge (info ... panic)
• name — Name der Veranstaltung (z. B. device-connected, system-rate-report)
• category — Kategorie (z. B. device, session, system)
• message — optionaler, für Menschen lesbarer String
• data — optionale verschachtelte JSON-Daten (die Struktur hängt vom Ereignis ab)

Vollständiger Veranstaltungskatalog: Veranstaltungen & Überwachung.

Senden / Empfangen

Nur passives Abonnement recv() wird verwendet; es wird nichts zurückgesendet. Alle drei Varianten implementieren dieselbe Filter-Pipeline; der interessante, für die Inverse-API spezifische Teil ist die Struktur der Ereignisstruktur.

Python

async for msg in websocket ist die kürzeste Form der reinen Empfangsschleife.

async with websockets.connect(uri) as websocket:
    async for msg in websocket:
        try:
            event = json.loads(msg)
        except json.JSONDecodeError:
            continue

        if accept_event(event, min_level_index, name_patterns, exclude_patterns):
            print(format_event(event))

C++ (nlohmann)

libhv-Callback-Modell — onmessage wird im E/A-Thread ausgeführt; der Hauptthread wird bei ENTER blockiert. Ereignisse werden als typfreies JSON behandelt – jedes Feld wird über .value(...) mit einem Zahlungsausfall.

ws.onmessage = [&](const std::string &msg) {
    json event;
    try { event = json::parse(msg); } catch (...) { return; }
    if (accept_event(event, opts.min_level, opts.name_patterns, opts.exclude_patterns))
        print_event(event);
};
ws.open("ws://localhost:10020");
while (std::cin.get() != '\n') {}  // block main thread

C++ (Glaze)

Die bekannten Ereignis-Felder werden einem typisierten event_data Struktur. Die data Das Feld bleibt unverändert glz::raw_json_view So können beliebig verschachtelte Payloads (die vom Ereignis abhängen) unverändert weitergeleitet werden, ohne dass ein vollständiges Schema definiert werden muss.

// Struct model — known fields typed, nested `data` kept as raw JSON
struct event_data {
    std::string level;
    std::string name;
    std::string category;
    std::string message;
    glz::raw_json_view data{};
};

// Send / receive
ws.onmessage = [&](const std::string &msg) {
    event_data event{};
    if (glz::read<glz_settings>(event, msg)) return;  // drop malformed
    if (accept_event(event, opts.min_level, opts.name_patterns, opts.exclude_patterns))
        print_event(event);
};
ws.open("ws://localhost:10020");
while (std::cin.get() != '\n') {}  // block main thread

Quelle: Python · C++ · C++ Glaze

Verwandte Themen: Ereignisse & Überwachung · WebSocket-Protokoll