Recomposed
Performance

Como Ler Qualquer Profiler

Nov 5, 2026 · 16 min read

Como Ler Qualquer Profiler

A intuição

Abra um profiler que você nunca usou, em uma plataforma que você nunca fez profiling, e as abas já parecem familiares: um número agregado, duas formas de percorrer uma árvore, um gráfico largo e colorido. Isso não é coincidência.

Quase todo profiler de CPU reduz sua gravação à mesma forma antes mesmo de desenhar uma UI: uma árvore de chamadas em que cada nó carrega dois números, e . Tudo mais na tela é só uma visão diferente construída a partir desses dois números.

  • Summary: um número agregado para o que estiver selecionado. Responde "isso é lento", não "onde".
  • Top-down: a árvore, da raiz até a folha. Responde "o que chamou essa coisa cara".
  • Bottom-up: a mesma árvore, da folha até a raiz, ordenada por tempo próprio. Responde "o que é caro, independente de quem chamou".
  • Flame chart: a mesma árvore de novo, desenhada como barras aninhadas, largura proporcional ao tempo.

Quatro visões, uma árvore subjacente. Aprenda a forma uma vez e as abas deixam de ser trivialidades específicas de ferramenta. São as mesmas quatro perguntas feitas a qualquer profiler que você abrir.

O exemplo recorrente abaixo é uma função acidentalmente quadrática, mostrada ao longo deste post no System Trace baseado em Perfetto do Android Studio. As visões em si não são específicas do Android. O Chrome DevTools e o Xcode Instruments mostram a mesma forma sob nomes de aba diferentes, cobertos mais adiante na tabela de comparação.

// ❌ List.contains() é uma busca linear, chamada uma vez por id, então
// a função inteira custa O(n²) conforme a lista cresce
fun dedupe(ids: List<String>): List<String> {
    val result = mutableListOf<String>()
    for (id in ids) {
        if (id !in result) result.add(id)
    }
    return result
}
 
// ✅ a verificação de membership de um Set é O(1), então a função inteira cai para O(n)
fun dedupe(ids: List<String>): List<String> {
    val seen = mutableSetOf<String>()
    val result = mutableListOf<String>()
    for (id in ids) {
        if (seen.add(id)) result.add(id)
    }
    return result
}

dedupe aparece como sua própria linha nomeada em todas as capturas de tela a seguir, assim como chamadas do framework como AndroidOwner:onTouch ou Compose:recompose. Essas são instrumentadas automaticamente, pelo framework. O seu próprio código não é, a menos que você mesmo envolva o ponto de chamada:

import androidx.tracing.trace
 
trace("dedupe") { dedupe(ids) }

Esse é o trace() do androidx.tracing, um wrapper fino em torno de android.os.Trace.beginSection("dedupe") / Trace.endSection() que cuida da chamada de término correspondente para você. Sem ele, o tempo de dedupe ainda está lá, só que silenciosamente dobrado em qualquer chamador que você consiga realmente ver nomeado. Esse é o problema de agregação sobre o qual todo este post trata, um nível antes de qualquer aba de profiler.

Também é seguro de enviar sem alterações. O R8 não remove essas chamadas, já que não consegue provar que uma chamada de plataforma real como beginSection não tem efeitos colaterais, então elas permanecem no APK de release de qualquer forma.

Elas são baratas independentemente disso: beginSection/endSection checam uma flag interna de habilitado antes de fazer qualquer trabalho real.

Antes do Android 12 (API 31), o sistema vai além e desabilita o tracing em nível de app em um build de release que não é debugável, ou, a partir da API 29, explicitamente marcado como profileable. Mais antigo que isso, a chamada é um verdadeiro no-op independente de tudo.

A partir da API 31, o tracing está sempre habilitado para todo app, o que só significa que ele pode emitir dados uma vez que algo esteja ativamente capturando um trace, não que esteja gravando por padrão.

Escolhendo uma tarefa de captura

FIG. 01
O seletor de tarefas do profiler do Android Studio. Três delas alimentam a árvore de chamadas sobre a qual este post trata. View Live Telemetry é um monitor em tempo real, não gravado, e o restante são tarefas de memória. Apenas as três são cobertas aqui.

