Skip to content

FD leak: container esgota 1024 file descriptors em ~2-3 dias e o healthcheck quebra por EMFILE #792

Closed

Description

@joseehilton147

FD leak: container esgota 1024 file descriptors em ~2-3 dias e o healthcheck quebra por EMFILE

Versão: ai-memory 2.2.0 (imagem Docker akitaonrails/ai-memory, :latest em 2026-09-12)
Ambiente: Docker Compose em VPS (Ubuntu), soft limit nofile = 1024, volume /data bind-montado, wiki watcher ativo.

Sintoma

Depois de ~30h de uptime o container fica unhealthy: o healthcheck (ai-memory status, timeout 5s) começa a estourar e os logs mostram EMFILE repetindo:

ERROR ai_memory_wiki::watcher: reconciliation failed error=Too many open files (os error 24) consecutive_failures=13
WARN  ai_memory_cli::commands::serve: scheduled lint failed for scope ... error=Too many open files (os error 24)
WARN  ai_memory_cli::commands::serve: scheduled maintenance job failed; retrying error=scheduled rule-based lint had 3 scope errors job="rule_lint"

Evidência

  • ls /proc/1/fd | wc -l = 1024/1024 (limite soft atingido).
  • Por classe: 1004 sockets, 11 arquivos em /data (SQLite/WAL), 6 anon_inode, 2 pipes.
  • Taxa medida após restart: 152 FDs → 208 FDs em ~4h (~12 FDs/hora), com o serviço ocioso (só capture/lifecycle de fundo).

Suspeita

Leak de conexões de rede: o crescimento dominante é de sockets que não são fechados. Os logs apontam para o ciclo de reconciliação do ai_memory_wiki::watcher e os lints agendados — que continuam tentando abrir arquivos/conexões depois que o pool esgota, sem recover.

Impacto

Com o pool de FDs esgotado, qualquer conexão nova falha — incluindo o próprio healthcheck HTTP/CLI — e o container é marcado unhealthy pelo orquestrador. restart do container resolve por horas/dias (mitigação), o leak volta a crescer.

Pergunta

Há correção conhecida para esse leak em 2.2.1/2.2.2/2.3.x? Podemos testar uma versão fixa e reportar de volta. Obrigado pelo projeto — usamos como camada de captura/continuidade cross-client no nosso stack.

