Arquivo

Posts Tagged ‘Instrumentação’

Instrumentação .NET – WMI

No podemos acessar uma série de informações do Windows através do Windows Management Instrumentation (WMI) como por exemplo versão do sistema operacional, temperatura do processador, nome dos HD´s instalados, quais são os Drives entre outras coisas. Para uma referência completa verifique o link “Classes WMI” no final deste artigo. Neste post irei descrever como executar as operações básicas de monitoramento.

Para se conectar ao WMI do Windows adicione o namespace System.Management e utilize o seguinte código:

  1. ManagementScope scope = new ManagementScope(@"\\localhost\root\cimv2");
  2. scope.Connect();

 

No exemplo acima estou instanciando uma classe do tipo ManagementScope e chamando o método para conectar no WMI.

O Framework nos permite utilizar uma subset do SQL chamada WMI Query Language (WQL) para realizar consultas no WMI do Windows. Para isso você terá que criar um ObjectQuery passando como parâmetro no construtor o WQL criado. Segue abaixo o exemplo.

  1. ObjectQuery query = new ObjectQuery("SELECT * FROM Win32_LogicalDisk");

 

Neste caso estou selecionando todos os drives lógicos que o Windows reconhece. Existem várias querys que podem ser realizadas, para uma referencia completa veja os links no final deste artigo.

Para realizar a consulta siga o exemplo abaixo:

  1. ManagementObjectSearcher searcher = new ManagementObjectSearcher(scope, query);
  2. ManagementObjectCollection queryCollection = searcher.Get();
  3. foreach (ManagementObject m in queryCollection)
  4. {
  5.     Console.WriteLine("{0} {1}", m["Name"].ToString(), m["Description"].ToString());
  6. }

 

Na linha 1 estou criando o objeto ManagementObjectSearcher passando como parâmetro o scope e a query. Na segunda linha eu executo a consulta chamando o método Get e retorno a coleção atribuindo ao objeto ManagementObjectCollection. Nas linhas finais eu executo um foreach através da coleção e retorno o nome e a descrição do drive passando como parâmetro suas chaves respectivamente. Para uma referencia completa das chaves, acessem os links no final deste artigo.

Outra opção é você monitorar os eventos WMI para que quando algum evento executar o seu código será chamado. Segue abaixo como fazer isso.

  1. WqlEventQuery query = new WqlEventQuery("__InstanceCreationEvent",
  2.                             new TimeSpan(0, 0, 1),
  3.                             "TargetInstance isa 'Win32_Process'");
  4. ManagementEventWatcher watcher = new ManagementEventWatcher(query);
  5. ManagementBaseObject e = watcher.WaitForNextEvent();
  6. Console.WriteLine(((ManagementBaseObject)e["TargetInstance"])["Name"]);
  7. watcher.Stop();

 

Na primeira linha estou criando o Objeto WqlEventQuery dizendo quais eventos eu quero monitorar. Na quarta linha eu crio o watcher que inicia o monitoramento. Na linha 5 eu digo para a aplicação que aguarde até que algum evento WMI seja executado. Na penúltima linha eu recupero qual o nome do processo que foi criado e na última linha eu paro o monitoramento.

Outra forma de realizar este monitoramento é através de eventos do watcher. Isto melhora sua aplicação pois a mesma não terá que ficar parada esperando que algum evento aconteça. Segue abaixo como fazer.

  1. watcher.EventArrived += new EventArrivedEventHandler(handler);
  2. watcher.Start();

 

Após criar o watcher estou associando um método ao evento EventArrived do mesmo, para que quando algum evento acontecer ele chamará automaticamente este método. Na última linha estou dizendo para o watcher começar o monitoramento.

E chegamos ao fim de mais um artigo desta série de instrumentação. Espero que tenham gostado e que seja útil para seu dia a dia.

Classes WMI : http://msdn.microsoft.com/en-us/library/aa394554.aspx

Scripts WMI: http://msdn.microsoft.com/en-us/library/aa394585(v=VS.85).aspx

Categorias:.NET Framework Etiquetas:,

Instrumentação .NET – Processos

Fala galera. Neste artigo vou demonstrar como desenvolver a maioria das funções que você encontra no gerenciador de tarefas do Windows. Segue abaixo um print do TaskManager do Windows que você pode acessar digitando “taskmgr” no executar do menu iniciar. (Se você identificar algum vírus na minha lista de processos me avise..rs).

