Demonstra Passo a passo: Ouvindo eventos WMI no ASP.NET integridade Monitoring

Artigo
10/15/2014

Essa explicação passo a passo mostra como escutar eventos Instrumentação de Gerenciamento do Windows (WMI) que foram mapeados para eventos de monitoramento da integridade ASP.NET.Tarefas ilustradas nesta explicação passo a passo incluem:

Criar um aplicativo de console que escuta eventos de monitoramento de integridade.
Configurar um aplicativo da Web a ser monitorado.
Testar o aplicativo de console.

Para obter mais informações sobre como usar WMI para fornecer eventos de monitoramento de integridade, consulte Usando WMI para entregar a integridade ASP.NET monitorando eventos.

Pré-requisitos

A fim de concluir este explicação passo a passo, será necessário:

O acesso a um servidor com Microsoft Internet Information Services (IIS) e o .NET Framework versão 2.0 instalado.
Permissões suficientes para poder criar um site ASP.NET da Web no servidor.
Permissão para executar o aplicativo com privilégios administrativos para acessar as informações de eventos da Web.

Processo de monitoramento de integridade do ASP.NET

A lista a seguir descreve as principais etapas que ocorrem durante ASP.NET o monitoramento de integridade se a entrega de dados do evento estiver configurada para ser processado pelo WMI:

ASP.NET gera um evento de integridade, de acordo com as configurações.
Monitoramento da integridade ASP.NET, com base nas configurações, distribui o evento para o provedor WmiWebEventProvider.
O provedor WmiWebEventProvider, com base nas informações contidas no arquivo WMI Managed Object Format (MOF) do ASP.NET (Aspnet.mof), passa as informações de evento para o sistema WMI por meio de uma chamada não gerenciada.
Finalmente, WMI passa os dados relevantes para o aplicativo personalizado.Esse aplicativo usa os tipos System.Management para fins de interoperabilidade entre os APIs ASP.NET gerenciado e WMI não gerenciado.

A ilustração a seguir mostra esse processo.

Processo de monitoramento de integridade do ASP.NET usando WMI.

Etapas envolvidas em usar WMI para escuta para eventos de monitoramento de integridade ASP.NET

Etapas padrões para usar WMI para escutar eventos de monitoramento da integridade ASP.NET são as seguintes:

Crie e construa um aplicativo personalizado de escuta.Nessa explicação passo a passo, o aplicativo de escuta é um aplicativo de console.
Configure o aplicativo da Web para permitir que o provedor personalizado processe eventos de integridade habilitando monitoração de integridade e especificando um provedor.Nessa explicação passo a passo, seu provedor é o provedor padrão WMI.
Ative o ouvinte no servidor onde o aplicativo da Web é executado.Porque o ouvinte é um aplicativo de console, isso significa executar o aplicativo a partir da linha de comando.
Acesse qualquer página do site monitorado em um navegador da Web.
Verifique que os eventos da integridade emitidos pelo site são capturados pelo ouvinte.

Criando a escuta de evento WMI

Um evento ouvinte WMI processa eventos de integridade ASP.NET após eles terem sido encaminhados para WMI.

O exemplo de código no procedimento a seguir for para um aplicativo de console de escuta de eventos WMI que acessa os objetos WMI que estão associados com os eventos de integridade ASP.NET.A lista a seguir descreve as principais etapas executadas por este aplicativo:

Obter o nome do computador no qual o ouvinte e o aplicativo da Web estão sendo executados.
Defina o caminho WMI para as entidades do ASP.NET.
Crie um inspetor de objeto gerenciado conforme definido no namespace System.Management.
Defina o escopo de eventos a assistir como sendo igual ao caminho WMI anterior.
Loop indefinidamente para capturar os eventos WMI.

Para criar um ouvinte de eventos WMI para eventos de integridade do ASP.NET

