# `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.

Novo 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=".")