Toda visão deste post sai de uma árvore de chamadas, mas uma árvore de chamadas primeiro precisa ser gravada. Só o Android Studio oferece três formas diferentes de gravar uma:

  • System Trace (Capture System Activities): o sistema inteiro, não só suas próprias chamadas, incluindo o pipeline de frames (Choreographer, vsync). A tarefa por trás de cada captura de tela deste post, e o padrão certo para recorrer primeiro.
  • Find CPU Hotspots, Callstack Sample: amostra a call stack em um intervalo fixo, cobrindo tanto seu código Kotlin/Java quanto código nativo (via simpleperf). Overhead menor que tracing instrumentado, ao custo de possivelmente perder uma chamada mais curta que o intervalo de amostragem.
  • Find CPU Hotspots, Java/Kotlin Method Recording: instrumenta cada chamada de método com um timestamp real, não só as que você envolveu manualmente como o dedupe acima. Essa precisão custa um overhead pesado o suficiente para o Android recomendar cinco segundos ou menos por gravação, e distorce a medição absoluta de tempo, então trate seus números como relativos (esta execução vs. aquela execução), não como um número de orçamento de frame.

As outras cinco tarefas no seletor não são formas alternativas de obter essa mesma árvore de chamadas, elas resolvem problemas diferentes:

  • View Live Telemetry: não é uma gravação, é uma leitura em tempo real de CPU, threads, memória e interações, para decidir o que vale a pena capturar.
  • Analyze Memory Usage (Heap Dump): um snapshot de todo objeto vivo na memória, com tamanho retido/raso por classe.
  • Find Memory Leaks with LeakCanary: a própria análise de leak do LeakCanary, executada na sua máquina de desenvolvimento em vez de no dispositivo.
  • Track Memory Consumption (Java/Kotlin Allocations): toda alocação e desalocação ao longo de uma janela de tempo, não só um snapshot.
  • Track Memory Consumption (Native Allocations): a mesma linha do tempo de alocações, para o heap nativo C/C++, amostrada por padrão.

Todas as cinco constroem uma forma de dados diferente, um grafo de memória ou um medidor em tempo real, não uma árvore de chamadas. O modelo deste post não se aplica a elas.

Para o bug do dedupe() neste post, o System Trace é a escolha certa desde o início. O ponto inteiro é capturar uma duração que sobe ao longo das chamadas, e isso só aparece quando você consegue ver o tempo ordenado ao longo de uma gravação completa, não uma janela instrumentada curta. Recorra ao Method Recording em vez disso quando a pergunta for mais restrita: "exatamente quantas vezes isso foi chamado", confirmado por um número em vez de olhar no olho uma coluna dur que sobe.

Qual thread, entre quarenta

Um System Trace grava toda thread agendada durante aquela janela, não só as do seu app. Expanda o painel Threads em um dispositivo real e você verá dezenas de linhas, a maioria delas contabilidade do sistema que nunca toca seu código.

Três são importantes para um bug de renderização de UI:

  • A main thread, nomeada a partir do processo do seu app (mi.composeplay2 nas capturas de tela deste post): executa o Choreographer, o despacho de input, measure/layout/draw, e qualquer código seu que nunca passou para outra thread. AndroidOwner:onTouch e dedupe vivem ambos aqui.
  • RenderThread: pega os comandos de desenho que a main thread produziu e os envia para a GPU. Separada da main thread desde o Android 5.0 (Lollipop), então um frame lento pode ser culpa da main thread, da RenderThread, ou de ambas.
  • GPU completion: quanto tempo a própria GPU levou em um frame que as duas threads acima já passaram adiante. Raramente o primeiro lugar para procurar, mas descarta as outras duas quando nenhuma mostra uma parada óbvia.

Tudo mais se encaixa em algumas categorias, quase nenhuma das quais é onde um bug de app se esconde:

  • Binder:<pid>_<n>: o pool de threads tratando chamadas de e para serviços do sistema. Vale a pena abrir só se a própria comunicação entre processos for o suspeito do gargalo.
  • HeapTaskDaemon, Jit thread pool, Signal Catcher, Profile Saver: manutenção do runtime ART, coleta de lixo, compilação JIT, tratamento de sinal de crash, persistência de profile. Você verá o efeito delas na sua própria thread (uma pausa de GC roubando tempo de CPU, como a lacuna coberta na seção da aba Events mais adiante) com muito mais frequência do que precisará abri-las diretamente.
  • Suas próprias threads em segundo plano, se seu app iniciou alguma (o pool de workers de um dispatcher de coroutine, um ExecutorService customizado): vale a pena checar só depois que o bug que você está perseguindo já tiver se movido de fato para fora da main thread.