Crie um arquivo de origem de um aplicativo de console e cole o código a seguir.Esse código escuta eventos WMI associados com eventos de monitoramento de integridade ASP.NET sobre o computador local, que é o mesmo computador onde o aplicativo da Web monitorado é executado.

Imports System
Imports System.Text
Imports System.Management

Namespace SamplesAspNet

    Class SampleWmiWebEventListener
        ' Displays event-related information.

        Public Shared Sub DisplayEventInformation(ByVal ev As ManagementBaseObject)

            ' This will hold the name of the 
            ' event class as defined in the 
            ' Aspnet.mof file.
            Dim eventTypeName As String

            ' Get the name of the WMI-raised event.
            eventTypeName = ev.ClassPath.ToString()

            ' Process the raised event.
            Select Case eventTypeName
                ' Process the heartbeat event.  
                Case "HeartBeatEvent"
                    Console.WriteLine("HeartBeat")
                    Console.WriteLine(vbTab + _
                    "Process: {0}", ev("ProcessName"))
                    Console.WriteLine(vbTab + "App: {0}", _
                    ev("ApplicationUrl"))
                    Console.WriteLine(vbTab + "WorkingSet: {0}", _
                    ev("WorkingSet"))
                    Console.WriteLine(vbTab + "Threads: {0}", _
                    ev("ThreadCount"))
                    Console.WriteLine(vbTab + "ManagedHeap: {0}", _
                    ev("ManagedHeapSize"))
                    Console.WriteLine(vbTab + "AppDomainCount: {0}", _
                    ev("AppDomainCount"))

                    ' Process the request error event. 
                Case "RequestErrorEvent"
                    Console.WriteLine("Error")
                    Console.WriteLine("Url: {0}", _
                    ev("RequestUrl"))
                    Console.WriteLine("Path: {0}", _
                    ev("RequestPath"))
                    Console.WriteLine("Message: {0}", _
                    ev("EventMessage"))
                    Console.WriteLine("Stack: {0}", _
                    ev("StackTrace"))
                    Console.WriteLine("UserName: {0}", _
                    ev("UserName"))
                    Console.WriteLine("ThreadID: {0}", _
                    ev("ThreadAccountName"))

                    ' Process the application lifetime event. 
                Case "ApplicationLifetimeEvent"
                    Console.WriteLine("App Lifetime Event {0}", _
                    ev("EventMessage"))

                    ' Handle events for which processing is not
                    ' provided.
                Case Else
                    Console.WriteLine("ASP.NET Event {0}", _
                    ev("EventMessage"))
            End Select

        End Sub 'DisplayEventInformation .

        ' The main entry point for the application.
        Public Shared Sub Main(ByVal args() As String)
            ' Get the name of the computer on 
            ' which this program runs.
            ' Note that the monitored application must also run 
            ' on this computer.
            Dim machine As String = Environment.MachineName

            ' Define the Common Information Model (CIM) path 
            ' for WMI monitoring. 
            Dim path As String = _
            String.Format("\\{0}\root\aspnet", machine)

            ' Create a managed object watcher as 
            ' defined in System.Management.
            Dim query As String = "select * from BaseEvent"
            Dim watcher As New ManagementEventWatcher(query)

            ' Set the watcher options.
            Dim timeInterval As New TimeSpan(0, 1, 30)
            watcher.Options = _
            New EventWatcherOptions(Nothing, timeInterval, 1)

            ' Set the scope of the WMI events to 
            ' watch to be ASP.NET applications.
            watcher.Scope = _
            New ManagementScope(New ManagementPath(path))

            ' Set the console background.
            Console.BackgroundColor = ConsoleColor.Blue
            ' Set the foreground color.
            Console.ForegroundColor = ConsoleColor.Yellow
            ' Clear the console.
            Console.Clear()

            ' Loop indefinitely to catch the events.
            Console.WriteLine( _
            "Listener started. Enter CntlC to terminate.")

            While True
                Try
                    ' Capture the WMI event related to 
                    ' the Web event.
                    Dim ev As ManagementBaseObject = _
                    watcher.WaitForNextEvent()
                    ' Display the Web event information.
                    DisplayEventInformation(ev)

                    ' Prompt the user.
                    Console.Beep()

                Catch e As Exception
                    Console.WriteLine("Error: {0}", e)
                    Exit While
                End Try
            End While

        End Sub 'Main 

    End Class 'SampleWmiWebEventListener 

End Namespace

using System;
using System.Text;
using System.Management;

namespace SamplesAspNet
{
    // Capture WMI events associated with 
    // ASP.NET health monitoring types. 
    class SampleWmiWebEventListener
    {
        // Displays event-related information.
        static void DisplayEventInformation(
            ManagementBaseObject ev)
        {

            // This will hold the name of the 
            // event class as defined in the 
            // Aspnet.mof file.
            string eventTypeName;

            // Get the name of the WMI-raised event.
            eventTypeName = ev.ClassPath.ToString();

            // Process the raised event.
            switch (eventTypeName)
            {
                // Process the heartbeat event.  
                case "HeartBeatEvent":
                    Console.WriteLine("HeartBeat");
                    Console.WriteLine("\tProcess: {0}",
                        ev["ProcessName"]);
                    Console.WriteLine("\tApp: {0}",
                        ev["ApplicationUrl"]);
                    Console.WriteLine("\tWorkingSet: {0}",
                        ev["WorkingSet"]);
                    Console.WriteLine("\tThreads: {0}",
                        ev["ThreadCount"]);
                    Console.WriteLine("\tManagedHeap: {0}",
                        ev["ManagedHeapSize"]);
                    Console.WriteLine("\tAppDomainCount: {0}",
                        ev["AppDomainCount"]);
                    break;

                // Process the request error event. 
                case "RequestErrorEvent":
                    Console.WriteLine("Error");
                    Console.WriteLine("Url: {0}",
                        ev["RequestUrl"]);
                    Console.WriteLine("Path: {0}",
                        ev["RequestPath"]);
                    Console.WriteLine("Message: {0}",
                        ev["EventMessage"]);
                    Console.WriteLine("Stack: {0}",
                        ev["StackTrace"]);
                    Console.WriteLine("UserName: {0}",
                        ev["UserName"]);
                    Console.WriteLine("ThreadID: {0}",
                        ev["ThreadAccountName"]);
                    break;

                // Process the application lifetime event. 
                case "ApplicationLifetimeEvent":
                    Console.WriteLine("App Lifetime Event {0}",
                        ev["EventMessage"]);

                    break;

                // Handle events for which processing is not
                // provided.
                default:
                    Console.WriteLine("ASP.NET Event {0}",
                        ev["EventMessage"]);
                    break;
            }
        } // End DisplayEventInformation.

        // The main entry point for the application.
        static void Main(string[] args)
        {
            // Get the name of the computer on 
            // which this program runs.
            // Note that the monitored application must also run 
            // on this computer.
            string machine = Environment.MachineName;

            // Define the Common Information Model (CIM) path 
            // for WMI monitoring. 
            string path = String.Format("\\\\{0}\\root\\aspnet", machine);

            // Create a managed object watcher as 
            // defined in System.Management.
            string query = "select * from BaseEvent";
            ManagementEventWatcher watcher =
                new ManagementEventWatcher(query);

            // Set the watcher options.
            TimeSpan timeInterval = new TimeSpan(0, 1, 30);
            watcher.Options =
                new EventWatcherOptions(null,
                timeInterval, 1);

            // Set the scope of the WMI events to 
            // watch to be ASP.NET applications.
            watcher.Scope =
                new ManagementScope(new ManagementPath(path));

            // Set the console background.
            Console.BackgroundColor = ConsoleColor.Blue;
            // Set the foreground color.
            Console.ForegroundColor = ConsoleColor.Yellow;
            // Clear the console.
            Console.Clear();

            // Loop indefinitely to catch the events.
            Console.WriteLine(
                "Listener started. Enter Cntl-C to terminate");


            while (true)
            {
                try
                {
                    // Capture the WMI event related to 
                    // the Web event.
                    ManagementBaseObject ev =
                        watcher.WaitForNextEvent();
                    // Display the Web event information.
                    DisplayEventInformation(ev);

                    // Prompt the user.
                    Console.Beep();

                }
                catch (Exception e)
                {
                    Console.WriteLine("Error: {0}", e);
                    break;
                }
            }
        }
    }
}

Crie o aplicativo de console.Talvez seja necessário incluir uma referência para o namespace System.Management.

Configurar o aplicativo para eventos WMI

O provedor WmiWebEventProvider padrão contém a lógica para gerar os eventos WMI associados aos eventos de integridade do ASP.NET.

Para configurar um aplicativo ASP.NET para usar WMI para ouvir eventos de monitoramento de integridade ASP.NET

Crie ou abra um arquivo Web.config na raiz do seu aplicativo.

Um arquivo web.config básico parece o seguinte exemplo de código.

<?xml version="1.0"?>
<configuration xmlns="https://schemas.microsoft.com/.NetConfiguration/v2.0">
    <appSettings/>
    <connectionStrings/>
    <system.web>
    </system.web>
</configuration>

Habilite monitoramento de integridade adicionando as seguintes linhas de código dentro da seção System.Web.
```
        <healthMonitoring enabled="true">
        </healthMonitoring>
```
Configure o aplicativo para usar o provedor WmiWebEventProvider para fornecer dados de monitoração de integridade, adicionando as seguintes linhas de código dentro da seção healthMonitoring.Observe que o provedor WmiWebEventProvider já está configurado.Para permitir o processamento de eventos da Web, basta definir uma regra da seguinte maneira.
```
           <rules>
              <add 
                 name="Wmi Listener"
                 eventName="All Events" 
                 provider="WmiWebEventProvider" 
                 profile="Critical"/>
           </rules>
```
O atributo eventName da regra adicionada permite que todos os eventos da Web sejam enviados para o provedor WmiWebEventProvider.

Testar seu aplicativo de escuta

Após ter criado e construído seu aplicativo ouvinte e configurado um site da Web para habilitar o monitoramento da integridade por eventos WMI, você pode verificar que eventos de integridade são capturados executando o aplicativo ouvinte enquanto você solicita uma página do seu site da Web.

Para testar o aplicativo de console ouvinte

Crie um página ASP.NET no mesmo aplicativo da Web que você configurou para habilitar o monitoramento da integridade.
A partir de linha de comando, execute o aplicativo ouvinte.

A janela de comando altera a cor para um plano de fundo azul com o seguinte texto amarelo exibido:
```
Listener started. Enter CntlC to terminate
```
E um navegador, solicite a página do seu aplicativo da Web.

Antes de a página terminar o processamento, a janela de comando que está executando o aplicativo ouvinte exibe o seguinte texto:
```
ASP.NET Event URL authorization succeeded for the request.
ASP.NET Event File authorization succeeded for the request.
```
Esse procedimento verifica que o ouvinte detectou o evento de autorização URL e o evento de autorização do arquivo a partir do ASP.NET.

Próximas etapas

O ouvinte WMI mostrado é um aplicativo simples de console, mas ele ilustra as etapas fundamentais para criar um ouvinte WMI e configurar um aplicativo para distribuir eventos da integridade.Desde esse início, você pode começar a explorar outras maneiras de monitorar seus aplicativos da Web.Sugestões para mais exemplos incluem:

Investigar o uso de aplicativos do Windows para coletar eventos WMI.
Explorar o uso dos recursos de processamento mais complexos com base no tipo de evento.
Aprender sobre como o o WMI e o .NET Framework integram sua funcionalidade.Para obter mais informações, consulte System.Management, System.Management.Instrumentation.
Pesquisar o Biblioteca MSDN para instrumentação de gerenciamento do Windows (WMI) e o Managed Object Format (MOF).