Condividi tramite

Procedura dettagliata: ascolto di eventi WMI durante il monitoraggio dello stato di ASP.NET

  • Articolo

Aggiornamento: novembre 2007

In questa procedura guidata viene illustrato come ascoltare gli eventi Strumentazione gestione Windows (WMI) associati agli eventi di monitoraggio dello stato ASP.NET. Di seguito sono elencate le attività illustrate nella procedura dettagliata:

  • Generazione di un'applicazione console che ascolta gli eventi di monitoraggio dello stato.

  • Configurazione di un'applicazione Web da monitorare.

  • Test dell'applicazione console.

Per ulteriori informazioni sull'utilizzo di WMI per la distribuzione degli eventi di monitoraggio dello stato, vedere Utilizzo di WMI per la distribuzione di eventi di monitoraggio dello stato ASP.NET.

Prerequisiti

Per completare questa procedura dettagliata è necessario:

  • Accesso a un server con Microsoft Internet Information Services (IIS) e .NET Framework versione 2.0.

  • Autorizzazioni sufficienti per la creazione di un sito Web ASP.NET sul server.

  • Autorizzazione per l'esecuzione dell'applicazione con privilegi di amministratore per accedere alle informazioni sugli eventi Web.

Processo di monitoraggio dello stato ASP.NET

Nel seguente elenco vengono descritte le operazioni principali eseguite nel corso del monitoraggio dello stato ASP.NET se la distribuzione dei dati di evento viene elaborata tramite WMI:

  1. ASP.NET genera un evento di stato in base alle impostazioni di configurazione.

  2. Il monitoraggio dello stato ASP.NET invia l'evento al provider WmiWebEventProvider, in base alle impostazioni di configurazione.

  3. Il provider WmiWebEventProvider passa le informazioni di evento al sistema WMI mediante una chiamata non gestita, in base alle informazioni contenute nel file MOF (Managed Object Format) WMI per ASP.NET (Aspnet.mof).

  4. Infine, WMI invia i dati pertinenti all'applicazione personalizzata, che utilizza i tipi System.Management per interagire con le API gestite ASP.NET e le API non gestite WMI.

Nella seguente figura viene illustrato questo processo.

Processo di monitoraggio dello stato ASP.NET mediante WMI

Passaggi per utilizzare WMI per l'ascolto degli eventi di monitoraggio dello stato ASP.NET

Di seguito sono riportati i passaggi standard per utilizzare WMI per l'ascolto degli eventi di monitoraggio dello stato ASP.NET:

  1. Creare e generare un'applicazione listener personalizzata. In questa procedura dettagliata l'applicazione listener è un'applicazione console.

  2. Configurare l'applicazione Web in modo da consentire al provider personalizzato di elaborare gli eventi di stato attivando il monitoraggio dello stato e specificando un provider. In questa procedura dettagliata il provider è il provider WMI predefinito.

  3. Attivare il listener sul server su cui viene eseguita l'applicazione Web. Poiché il listener è un'applicazione console, l'applicazione deve essere eseguita dalla riga di comando.

  4. Accedere a una delle pagine del sito Web monitorato in un browser Web.

  5. Verificare che gli eventi di stato emessi dal sito Web siano catturati dal listener.

Creazione del listener di eventi WMI

Un listener di eventi WMI elabora gli eventi di stato ASP.NET dopo che sono stati inoltrati a WMI.

L'esempio di codice riportato nella seguente procedura è per un'applicazione console del listener di eventi WMI che accede agli oggetti WMI associati agli eventi di stato ASP.NET. Nell'elenco seguente vengono descritte le operazioni principali eseguite dall'applicazione:

  • Ottenere il nome del computer su cui sono in esecuzione il listener e l'applicazione Web.

  • Impostare il percorso WMI per le entità ASP.NET.

  • Creare un analizzatore di oggetti gestito come definito nello spazio dei nomi System.Management.

  • Impostare l'ambito degli eventi da analizzare in modo che corrisponda al percorso WMI precedente.

  • Eseguire un ciclo infinito per catturare gli eventi WMI.