Clicar na linha de uma thread, não no gráfico de visão geral acima dela, é o que filtra todas as outras visões deste post para aquela única thread. Summary, Top-down, Bottom-up e a aba Events todos leem a partir de qualquer thread que esteja selecionada no momento.

Summary: um número, nenhum local

FIG. 02
Summary para a explosão de dedupe(), com tanto o intervalo de tempo quanto a thread selecionados. dedupe já domina a coluna Self Time, mesmo que suas chamadas de despacho ancestrais ainda postem o Wall Duration maior.

Selecione apenas um intervalo de tempo e o Summary fica quase vazio, só Time Range e Duration. Selecione a thread também, e a tabela "Longest running events" se preenche, os maiores blocos individuais de trabalho naquela seleção.

Seis das doze chamadas de dedupe só por si preenchem mais da metade dessa lista top-10, cada uma com seu Self Time bem acima das chamadas de despacho do framework sentadas acima delas. Essas chamadas do framework ainda postam o Wall Duration maior, porém, já que sua Duration inclui o próprio tempo de dedupe mais tudo mais que elas fizeram.

Cada linha ali carrega na verdade quatro números, não um, dois eixos independentes empilhados juntos:

ColunaEixoMede
Wall DurationTotal, relógio de paredeTempo real decorrido para esta chamada e tudo que ela chamou
Wall Self TimePróprio, relógio de paredeTempo real decorrido que o código desta própria chamada levou, não dos seus chamados
CPU DurationTotal, só CPUTempo em que um núcleo de CPU esteve de fato ocupado executando esta chamada e seus chamados
CPU Self TimePróprio, só CPUA mesma medida só-CPU, apenas o código desta própria chamada

Ambos os eixos se reduzem à forma do código, não ao app específico. AndroidOwner:onTouch e dedupe são os nomes reais da captura de tela acima, reconstruídos aqui em um substituto simplificado para que o mecanismo fique visível em duas linhas em vez de enterrado em uma call stack real:

fun onTouch(event: MotionEvent) = trace("AndroidOwner:onTouch") {
    recordGesture(event)   // apenas uma chamada, igual à abaixo
    dedupe(ids)             // também apenas uma chamada, a partir daqui. Nada no
                            // próprio corpo de onTouch marca uma diferença
}
 
fun dedupe(ids: List<String>) = trace("dedupe") {   // <- esta é a diferença:
                                                      //    dedupe abre sua PRÓPRIA
                                                      //    seção, recordGesture
                                                      //    nunca faz isso
    for (id in ids) {
        if (id !in result) result.add(id)   // trabalho real: Wall Duration, CPU Duration
    }
    // uma pausa de GC pode cair em qualquer lugar aqui: a thread é suspensa, então
    // ainda conta para o Wall Duration, mas não para o CPU Duration
}

As duas chamadas parecem idênticas vistas de dentro de onTouch, mesma forma de linha, lado a lado. O que as separa não é a posição no código, é se o chamado abre sua própria seção de trace.

recordGesture() nunca faz isso, então seu tempo permanece dobrado no Self Time de onTouch, não importa quanto tempo ele rode. dedupe() faz isso, na sua própria definição abaixo, então no instante em que a execução entra nele, o profiler começa a contar esse tempo contra a própria seção de dedupe em vez disso.

A Duration de onTouch ainda inclui tudo isso, pausa de GC e tudo mais, mas seu Self Time cobre só recordGesture(), a parte que nunca passou para uma seção filha.

Duration vs. Self é a mesma divisão com que a seção de Intuição abriu, tempo total vs. tempo próprio. É exatamente o que o Top-down e o Bottom-up leem a partir dessa mesma árvore de chamadas em seguida.

Wall vs. CPU é o segundo eixo. O relógio de parede conta todo microssegundo que de fato passou. O tempo de CPU conta só os microssegundos em que um núcleo estava realmente executando essa chamada. O tempo de CPU nunca pode exceder o tempo de parede, a lacuna entre eles é exatamente quanto tempo a thread passou desagendada, bloqueada, ou pausada no meio da chamada. A pausa de GC no trecho acima é um caso concreto dessa lacuna, coberto de novo mais adiante na seção da aba Events.

