Compartilhar via

Rastreamento e instrumentação de aplicativos

  • Artigo

Observação

Este artigo é específico para aplicativos .NET Framework. Não se aplica a implementações mais recentes do .NET, incluindo o .NET 6 e versões posteriores.

O rastreamento é uma maneira de você monitorar a execução de seu aplicativo enquanto ele é executado. É possível adicionar a instrumentação de rastreamento e depuração ao aplicativo do .NET Framework durante seu desenvolvimento e usar essa instrumentação enquanto você estiver desenvolvendo o aplicativo e depois de implantá-lo. É possível usar as classes System.Diagnostics.Trace, System.Diagnostics.Debug e System.Diagnostics.TraceSource para registrar informações sobre erros e a execução do aplicativo em logs, arquivos de texto ou outros dispositivos para análise posterior.

O termo instrumentação refere-se à capacidade de monitorar ou medir o nível de desempenho de um produto e de diagnosticar erros. Em programação, isso significa a capacidade de um aplicativo de incorporar:

  • Rastreamento de código –Recebimento de mensagens informativas sobre a execução de um aplicativo em tempo de execução.

  • Depuração – Rastreamento e correção de erros de programação em um aplicativo em desenvolvimento. Para obter mais informações, consulte Depurando.

  • Contadores de desempenho – Componentes que permitem acompanhar o desempenho do aplicativo. Para obter mais informações, consulte Performance Counters.

  • Logs de eventos – Componentes que permitem receber e acompanhar os principais eventos na execução do aplicativo. Para obter mais informações, consulte a classe EventLog.

A instrumentação do aplicativo com a colocação de instruções de rastreamento em locais estratégicos no código é especialmente útil para aplicativos distribuídos. Usando as instruções de rastreamento, você pode instrumentar um aplicativo não apenas para exibir informações quando as coisas dão errado, mas também para monitorar o desempenho do aplicativo.

A classe TraceSource fornece recursos de rastreamento avançados e pode ser usada no lugar dos métodos estáticos das classes de rastreamento antigas Trace e Debug. As classes Trace e Debug conhecidas ainda são amplamente usadas, mas a classe TraceSource é recomendada para novos comandos de rastreamento, como TraceEvent e TraceData.

As classes Trace e Debug são idênticas, exceto pelo fato de que os procedimentos e as funções da classe Trace são compiladas por padrão em builds de versão, ao contrário daqueles da classe Debug.

As classes Trace e Debug fornecem os meios para monitorar e examinar o desempenho do aplicativo durante o desenvolvimento ou após a implantação. Por exemplo, é possível usar a classe Trace para acompanhar determinados tipos de ações em um aplicativo implantado, conforme eles ocorrem (por exemplo, criação de novas conexões de banco de dados) e, portanto, é possível monitorar a eficiência do aplicativo.

Rastreamento e depuração de código

Durante o desenvolvimento, use os métodos de saída da classe Debug para exibir mensagens na janela de Saída do IDE (ambiente de desenvolvimento integrado) do Visual Studio. Por exemplo:

Trace.WriteLine("Hello World!")
Debug.WriteLine("Hello World!")

System.Diagnostics.Trace.WriteLine("Hello World!");
System.Diagnostics.Debug.WriteLine("Hello World!");

Cada um desses exemplos exibirá "Olá, Mundo!" na janela de Saída quando o aplicativo for executado no depurador.

Isso permite depurar os aplicativos e otimizar seu desempenho com base em seu comportamento no ambiente de teste. É possível depurar o aplicativo no build de depuração com o atributo condicional Debug ativado, de modo que toda a saída de depuração seja recebida. Quando o aplicativo está pronto para liberação, é possível compilar o build de versão sem ativar o atributo condicional Debug, de modo que o compilador não inclua o código de depuração no executável final. Para obter mais informações, consulte Como compilar condicionalmente com Trace e Debug. Para obter mais informações sobre diferentes configurações de build para o aplicativo, consulte Compilando e criando.

Você também pode rastrear a execução de código em um aplicativo instalado, usando métodos da classe Trace. Incluindo Opções de Rastreamento em seu código, você pode controlar se o rastreamento ocorre e qual a sua extensão. Isso permite monitorar o status do aplicativo em um ambiente de produção. Isso é particularmente importante em um aplicativo de negócios que usa vários componentes executados em vários computadores. É possível controlar como as opções são usadas após a implantação por meio do arquivo de configuração. Para obter mais informações, consulte Como criar, inicializar e configurar opções de rastreamento.