Nova Imagem (1)

Dentro no namespace System.Diagnostics você tem a classe Process que permite você executar um novo processo, monitorar algum existente, fechar um processo e outras coisas mais. Segue abaixo um exemplo de como executar um novo processo.

  1. Process.Start("Calc");
  2. Process.Start("Notepad", @"c:\Teste.txt");

 

No exemplo acima eu primeiro iniciei uma instancia da calculadora do Windows. Na segunda linha eu estou iniciando uma instancia do notepad do Windows passando como parâmetro o arquivo “C:\Teste.txt” para ser aberto pelo notepad.

Outra forma de iniciar um processo é utilizando a classe ProcessStartInfo que é utilizada quando você precisa realizar mais configurações para iniciar um processo ou quando você precisa criar essas configurações de modo dinâmico ou em etapas diferentes. Segue abaixo um exemplo.

  1. ProcessStartInfo psi = new ProcessStartInfo();
  2. psi.Arguments = @"c:\windows\win.ini";
  3. psi.FileName = "Notepad";
  4. Process.Start(psi);

O ProcessStarInfo tem várias propriedades que permitem você tratar a inicialização do seu processo. Abaixo eu demonstro algumas propriedades para você configurar sobre qual domínio sua propriedade ser inicializada.

  1. psi.Domain = "Dominio.com";
  2. psi.UserName = "Francisco";

 

A classe Process contém um método estático que retorna todos os processos que estão executando no computador atualmente. Para utiliza-lo chame o método GetProcesses como demonstrado no exemplo abaixo.

  1. foreach (Process p in Process.GetProcesses())
  2. {
  3.    Console.WriteLine(p.Id); //Id do Processo
  4.    Console.WriteLine(p.ProcessName); //Nome do Processo
  5.    Console.WriteLine(p.MainModule); //Módulo principal da execução
  6.    Console.WriteLine(p.Responding); //Verifica se a aplicação esta respondendo
  7.    Console.WriteLine(p.TotalProcessorTime); //Tempo de processamento
  8.    Console.WriteLine(p.VirtualMemorySize64); //Total de memória virtual
  9. }

 

Além monitorar os processos você ainda tem a opção de gerencia-los. Segue abaixo alguns exemplos.

  1. Process p = Process.Start("Notepad", @"c:\Teste.txt");
  2. p.CloseMainWindow();
  3. p.Kill();
  4. p.Start();
  5. p.WaitForExit();

Na linha 2 eu estou dizendo para que o notepad feche naturalmente, isto quer dizer que o notepad irá executar seu comportamento padrão de execução exibindo aquela tela para salvar as alterações. Na terceira linha estou matando o processo, funciona da mesma forma que o “Finalizar processo” do gerenciador de tarefas. Na quarta linha estou iniciando o processo novamente e na ultima linha eu digo para o nosso processo esperar que o notepad feche para continuarmos a execução.

A classe processo nos permite retornar todos os módulos associados ao processo utilizando o método modules. Segue o exemplo demonstrando como utilizar. 

  1. foreach (ProcessModule pm in p.Modules)
  2. {
  3.     Console.WriteLine(pm.FileName); //Arquivo do Módulo
  4.     Console.WriteLine(pm.ModuleMemorySize); //Memória utilizada
  5.     Console.WriteLine(pm.ModuleName); //Nome do Módulo
  6.     Console.WriteLine(pm.FileVersionInfo.ToString()); //Informação sobre a versão
  7. }

Espero que tenham gostado e até o próximo artigo.

Categorias:.NET Framework Etiquetas:,

Instrumentação .NET – Contadores de Performance

Olá amigos..

Neste artigo irei demonstrar como monitorar sua aplicação com contadores de performance.

O Windows tem uma ferramenta para gerenciar contadores de performance chamada “perfmon”. Você pode acessa-la digitando “perfmon” no executar do Windows.

Nova Imagem

Nesta ferramenta você pode monitorar uma série de contadores que já estão configurados no seu computador. Utilizando o namespace System.Diagnostics você poderá criar um contador de performance para ser monitorado, você também poderá ler um contador a partir de sua aplicação. Vamos aprender como ler um contador de performance.

PerformanceCounter contadorPerformance = new PerformanceCounter(“Processor”, “% Processor Time”, “_Total”);