Activity

  1. akitaonrails commented on Sep 19, 2026

    @akitaonrails
    Owner

    Obrigado pelo relatório detalhado — os números de /proc/1/fd ajudam muito. Investigamos o código do serve (2.2.x → main) atrás de um vazamento de fd em caminho periódico/por-requisição e ainda não conseguimos localizar um vazamento no nosso código que explique o perfil medido:

    • Seu próprio recorte mostra 1004 sockets mas só 11 arquivos em /data — isso descarta as conexões SQLite (writer/reader pool) e os handles do git2/libgit2, que apareceriam como fds de arquivo.
    • O watcher da wiki é instalado uma única vez (não re-registra a cada ciclo) e o reconcile só faz I/O de disco/DB — os erros Too many open files dele são consequência do pool já esgotado, não a causa.
    • O healthcheck (ai-memory status) roda como processo separado; o handler /admin/status só lê contadores em memória — não abre fd por probe.
    • Os clientes HTTP de LLM/embeddings são criados uma vez e reutilizados (com timeout) — não há o vazamento clássico de reqwest::Client por requisição no servidor.

    Para localizar, precisamos de:

    1. ss -tanp | head -50 (ou lsof -p 1 -nP | grep -i sock | head) dentro do container com fd alto — queremos ver o estado TCP (ESTABLISHED/CLOSE_WAIT/…) e o peer de alguns sockets (loopback? endereço do provedor LLM? conexões de entrada dos seus clientes?).
    2. Seu config.toml/env: qual provider de LLM e de embeddings, e se maintenance/auto_improve/consolidate_on_session_end estão ligados.
    3. Como sua camada de captura cross-client conversa com o servidor — transporte MCP (streamable/SSE?), se abre conexão por evento/sessão e se as fecha.

    Hipótese atual: sockets de entrada abertos por clientes e abandonados sem fechamento limpo, que o axum::serve hoje não recicla (sem idle-timeout nem TCP keepalive). Estamos avaliando adicionar keepalive + idle-timeout no listener como blindagem, independentemente de confirmar este caso. O ss acima confirma ou refuta rapidamente.

  2. joseehilton147 commented on Sep 20, 2026

    @joseehilton147
    Author

    Obrigado pela análise — respondendo os 3 pontos com o que verificamos de fato:

    2. Config/env: sem provider de LLM nem de embeddings configurado (envs do container: AI_MEMORY_BIND, AI_MEMORY_ALLOWED_HOSTS, AI_MEMORY_AUTH_TOKEN, AI_MEMORY_AUTO_IMPROVE__REQUIRE_APPROVAL; não usamos config.toml). Ou seja: os clientes HTTP de LLM/embeddings do servidor nem entram em cena neste caso — o caminho de conexões aqui é o do MCP server.

    3. Transporte dos nossos clientes: o consumidor principal é o nosso dashboard (web-server). Ele fala JSON-RPC streamable HTTP em POST /mcp com fetch novo por chamada de tool (Accept: application/json, text/event-stream), sem MCP-Session-Id, sem teardown explícito, com AbortSignal.timeout(8s) no lado do cliente. Fonte: apps/web-server/src/lib/ai-memory-client.ts do nosso monorepo. Um segundo consumidor (bot de Telegram, captura de sessão) existe no host, mas não o mapeamos em detalhe ainda.

    1. ss do pico: não temos — a imagem anterior morreu sem captura (recriamos o container aplicando ulimits nofile soft 4096 antes de coletar). O que fizemos para a próxima janela: o nosso dead-man's switch agora grava dump cru de /proc/net/tcp+tcp6 do container no momento em que os FDs cruzam 3000 (limiar do alerta; teto 4096). Pelo ritmo medido (~12 FDs/h), o dump chega em ~10 dias e trazemos aqui.

    Sobre a hipótese de vocês: Inferido — consistente com o que vemos. Nosso cliente abandona a requisição em 8s por timeout; se o axum::serve não tem idle-timeout/keepalive no listener, cada timeout deixaria uma conexão de entrada viva para sempre no servidor — e o dashboard gera chamadas o dia todo. Não medimos isso no pico, então fica como inferência até o dump.

    Um detalhe do nosso lado que a investigação trouxe: o nosso wrapper de entrega de alertas morria num filtro jq mal-formado justamente quando um alerta notificado virava stale — por isso ninguém viu "resolvido" quando reiniciamos o container. Corrigido no nosso repo.

    Se 2.3.x trouxer idle-timeout/keepalive no listener, testamos na hora e reportamos a curva de FDs. Obrigado pela resposta rápida!

  3. joseehilton147 commented on Sep 20, 2026

    @joseehilton147
    Author

    Avanço com a assinatura exata que você pediu — e um experimento que descarta um caminho:

    Assinatura no container de produção (2.2.0, ~4,5h de uptime, 120 fds no total, crescendo ~20 fds/h):

    sockets do processo (por inode × /proc/net/tcp+tcp6):
      98 ESTAB -> 0.0.0.0:0   <- conexões mortas, fd nunca fechado
       1 LISTEN -> 0.0.0.0:0
    

    Ou seja: todos os sockets acumulados estão ESTABLISHED com peer indefinido (0.0.0.0:0) — a estrutura de conexão já não existe do lado do kernel, mas o processo mantém o fd. É leak de fd pós-desconexão, não conexões de clientes ativas.

    Experimento controlado (container limpo 2.2.0, rede isolada, tmpfs):

    • 300 POST /mcp completos (tools/list) → fds estáveis (20→20).
    • 300 POST /mcp abandonados no meio (cliente corta em 50 ms, Accept: application/json, text/event-stream, tools/call) → fds estáveis (20→20; só LISTEN/TIME_WAIT).

    Ou seja: request completo e request abortado cedo não reproduzem — o servidor recicla. O gatilho está num caminho que esse tráfego básico não toca. Nossa candidata: o stream SSE do rmcp interrompido no meio pelo timeout do cliente (nosso cliente aceita application/json, text/event-stream com AbortSignal.timeout(8s); quando o servidor decide responder em stream e o cliente some no meio, o fd do stream morre pendurado).

    Pergunta para vocês: nesse perfil (ESTAB 0.0.0.0:0 no processo do serve), onde o ciclo de vida do rmcp/axum deveria fechar o fd quando a conexão morre no meio de um stream — e há algo em 2.2.1–2.3.x nesse caminho? Se vocês apontarem o handler, testamos a versão na hora. Nosso dump cru de /proc/net/tcp no próximo pico segue instrumentado como plano B.

  4. akitaonrails commented on Sep 20, 2026

    @akitaonrails
    Owner

    Update — a strong candidate fix just landed.

    Your signature (sockets stuck `ESTABLISHED → 0.0.0.0:0`, i.e. the peer is gone from the kernel but the process keeps the fd, all on the streamable-HTTP `POST /mcp` transport, no `MCP-Session-Id`, no LLM/embedding provider configured) matches GHSA-9pj6-vhgr-3mwh — "unauthenticated permanent session-table leak in the rmcp Streamable HTTP server transport leads to remote denial-of-service." That is an upstream rmcp transport bug, which is exactly the layer your dashboard talks to, and it is consistent with an isolated single-request abandon not reproducing while a long-lived real client that opens a fresh session per tool-call does.

    We have bumped rmcp 1.7 → 2.2.0 (which carries the fix), merged as #819. It is on the current line and will ship in the next release.

    Could you retest on a build that includes it (build from the current branch, or the next tagged image once it publishes) and report the fd curve? We are keeping this issue open until you confirm the leak is gone in production. Independently, we are also evaluating a TCP-keepalive + idle-timeout on the listener as defense-in-depth regardless of this specific cause.

    Thanks again for the /proc/net/tcp signature and the controlled experiment — they are what let us tie this to the transport layer.

  5. ranierelm commented on Sep 22, 2026

    @ranierelm
    Contributor

    I'd like to take the defense-in-depth half of this: TCP keepalive plus a header-read/idle timeout on the HTTP listener, independent of the rmcp fix.

    Shape I intend to build, so you can redirect before code lands:

    • Idle timeout: axum::serve doesn't expose hyper's timeouts, so I'd take over the accept loop at serve.rs:1488 with hyper_util::server::conn::auto::Builder (already in the tree, 0.1.20), keep the router and ConnectInfo exactly as they are, and set http1().header_read_timeout(...) plus a per-connection deadline for idle keep-alive connections. Graceful shutdown keeps the current bounded drain.
    • Keepalive: on every accepted socket, set SO_KEEPALIVE with an explicit idle/interval via socket2 (also already in the lock file, 0.6.3). Needed because both macOS and Linux default keepidle to 2h, so relying on the OS gives nothing useful for a dead peer.
    • Two config keys with conservative defaults, env overrides, documented in ARCHITECTURE.md and deploy.md; ### Added in the CHANGELOG. Names open to your preference; I'd go with http_idle_timeout_secs and http_keepalive_secs, 0 disabling each.
    • Tests with controls: a client that sends a partial request and goes silent is closed by the server within the timeout; with the timeout disabled the same socket survives. Plus a before/after fd count against the reporter's abandon pattern on a local build, pasted in the PR.

    No new dependencies. If any of this collides with something already in flight on 2.4, tell me and I'll adjust.

  6. joseehilton147 commented on Sep 22, 2026

    @joseehilton147
    Author

    Reteste em produção na 2.4.0 (imagem ad047823…, rmcp 2.2.0 dentro) — resultado dividido em dois:

    O fix do rmcp funcionou (Obs): probe de 30 sessões completas (initialize → tool call → disconnect limpo) deixou o processo em 27→27→26 fds. A assinatura ESTAB → 0.0.0.0:0 do 2.2.0 não reapareceu — o session-table leak está resolvido no nosso tráfego.

    Mas ~3h depois apareceu a segunda assinatura — a que vocês já previam no primeiro comentário (Obs):

    fd count: 27 (estável ~3h) → 338 → 437 em ~40min (~20 fd/min no pico)
    sockets do processo × /proc/net/tcp:
      390 ESTAB -> 172.20.0.1:XXXXX   <- conexões VIVAS no kernel, peer morto
        0 CLOSE_WAIT / TIME_WAIT / órfãos de inode
      timers (ss -o): 390/392 sem timer — sem keepalive, nada os recicla
    

    Diferença para a assinatura anterior: desta vez todos os fds têm socket vivo em /proc/net/tcp (0 órfãos) — não é sessão esquecida, é conexão TCP formalmente ESTABLISHED cujo peer morreu sem FIN. O fix do rmcp cobre o disconnect notificado; peer-morto-sem-FIN nunca notifica, então a session-table pode estar limpa e o fd vazar mesmo assim.

    Origem (Obs): SYNs novos chegam de 100.127.95.124 — nossa máquina Windows via Tailscale, passando pelo docker-proxy (publish 100.103.73.60:49374:49374). São processos efêmeros (hooks de lifecycle que os clients MCP instalam: SessionStart/PreToolUse/SessionEnd) — conectam, morrem, e o FIN se perde no caminho (sleep da máquina, flap do Tailscale, kill abrupto). O docker-proxy segura o backend ESTABLISHED porque o frontend ainda não foi declarado morto.

    Prova de zumbi (Obs): ss -K dentro do netns com sport = :49374 derrubou 416 ESTABLISHED → 1 e fds 437→22, sem restart, e o serviço seguiu healthy — conexões legítimas reconectaram transparentes.

    Mitigação rodando aqui: cron a cada 15min checa o fd count; acima de 512 faz ss -K no netns do container e loga. Zero disrupção em operação normal (~30 fds) e compra tempo infinito contra o acúmulo.

    Amarração: é exatamente o caso do defense-in-depth que o @ranierelm descreveu no comentário acima — keepalive + idle-timeout no listener fecharia esses fds na fonte. Se ajudar no before/after, esse tráfego real é trivial de instrumentar aqui: fd count por minuto durante um storm de hooks sai de graça. Config atual: AI_MEMORY_BIND, AI_MEMORY_ALLOWED_HOSTS, AI_MEMORY_AUTH_TOKEN, provider openai_compat via proxy interno — o acúmulo independe do provider, é camada de transporte.

  7. akitaonrails commented on Sep 22, 2026

    @akitaonrails
    Owner

    The remaining half (half-open sockets never reaped) is fixed on main for 2.4.1: ai-memory serve now enables TCP keepalive on every accepted connection via axum's ListenerExt::tap_io + socket2, so a dead peer (sleep / VPN flap / kill) is probed and its fd reclaimed instead of sitting ESTABLISHED forever. New tcp_keepalive_secs config (default 60s; AI_MEMORY_TCP_KEEPALIVE_SECS; 0 disables), with socket-level regression tests. The rmcp session-table half was already fixed in 2.4.0 (#794). Slowloris/idle-request-timeout hardening is noted as a separate follow-up. Thanks for the production capture and the precise ss//proc/net/tcp diagnosis.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Metadata

Metadata

Assignees

No one assigned

    Labels

    bugSomething isn't working

    Projects

    No projects

      Milestone

      No milestone

      Relationships

      None yet

      Development

      No branches or pull requests

      Issue actions