Quando você estiver desenvolvendo um aplicativo para o qual pretende usar o rastreamento, você geralmente incluirá mensagens de rastreamento e depuração no código do aplicativo. Quando estiver pronto para implantar o aplicativo, compile o build de versão sem ativar o atributo condicional Debug. No entanto, você pode ativar o atributo condicional Trace, de modo que o compilador inclua o código de rastreamento no executável. Para obter mais informações, consulte Como compilar condicionalmente com Trace e Debug.

Fases de rastreamento de código

Há três fases de rastreamento de código:

  1. Instrumentação – você adiciona o código de rastreamento ao aplicativo.

  2. Rastreamento – o código de rastreamento grava as informações no destino especificado.

  3. Análise – você avalia as informações de rastreamento para identificar e entender problemas no aplicativo.

Durante o desenvolvimento, todos os métodos de saída de depuração e rastreamento gravam informações na janela de Saída do Visual Studio por padrão. Em um aplicativo implantado, os métodos gravam informações de rastreamento nos destinos especificados. Para obter mais informações sobre como especificar um destino de saída de rastreamento ou de depuração, consulte Ouvintes de rastreamento.

Veja a seguir uma visão geral das principais etapas geralmente envolvidas no uso do rastreamento para analisar e corrigir problemas potenciais em aplicativos implantados. Para obter mais informações sobre como executar essas etapas, consulte o link apropriado.

Para usar o rastreamento em um aplicativo

  1. Considere qual saída de rastreamento você desejará receber no local depois de implantar o aplicativo.

  2. Crie um conjunto de opções. Para obter mais informações, consulte Como: configurar opções de rastreamento.

  3. Adicione as instruções de rastreamento ao código do aplicativo.

  4. Determine o local em que você deseja que a saída de rastreamento seja exibida e adicione os ouvintes apropriados. Para obter mais informações, consulte Criando e inicializando ouvintes de rastreamento.

  5. Teste e depure o aplicativo e o código de rastreamento que ele contém.

  6. Compile o aplicativo no código executável usando um dos seguintes procedimentos:

    • Use o menu Compilar juntamente com a página Depurar da caixa de diálogo Páginas de Propriedades no Gerenciador de Soluções. Use essa opção quando estiver compilando no Visual Studio.

      - ou -

    • Use as diretivas do compilador Trace e Debug para o método de compilação de linha de comando. Para obter mais informações, consulte Compilando condicionalmente com Trace e Debug. Use essa opção quando estiver compilando na linha de comando.

  7. Se ocorrer um problema durante o tempo de execução, ative a opção de rastreamento apropriada. Para obter mais informações, consulte Configurando Opções de Rastreamento.

    O código de rastreamento grava mensagens de rastreamento em um destino especificado, por exemplo, uma tela, um arquivo de texto ou um log de eventos. O tipo de ouvinte incluído na coleção Trace.Listeners determina o destino.

  8. Analise as mensagens de rastreamento para identificar e entender o problema no aplicativo.

Instrumentação de rastreamento e aplicativos distribuídos

Ao criar um aplicativo distribuído, talvez seja difícil testá-lo da maneira em que ele será usado. Poucas equipes de desenvolvimento têm a capacidade de testar todas as combinações possíveis de sistemas operacionais ou navegadores da Web (incluindo todas as opções de idiomas localizados) ou de simular o grande número de usuários que acessarão o aplicativo ao mesmo tempo. Nessas circunstâncias, não é possível testar como um aplicativo distribuído responderá a grandes volumes, diferentes configurações e comportamentos exclusivos do usuário final. Além disso, muitas partes de um aplicativo distribuído não tem nenhuma interface do usuário com a qual é possível interagir diretamente ou exibir a atividade dessas partes.

No entanto, é possível compensar isso permitindo que os aplicativos distribuídos descrevam determinados eventos de interesse para os administradores do sistema, especialmente, as coisas que dão errado, com a instrumentação do aplicativo – ou seja, colocando instruções de rastreamento em locais estratégicos no código. Portanto, se algo inesperado ocorrer em tempo de execução (por exemplo, um tempo de resposta excessivamente lento), será possível determinar a provável causa.

