इवेंट

जॉब चलते समय जो कुछ भी होता है — रन के चरण, मॉनिटर के संदेश, बर्स्ट की संख्याएँ, इंस्पेक्टर के फ़्रेम, जॉब का अंत — वह एक इवेंट के रूप में भेजा जाता है। ब्राउज़र में सर्वर का पेज उन्हें एक WebSocket, /api/events पर पाता है; स्क्रिप्ट उसी सॉकेट पर सुन सकती है। डेस्कटॉप ऐप वही इवेंट, उन्हीं नामों और पेलोड के साथ, ऐप के भीतर पाता है।

सर्वर पर /api/events को एक WebSocket खोलें:

bash

websocat -H "Authorization: Bearer $TOKEN" ws://127.0.0.1:1430/api/events

प्रमाणीकरण API के बाकी हिस्से जैसा है: Authorization: Bearer के रूप में टोकन, या ब्राउज़र का सेशन कुकी। इसके बिना अपग्रेड 401 auth.required के साथ अस्वीकार हो जाता है।
Origin: जो क्लाइंट Origin हेडर भेजता है उसे सर्वर का अपना भेजना चाहिए (हॉस्ट और पोर्ट Host के बराबर), वरना अपग्रेड 403 auth.origin के साथ अस्वीकार हो जाता है। ब्राउज़र के बाहर की ज़्यादातर WebSocket लाइब्रेरी कोई नहीं भेजतीं।
हर इवेंट हर क्लाइंट को। सब्सक्राइब करने को कुछ नहीं है: हर सॉकेट हर जॉब का हर इवेंट पाता है, चाहे उसे किसी ने भी शुरू किया हो। जो चाहिए उसे event से, और पेलोड में job_id से चुनें।
केवल सुनें। क्लाइंट जो भेजता है सर्वर उसे नज़रअंदाज़ करता है, बंद करने के सिवा; 64 KiB से बड़ा संदेश सॉकेट बंद कर देता है।
कीप-अलाइव। सर्वर हर 20 s में पिंग करता है, इसलिए शांत सॉकेट प्रॉक्सी के आर-पार खुला रहता है। सर्वर बंद होने पर हर सॉकेट बंद कर देता है।
कुछ दोहराया नहीं जाता। जब क्लाइंट जुड़ा नहीं था तब भेजे गए इवेंट उसके लिए खो जाते हैं। जो क्लाइंट फिर जुड़ता है उसे मौजूदा हाल कमांड से पढ़ना चाहिए (jobs_list, inspect_snapshot, emulator_exchanges…)।
पीछे रह जाना। एक सॉकेट के लिए अधिकतम 4096 इवेंट प्रतीक्षा करते हैं। जो क्लाइंट इससे और पीछे रह जाता है, उसे server://lagged मिलता है, यह बताते हुए कि कितने छूटे।

संदेश का रूप

हर इवेंट एक JSON ऑब्जेक्ट रखने वाला एक टेक्स्ट संदेश है:

json

{ "event": "scan://open", "payload": { "job_id": 9, "ts": 1759600000123, "port": 8080, "banner": null } }

फ़ील्ड	यह क्या है
`event`	चैनल, नीचे
`payload`	इवेंट के मान; उसका रूप चैनल पर निर्भर है

समय (ts, किसी पीयर के first_ms और last_ms) 1970 से मिलीसेकंड में हैं; विलंब और दूसरी अवधियाँ (*_latency_ms, p50_ms…, ms) मिलीसेकंड में। पेलोड में त्रुटियाँ EngineError ऑब्जेक्ट हैं; उनके कोड त्रुटि संदेश में सूचीबद्ध हैं।

चैनल

