sigwire

tail -f for signals. बॉक्स पर किसी भी प्रक्रिया द्वारा उठाया गया हर सिग्नल — किसने भेजा, किसको लगा, कौन सा सिग्नल, कैसे उठाया गया (kill(2), कर्नेल, एक POSIX टाइमर), क्या लक्ष्य ने इसे पकड़ा और इसके हैंडलर ने कितनी देर चला, क्या इसने एक अवरुद्ध सिस्कॉल को EINTR के साथ फाड़ दिया — कर्नेल के सिग्नल ट्रेसपॉइंट्स से डिकोड करके लाइव आपके टर्मिनल पर स्ट्रीम किया गया। एक पीआईडी पर कोई strace -f नहीं, कोई ptrace नहीं, शामिल प्रक्रियाओं से कोई सहयोग नहीं।

sigwire कर्नेल के सिग्नल तंत्र को एक लाइव पैचबे में बदल देता है: प्रत्येक पंक्ति sender ──SIGNAL──▶ target है, गंभीरता के अनुसार रंगीन, कैसे उठाया गया इसके साथ टैग किया गया, क्या लक्ष्य ने इसे पकड़ा (और इसका हैंडलर कितनी देर चला), क्या इसने एक अवरुद्ध सिस्कॉल को बाधित किया (↯ EINTR read), जब कुछ स्पैम करता है तो ×N में संक्षिप्त, और जब यह वास्तविक घातक प्रहार होता है तो ☠ चिह्नित। एक साइड रेल यह गणना करता है कि वायर पर क्या उड़ रहा है; रुकें और एक पंक्ति चुनें पूरी तस्वीर देखने के लिए — स्वभाव, हैंडलर पता, sigaction फ़्लैग, और लक्ष्य उस समय किन सिग्नलों को ब्लॉक कर रहा था।

क्योंकि यह कर्नेल के ट्रेसपॉइंट्स को हुक करता है, किसी एक प्रक्रिया को नहीं, एक ही रन होस्ट पर हर सिग्नल को एक साथ देखता है — आपका ऐप, एक पर्यवेक्षक, कर्नेल का अपना फॉल्ट तंत्र — उनमें से कोई भी इस बात से अवगत नहीं कि उन पर नज़र रखी जा रही है।

[!TIP] हर सिग्नल के दो पहलू. sigwire दोनों signal:signal_generate (प्रेषक का दृश्य — किसने क्या उठाया, स्विचबोर्ड लाइन) और signal:signal_deliver (लक्ष्य का दृश्य — क्या इसे पकड़ा, किस हैंडलर और फ़्लैग के साथ, क्या ब्लॉक कर रहा था, और क्या इसने सिस्कॉल को बाधित किया) देखता है। दो और हुक — rt_sigreturn(2) और syscall-exit ट्रेसपॉइंट — हैंडलर को टाइम करते हैं और EINTR को पकड़ते हैं। यह सब एक पंक्ति में सहसंबंधित होता है। यह विभाजन भी कारण है कि ☠ fatal गणना जानबूझकर रूढ़िवादी है (देखें क्या घातक माना जाता है): जनरेशन डिलीवरी से पहले होती है, इसलिए प्रेषक पक्ष किसी सिग्नल के भाग्य को नहीं जान सकता — केवल डिलीवरी पक्ष जान सकता है, और केवल उन मामलों के लिए जो वह देखता है।

त्वरित आरंभ```sh

curl -fsSL https://yeet.cx | sh # install the yeet daemon (one time) yeet run github:yeet-src/sigwire # run the dashboard (the daemon does the privileged BPF load)

[Manual install guide](https://yeet.cx/docs/manual-installation) | Linux only

कॉन्फ़िगर करने के लिए कुछ नहीं — सिग्नल किसी भी बॉक्स पर लगातार बैकग्राउंड ट्रैफ़िक होते हैं, इसलिए पंक्तियाँ तुरंत शीर्ष पर आने लगती हैं। कुछ खुद उत्पन्न करना चाहते हैं? `kill -USR1 <pid>`, `Ctrl-C` एक फोरग्राउंड जॉब को, या कोई प्रबंधित रनटाइम शुरू करें और देखें कि इसका GC/शेड्यूलर अपने थ्रेड्स को पिंग करता है (`↯ EINTR futex` स्क्रॉल करता हुआ)।

## नियंत्रण

फ़ीड डिफ़ॉल्ट रूप से नवीनतम सिग्नल का अनुसरण करता है; एक पंक्ति चुनें या रोकें और डेटा नीचे बहता रहता है जबकि यह स्थिर रहता है।

| कुंजी | क्रिया |
| --- | ------ |
| `p` · `Space` | फ़ीड को रोकें / फिर से शुरू करें (पढ़ने के लिए फ़्रीज़ करें) |
| `↑`/`↓`, `k`/`j` | रुकें और एक पंक्ति का निरीक्षण करें — विवरण पैनल खोलता है |
| `/` | फ़ज़ी फ़िल्टर — प्रक्रिया, PID, सिग्नल, स्रोत, और स्वभाव से मेल खाता है; मेल खाने वाले वर्ण लाइव हाइलाइट होते हैं |
| `e` | फ़िल्टर **केवल बाधित सिस्कॉल** (`↯ EINTR` / `↺ पुनर्प्रारंभित`) |
| `s` | **सिग्नल पिकर** खोलें — किसी भी सिग्नल को म्यूट या दिखाएँ, लाइव |
| `Esc` | एक स्तर पीछे जाएँ — फ़िल्टर साफ़ करें / पिकर बंद करें / चयन हटाएँ, फिर बाहर निकलें |
| `q` | बाहर निकलें |

## आप क्या देख रहे हैं

प्रत्येक पंक्ति एक उत्पन्न सिग्नल है, सबसे नया शीर्ष पर:```
 WHEN            SENDER  SIGNAL        TARGET               NOTE
  now       bash·4402──SIGINT───▶  node·8813        kill(2)  ↯ EINTR read  caught 41µs
 1.2s    systemd·1──────SIGTERM──▶  nginx·1291       kill(2)  caught 1.2ms
 3.4s     kernel·8813──SIGSEGV──▶  chrome·8813       fault    default  ☠
 4.1s   postgres·507──SIGUSR1───▶  postgres·509 ×6  kill(2)  caught 9µs