No código acima estou indicando que quero criar um contador de Performance baseado em um já existente no sistema operacional. No caso específico estou indicando a categoria “Processor”, Indicando o contador “% Processor Time” e a instancia “_Total”.

Depois de instanciado o contador você poderá monitora-lo. Segue abaixo um exemplo.

for (int i = 0; i < 10; i++)
{
    Thread.Sleep(1000);
    Console.WriteLine(contadorPerformance.NextValue());
}

No exemplo acima eu utilizei a propriedade NextValue para recuperar qual o valor calculado do contador.

Para criar um contador de performance você pode utilizar o seguinte exemplo:

PerformanceCounterCategory.Create(“Categoria do meu Contador”, “Ajuda da Categoria”,
                PerformanceCounterCategoryType.SingleInstance, “Meu contador”, “Ajuda do Meu contador”);

O primeiro parâmetro indica o nome da categoria a ser criada, seguido pelo parâmetro que indica o Help da mesma, o terceiro parâmetro indica a quantidade de instancias o contador poderá ter, já o quarto parâmetro indica o nome do contador e logo em seguida vem o parâmetro que indica o Help do mesmo. Segue abaixo alguns métodos interessantes para o gerenciamento de contadores.

PerformanceCounterCategory.Delete(“Categoria do meu Contador”); //Exclui uma categoria
PerformanceCounterCategory.CounterExists(“Meu contador”, “Categoria do meu Contador”); //Verifica se um contador existe
PerformanceCounterCategory.Exists(“Categoria do meu Contador”); //Verifica se uma categoria existe
PerformanceCounterCategory.GetCategories(); //Retorna todas as categorias cadastradas

Você também pode adicionar vários contadores a mesma categoria.

CounterCreationDataCollection conts = new CounterCreationDataCollection();
conts.Add(new CounterCreationData(“Contador 1”, “Ajuda do Contador 1”, PerformanceCounterType.NumberOfItems64));
conts.Add(new CounterCreationData(“Contador 2”, “Ajuda do Contador 2”, PerformanceCounterType.NumberOfItems64));
PerformanceCounterCategory.Create(“Categoria do meu Contador”, “Ajuda da Categoria”,
PerformanceCounterCategoryType.SingleInstance, conts);

Você pode verificar o parâmetro criado na ferramenta perfmon do Windows. Clique em um botão com o sinal de positivo “+” e procure o sua categoria criada e seu contador criado e adicione ao monitoramento.

PerformanceCounter contPerf = new PerformanceCounter(“Categoria do meu Contador”, “Meu contador”, false);
for (int i = 0; i < 100; i++)
{
   contPerf.Increment();
   Console.WriteLine(contPerf.NextValue());
}

No exemplo acima eu instancia o contador criado no exemplo anterior passando um parâmetro booleano como false. Este parâmetro indica que o contador não é read-only. O método “Increment” adiciona o valor 1 no contador. Você pode verificar o incremento tanto no console quanto no perfmon. Segue abaixo alguns métodos úteis para utilização do contador de performance.

contPerf.RawValue = 5; //Configura um valor para o contador
contPerf.Increment(); //Adiciona 1 ao contador. Tipo thread-Safe
contPerf.Decrement(); //Remove 1 ao contador. Tipo thread-Safe
contPerf.IncrementBy(2); //Adiciona 2 ao contador. Tipo thread-Safe
Console.WriteLine(contPerf.CategoryName); //Recupera a categoria do contador
Console.WriteLine(contPerf.CounterHelp); //Recupera o help do contador
Console.WriteLine(contPerf.CounterName); //Recupera o nome do contador
Console.WriteLine(contPerf.CounterType); //Recupera o tipo do contador
Console.WriteLine(contPerf.InstanceName); //Recupera o nome da instancia do contador

E é isso ai pessoal, espero que a partir de hoje você saiba como monitorar a performance de sua aplicação de uma forma que seja de fácil leitura para o pessoal de Infra da sua empresa.

Instrumentação .NET – Debug e Trace

Quantas vezes nós já passamos por situações em que após realizarmos todos os testes em nossa maquina, confirmamos que o sistema esta ok, porém quando enviamos para o servidor de homologação o sistema parece outro, cheio de erros. E a pior parte é que não podemos debugar no ambiente de homologação.  Isto se resume da frase: “Na minha maquina funciona”.