चैनल	कौन भेजता है	कब
`experiment://step`	एक रन	चरण शुरू होता है, पास होता है, विफल होता है, दोबारा प्रयास करता है, दोहराता है या लोड बताता है
`experiment://ended`	एक रन	एक बार, जब रन अपने आप समाप्त होता है
`job://ended`	हर जॉब	एक बार, जब जॉब अपने आप समाप्त होता है या विफल होता है
`osc://message`	OSC मॉनिटर	हर पैकेट
`osc://gen-tick`	OSC जनरेटर	हर संदेश, या 60 संदेश प्रति सेकंड से ऊपर 30 से 45 बार प्रति सेकंड
`http://burst-progress`	HTTP बर्स्ट	हर 100 ms, और अंत में
`ws://state`	WebSocket कनेक्शन	जुड़ा, बंद
`ws://messages`	WebSocket कनेक्शन	हर 100 ms, जब कुछ नया हो
`mqtt://state`	MQTT कनेक्शन	जुड़ा, सब्सक्राइब किया, बंद
`mqtt://messages`	MQTT कनेक्शन	हर 100 ms, जब कुछ नया हो
`mqtt://ack`	MQTT कनेक्शन	QoS 1/2 पब्लिश पूरी हुई; अनसब्सक्राइब का जवाब आया
`broadcast://emit-stat`	बीकन	हर 250 ms, और अंत में
`broadcast://peers`	डिस्कवरी लिसनर	हर 400 ms
`netsim://stat`	इम्पेयरमेंट रिले	हर 250 ms
`storm://stat`	स्टॉर्म	हर 250 ms, और अंत में
`scan://open`	स्कैनर	हर खुला पोर्ट
`scan://progress`	स्कैनर	लगभग रेंज के हर 1 % पर, और अंत में
`emulator://activity`	एमुलेटर जॉब	हर 200 ms, जब कुछ नया हो
`inspect://batch`	इंस्पेक्टर	नए फ़्रेम के साथ हर 120 ms, शांत रहने पर लगभग सेकंड में एक बार, जब तक कैप्चर चालू हो
`server://lagged`	सर्वर	कोई क्लाइंट पीछे रह गया

`experiment://step`

रन का एक चरण: नोड का शुरू होना, पास होना, विफल होना, दोबारा प्रयास की प्रतीक्षा, दोहराना, या लोड की प्रगति बताना। /api/run से शुरू किया रन अपने जवाब पर वही चरण भेजता है (देखें रन)।

फ़ील्ड	प्रकार	अर्थ
`job_id`	संख्या	रन का जॉब
`ts`	संख्या	कब
`node_id`	स्ट्रिंग	नोड
`state`	स्ट्रिंग	`running`, `passed`, `failed`, `retry` (कोई प्रयास विफल हुआ और चरण रुकने के बाद फिर चलता है), `repeating` (दोहराने वाली क्रिया की प्रगति, अधिकतम सेकंड में एक बार) या `load` (लोड की प्रगति, अधिकतम सेकंड में एक बार)
`detail`	स्ट्रिंग	क्या हुआ, अंग्रेज़ी में; `running` और `failed` के लिए ख़ाली (देखें `error`)
`message_key`	स्ट्रिंग या null	उसके लिए इंटरफ़ेस का टेक्स्ट, उसकी डिक्शनरी की कुंजी के रूप में
`message_params`	ऑब्जेक्ट या null	वे मान जिनका नाम `message_key` देता है
`vars`	ऑब्जेक्ट	चरण द्वारा लिखे वेरिएबल; न हों तो छोड़ दिए जाते हैं
`error`	`EngineError`	यह क्यों विफल हुआ, या प्रयास क्यों विफल हुआ (`retry`); वरना छोड़ दिया जाता है
`frame`	संख्या	जिस संदेश से किसी प्रतीक्षा (या भेजाव के अपेक्षित जवाब) का मेल हुआ, उसका इंस्पेक्टर फ़्रेम, जब कैप्चर चालू था; वरना छोड़ दिया जाता है
`load`	ऑब्जेक्ट	लोड ने क्या मापा, उसकी थ्रेशोल्ड पढ़ी गईं — लोड चरण के अंतिम इवेंट पर, पास या विफल; वरना छोड़ दिया जाता है। देखें लोड

रन का अंत नोड running दिखाता है जब पहली शाखा उस तक पहुँचती है, और passed जब हर शाखा बिना विफलता के समाप्त हो जाती है। सीक्रेट मान हर फ़ील्ड में मास्क होते हैं।

`experiment://ended`

रन अपने आप समाप्त हुआ: पास हुआ, विफल हुआ या समय समाप्त हो गया। job://ended पर वही पेलोड आने के ठीक बाद भेजा जाता है। job_stop या सभी रोकें से रोका गया रन न यह भेजता है न कोई रिपोर्ट सहेजता है।

फ़ील्ड	प्रकार	अर्थ
`job_id`	संख्या	रन का जॉब
`kind`	स्ट्रिंग	`experiment`
`seed`	संख्या	सीड जिसके साथ यह चला
`profile`	स्ट्रिंग या null	इसका प्रोफ़ाइल
`overridden`	बूलियन	कुछ पैरामीटर मान इसके साथ चलाएँ… या `overrides` से आए
`error`	`EngineError` या null	रन की पहली विफलता; पास होने पर null
`report_path`	स्ट्रिंग या null	इसकी रिपोर्ट, डेटा फ़ोल्डर के `runs/` में
`report_error`	`EngineError` या null	रिपोर्ट क्यों नहीं लिखी जा सकी

`job://ended`

जॉब अपने आप समाप्त हुआ या विफल हुआ। job_stop या jobs_stop_all से रोका गया जॉब इसे नहीं भेजता।

फ़ील्ड	प्रकार	अर्थ
`job_id`	संख्या	जॉब
`kind`	स्ट्रिंग	`osc-monitor`, `osc-gen`, `http-burst`, `netsim`, `storm`, `scan`, `beacon`, `discovery`, `mqtt`, `websocket`, `emulator` या `experiment`
`error`	`EngineError` या null	कुछ ग़लत होने पर यह क्यों समाप्त हुआ

रन का job://ended experiment://ended के फ़ील्ड भी ले जाता है। हर तरह को क्या समाप्त करता है:

`kind`	कब समाप्त होता है	`error`
`osc-monitor`	सॉकेट अब प्राप्त नहीं कर सकता	`wait.receive_failed`
`osc-gen`	इसकी अवधि ख़त्म, या कोई भेजाव विफल	null, या `transport.*`
`http-burst`	इसका कुल या अवधि पूरी	null
`storm`	इसकी अवधि ख़त्म	null
`scan`	रेंज का हर पोर्ट आज़माया गया	null
`beacon`	इसके राउंड या अवधि ख़त्म, या 32 से ज़्यादा भेजाव विफल हुए और कोई नहीं गया	null, या `transport.*`
`discovery`	सॉकेट अब प्राप्त नहीं कर सकता	`wait.receive_failed`
`mqtt`	ब्रोकर ने कनेक्शन बंद किया या वह खो गया	`transport.*` (`transport.reset` जब ब्रोकर ने इसे बंद किया), या `mqtt.protocol`
`websocket`	कनेक्शन बंद हुआ	null, या यह क्यों खोया
`netsim`	रिले अब काम नहीं कर सकता	क्यों
`emulator`	इसका सॉकेट विफल होता है	क्यों
`experiment`	रन समाप्त होता है	रन की विफलता, या null

`osc://message`

OSC मॉनिटर को मिला एक UDP पैकेट, डिकोड किया हुआ। हर पैकेट के लिए भेजा जाता है, बिना बैच के।

फ़ील्ड	प्रकार	अर्थ
`job_id`	संख्या	मॉनिटर का जॉब
`ts`	संख्या	यह कब आया
`from`	स्ट्रिंग	भेजने वाला, `IP:port`
`bytes`	संख्या	पैकेट का आकार
`messages`	ऑब्जेक्ट[]	पैकेट का हर संदेश (बंडल में कई होते हैं): `address` और `args` (`OscArg[]`)
`error`	`EngineError` या null	जब पैकेट डिकोड नहीं हुआ तो `osc.packet_malformed` (तब `messages` ख़ाली होता है)

`osc://gen-tick`

OSC जनरेटर की प्रगति: 60 संदेश प्रति सेकंड से नीचे हर संदेश के लिए; उससे ऊपर हर n-वें के लिए, जहाँ n दर को 30 से भाग देकर नीचे की ओर पूर्णांकित करने पर मिलता है — सेकंड में 30 से 45 बार।

फ़ील्ड	प्रकार	अर्थ
`job_id`	संख्या	जनरेटर का जॉब
`ts`	संख्या	कब
`value`	संख्या	अभी भेजा गया मान, इससे पहले कि उसे पूर्णांक या 32-bit float में पूर्णांकित किया जाए
`sent`	संख्या	अब तक भेजे संदेश

`http://burst-progress`

HTTP बर्स्ट की संख्याएँ, चलते समय हर 100 ms, और अपने आप समाप्त होने पर done: true के साथ एक बार और।

फ़ील्ड	प्रकार	अर्थ
`job_id`	संख्या	बर्स्ट का जॉब
`ts`	संख्या	कब
`sent`	संख्या	अब तक जवाब पाई या विफल रिक्वेस्ट
`ok`	संख्या	उनमें से 2xx स्टेटस के साथ जवाब पाई
`failed`	संख्या	उनमें से कोई दूसरा स्टेटस या कोई जवाब नहीं
`missed`	संख्या	पेस्ड बर्स्ट की वे रिक्वेस्ट जो ख़ाली वर्कर के लिए बहुत देर प्रतीक्षा करके छोड़ दी गईं
`rps`	संख्या	पिछले 100 ms में रिक्वेस्ट प्रति सेकंड; अंतिम इवेंट में पूरे बर्स्ट पर
`last_latency_ms`, `min_latency_ms`, `max_latency_ms`, `avg_latency_ms`	संख्या	अब तक के विलंब
`p50_ms`, `p90_ms`, `p95_ms`, `p99_ms`	संख्या	अब तक की हर रिक्वेस्ट के प्रतिशतक, विफलताओं समेत, 0.5 % के भीतर
`done`	बूलियन	बर्स्ट का अंतिम इवेंट

`ws://state`

ws_connect से खोला गया WebSocket कनेक्शन जुड़ा, या बंद हुआ। जिस कनेक्शन का जॉब रोका गया, वह closed नहीं भेजता।

फ़ील्ड	प्रकार	अर्थ
`job_id`	संख्या	कनेक्शन का जॉब
`ts`	संख्या	कब
`state`	स्ट्रिंग	`connected` या `closed`
`handshake`	ऑब्जेक्ट	`url`, `peer`, `local`, `protocol` (सर्वर द्वारा चुना सबप्रोटोकॉल, या null) और `ms` (कनेक्ट होना और अपग्रेड)
`closed`	ऑब्जेक्ट या null	`closed` के साथ: `code`, `reason`, `by` (`client`, `server` या `lost`) और `error`

`ws://messages`

पिछले इवेंट के बाद WebSocket कनेक्शन ने क्या भेजा और पाया, हर 100 ms जब कुछ हो।

फ़ील्ड	प्रकार	अर्थ
`job_id`	संख्या	कनेक्शन का जॉब
`ts`	संख्या	कब
`messages`	ऑब्जेक्ट[]	क्रम में: `ts`, `dir` (`rx` प्राप्त, `tx` भेजा), `kind` (`text` या `binary`), `text` (पहले 64 KiB UTF-8 के रूप में, बाइनरी संदेश का भी; जो बाइट नहीं हैं वे `�` बन जाते हैं), `hex` (बाइनरी संदेश के पहले 4096 बाइट hex में, वरना null), `bytes` (पूरा आकार) और `truncated` (दिखाए गए से ज़्यादा: टेक्स्ट के 64 KiB से आगे, बाइनरी के 4096 बाइट से आगे)
`dropped`	संख्या	इस इवेंट से छोड़े गए संदेश क्योंकि 2000 से ज़्यादा थे; सबसे पुराने पहले

`mqtt://state`

MQTT कनेक्शन की स्थिति बदली।

फ़ील्ड	प्रकार	अर्थ
`job_id`	संख्या	कनेक्शन का जॉब
`ts`	संख्या	कब
`state`	स्ट्रिंग	`connected`; सब्सक्राइब के हर जवाब के बाद `subscribed`; कनेक्शन समाप्त होने पर `closed` (तब नहीं जब उसका जॉब रोका गया)
`broker`	स्ट्रिंग	`host:port`
`error`	`EngineError` या null	`closed` कनेक्शन क्यों समाप्त हुआ (`transport.reset` जब ब्रोकर ने इसे बंद किया); वरना null
`grants`	ऑब्जेक्ट[]	`subscribed` के साथ: माँगा गया हर फ़िल्टर, `filter`, `qos` (दिया गया) और `accepted` के साथ; वरना ख़ाली

`mqtt://messages`

पिछले इवेंट के बाद MQTT कनेक्शन ने क्या पाया, हर 100 ms जब कुछ हो। दोबारा दिया गया QoS 2 संदेश एक बार दिखाया जाता है।

फ़ील्ड	प्रकार	अर्थ
`job_id`	संख्या	कनेक्शन का जॉब
`ts`	संख्या	कब
`messages`	ऑब्जेक्ट[]	`ts`, `topic`, `payload` (UTF-8 के रूप में; जो बाइट नहीं हैं वे `�` बन जाते हैं), `bytes`, `qos`, `retain`, `dup`
`dropped`	संख्या	संदेश छोड़े गए क्योंकि 100 ms में 4000 से ज़्यादा आए; सबसे पुराने पहले