प्रत्येक पंक्ति एक ब्लॉक है: प्रेषक → लक्ष्य comm·pid हैं (प्रेषक वह है जिसने सिग्नल उठाया, current; लक्ष्य वह है जिसके लिए यह लक्षित है), तार बीच में सिग्नल का नाम लेकर चलता है जो गंभीरता के अनुसार रंगीन होता है, ×N एक पंक्ति में समान सिग्नल के प्रस्फोट को मोड़ता है, और दाईं ओर नोट स्रोत देता है, फिर कोई syscall व्यवधान, फिर निपटान।

प्रत्येक पंक्ति उस क्षण स्थिर हो जाती है जब इसकी डिलीवरी हल हो जाती है और फिर कभी नहीं बदलती — इसलिए एक प्रस्फोट एक स्थिर लॉग के रूप में स्क्रॉल करता है, न कि झिलमिलाते समुच्चय के रूप में।

तार गंभीरता के अनुसार रंगीन होता है उसी 256-रंग पैलेट पर जैसा कि शेष UI में:

गंभीरता	सिग्नल	रंग
मार	SIGKILL	गर्म लाल
घातक (कोर डंपिंग)	SEGV BUS ABRT ILL FPE TRAP SYS QUIT	लाल
समाप्त करने वाला	TERM INT HUP PIPE ALRM …	एम्बर
कार्य नियंत्रण	STOP TSTP TTIN TTOU	पीला
जारी रखें	CONT	हरा
उपयोगकर्ता	USR1 USR2	सियान
रीयल-टाइम	SIGRTMIN+n	बैंगनी
गृह व्यवस्था	CHLD URG WINCH …	ग्रे

नोट स्रोत है (kill(2), tgkill, sigqueue, timer, kernel, fault); फिर, यदि इसने एक अवरुद्ध syscall को बाधित किया, तो ↯ EINTR read (या ↺ restarted read जब SA_RESTART ने इसे स्वचालित रूप से फिर से शुरू किया); फिर निपटान — caught 41µs (एक हैंडलर चला, और इसमें कितना समय लगा), default (कोई हैंडलर नहीं, डिफ़ॉल्ट कार्रवाई लागू हुई), या ⊘ ignored। एक ☠ एक वास्तविक घातक प्रहार को चिह्नित करता है (देखें क्या घातक माना जाता है)।

[!NOTE] ↯ EINTR देखने वाला है। एक सिग्नल जो तब आता है जब एक थ्रेड एक धीमी syscall (read, poll, accept, futex, nanosleep, …) में रुका होता है, उसे बाहर खींच लेता है: syscall -1 / EINTR लौटाता है और, जब तक हैंडलर ने SA_RESTART सेट नहीं किया, यह फिर से शुरू नहीं होता — ऐप को दोबारा प्रयास करना होता है। इसे भूलना एक क्लासिक, क्रोधित करने वाला, समय-निर्भर बग है ("मेरी read() विफल क्यों हुई एक बार?")। sigwire इसे लाइव होते हुए दिखाता है, और किस syscall पर चोट लगी। दबाएं e बाकी सब कुछ छिपाने के लिए और केवल इंटरप्ट देखने के लिए।

दाईं ओर की पटरी समुच्चय दृश्य है: मात्रा के अनुसार शीर्ष सिग्नल, स्रोत के अनुसार एक विभाजन, और डिलीवरी का गणना — कितने सिग्नल पकड़े गए बनाम उनका डिफ़ॉल्ट लगा बनाम अनदेखा किया गया।

एक सिग्नल का निरीक्षण करें