Para ajudar a resolver esses problemas o .NET Framework disponibiliza as classes de Debug e Trace dentro do namespace System.Diagnostics. As duas classes são implementadas da mesma maneira e tem comportamento semelhante. A principal diferença entre elas é que a classe Trace é utilizada quando sua aplicação esta compilada em modo de release e a Debug quando esta compilada em modo de Debug. Essas classes nos permitem criar logs, mensagens, PopUp entre outros para monitorar a aplicação.

Vou demonstrar como utilizar essas classes usando como exemplo a classe Debug,  mas você pode substituir pela classe Trace caso seja necessário.

Debug.Write(“Mensagem: Debug”); //Escreve um texto.

O texto irá aparecer na janela Output do Visual Studio.

image

O texto apareceu na janela de Output porque esta configurado por padrão para fazer isso. A saída do texto pode ser configurada com ajuda dos Listeners. Segue abaixo alguns exemplos.

Debug.Listeners.Add(new DefaultTraceListener()); //Listener padrão. Exibe as mensagens na janela de output do VS.
Debug.Listeners.Add(new TextWriterTraceListener(“Teste.txt”)); // Grava as mensagens em um arquivo texto.
Debug.Listeners.Add(new XmlWriterTraceListener(“teste.xml”)); //Grava as mensagens em um arquivo xml.
Debug.Listeners.Add(new EventLogTraceListener(new EventLog(“DebugLog”, “.”, “DebugSource”))); //Grava as mensagens no log do Windows.
Debug.Listeners.Add(new ConsoleTraceListener()); //Exibe as mensagens em uma janela console.

Você também pode usar o web.config ou app.config para configurar os Listeners. Segue abaixo alguns exemplos.

<system.diagnostics>
   <trace autoflush =”true” indentsize=”4″>
     <listeners>
       <add name=”TextTraceListener”
            type=”System.Diagnostics.TextWriterTraceListener”
            initializeData=”output.txt” />
       <add name=”XmlWriterTraceListener”
            type=”System.Diagnostics.XmlWriterTraceListener”
            initializeData=”output.xml” />
       <add name=”ConsoleTraceListener”
           type=”System.Diagnostics.ConsoleTraceListener” />
       <remove name=”Default” />
     </listeners>
   </trace>
</system.diagnostics>

Segue abaixo alguns métodos e propriedades interessantes para serem utilizados.

Debug.Assert(false, “Mensagem”); //Exibe a mensagem caso a condição seja falsa.
Debug.Write(“Mensagem”); //Exibe a mensagem
Debug.WriteLine(“Mensagem”); //Exibe a mensagem e pula uma linha
Debug.WriteIf(true, “Mensagem”); //Exibe a mensagem caso a condição seja verdadeira
Debug.WriteLineIf(true, “Mensagem”); //Exibe a mensagem caso a condição seja verdadeira e pula uma linha
Debug.Fail(“ErrorMensagem”); //Exibe uma mensagem de Erro.
Debug.Flush(); //Escreve toda as mensagem que estiverem na memória.
Debug.IndentSize = 10; // Tamanho da indentação das mensagens.
Debug.IndentLevel = 1; // Nível da indentação das mensagens.
Debug.Indent(); //Adiciona um nível de indentação para as próximas mensagens
Debug.Unindent(); //Retorna um nível de indentação para as próximas mensagens

Espero ter ajudado para que os próximos problemas que você tiver em produção não seja um pânico total. Basta usar o Trace para monitorar sua aplicação

 

 

 

Categorias:.NET Framework Etiquetas:, ,

Instrumentação .NET – EventLog

No artigo de hoje irei demonstrar como usar o Visualizador de Eventos do Windows para instrumentar sua aplicação.

Para acessar o Visualizador de Eventos do Windows digite “eventvwr” no executar. Este gerenciador de eventos disponibiliza, na janela da esquerda, todos os EventLog cadastrados no computador, o próprio Windows utiliza eles para logar eventos do sistema. Já na janela da direita, quando você selecionar um EventLog deve aparecer uma lista de eventos que foram registrados pelo Windows. Preste atenção na coluna “Fonte”, ela indica de onde veio este evento, que no nosso caso virá do aplicativo criado.

Para criar um EventLog via código para ser usado pela sua aplicação devemos importar o namespace System.Diagnostics e utilizar a classe EventLog. Como no exemplo abaixo:

