perfetto-analyzer 1.0.3 → 1.0.5

package/CHANGELOG.md

@@ -1,5 +1,31 @@
 # Changelog
 
+## [1.0.5] - 2026-07-09
+
+### Adicionado
+- **`parse_perfetto_pb.py`** — Nova função `extract_thread_states()` que analisa a tabela `thread_state` do Perfetto: detecta I/O síncrono (estado `D` — uninterruptible sleep com `blocked_function`) e contenção de locks Java (slices de Monitor) por thread do app. Dado ausente nos traces anteriores que agora resolve o padrão "app travou mas o profiler não mostra nada".
+- **`parse_perfetto_pb.py`** — Nova função `extract_cpu_megacycles()` usando o stdlib module `linux.cpu.utilization.process` (Android 12+). Retorna `[]` silenciosamente em versões anteriores.
+- **`scripts/configs/oom.textproto`** — Novo tipo de trace `oom`: captura heap dump automaticamente ao momento do `OutOfMemoryError` via trigger `android.java_hprof.oom`. Aguarda até 1h o crash acontecer.
+- **`analyze_metrics.py`** — Nova função `analyze_thread_states()` que gera issue `critical` quando a main thread está em I/O síncrono >10ms e `warning` para contenção de lock >5ms.
+- **`generate_report.py`** — Nova seção **"Contenção de Threads"** na seção CPU com tabelas separadas para I/O bloqueante e Monitor contention.
+- **`generate_report.py`** — Nova seção **"CPU Megacycles por Processo"** exibida quando disponível (Android 12+).
+- **`collect_trace.py`** — Suporte ao tipo `oom`: modo especial sem countdown, aguarda o crash via Ctrl+C para cancelar.
+
+### Referências (cookbooks do Perfetto que inspiraram estas melhorias)
+- [Android Trace Analysis](https://perfetto.dev/docs/getting-started/android-trace-analysis)
+- [Android OOM](https://perfetto.dev/docs/case-studies/android-outofmemoryerror)
+
+## [1.0.4] - 2026-07-09
+
+### Adicionado
+- **`generate_report.py`** — Seção "Próximos Passos" agora inclui sugestões de traces de correlação automáticas quando fazem sentido:
+  - `cpu` com Compose: sugere `frames` para confirmar se as recomposições causam drops reais
+  - `cpu` com problemas: sugere `memory` para verificar heap churn nos mesmos hot paths
+  - `frames` com jank: sugere `cpu` para identificar a callstack durante o deadline miss
+  - `memory` com problemas: sugere `cpu` (hotspots de alocação) e `frames` (GC causando jank)
+  - `battery` com problemas: sugere `cpu` e `all`
+  - Trace tipo `all`: nenhuma sugestão (já captura tudo)
+
 ## [1.0.3] - 2026-07-09
 
 ### Corrigido

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "perfetto-analyzer",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "AI skill for Android performance analysis using Perfetto — works with Claude Code, Cursor, GitHub Copilot, Codex, Antigravity and Devin",
   "bin": {
     "perfetto-analyzer": "bin/cli.js"

package/skill/scripts/configs/oom.textproto

@@ -0,0 +1,25 @@
+buffers: {
+    size_kb: 524288
+    fill_policy: DISCARD
+}
+
+data_sources: {
+    config {
+        name: "android.java_hprof.oom"
+        java_hprof_config {
+            process_cmdline: "__PACKAGE__"
+        }
+    }
+}
+
+# Dispara automaticamente ao detectar java.lang.OutOfMemoryError
+# no processo monitorado. Para o trace 500ms após a detecção
+# para garantir que o heap dump seja capturado.
+trigger_config {
+    trigger_mode: STOP_TRACING
+    triggers {
+        name: "com.android.telemetry.art-outofmemory"
+        stop_delay_ms: 500
+    }
+    trigger_timeout_ms: 3600000
+}

package/skill/scripts/generate_report.py

@@ -77,6 +77,66 @@ def severity_emoji(s):
 JVM_NOISE = {"RuntimeInit", "ZygoteInit", "NativeStart", "Looper.loop"}
 
 
+def _correlations(trace_type, recommendations):
+    """Sugere traces complementares com base no tipo atual e nos problemas encontrados."""
+    if trace_type == "all":
+        return []
+
+    categories = {r.get("category") for r in recommendations}
+    titles = " ".join(r.get("title", "") for r in recommendations)
+    suggestions = []
+
+    if trace_type == "cpu":
+        if "Recomposição" in titles or "Compose" in titles:
+            suggestions.append((
+                "frames",
+                "Correlacionar recomposições com drops reais — o trace de frames mostra se as "
+                "recomposições detectadas aqui estão de fato causando frames janked visíveis.",
+            ))
+        if "cpu" in categories:
+            suggestions.append((
+                "memory",
+                "Verificar se heap churn está pressionando a CPU — GC frequente aparece como "
+                "picos de CPU; o trace de memória confirma alocações excessivas nos mesmos hot paths.",
+            ))
+
+    elif trace_type == "frames":
+        if "frames" in categories:
+            suggestions.append((
+                "cpu",
+                "Identificar a callstack responsável pelos drops — o trace de CPU a 60 Hz mostra "
+                "exatamente qual função estava rodando durante cada deadline miss.",
+            ))
+
+    elif trace_type == "memory":
+        if "memory" in categories:
+            suggestions.append((
+                "cpu",
+                "Localizar os hotspots de alocação no callstack — o trace de CPU revela quais "
+                "funções disparam as alocações identificadas aqui.",
+            ))
+            suggestions.append((
+                "frames",
+                "Verificar se o churn de memória/GC está causando jank — pausas de GC aparecem "
+                "como frames dropados no trace de frames.",
+            ))
+
+    elif trace_type == "battery":
+        suggestions.append((
+            "cpu",
+            "Identificar quais funções consomem mais CPU e drenam a bateria — o trace de CPU "
+            "mapeia o gasto energético a callstacks específicos.",
+        ))
+        if recommendations:
+            suggestions.append((
+                "all",
+                "Trace completo para correlação total — combina CPU, frames e memória para uma "
+                "visão unificada do drain.",
+            ))
+
+    return suggestions
+
+
 def generate_report(data, package, trace_type):
     now = datetime.now().strftime("%Y-%m-%d %H:%M")
     duration = data.get("trace_duration_seconds", 0)
@@ -357,11 +417,16 @@ def generate_report(data, package, trace_type):
         lines += ["Nenhum problema detectado automaticamente. Revise o trace manualmente no [Perfetto UI](https://perfetto.dev/ui).", ""]
 
     # Próximos Passos
-    lines += [
-        "---",
-        "",
-        "## Próximos Passos",
-        "",
+    correlations = _correlations(trace_type, recommendations)
+
+    next_steps = ["---", "", "## Próximos Passos", ""]
+
+    if correlations:
+        for next_type, reason in correlations:
+            next_steps.append(f"- [ ] **Trace `{next_type}`** — {reason}")
+        next_steps.append("")
+
+    next_steps += [
         "- [ ] Abrir o arquivo `.pb` em [perfetto.dev/ui](https://perfetto.dev/ui) para análise visual",
         "- [ ] Usar o SQL Explorer do Perfetto UI para queries customizadas",
         "- [ ] Correlacionar picos de CPU/memória com interações do usuário na timeline",
@@ -372,6 +437,8 @@ def generate_report(data, package, trace_type):
         f"*Gerado por perfetto-analyzer em {now}*",
     ]
 
+    lines += next_steps
+
     return "\n".join(lines)