Essa ainda não é, porém, a visão para este bug específico. A tabela limita a dez linhas e ordena por duração, não por ordem de chamada, então só o punhado maior das doze chamadas entra na lista, e não na ordem em que foram executadas.

Você consegue perceber que algo chamado dedupe é caro. Você não consegue dizer se esse custo é constante, crescente, ou aleatório apenas a partir dessa tabela, porque o Summary nunca foi construído para preservar ordem, só magnitude.

Top-down: o que chamou isso

FIG. 03
Top Down para o mesmo trace. dedupe é uma única linha aqui, Total 1.194.813µs, 61,18% do tempo selecionado da thread, Self igual ao Total já que não tem filhos próprios.

O Top-down começa na raiz da árvore de chamadas (a própria thread aqui) e expande para baixo em tudo que ela chamou. Cada linha mostra dois números para aquele nó:

  • Total: ele mesmo mais tudo abaixo dele
  • Self: só aquele nó, nada que ele chamou

Seguir dispatchInputEvent → deliverInputEvent → ViewPostImeInputStage → AndroidOwner:onTouch até dedupe é a visão para "eu sei aproximadamente onde no meu código isso aconteceu, me mostre o caminho que chegou até ali".

Aquela única linha de dedupe também é a agregação da seção de Intuição tornada concreta: seu Total, 1.194.813µs, é (dentro do arredondamento) a soma das doze durações de chamada individuais que a aba Events listou separadamente. O Top-down dobrou doze chamadas compartilhando a mesma call stack em uma linha no instante em que você parou de olhar eventos brutos e começou a ler uma árvore.

Bottom-up: o que é caro, independente do chamador

FIG. 04
Bottom Up para o mesmo trace. A coluna Self de dedupe, 1.194.813µs, é maior que o próprio tempo próprio não atribuído da thread (429.887µs, tempo nesta thread fora de qualquer seção nomeada) e o self time de todas as outras funções somadas.

O Bottom-up inverte a direção do Top-down: cada linha é uma função, e expandi-la mostra seus chamadores, não seus chamados. Os números de Self e Total em uma linha são somados em todo lugar de onde aquela função foi chamada em qualquer lugar da gravação, não só um caminho. Essa é a visão para "eu ainda não sei qual chamador é o problema, só quero a única função mais cara, ponto final".

Olhando a coluna Self diretamente, ignorando a posição na árvore por completo, torna o bug deste trace óbvio: dedupe sozinho representa mais tempo próprio (1.194.813µs) do que o próprio tempo não atribuído da thread (429.887µs) e o self time de todas as outras funções combinadas. Se dedupe() aparecesse tão alto no Bottom-up independente de qual tela ou gesto o disparou, isso apontaria para a própria função, não para como algum chamador específico a está usando.

Flame chart: a mesma árvore, desenhada como largura

FIG. 05
Flame Chart para o mesmo trace. As doze chamadas de dedupe colapsam na única barra larga em cima, mesma largura de AndroidOwner:onTouch embaixo dela, porque todas compartilham a call stack idêntica. As barras finas à direita são folhas não relacionadas em outro lugar da thread, não fragmentos de dedupe.

Um flame chart desenha exatamente a mesma árvore de chamadas como uma imagem: cada nó é uma barra horizontal, largura proporcional ao tempo, empilhada acima de seu pai, raiz na base. Barras mais largas são mais caras, visualmente, sem ler um único número.

dedupe sendo chamado doze vezes não produz doze barras aqui, igual ao Top-down. Toda chamada compartilhando aquela stack se dobra na única barra em cima.

Duas coisas diferentes compartilham esse nome

A aba Flame Chart do Android Studio e do Perfetto mescla toda chamada com a mesma stack em uma barra, a mesma agregação que o Top-down e o Bottom-up fazem, só desenhada como largura em vez de um número. A trilha de main thread do Chrome DevTools parece similar mas não é mesclada de forma alguma, cada caixa é uma chamada real em sua posição cronológica real.

Ler uma como a outra é um erro fácil de cometer. Uma trilha estilo Chrome pode mostrar um bug crescendo ao longo do tempo a olho nu. Uma aba de flame chart mesclada não consegue, porque toda chamada já foi dobrada em uma barra antes de ser desenhada.

A única coisa que nenhuma delas te dá

FIG. 06
12 chamadas de dedupe(), ordenadas por nome, na mesma ordem em que foram executadas. A Duration sobe de 1,72ms a um pico de 273,88ms, depois se estabiliza na faixa de 150-190ms, a explosão quadrática (com ruído de GC sobreposto), invisível em todas as quatro visões agregadas acima.

Execute dedupe() em uma lista crescente e alimente-a com uma entrada um pouco mais longa a cada chamada. O Summary te dá um total. O Top-down e o Bottom-up te dão um par Total/Self por caminho de chamada único, não por chamada. A aba Flame Chart mesclada dobra toda chamada em uma barra.

Todas as quatro visões já descartaram a única informação que mostraria uma função acidentalmente quadrática em flagrante: a duração própria de cada chamada individual, na ordem em que aconteceu.

Esse dado ainda existe. Todo profiler grava um timestamp e uma duração por chamada, só não é o que nenhuma das quatro visões agregadas escolhe te mostrar.

No Android Studio, o ajuste é ordenação, não consulta: a aba Events (ao lado de Bottom Up, depois de selecionar uma thread) lista toda seção nomeada naquela thread. Ordene por Name, e toda chamada de dedupe se agrupa em ordem de Start Time, com o Wall Duration bem ao lado, sem SQL envolvido.

Lido de cima para baixo, uma coluna de duração plana significa que o custo por chamada é constante. Uma que sobe é a explosão quadrática, visível no momento em que você para de agregar e olha cada chamada por conta própria.

Essa subida não é perfeitamente suave, porém, e a divisão Wall-vs-CPU da seção Summary explica por quê. dedupe() aloca uma lista crescente em toda chamada, e passado um certo tamanho isso dispara pausas reais de coleta de lixo, tempo em que a thread fica desagendada, não tempo que ela gasta computando.

O Wall Duration conta essa pausa. O CPU Duration não. As chamadas maiores mostram uma lacuna wall-vs-CPU notavelmente mais larga que as menores, pressão de GC se somando ao custo quadrático real. É exatamente o que um trace real de dispositivo parece uma vez que a curva idealizada limpa encontra um heap real.

A camada de consulta também não é específica de ferramenta

A aba Events do Android Studio é suficiente quando você está olhando um trace, uma vez, a olho nu. Ela deixa de ser suficiente no momento em que a pergunta muda de forma:

  • Comparar as durações de dedupe desta execução contra a baseline da semana passada.
  • Filtrar em um trace com dezenas de milhares de eventos em vez de 281.
  • Ler um trace que não saiu do Android Studio de forma alguma.

É para isso que a camada SQL realmente serve, roteirizar a mesma pergunta que o Events responde manualmente.

Duas coisas primeiro: o próprio arquivo de trace, exportado da aba Past Recordings do Android Studio (Export recording, nem todo tipo de captura dá suporte a isso), e o trace_processor instalado localmente:

curl -LO https://get.perfetto.dev/trace_processor
chmod +x ./trace_processor

Todo trace compartilha a mesma tabela slice, então query.sql só pergunta a ela diretamente:

SELECT ts, dur FROM slice WHERE name = 'dedupe' ORDER BY ts;
# lê um trace capturado pelo Android
trace_processor query -f query.sql android-trace.perfetto-trace
 
# lê um trace que o Chrome DevTools exportou como JSON, mesma query, mesmas tabelas
trace_processor query -f query.sql chrome-trace.json

O arquivo é opcional. Para uma consulta pontual, pule-o e passe o SQL diretamente como uma string:

trace_processor query android-trace.perfetto-trace \
  "SELECT ts, dur FROM slice WHERE name = 'dedupe' ORDER BY ts"

O trace_processor do Perfetto analisa tanto um trace de sistema do Android quanto o JSON exportado pelo Chrome DevTools (o Trace Event Format que o Chrome usa desde o chrome://tracing) nas mesmas tabelas SQL slice/track/thread. A query acima roda sem modificação contra qualquer um dos arquivos. A camada SQL nunca foi específica do Android, só por acaso é a ferramenta que o Android disponibiliza.

O Xcode Instruments não tem um equivalente. xctrace export te dá dados estruturados a partir de um arquivo .trace, mas via XPath contra a tabela de conteúdo do trace, em XML, não SQL:

xctrace export --input recording.trace \
  --xpath '/trace-toc/run[@number="1"]/data/table[@schema="time-profile"]' \
  --output time-profile.xml

Você ainda consegue obter uma lista por instância, ordenada no tempo, dessa forma. É só um script que você mesmo escreve contra XML em vez de uma consulta contra um banco de dados que já tem as colunas certas.

Qual visão, em qual ferramenta

O que mostraAndroid Studio / PerfettoChrome DevToolsXcode Instruments
Um número agregado para uma seleçãoSummarySummaryTop Functions
Árvore de chamadas, da raiz até a folhaTop DownCall TreeCall Tree
Árvore de chamadas, da folha até a raiz, ordenada por tempo próprioBottom UpBottom-UpCall Tree, com Invert Call Tree marcado
Call stacks mescladas, largura = tempoFlame Chart (mesclado)trilha de main thread (não mesclada, cronológica)Flame Graph
Por instância, ordenado no tempo, roteirizávelAba Events (manual), trace_processor (SQL, roteirizável)trace_processor (SQL, via importação de JSON)xctrace export (XPath → XML, sem SQL)

Quando recorrer a um profiler

Um profiler responde "por que isso está lento", não "isso está lento". Essa pergunta geralmente chega primeiro, de outro lugar: um gate de CI sinalizando uma regressão, um colega de equipe dizendo que um gesto parece travado, uma métrica de frames perdidos subindo em produção. Abrir um profiler antes de esse sinal existir significa ler árvores de chamadas para um problema que você ainda não confirmou ser real.

Também é lento de propósito, não por acidente. Capturar um trace, escolher uma tarefa de captura, ler quatro visões agregadas, depois escrever uma consulta para a única coisa que elas não mostram, são minutos de atenção focada por trace.

Esse custo faz sentido uma vez, para diagnóstico. Não escala para rodar em todo commit.

Essa é a linha real: diagnóstico (por quê) permanece manual, detecção (isso regrediu) não precisa ser. Envolva a chamada suspeita na mesma seção de trace nomeada que um profiler já lê, depois grave sua duração em toda execução de CI em vez de esperar alguém notar:

// grava a própria duração de dedupe() em toda execução de CI, via a mesma seção
// de trace nomeada que toda captura de tela de profiler deste post lê
@Test
fun dedupeDuration() = benchmarkRule.measureRepeated(
    packageName = "com.example.app",
    metrics = listOf(TraceSectionMetric("dedupe", TraceSectionMetric.Mode.Sum)),
    iterations = 10,
    setupBlock = { startActivityAndWait() },
) {
    triggerTheFlowThatCallsDedupe()
}

Isso produz um número, não um veredito. O resultado de cada execução ainda precisa ser comparado contra uma baseline armazenada para decidir passa ou falha. O profiler só é aberto uma vez que essa comparação falha, para responder o porquê, que é a pergunta sobre a qual o resto deste post realmente trata.

Variações e tradeoffs

  • Agregação é o padrão, não um bug. Cada uma das quatro visões principais existe especificamente para colapsar chamadas repetidas em um número, porque é isso que torna "o que está lento" respondível em menos de um segundo para os 95% dos casos em que o custo por chamada realmente é constante. O bug do loop quadrático acima é exatamente os outros 5%, o caso em que agregar a ordem por chamada esconde a forma real do problema.
  • Esse modelo mental é especificamente para profiling de CPU/tempo de parede. Uma árvore de chamadas com tempo próprio/total é a forma compartilhada por trás de profilers de CPU por amostragem e por tracing. O grafo de tamanho retido de um heap profiler ou a divisão por estágio de pipeline de um profiler de frames de GPU é uma forma de dados genuinamente diferente. Os mesmos quatro nomes de aba às vezes são reutilizados por convenção, mas não são construídos a partir da mesma árvore subjacente, então o mapeamento deste post não se transfere para eles.
  • Não ter uma camada SQL é um custo real, não trivialidade. Se você precisa da resposta por instância, ordenada no tempo, no iOS e não quer analisar XML manualmente, as opções honestas são roteirizar contra a saída do xctrace export ou converter o trace em um formato que outra coisa consiga consultar. Não existe um atalho de primeira parte do jeito que o trace_processor é um para Android e Chrome.
Keep reading

Related reads

Receba novos posts no seu e-mail