Exemplarische Vorgehensweise: Überwachen von WMI-Ereignissen in der ASP.NET-Systemüberwachung

Artikel
10/22/2014

Aktualisiert: November 2007

In dieser exemplarischen Vorgehensweise wird veranschaulicht, wie WMI-Ereignisse (Windows Management Instrumentation) überwacht werden, die Systemüberwachungsereignissen in ASP.NET zugeordnet wurden. Zu den Aufgaben in dieser exemplarischen Vorgehensweise gehören:

Erstellen einer Konsolenanwendung, die Systemüberwachungsereignisse überwacht
Konfigurieren einer zu überwachenden Webanwendung
Testen der Konsolenanwendung

Weitere Informationen zum Verwenden von WMI für das Bereitstellen von Systemüberwachungsereignissen finden Sie unter Verwenden von WMI zum Bereitstellen von ASP.NET-Systemüberwachungsereignissen.

Vorbereitungsmaßnahmen

Für die Durchführung dieser exemplarischen Vorgehensweise benötigen Sie Folgendes:

Zugriff auf einen Server, auf dem Microsoft-Internetinformationsdienste (IIS) und .NET Framework, Version 2.0, installiert sind.
Ausreichende Berechtigungen zum Erstellen einer ASP.NET-Website auf dem Server.
Berechtigung zum Ausführen der Anwendung mit Administratorrechten, um auf die Webereignisinformationen zuzugreifen.

ASP.NET-Systemüberwachungsprozess

In der folgenden Liste sind die Hauptschritte beschrieben, die während der ASP.NET-Systemüberwachung ausgeführt werden, wenn die Übermittlung von Ereignisdaten für die Verarbeitung durch WMI konfiguriert ist:

ASP.NET löst gemäß den Konfigurationseinstellungen ein Systemüberwachungsereignis aus.
Die ASP.NET-Systemüberwachung sendet das Ereignis entsprechend den Konfigurationseinstellungen an den WmiWebEventProvider-Anbieter.
Der WmiWebEventProvider-Anbieter übergibt die Ereignisinformationen über einen nicht verwalteten Aufruf basierend auf den in der WMI-MOF-Datei (Managed Object Format) für ASP.NET (Aspnet.mof) enthaltenen Informationen.
Als Letztes übergibt WMI die relevanten Daten an die benutzerdefinierte Anwendung. Diese Anwendung verwendet die System.Management-Typen für die Zusammenarbeit zwischen verwalteten ASP.NET-APIs und nicht verwalteten WMI-APIs.

Die folgende Abbildung veranschaulicht diesen Vorgang.

ASP.NET-Systemüberwachungsprozess mit WMI

Schritte bei der Verwendung von WMI zur Überwachung von ASP.NET-Systemüberwachungsereignissen

Im Folgenden sind die Standardschritte zur Verwendung von WMI für die Überwachung von ASP.NET-Systemüberwachungsereignissen aufgeführt:

Erstellen Sie eine benutzerdefinierte Listeneranwendung. In dieser exemplarischen Vorgehensweise ist die Listeneranwendung eine Konsolenanwendung.
Legen Sie in der Konfiguration der Webanwendung fest, dass der benutzerdefinierte Anbieter Systemüberwachungsereignisse durch Aktivieren der Systemüberwachung und durch Angeben eines Anbieters verarbeiten kann. In dieser exemplarischen Vorgehensweise ist der Anbieter der Standard-WMI-Anbieter.
Aktivieren Sie den Listener auf dem Server, auf dem die Webanwendung ausgeführt wird. Da der Listener eine Konsolenanwendung ist, bedeutet dies, dass die Anwendung über die Befehlszeile ausgeführt wird.
Greifen Sie in einem Webbrowser auf eine beliebige Seite der überwachten Website zu.
Überprüfen Sie, ob die von der Website ausgelösten Systemüberwachungsereignisse vom Listener erfasst werden.

Erstellen des WMI-Ereignislisteners

Ein WMI-Ereignislistener verarbeitet ASP.NET-Systemüberwachungsereignisse, nachdem sie an WMI weitergeleitet wurden.

Das Codebeispiel in der folgenden Prozedur stellt eine Konsolenanwendung für den WMI-Ereignislistener dar, die auf die WMI-Objekte zugreift, die ASP.NET-Systemüberwachungsereignissen zugeordnet sind. In der folgenden Liste sind die von dieser Anwendung ausgeführten Hauptschritte aufgeführt:

Rufen Sie den Namen des Computers ab, auf dem der Listener und die Webanwendung ausgeführt werden.
Legen Sie den WMI-Pfad für die ASP.NET-Entitäten fest.
Erstellen Sie einen Monitor für verwaltete Objekte, wie im System.Management-Namespace definiert.
Legen Sie den Bereich von zu überwachenden Ereignissen so fest, dass er dem vorherigen WMI-Pfad entspricht.
Durchlaufen Sie zum Erfassen der WMI-Ereignisse eine unendliche Schleife.

So erstellen Sie einen WMI-Ereignislistener für ASP.NET-Systemüberwachungsereignisse

Erstellen Sie eine Quelldatei für eine Konsolenanwendung, und fügen Sie den folgenden Code ein. Dieser Code überwacht WMI-Ereignisse, die ASP.NET-Systemüberwachungsereignissen auf dem lokalen Computer zugeordnet sind. Der lokale Computer entspricht dem Computer, auf dem die überwachte Webanwendung ausgeführt wird.

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

Erstellen Sie die Konsolenanwendung. Sie müssen möglicherweise einen Verweis für den System.Management-Namespace einschließen.

Konfigurieren der Anwendung für WMI-Ereignisse

Der WmiWebEventProvider-Standardanbieter enthält die Logik zum Generieren der WMI-Ereignisse, die den ASP.NET-Systemüberwachungsereignissen zugeordnet sind.

So legen Sie in der Konfiguration einer ASP.NET-Anwendung fest, dass für die Überwachung von ASP.NET-Systemüberwachungsereignissen WMI verwendet wird

Erstellen oder öffnen Sie eine Web.config-Datei im Stamm der Anwendung.

Im folgenden Codebeispiel ist eine einfache Web.config-Datei dargestellt.

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

Aktivieren Sie die Systemüberwachung, indem Sie im Abschnitt system.web die folgenden Codezeilen hinzufügen.
```
        <healthMonitoring enabled="true">
        </healthMonitoring>
```
Konfigurieren Sie die Anwendung so, dass Überwachungsdaten unter Verwendung des WmiWebEventProvider-Anbieters gesendet werden. Fügen Sie hierzu im Abschnitt healthMonitoring die folgenden Codezeilen hinzu: Beachten Sie, dass der WmiWebEventProvider-Anbieter bereits konfiguriert ist. Um die Verarbeitung von Webereignissen zu ermöglichen, müssen Sie lediglich eine Regel wie im folgenden Beispiel definieren.
```
           <rules>
              <add 
                 name="Wmi Listener"
                 eventName="All Events" 
                 provider="WmiWebEventProvider" 
                 profile="Critical"/>
           </rules>
```
Durch das eventName-Attribut der hinzugefügten Regel können alle Webereignisse an den WmiWebEventProvider-Anbieter gesendet werden.

Testen der Listeneranwendung

Nachdem Sie die Listeneranwendung erstellt haben und in der Konfiguration einer Website die Systemüberwachung durch WMI-Ereignisse aktiviert haben, können Sie überprüfen, ob Systemüberwachungsereignisse durch Ausführen der Listeneranwendung erfasst werden, während Sie eine Seite der Website anfordern.

So testen Sie die Listenerkonsolenanwendung

Erstellen Sie eine ASP.NET-Seite in derselben Webanwendung, in deren Konfiguration Sie die Systemüberwachung aktiviert haben.
Führen Sie die Listeneranwendung über die Befehlszeile aus.

Die Farbe des Befehlsfensters ändert sich in einen blauen Hintergrund, auf dem der folgende gelbe Text angezeigt wird:
```
Listener started. Enter CntlC to terminate
```
Fordern Sie in einem Webbrowser die Seite aus der Webanwendung an.

Bevor die Wiedergabe der Seite abgeschlossen ist, wird in dem Befehlsfenster, in dem die Listeneranwendung ausgeführt wird, der folgende Text angezeigt:
```
ASP.NET Event URL authorization succeeded for the request.
ASP.NET Event File authorization succeeded for the request.
```
Dadurch wird überprüft, ob der Listener das URL-Autorisierungsereignis und das Dateiautorisierungsereignis von ASP.NET erfasst hat.

Nächste Schritte

Der angezeigte WMI-Listener ist eine einfache Konsolenanwendung, die jedoch die grundlegenden Schritte beim Erstellen eines WMI-Listeners und beim Konfigurieren einer Anwendung zum Senden von Systemüberwachungsereignissen veranschaulicht. Hierauf aufbauend können Sie sich nun mit weiteren Möglichkeiten zur Überwachung von Webanwendungen vertraut machen. Hier einige Vorschläge:

Verwenden von Windows-Anwendungen zum Erfassen von WMI-Ereignissen
Verwenden von komplexeren Verarbeitungsfunktionen basierend auf dem Ereignistyp
Vertiefen Ihrer Kenntnisse über WMI und Integrieren der WMI-Funktionen in .NET Framework Weitere Informationen finden Sie unter System.Management und System.Management.Instrumentation.
Durchsuchen Sie die MSDN Library nach WMI (Windows Management Instrumentation) und MOF (Managed Object Format).