Per creare un listener di eventi WMI per gli eventi di stato ASP.NET

  1. Creare un file di origine per un'applicazione console e inserire il codice riportato di seguito per ascoltare gli eventi WMI associati agli eventi di monitoraggio dello stato ASP.NET sul computer locale, su cui è anche eseguita l'applicazione Web monitorata.

    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;
                }
            }
        }
    }
}

  2. Generare l'applicazione console. Potrebbe essere necessario includere un riferimento allo spazio dei nomi System.Management.

Configurazione dell'applicazione per gli eventi WMI

Il provider WmiWebEventProvider standard contiene la logica per generare gli eventi WMI associati agli eventi di stato ASP.NET.

Per configurare un'applicazione ASP.NET al fine di utilizzare WMI per ascoltare gli eventi di monitoraggio dello stato ASP.NET

  1. Creare o aprire un file Web.config nella directory principale dell'applicazione.

    Un file Web.config di base è simile a quello riportato nel seguente esempio di codice.

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

  2. Attivare il monitoraggio dello stato aggiungendo le seguenti righe di codice nella sezione system.web.

            <healthMonitoring enabled="true">
        </healthMonitoring>

  3. Configurare l'applicazione in modo che venga utilizzato il provider WmiWebEventProvider per la distribuzione dei dati di monitoraggio dello stato aggiungendo le seguenti righe di codice nella sezione healthMonitoring. Tenere presente che il provider WmiWebEventProvider è già configurato. Per consentire l'elaborazione degli eventi Web, è sufficiente definire una regola come descritto di seguito.

               <rules>
              <add 
                 name="Wmi Listener"
                 eventName="All Events" 
                 provider="WmiWebEventProvider" 
                 profile="Critical"/>
           </rules>

    L'attributo eventName della regola aggiunta consente l'invio di tutti gli eventi Web al provider WmiWebEventProvider.

Test dell'applicazione listener

Una volta creata e generata l'applicazione listener e configurato un sito Web per il monitoraggio dello stato tramite gli eventi WMI, è possibile verificare che gli eventi di stato vengano catturati eseguendo l'applicazione listener durante la richiesta di una pagina dal sito Web.

Per eseguire il test dell'applicazione console listener

  1. Creare una pagina ASP.NET nella stessa applicazione Web configurata per il monitoraggio dello stato.

  2. Eseguire l'applicazione listener dalla riga di comando.

    Lo sfondo della finestra di comando diventa blu e il seguente testo viene visualizzato in giallo:

    Listener started. Enter CntlC to terminate

  3. In un browser richiedere una pagina dall'applicazione Web.

    Prima che il rendering della pagina sia stato completato, nella finestra di comando che esegue l'applicazione listener viene visualizzato il seguente testo:

    ASP.NET Event URL authorization succeeded for the request.
ASP.NET Event File authorization succeeded for the request.

    In questo modo si verifica che il listener ha catturato gli eventi di autorizzazione URL e file da ASP.NET.

Passaggi successivi

Sebbene il listener WMI utilizzato sia una semplice applicazione console, è sufficiente per illustrare i passaggi fondamentali per generare un listener WMI e configurare un'applicazione per la distribuzione degli eventi di stato. Da questo punto di partenza è possibile iniziare a esplorare altri metodi per monitorare le applicazioni Web. Per approfondire l'argomento, si consiglia di effettuare le seguenti operazioni:

  • Analizzare l'utilizzo di applicazioni Windows per la raccolta degli eventi WMI.

  • Considerare l'uso di funzionalità di elaborazione più complesse basate sul tipo di evento.

  • Approfondire le proprie conoscenze su WMI e su come .NET Framework integra tale funzionalità. Per ulteriori informazioni, vedere System.Management e System.Management.Instrumentation.

  • Ricercare nella libreria MSDN i termini Windows Management Instrumentation (WMI) e Managed Object Format (MOF).

Vedere anche

Riferimenti

Elemento healthMonitoring (schema delle impostazioni ASP.NET)

WmiWebEventProvider

System.Management

System.Management.Instrumentation

Altre risorse

Utilizzo di WMI per la distribuzione di eventi di monitoraggio dello stato ASP.NET