EventLog.CreateEventSource(“Fonte”, “TesteLog”);// Cria um EventLog junto com uma fonte válida
EventLog.CreateEventSource(“Fonte2”, “TesteLog”);// Cria uma segunda fonte aproveitando o EventLog já criado

Você pode perceber que o EventLog contêm uma inteligência dentro da criação do evento, ou seja, caso o evento já tenha sido criado ele aproveita este evento e adiciona uma fonte nele. Outra item interessante é que, quando você cria um EventLog automaticamente ele cria um uma fonte de mesmo nome. Isto garante que o EventLog poderá ser usado.

Quando você cria uma nova fonte, você deve verificar se esta fonte já não esta registrada no computador, se já estiver registrada sua aplicação irá disparar uma exceção. Segue abaixo alguns recursos interessante que o EventLog tem para você evitar este problema e outros.

EventLog.Exists(“TesteLog”); //Verifica se existe um EventLog
EventLog.SourceExists(“TesteLog”); //verifica se existe uma fonte
EventLog.Delete(“TesteLog”); //Apaga o EventLog junto com todas as suas fontes
EventLog.DeleteEventSource(“Fonte”); //Exclui a fonte do evento
EventLog.CreateEventSource(“Fonte”, “TesteLog”);// Cria um EventLog junto com uma fonte válida

Você pode retornar uma lista de EventLogs cadastrados no computador utilizando o método GetEventLogs. Segue abaixo um exemplo.

foreach (EventLog e in EventLog.GetEventLogs())
{
    Console.WriteLine(e.Log); //Nome do Log
    Console.WriteLine(e.Source); //Recupera o nome da fonte ou registra quando você der uma entrada no log
    Console.WriteLine(e.LogDisplayName); //Nome de visualização
    Console.WriteLine(e.MachineName); //Maquina a qual o log esta referenciado
    Console.WriteLine(e.OverflowAction.ToString()); //Retorna qual será o comportamento do log caso ele fique cheio
}

Enfim vamos aprender como registrar um evento que aconteceu na sua aplicação.

EventLog log = new EventLog(“TesteLog”); //Configura qual EventLog será utilizado para gravar o evento
log.Source = “Fonte”; //Configura em qual fonte será a entrada do evento.
log.WriteEntry(“Erro da aplicação”, EventLogEntryType.Error, 1001, 1); //Efetiva as configurações anteriores e grava o evento

Perceba que o método WriteEntry aceita quatro parâmetros de entrada. O primeiro é a descrição do evento, o segundo é o tipo do evento, que pode ser de Erro, Informação, Alerta, Sucesso ou Falha em uma auditoria de segurança, já os últimos dois são utilizados para identificar mais fácil o evento, Id do Evento e Id da Categoria. É muito útil caso você crie uma documentação do seu sistema. Porém você pode usar outros métodos WriteEntry que contêm menos parâmetros.

Para ler os eventos registrados em um determinado EventLog utilize o seguinte exemplo.

EventLog log = new EventLog(“TesteLog”); //Recupera um log existente
foreach (EventLogEntry entrada in log.Entries)
{
     Console.WriteLine(entrada.Message); //Descrição do evento ocorrido
     Console.WriteLine(entrada.Category); //Categoria do evento
     Console.WriteLine(entrada.CategoryNumber); //Número da categoria do evento
     Console.WriteLine(entrada.EntryType.ToString()); //Tipo do evento
     Console.WriteLine(entrada.Index); //Índice do evento em relação a lista
     Console.WriteLine(entrada.MachineName); //Maquina a qual o evento foi geral
     Console.WriteLine(entrada.Source); //Fonte do evento
     Console.WriteLine(entrada.TimeWritten); //Qual horário o evento foi escrito
     Console.WriteLine(entrada.TimeGenerated); //Qual horário o evento foi gerado
     Console.WriteLine(entrada.UserName); //Qual usuário estava logado durante o evento
}

E finalmente, para limpar o EventLog utilize o método Clear.

EventLog log = new EventLog(“TesteLog”); //Recupera um log existente
log.Clear(); //Limpa todas as entradas de um EventLog específico

Espero que este post tenha sido simples e prático e que possa ajudar você a instrumentar sua aplicação.

Categorias:.NET Framework Etiquetas:,
%d bloggers like this: