trace — Rastreia ou acompanha a execução de instruções Python

Código-fonte: Lib/trace.py

O módulo trace permite que você rastreie a execução do programa, gere listagens de cobertura de instrução anotada, imprima relações de chamador/receptor e funções de lista executadas durante a execução de um programa. Ele pode ser usado em outro programa ou na linha de comando.

Ver também

Coverage.py

Uma popular ferramenta de cobertura de terceiros que fornece saída HTML junto com recursos avançados, como cobertura de ramificações.

Uso na linha de comando

O módulo trace pode ser chamado a partir da linha de comando. Pode ser tão simples quanto:

python -m trace --count -C . somefile.py ...

O comando acima irá executar algumarquivo.py e gerar listagens anotadas de todos os módulos Python importados durante a execução para o diretório atual.

--help

Exibe o modo de uso e sai.

--version

Exibe a versão do módulo e sai.

Adicionado na versão 3.8: Adicionada a opção --module que permite executar um módulo executável.

Opções principais

Pelo menos uma das seguintes opções deve ser especificada ao invocar trace. A opção --listfuncs é mutuamente exclusiva com as opções --trace e --count. Quando --listfuncs é fornecida, nem --count nem --trace são aceitas, e vice-versa.

-c, --count

Produz um conjunto de arquivos de listagem anotada após a conclusão do programa que mostra quantas vezes cada instrução foi executada. Veja também --coverdir, --file e --no-report abaixo.

-t, --trace

Exibe linhas como elas são executadas.

-l, --listfuncs

Exibe as funções executadas executando o programa.

-r, --report

Produz uma lista anotada de uma execução de programa anterior que usava a opção --count e --file. Isso não executa nenhum código.

-T, --trackcalls

Exibe os relacionamentos de chamada expostos ao executar o programa.

Modificadores

-f, --file=<file>

Nome de um arquivo para acumular contagens em várias execuções de rastreamento. Deve ser usado com a opção --count.

-C, --coverdir=<dir>

Diretório para onde vão os arquivos de relatório. O relatório de cobertura para pacote.módulo é escrito em arquivo dir/pacote/módulo.cover.

-m, --missing

Ao gerar listagens anotadas, marca as linhas que não foram executadas com >>>>>>.

-s, --summary

Ao usar --count ou --report, escreve um breve resumo no stdout para cada arquivo processado.

-R, --no-report

Não gera listagens anotadas. Isso é útil se você pretende fazer várias execuções com --count, e então produzir um único conjunto de listagens anotadas no final.

-g, --timing

Prefixa cada linha com o tempo desde o início do programa. Usado apenas durante o rastreamento.

Filtros

Essas opções podem ser repetidas várias vezes.

--ignore-module=<mod>

Ignora cada um dos nomes de módulo fornecidos e seus submódulos (se for um pacote). O argumento pode ser uma lista de nomes separados por uma vírgula.

--ignore-dir=<dir>

Ignora todos os módulos e pacotes no diretório e subdiretórios nomeados. O argumento pode ser uma lista de diretórios separados por os.pathsep.

Interface programática

class trace.Trace(count=1, trace=1, countfuncs=0, countcallers=0, ignoremods=(), ignoredirs=(), infile=None, outfile=None, timing=False)

Cria um objeto para rastrear a execução de uma única instrução ou expressão. Todos os parâmetros são opcionais. count ativa a contagem de números de linha. trace ativa o rastreamento de execução de linha. countfuncs ativa a listagem das funções chamadas durante a execução. countcallers ativa o rastreamento de relacionamento de chamada. ignoremods é uma lista de módulos ou pacotes a serem ignorados. ignoreirs é uma lista de diretórios cujos módulos ou pacotes devem ser ignorados. infile é o nome do arquivo do qual deve ler as informações de contagem armazenadas. outfile é o nome do arquivo no qual deve escrever as informações de contagem atualizadas. timing ativa a exibição de um carimbo de data/hora relativo ao momento em que o rastreamento foi iniciado.

run(cmd)

Executa o comando e reúne estatísticas da execução com os parâmetros de rastreamento atuais. cmd deve ser uma string ou objeto código, adequado para passar para exec().

runctx(cmd, globals=None, locals=None)

Executa o comando e reúne estatísticas da execução com os parâmetros de rastreamento atuais, nos ambientes global e local definidos. Se não for definido, globals e locals usam como padrão dicionários vazios.

runfunc(func, /, *args, **kwds)

Chama func com os argumentos fornecidos sob controle do objeto Trace com os parâmetros de rastreamento atuais.

results()

Retorna um objeto CoverageResults que contém os resultados cumulativos de todas as chamadas anteriores para run, runctx e runfunc para a instância Trace fornecida. Não redefine os resultados de rastreamento acumulados.

class trace.CoverageResults

Um contêiner para resultados de cobertura, criado por Trace.results(). Não deve ser criado diretamente pelo usuário.

update(other)

Mescla dados de outro objeto CoverageResults.

write_results(show_missing=True, summary=False, coverdir=None)

Escreve os resultados da cobertura. Defina show_missing para mostrar as linhas que não tiveram ocorrências. Defina o summary para incluir na saída o resumo da cobertura por módulo. coverdir especifica o diretório no qual os arquivos de resultados de cobertura serão enviados. Se for None, os resultados de cada arquivo de origem são colocados em seu diretório.

Um exemplo simples que demonstra o uso da interface programática:

import sys
import trace

# create a Trace object, telling it what to ignore, and whether to
# do tracing or line-counting or both.
tracer = trace.Trace(
    ignoredirs=[sys.prefix, sys.exec_prefix],
    trace=0,
    count=1)

# run the new command using the given tracer
tracer.run('main()')

# make a report, placing output in the current directory
r = tracer.results()
r.write_results(show_missing=True, coverdir=".")