इंस्पेक्टर

इंस्पेक्टर हर टूल के लिए एक ही टाइमलाइन है: हर OSC संदेश, डेटाग्राम, HTTP आदान-प्रदान, MQTT पब्लिश, WebSocket संदेश, रिले किया गया पैकेट और एमुलेटर आदान-प्रदान वहाँ डिकोड किए हुए, उन बाइट के साथ जिनसे वे बने, पहुँचते हैं। इसका उपयोग यह देखने के लिए करें कि असल में तार पर क्या गया, किस क्रम में, और उसके साथ क्या हुआ।

यह निचले पैनल में, कंसोल के बगल में इंस्पेक्टर टैब के रूप में रहता है, इसलिए यह हर स्क्रीन पर मौजूद रहता है। इसे खोलने के लिए टैब पर क्लिक करें; पैनल कुछ पंक्तियों और एक फ़्रेम के विवरण के लिए काफ़ी ऊँचा खुलता है। ⤢ बटन (विंडो जितना ऊँचा) पैनल को विंडो जितना ऊँचा कर देता है। पैनल बंद करने या स्क्रीन बदलने पर भी इंस्पेक्टर अपनी सूची और चयन रखता है।

कैप्चर करना

Signal Lab के शुरू होने पर कैप्चर बंद रहता है, और बंद रहते इसका कोई ख़र्च नहीं होता: टूल फ़्रेम बनाते तक नहीं।

1. इंस्पेक्टर टैब खोलें।
2. कैप्चर चालू करें दबाएँ। टैब का बिंदु लाल होकर धड़कने लगता है।
3. कोई भी टूल उपयोग करें। फ़्रेम सूची के ऊपर आते हैं, सबसे नया सबसे पहले।
4. जो चाहिए वह मिल जाने पर कैप्चर बंद करें दबाएँ।

टैब बताता है कि कितने फ़्रेम कैप्चर हुए, किसी भी स्क्रीन से।

फ़्रेम कैप्चर चालू करने के क्षण से पकड़े जाते हैं, उससे पहले कभी नहीं: पहले उसे चालू करें, फिर भेजें।

सर्वर पर कैप्चर सर्वर का होता है: उससे साइन-इन हर पेज वही फ़्रेम देखता है, और एक पेज पर उसे चालू या साफ़ करना सबके लिए वही करता है।

क्या कैप्चर होता है

टूल	फ़्रेम	कितने
OSC: भेजना	भेजा गया हर संदेश	हर एक
OSC: मॉनिटर	प्राप्त हर पैकेट; जो डिकोड नहीं होता वह डिकोड त्रुटि के साथ चिह्नित होता है	हर एक
OSC: सिग्नल जनरेटर	भेजे गए संदेश	हर 100 ms में अधिकतम एक, sampled चिह्नित
Broadcast: एक बार भेजें	हर डेटाग्राम, प्रति लक्ष्य एक; विफल भेजाव उसकी त्रुटि के साथ	हर एक
Broadcast: बीकन	भेजे गए डेटाग्राम	हर 50 ms में अधिकतम एक
Broadcast: डिस्कवरी लिसनर	प्राप्त प्रोब	हर 40 ms में अधिकतम एक
Broadcast: डिस्कवरी लिसनर	उसके जवाब (auto-reply)	हर एक
HTTP: भेजना, सिग्नल, प्रयोग की रिक्वेस्ट	हर आदान-प्रदान: रिक्वेस्ट पंक्ति, स्टेटस और समय, रिस्पॉन्स हेडर और बॉडी की शुरुआत	हर एक
HTTP: लोड बर्स्ट, और लोड के तहत रिक्वेस्ट	आदान-प्रदान	हर 100 ms में अधिकतम एक
MQTT: कनेक्शन	भेजे गए पब्लिश	हर एक
MQTT: कनेक्शन	प्राप्त संदेश	हर 200 ms में अधिकतम एक
MQTT: स्क्रीन उसके ब्रोकर से जुड़ी न रहते भेजा गया MQTT सिग्नल	पब्लिश	हर एक
WebSocket	भेजे और प्राप्त संदेश	ट्रैफ़िक हल्का रहते हर एक; प्रति सेकंड अधिकतम 200
एमुलेटर	जो आता है और जवाब, एक साथ	हर 10 ms में अधिकतम एक आदान-प्रदान
इम्पेयरमेंट	हर रिले किया गया डेटाग्राम या चंक, दोनों दिशाओं में, उसके हश्र के साथ	दोनों दिशाओं को मिलाकर हर 25 ms में अधिकतम एक
Storm (UDP)	फ़्लड पैकेट, सब एक जैसे	सेकंड में एक, sampled 1/s चिह्नित; TCP स्टॉर्म कुछ भी कैप्चर नहीं करता
स्कैनर	हर खुला पोर्ट, उसके बैनर के साथ	हर एक
प्रयोग	किसी रन के चरण जो भेजते हैं (TCP संदेश: लिखा गया पेलोड और पढ़ा गया जवाब), और उसके वेट जो प्राप्त करते हैं	जिस टूल का उपयोग करता है उसके अनुसार

जो टूल सैंपल करता है वह बाकी जानबूझकर छोड़ देता है, और उन्हें गिनता है: अगला फ़्रेम जो वह बनाता है, बताता है कि कितने रोके गए, अपने फ़ैसले में +n not shown के रूप में (sampled · +5 not shown)। गिनती उसकी है जो टूल बनाता, कैप्चर के अपने निपटान की नहीं (देखें गिनतियाँ और अंतराल)।

फ़्रेम सूची

कॉलम	क्या
समय	यह कब कैप्चर हुआ, मिलीसेकंड तक।
दिशा	→ भेजा (tx), ← प्राप्त (rx)। रिले के लिए → क्लाइंट से लक्ष्य और ← लक्ष्य से क्लाइंट।
प्रोटोकॉल	osc, udp, tcp, http, mqtt या ws।
पीयर	दूसरा सिरा: एक IP:port, एक URL, एक ब्रोकर।
बाइट	फ़्रेम का आकार।
सारांश	प्रोटोकॉल की अपनी नोटेशन में एक पंक्ति, जैसे /fader/1 0.75 या GET http://127.0.0.1:8080/ → 200 in 3ms।
निष्कर्ष	इसके साथ क्या हुआ, जब कहने को कुछ हो।

फ़ैसला हरा, पीला या लाल होता है। लाल नुकसान या विफलता है (dropped (loss), failed, error: …); पीला ऐसा फ़्रेम है जो बदला गया या कई में से केवल एक नमूना (corrupted, copy 2/2, sampled, +n not shown); हरा बाकी है। कुछ फ़ैसले जो आपको मिलेंगे:

फ़ैसला	कहाँ से	अर्थ
forwarded +42ms	इम्पेयरमेंट	उस विलंब के बाद आगे भेजा; उसके बाद · corrupted, · reordered या · copy 1/2 आ सकता है।
dropped (loss), dropped (burst), dropped (offline)	इम्पेयरमेंट	जानबूझकर खोया गया, और क्यों।
throttled	इम्पेयरमेंट	बैंडविड्थ सीमा से गिराया गया।
· client→target, · target→client	इम्पेयरमेंट	हर रिले किए फ़्रेम के फ़ैसले को ख़त्म करता है, किसी भी +n not shown से पहले: वह किस दिशा में जा रहा था।
#2 → 200 OK · 37 B, — → 404 …	एमुलेटर	किस नियम ने जवाब दिया (—: कोई नहीं) और जवाब।
down, down → 503	एमुलेटर	यह तब आया जब एमुलेटर बंद था।
200 OK, failed	HTTP	रिस्पॉन्स स्टेटस, या बिलकुल कोई जवाब नहीं।
open	स्कैनर	एक खुला पोर्ट।
auto-reply	डिस्कवरी	एक जवाब जो लिसनर ने किसी प्रोब को भेजा।
clears retained	MQTT	एक ख़ाली retained पब्लिश।
+n not shown	कोई भी सैंपल करने वाला टूल	पिछले वाले के बाद के इतने फ़्रेम छोड़ दिए गए; यह · के बाद फ़्रेम के बाकी फ़ैसले के साथ आता है।

सूची नवीनतम 4000 फ़्रेम रखती है और फ़िल्टर से मेल खाने वाले नवीनतम 300 बनाती है; फ़िल्टरों के नीचे यह बताती है कि मेल खाने वालों में से कितने दिखा रही है।

फ़िल्टर करना

