sigwire

tail -f para sinais. Cada sinal que qualquer processo na máquina levanta — quem o enviou, quem o recebeu, qual sinal, como foi levantado (kill(2), o kernel, um timer POSIX), se o alvo o capturou e quanto tempo o seu manipulador executou, se ele interrompeu uma chamada de sistema bloqueada com EINTR — decodificado a partir dos tracepoints de sinais do kernel e transmitido ao vivo para o seu terminal. Sem strace -f num único pid, sem ptrace, sem cooperação dos processos envolvidos.

sigwire transforma a maquinaria de sinais do kernel num patchbay ao vivo: cada linha é sender ──SIGNAL──▶ target, colorida por gravidade, etiquetada com como foi levantado, se o alvo capturou (e quanto tempo o seu manipulador executou), se interrompeu uma chamada de sistema bloqueada (↯ EINTR read), colapsada para ×N quando algo enche, e marcada ☠ quando é um golpe fatal genuíno. Uma barra lateral contabiliza o que está voando pelo fio; pause e escolha uma linha para inspecionar o quadro completo — disposição, endereço do manipulador, flags sigaction, e os sinais que o alvo estava bloqueando naquele instante.

Porque ele hooka os tracepoints do kernel, não um único processo, uma única execução observa todos os sinais no host de uma vez — o seu aplicativo, um supervisor, a própria maquinaria de falhas do kernel — sem que nenhum deles saiba que está sendo rastreado.

[!TIP] Dois lados de cada sinal. sigwire observa tanto signal:signal_generate (a visão do remetente — quem levantou o quê, a linha do quadro de distribuição) quanto signal:signal_deliver (a visão do alvo — ele capturou, com qual manipulador e flags, o que estava bloqueando, e interrompeu uma chamada de sistema?). Mais dois hooks — rt_sigreturn(2) e o tracepoint de saída de chamada de sistema — temporizam o manipulador e capturam EINTR. Tudo é correlacionado de volta a uma única linha. Esta divisão é também a razão pela qual a contagem ☠ fatal é deliberadamente conservadora (veja O que conta como fatal): a geração acontece antes da entrega, então o lado do remetente não pode saber o destino de um sinal — apenas o lado da entrega pode, e apenas para os casos que observa.

Início rápido```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)

[Guia de instalação manual](https://yeet.cx/docs/manual-installation) | Apenas Linux

Nada para configurar — sinais são tráfego constante de fundo em qualquer máquina, então as linhas começam a aparecer no topo imediatamente. Quer gerar alguns você mesmo? `kill -USR1 <pid>`, `Ctrl-C` em um job em primeiro plano, ou inicie qualquer runtime gerenciado e observe seu GC/agendador pingar suas próprias threads (`↯ EINTR futex` passando pela tela).

## Controles

O feed segue o sinal mais recente por padrão; selecione uma linha ou pause e ele ficará parado enquanto os dados continuam fluindo abaixo.

| tecla | ação |
| --- | ------ |
| `p` · `Space` | pausar / retomar o feed (congelar para ler) |
| `↑`/`↓`, `k`/`j` | pausar e inspecionar uma linha — abre o painel de detalhes |
| `/` | filtro difuso — corresponde a processo, pid, sinal, fonte e disposição; caracteres correspondentes destacam-se ao vivo |
| `e` | filtrar para **apenas syscalls interrompidas** (`↯ EINTR` / `↺ reiniciadas`) |
| `s` | abrir o **seletor de sinais** — silenciar ou mostrar qualquer sinal, ao vivo |
| `Esc` | retroceder uma camada — limpar o filtro / fechar o seletor / descartar a seleção, depois sair |
| `q` | sair |

## O que você está vendo

Cada linha é um sinal gerado, o mais recente no topo:```
 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

Cada linha é um bloco: o remetente → destino são comm·pid (o remetente é quem gerou o sinal, current; o destino é para quem ele é enviado), o fio no meio carrega o nome do sinal colorido por severidade, ×N agrupa uma rajada de sinais idênticos em uma única linha, e a nota à direita fornece a fonte, depois qualquer interrupção de chamada de sistema, depois a disposição.

Cada linha é congelada no momento em que sua entrega é resolvida e nunca mais muda — portanto, uma rajada passa como um registro estável, não um agregado tremeluzente.

O fio é colorido por severidade na mesma paleta de 256 cores que o resto da interface:

severidade	sinais	cor
kill	SIGKILL	vermelho intenso
fatal (com core dump)	SEGV BUS ABRT ILL FPE TRAP SYS QUIT	vermelho
terminação	TERM INT HUP PIPE ALRM …	âmbar
controle de jobs	STOP TSTP TTIN TTOU	amarelo
continuação	CONT	verde
usuário	USR1 USR2	ciano
tempo real	SIGRTMIN+n	violeta
manutenção	CHLD URG WINCH …	cinza

A nota é a fonte (kill(2), tgkill, sigqueue, timer, kernel, fault); depois, se interrompeu uma chamada de sistema bloqueada, ↯ EINTR read (ou ↺ restarted read quando SA_RESTART a retomou automaticamente); depois a disposição — caught 41µs (um manipulador foi executado e quanto tempo levou), default (nenhum manipulador, a ação padrão foi aplicada) ou ⊘ ignored. Um ☠ marca um golpe fatal genuíno (veja O que conta como fatal).

[!NOTE] ↯ EINTR é o que deve ser observado. Um sinal que chega enquanto uma thread está bloqueada em uma chamada de sistema lenta (read, poll, accept, futex, nanosleep, …) a remove: a chamada de sistema retorna -1 / EINTR e, a menos que o manipulador tenha definido SA_RESTART, ela não é retomada — o aplicativo deve tentar novamente. Esquecer isso é um bug clássico, irritante e dependente de temporização ("por que meu read() falhou uma vez?"). O sigwire mostra isso acontecendo, ao vivo, e qual chamada de sistema sofreu o impacto. Pressione e para ocultar todo o resto e assistir apenas às interrupções.

A barra à direita é a visão agregada: principais sinais por volume, uma discriminação por fonte e uma contagem de entrega — quantos sinais foram capturados vs. atingiram seu padrão vs. ignorados.

Inspecionar um sinal