`mqtt://ack`

ब्रोकर ने वह पूरा किया जो कनेक्शन ने माँगा।

फ़ील्ड	प्रकार	अर्थ
`job_id`	संख्या	कनेक्शन का जॉब
`ts`	संख्या	कब
`kind`	स्ट्रिंग	`published` (QoS 1 या 2 पब्लिश पूरी हुई) या `unsubscribed`
`packet_id`	संख्या	MQTT पैकेट id
`topic`	स्ट्रिंग या null	पब्लिश किया टॉपिक; `unsubscribed` के लिए null

`broadcast://emit-stat`

बीकन के काउंटर, हर 250 ms, और अपने आप समाप्त होने पर pps 0 के साथ एक बार और।

फ़ील्ड	प्रकार	अर्थ
`job_id`	संख्या	बीकन का जॉब
`ts`	संख्या	कब
`targets`	संख्या	हर राउंड में गंतव्य
`rounds`	संख्या	भेजे गए राउंड
`packets`, `bytes`	संख्या	भेजे गए डेटाग्राम और बाइट
`errors`	संख्या	विफल भेजाव
`pps`	संख्या	पिछले 250 ms में डेटाग्राम प्रति सेकंड

`broadcast://peers`

डिस्कवरी लिसनर ने क्या सुना, हर 400 ms।

फ़ील्ड	प्रकार	अर्थ
`job_id`	संख्या	लिसनर का जॉब
`ts`	संख्या	कब
`peers`	ऑब्जेक्ट[]	सबसे हाल में सुना पहले: `addr`, `proto`, `packets`, `bytes`, `first_ms`, `last_ms`, `last_summary`, `responded` (उसके वे पैकेट जिनका जवाब दिया गया, आते ही गिने गए); अधिकतम 512
`packets`, `bytes`	संख्या	जो कुछ प्राप्त हुआ
`responses`	संख्या	भेजे गए जवाब

`netsim://stat`

इम्पेयरमेंट रिले के काउंटर, हर 250 ms। रन के नेटवर्क बाधा नोड के रिले इसके बजाय रन की रिपोर्ट में बताते हैं।

फ़ील्ड	प्रकार	अर्थ
`job_id`	संख्या	रिले का जॉब
`ts`	संख्या	कब
`received`, `forwarded`	संख्या	अंदर और बाहर डेटाग्राम या चंक
`dropped`	संख्या	`loss`, बर्स्ट या `offline` से खोए (UDP; TCP रिले ऑफ़लाइन रहते स्ट्रीम रोके रखता है और कुछ नहीं गिराता)
`throttled`	संख्या	UDP: बैंडविड्थ सीमा से गिराए, या क्योंकि बहुत सारे पहले से रास्ते में थे। TCP: वे चंक जो बैंडविड्थ सीमा के लिए अपनी स्ट्रीम रोके रहे
`duplicated`, `corrupted`, `reordered`	संख्या	प्रोफ़ाइल ने इनके साथ क्या किया
`bytes`	संख्या	आगे भेजे गए बाइट
`connections`, `reset`, `stalled`	संख्या	TCP: लिए गए कनेक्शन, रीसेट किए, हाफ-ओपन छोड़े; 0 रहते छोड़ दिए जाते हैं
`profile`	स्ट्रिंग	जिस प्रोफ़ाइल से यह अब इम्पेयर कर रहा है, जैसे टाइमलाइन उसे नाम देती है: उसका नाम, या यह क्या करता है (`60 ms ±25 · loss 2%`)

`storm://stat`

स्टॉर्म के काउंटर, हर 250 ms, और अपने आप समाप्त होने पर pps तथा mbps 0 के साथ एक बार और।

फ़ील्ड	प्रकार	अर्थ
`job_id`	संख्या	स्टॉर्म का जॉब
`ts`	संख्या	कब
`packets`, `bytes`	संख्या	भेजे गए डेटाग्राम (या TCP कनेक्शन) और बाइट
`errors`	संख्या	विफल भेजाव या कनेक्शन
`pps`	संख्या	पिछले 250 ms में प्रति सेकंड
`mbps`	संख्या	पिछले 250 ms में मेगाबिट प्रति सेकंड

`scan://open`

स्कैनर को एक खुला पोर्ट मिला।

फ़ील्ड	प्रकार	अर्थ
`job_id`	संख्या	स्कैन का जॉब
`ts`	संख्या	कब
`port`	संख्या	पोर्ट
`banner`	स्ट्रिंग या null	सेवा ने सबसे पहले क्या भेजा, जब बैनर माँगे गए और उसने 400 ms के भीतर कुछ कहा

`scan://progress`

स्कैन कितना आगे है: लगभग रेंज के हर 1 % पर, और अपने आप समाप्त होने पर done के total के बराबर होने के साथ (वह एक दो बार आ सकता है)।

फ़ील्ड	प्रकार	अर्थ
`job_id`	संख्या	स्कैन का जॉब
`ts`	संख्या	कब
`done`	संख्या	आज़माए गए पोर्ट
`total`	संख्या	रेंज में पोर्ट
`open`	संख्या	मिले खुले पोर्ट

`emulator://activity`

emulator_start से शुरू किया एमुलेटर पिछले इवेंट के बाद क्या पाया और उसका जवाब दिया, हर 200 ms जब कुछ बदले (कोई आदान-प्रदान, बंद या चालू किया जाना, या कोई संदेश जो MQTT ब्रोकर पहुँचा नहीं सका)। रन के एमुलेटर नोड इसे नहीं भेजते; उनके काउंटर रन की रिपोर्ट में होते हैं।

फ़ील्ड	प्रकार	अर्थ
`job_id`	संख्या	एमुलेटर का जॉब
`ts`	संख्या	कब
`counts`	ऑब्जेक्ट	`total`, `unmatched`, `failed`, `down`, `hits` (प्रति नियम), और `missed` (MQTT; 0 रहते छोड़ दिया जाता है) — `emulator_exchanges` की तरह
`forced`	स्ट्रिंग	जब यह बंद किया गया हो तो `unavailable`, `reset` या `timeout`; वरना छोड़ दिया जाता है
`exchanges`	ऑब्जेक्ट[]	नए आदान-प्रदान, जैसे `emulator_exchanges` उन्हें सूचीबद्ध करता है पर `data` के बिना; अधिकतम 200
`dropped`	संख्या	अंतराल के पहले 200 के बाद के आदान-प्रदान, यहाँ नहीं भेजे गए; `emulator_exchanges` के पास फिर भी अंतिम 500 हैं

`inspect://batch`

नए इंस्पेक्टर फ़्रेम। केवल तब भेजे जाते हैं जब कैप्चर चालू हो: नए फ़्रेम होने पर हर 120 ms, और न होने पर लगभग सेकंड में एक बार, ताकि काउंटर ताज़ा रहें।

फ़ील्ड	प्रकार	अर्थ
`frames`	ऑब्जेक्ट[]	नए फ़्रेम, सबसे पुराने पहले, अधिकतम 250; उनके बाइट के बिना (`inspect_payload` उपयोग करें)
`stats`	ऑब्जेक्ट	कैप्चर के काउंटर, `CaptureStats`
`skipped_now`	संख्या	पिछले बैच के बाद पकड़े गए पर इस बैच में न रहने वाले फ़्रेम — 250 से ज़्यादा आए, या बफ़र ने उन्हें छोड़ दिया। जब तक बफ़र उन्हें रखे है, वे एक्सपोर्ट में फिर भी रहते हैं

`server://lagged`

केवल सर्वर। यह क्लाइंट 4096 से ज़्यादा इवेंट पीछे रह गया और कुछ चूक गया। हाल को कमांड से फिर पढ़ें।

फ़ील्ड	प्रकार	अर्थ
`skipped`	संख्या	यह कितने इवेंट चूका

इवेंट ​

सब्सक्राइब करना ​

संदेश का रूप ​

चैनल ​

experiment://step ​

experiment://ended ​

job://ended ​

osc://message ​

osc://gen-tick ​

http://burst-progress ​

ws://state ​

ws://messages ​

mqtt://state ​

mqtt://messages ​

mqtt://ack ​

broadcast://emit-stat ​

broadcast://peers ​

netsim://stat ​

storm://stat ​

scan://open ​

scan://progress ​

emulator://activity ​

inspect://batch ​

server://lagged ​