• टेक्स्ट फ़ील्ड (पते, पीयर, स्रोत से फ़िल्टर करें…) में टाइप करें ताकि वे फ़्रेम रहें जिनके सारांश, पीयर, स्रोत, प्रोटोकॉल या फ़ैसले में वह टेक्स्ट हो।
• प्रोटोकॉल चिप (osc, udp, tcp, http, mqtt, ws) पर क्लिक करें ताकि केवल वे प्रोटोकॉल दिखें। कोई चिप चालू न हो तो हर प्रोटोकॉल दिखता है।
• केवल भेजे या केवल प्राप्त फ़्रेम दिखाने के लिए tx या rx पर क्लिक करें।
• रीसेट तीनों साफ़ कर देता है।

फ़िल्टर केवल यह बदलते हैं कि सूची क्या दिखाती है। कैप्चर, गिनतियाँ और एक निर्यात हमेशा सब कुछ कवर करते हैं।

रोकना और साफ़ करना

दृश्य रोकें सूची को जमा देता है ताकि ट्रैफ़िक चलते रहते आप उसे पढ़ सकें; कैप्चर जारी रहता है। दृश्य फिर शुरू करें नए फ़्रेम फिर आने देता है। जो फ़्रेम दृश्य रुके रहते आए वे सूची में नहीं जुड़ते, पर वे कैप्चर में और निर्यात में होते हैं।

साफ़ करें सूची और कैप्चर ख़ाली कर देता है, और उसकी गिनतियाँ फिर से सेट कर देता है।

गिनतियाँ और अंतराल

ऊपर की पट्टी कैप्चर किए गए फ़्रेम और उनके बाइट गिनती है, और बताती है कि कैप्चर कितना भरा है (8192 में से कितने फ़्रेम रखे)।

जब फ़्रेम सूची के उठा सकने से तेज़ आते हैं — अंदाज़न एक-आठवें सेकंड में 250 से ज़्यादा — तो सूची उनमें सबसे पुराने छोड़ देती है। तब एक पीली चिप न दिखाए गए फ़्रेम गिनती है, और सूची की एक पंक्ति चिह्नित करती है कि वे कहाँ ग़ायब हैं। वे फ़्रेम अब भी कैप्चर में होते हैं, जब तक उनसे नए फ़्रेम उन्हें बाहर न धकेल चुके हों: उन्हें देखने के लिए निर्यात करें।

किसी फ़्रेम का विवरण

फ़्रेम को दाईं ओर देखने के लिए किसी पंक्ति पर क्लिक करें।

फ़ील्ड	क्या
क्रमांक	फ़्रेम की संख्या। संख्याएँ कैप्चर क्रम में बढ़ती हैं और कभी दोबारा उपयोग नहीं होतीं।
समय	यह कब कैप्चर हुआ।
दिशा	भेजा गया या प्राप्त।
प्रोटोकॉल	सूची की तरह।
स्रोत	जिस टूल ने इसे कैप्चर किया (osc-send, osc-monitor, netsim, emulator, experiment-wait, …), और जब यह किसी का हिस्सा हो तो उसका जॉब नंबर।
लोकल	इस सिरे का पता, जब कोई हो। रिले किए फ़्रेम के लिए, वह पता जिस पर रिले सुनता है।
पीयर	दूसरा सिरा। रिले किए फ़्रेम के लिए, वह कहाँ जा रहा था: लक्ष्य, या वह क्लाइंट जिसे जवाब वापस गया।
आकार	उसका आकार बाइट में।
निष्कर्ष	सूची की तरह।

डिकोड किया गया के नीचे फ़्रेम अपने प्रोटोकॉल में पढ़ा हुआ है: OSC बंडल का हर संदेश उसके आर्ग्युमेंट के साथ, HTTP रिस्पॉन्स के हेडर और उसकी बॉडी की शुरुआत, एमुलेटर की रिक्वेस्ट और उसका जवाब।

बाइट के नीचे एक hex डंप है: ऑफ़सेट, hex में 16 बाइट, और वही बाइट टेक्स्ट के रूप में। सूची हर फ़्रेम का पहला KiB रखती है; फ़्रेम लंबा हो तो डंप के नीचे का एक बटन उसे पूरा लोड कर देता है।

एक फ़्रेम क्या रखता है

सीमा	मान	सीमा पर
एक फ़्रेम जो बाइट रखता है	256 KiB	लंबा फ़्रेम अपने पहले 256 KiB रखता है और बताता है कि कुल में से कितना रखा।
कैप्चर में फ़्रेम	8192	सबसे पुराना फ़्रेम जगह बनाता है।
कैप्चर कुल कितने बाइट रखता है	64 MiB	सबसे पुराने फ़्रेम जगह बनाते हैं।

कुछ फ़्रेम कोई बाइट नहीं रखते: HTTP आदान-प्रदान (उनका आकार दर्ज होता है, और रिस्पॉन्स हेडर तथा बॉडी की शुरुआत इसके बजाय डिकोड किए टेक्स्ट में होती है) और स्कैनर के खुले पोर्ट।

एक MQTT फ़्रेम संदेश का पेलोड रखता है, उसके चारों ओर का प्रोटोकॉल पैकेट नहीं; टॉपिक, QoS और retain फ़्लैग उसके सारांश में होते हैं।

सीक्रेट

जब कोई प्रयोग रन या अभी भेजें सीक्रेट का उपयोग करता है, तो उनके मान हर फ़्रेम में उसके कैप्चर होने से पहले मास्क कर दिए जाते हैं: सारांश, डिकोड किए टेक्स्ट, पतों और फ़ैसले में ••••, और पेलोड में हर बाइट के लिए *, ताकि डंप के ऑफ़सेट सच्चे रहें। HTTP स्क्रीन के क्रेडेंशियल भी कभी नहीं दिखते: एक HTTP फ़्रेम रिस्पॉन्स रखता है, वह Authorization हेडर नहीं जो भेजा गया था।

किसी फ़्रेम को सिग्नल के रूप में सहेजना

किसी पकड़े गए पैकेट को रखने और बाद में फिर भेजने के लिए — जब उसे भेजने वाला डिवाइस अब न हो:

1. फ़्रेम चुनें।
2. सिग्नल के रूप में सहेजें दबाएँ।

सिग्नल सिग्नल लाइब्रेरी के कैप्चर किए गए फ़ोल्डर में जाता है, फ़्रेम के हर बाइट के साथ, उससे लिया गया जो कैप्चर ने रखा, डिकोड किए टेक्स्ट से नहीं। इसका नाम फ़्रेम के सारांश पर रखा जाता है, और उसका नोट बताता है कि यह किस फ़्रेम से आया।

आपको क्या मिलेगा यह फ़्रेम पर निर्भर है:

फ़्रेम	सिग्नल
एक OSC या UDP डेटाग्राम	फ़्रेम के बाइट वाला एक कच्चा UDP सिग्नल, hex।
एक MQTT पब्लिश — भेजा, प्राप्त, या एमुलेटर का	फ़्रेम के ब्रोकर, टॉपिक, QoS और retain फ़्लैग वाला एक MQTT सिग्नल, और उसका पेलोड टेक्स्ट के रूप में, ठीक जैसा था। ख़ाली पेलोड रखा जाता है, इसलिए किसी retained मान को साफ़ करना सहेजा जा सकता है।
बाकी कुछ भी: एक TCP स्ट्रीम (जिसमें रिले का लाया हुआ, या TCP नोड का भी), एक HTTP आदान-प्रदान, एक WebSocket संदेश, एक MQTT पैकेट जो पब्लिश नहीं है (किसी एमुलेटर पर क्लाइंट का सब्सक्राइब)	कुछ नहीं: बटन बंद है, और उसका टिप बताता है क्यों। एक सिग्नल एक डेटाग्राम या एक पब्लिश भेजता है; इन्हें जैसे थे वैसे फिर नहीं भेजा जा सकता।

डेटाग्राम यहाँ भेजा जाता है:

• एक प्राप्त फ़्रेम — जिस पते ने इसे प्राप्त किया (लोकल सिरा), ताकि सिग्नल भेजने वाले की जगह ले;
• एक भेजा फ़्रेम — वह पीयर जिसे यह भेजा गया था;
• एक रिले किया फ़्रेम, किसी भी दिशा में — जिस पते पर यह जा रहा था: क्लाइंट से जाने वाले फ़्रेम के लिए लक्ष्य, किसी जवाब के लिए क्लाइंट।

जब वह पता इस कंप्यूटर का हर पता हो — 0.0.0.0:9000 या [::]:9000 पर सुनता कोई मॉनिटर — तो सिग्नल इसके बजाय इसी कंप्यूटर पर निशाना लेता है: 127.0.0.1:9000 या [::1]:9000। अगर आपका मतलब कोई और पता है तो सिग्नल खोलें और उसका लक्ष्य बदलें।

एक MQTT सिग्नल उस ब्रोकर पर जाता है जो फ़्रेम बताता है। हर पते पर सुनता ब्रोकर भी उसी तरह 127.0.0.1 पर पहुँचा जाता है।

बटन इनके लिए भी बंद है:

• ऐसा फ़्रेम जो पूरा नहीं रखा गया: 256 KiB से बड़ा, या जिसने कोई बाइट नहीं रखा;
• ऐसा MQTT संदेश जिसका पेलोड टेक्स्ट नहीं है — सिग्नल का पेलोड टेक्स्ट होता है, इसलिए उसके बाइट जैसे थे वैसे फिर नहीं भेजे जा सकते;
• ऐसा प्राप्त फ़्रेम जो इस सिरे पर कोई सॉकेट नहीं बताता, इसलिए भेजने को कोई पता नहीं है।

जिस फ़्रेम को कैप्चर पहले ही छोड़ चुका है उसे भी नहीं सहेजा जा सकता; कंसोल ऐसा बताता है। जब तक लाइब्रेरी फ़ाइल पढ़ी नहीं जा सकती, सिग्नल के रूप में सहेजें भी बंद रहता है, और टिप फ़ाइल की त्रुटि दिखाता है (देखें सिग्नल)।

निर्यात करना

.jsonl निर्यात करें और .txt निर्यात करें पूरा कैप्चर — 8192 फ़्रेम तक, हर एक द्वारा रखा हर बाइट, फ़िल्टर जो दिखाएँ चाहे जो — डेटा फ़ोल्डर में capture-<time>.jsonl या capture-<time>.txt फ़ाइल में लिख देते हैं (देखें फ़ाइलें)। कंसोल बताता है कि कहाँ। किसी सर्वर से जुड़े ब्राउज़र में फ़ाइल सर्वर पर लिखी जाती है और आपका ब्राउज़र उसे डाउनलोड करता है।

ख़ाली कैप्चर नहीं लिखा जाता; कंसोल कहता है कि सहेजने को कुछ नहीं है।

• .jsonl — प्रति पंक्ति एक JSON ऑब्जेक्ट, प्रति फ़्रेम एक पंक्ति: seq, ts (1970 से मिलीसेकंड), proto, dir, source, job_id, local, remote, bytes, kept, summary, detail, hex (पहले KiB का डंप), verdict, और data, उसके रखे बाइट base64 में।
• .txt — पढ़ने के लिए: प्रति फ़्रेम एक पंक्ति उसके नंबर, समय, दिशा, प्रोटोकॉल, पीयर, आकार और फ़ैसले के साथ, फिर उसका सारांश, उसका डिकोड किया टेक्स्ट और उसके रखे हर बाइट का hex डंप।

{"seq":12,"ts":1767225600123,"proto":"osc","dir":"rx","source":"osc-monitor","job_id":3,"local":"0.0.0.0:9000","remote":"127.0.0.1:53211","bytes":20,"summary":"/fader/1 0.75","detail":"/fader/1 0.75","hex":"0000  2f 66 61 64 65 72 2f 31  00 00 00 00 2c 66 00 00  |/fader/1....,f..|\n0010  3f 40 00 00                                       |?@..|\n","verdict":null,"kept":20,"data":"L2ZhZGVyLzEAAAAALGYAAD9AAAA="}

कहीं और से आना

दूसरी स्क्रीनें फ़्रेम की ओर इशारा करती हैं: किसी प्रयोग की टाइमलाइन में एक वेट उस फ़्रेम से जोड़ता है जिससे वह मेल खाया, और एमुलेटर की प्राप्त सूची में हर आदान-प्रदान पर एक ⌕ बटन (इंस्पेक्टर में खोलें) होता है। किसी पर चलने से इंस्पेक्टर उस फ़्रेम के चुने हुए, फ़िल्टर साफ़ किए हुए और दृश्य फिर शुरू किए हुए खुलता है।

संबंधित

• सिग्नल — एक सहेजा गया फ़्रेम क्या बनता है।
• इम्पेयरमेंट — रिले के फ़ैसले।
• एमुलेटर — एक एमुलेटर ने क्या प्राप्त किया।