Com instruções de rastreamento, você pode evitar a difícil tarefa de examinar o código-fonte original, modificá-lo, recompilá-lo e tentar produzir o erro em tempo de execução no ambiente de depuração. Lembre-se de que é possível instrumentar um aplicativo não apenas para exibir erros, mas também para monitorar o desempenho.

Posicionamento estratégico de instruções de rastreamento

Tenha cuidado especial ao colocar as instruções de rastreamento para uso durante o tempo de execução. Considere quais informações de rastreamento são provavelmente necessárias em um aplicativo implantado, para que todos os prováveis cenários de rastreamento sejam abordados de forma adequada. No entanto, como os aplicativos que usam o rastreamento variam muito, não há diretrizes gerais para o posicionamento estratégico de rastreamento. Para obter mais informações sobre como inserir instruções de rastreamento, consulte Como adicionar instruções de rastreamento ao código do aplicativo.

Saída de rastreamento

A saída de rastreamento é coletada por objetos chamados ouvintes. Um ouvinte é um objeto que recebe a saída de rastreamento e grava-a em um dispositivo de saída (geralmente, uma janela, um log ou um arquivo de texto). Quando um ouvinte de rastreamento é criado, normalmente, ele é adicionado à coleção Trace.Listeners, permitindo que o ouvinte receba toda a saída de rastreamento.

As informações de rastreamento são sempre gravadas, pelo menos, no destino de saída Trace padrão, o DefaultTraceListener. Se, por algum motivo, você excluiu o DefaultTraceListener sem adicionar outros ouvintes à coleção Listeners, não receberá nenhuma mensagem de rastreamento. Para obter mais informações, consulte Ouvintes de rastreamento.

Os seis membros Debug e métodos Trace que gravam informações de rastreamento são listados na tabela a seguir.

Método Saída
Assert O texto especificado; ou, se nenhum for especificado, a Pilha de Chamadas. A saída só é gravada se a condição especificada como argumento na instrução Assert for false.
Fail O texto especificado; ou, se nenhum for especificado, a Pilha de Chamadas.
Write O texto especificado.
WriteIf O texto especificado, se a condição especificada como argumento na instrução WriteIf for atendida.
WriteLine O texto especificado e um retorno de carro.
WriteLineIf O texto especificado e um retorno de carro, se a condição especificada como argumento na instrução WriteLineIf for atendida.

Todos os ouvintes na coleção Listeners recebem as mensagens descritas na tabela acima, mas as ações executadas podem variar, dependendo de qual tipo de ouvinte recebe a mensagem. Por exemplo, DefaultTraceListener exibe uma caixa de diálogo de declaração quando recebe uma notificação Fail ou Assert com falha, mas um TextWriterTraceListener apenas grava a saída no fluxo.

Produza resultados personalizados implementando seu próprio ouvinte. Um ouvinte de rastreamento personalizado pode, por exemplo, exibir as mensagens em uma caixa de mensagem ou se conectar a um banco de dados para adicionar mensagens a uma tabela. Todos os ouvintes personalizados devem dar suporte aos seis métodos mencionados acima. Para obter mais informações sobre como criar ouvintes definidos pelo desenvolvedor, consulte TraceListener na referência do .NET Framework.

Os métodos Write e WriteLine sempre gravam o texto especificado. Assert, WriteIf e WriteLineIf exigem um argumento Booliano que controle se eles gravam o texto especificado; eles só gravam o texto especificado se a expressão for true (para WriteIf e WriteLineIf), ou false (para Assert). O método Fail sempre grava o texto especificado. Para obter mais informações, consulte Como adicionar instruções de rastreamento ao código do aplicativo e a referência do .NET Framework.

Problemas de segurança

Se você não desabilitar o rastreamento e a depuração antes de implantar um aplicativo ASP.NET, o aplicativo poderá revelar informações sobre si mesmo que podem ser exploradas por um programa mal-intencionado. Para obter mais informações, consulte Como compilar condicionalmente com Trace e Debug, Compilando e criando e Como criar, inicializar e configurar opções de rastreamento. A depuração também é configurável por meio do IIS (Serviços de Informações da Internet).

Confira também