Partager via

Procédure pas à pas : écoute des événements WMI lors du contrôle d'état ASP.NET

  • Article

Mise à jour : novembre 2007

Cette procédure pas à pas indique comment écouter les événements WMI (Windows Management Instrumentation) qui ont été mappés aux événements de contrôle d'état ASP.NET. Cette procédure pas à pas illustre les tâches suivantes :

  • Génération d'une application console qui écoute les événements de contrôle d'état.

  • Configuration d'une application Web à surveiller.

  • Test de l'application console.

Pour plus d'informations sur l'utilisation de WMI pour remettre des événements de contrôle d'état, consultez Utilisation de WMI pour émettre des événements de contrôle d'état ASP.NET.

Composants requis

Pour exécuter cette procédure pas à pas, vous devrez utiliser :

  • Accès à un serveur avec Microsoft Internet Information Services (IIS) et le .NET Framework version 2.0 installés.

  • Autorisations suffisantes pour pouvoir créer un site Web ASP.NET sur le serveur.

  • Autorisation pour exécuter l'application avec des privilèges d'administration afin de pouvoir accéder aux informations sur les événements Web.

Processus de contrôle d'état ASP.NET

La liste suivante décrit les étapes principales qui ont lieu pendant le contrôle d'état ASP.NET si la remise de données d'événement est configurée pour être traitée via le service WMI :

  1. ASP.NET déclenche un événement d'état, selon les paramètres de configuration.

  2. Le contrôle d'état ASP.NET, selon les paramètres de configuration, distribue l'événement au fournisseur WmiWebEventProvider.

  3. Le fournisseur WmiWebEventProvider, selon les informations contenues dans le fichier MOF (Managed Object Format) de WMI pour ASP.NET (Aspnet.mof), passe les informations sur l'événement au système WMI via un appel non managé.

  4. Enfin, WMI passe les données pertinentes à l'application personnalisée. Cette application utilise les types System.Management pour interopérer entre l'ASP.NET managé et les API non managées de WMI.

L'illustration ci-dessous décrit ce processus.

Processus de contrôle d'état ASP.NET à l'aide de WMI

Étapes nécessaires à l'utilisation de WMI pour écouter les événements de contrôle d'état ASP.NET

Les étapes standard d'utilisation de WMI pour écouter les événements de contrôle d'état ASP.NET sont les suivantes :

  1. Créer et générer une application écouteur personnalisée. Dans cette procédure pas à pas, votre application écouteur est une application console.

  2. Configurez votre application Web pour permettre au fournisseur personnalisé de traiter les événements d'état en activant le contrôle d'état et en spécifiant un fournisseur. Dans cette procédure pas à pas, votre fournisseur est le fournisseur WMI par défaut.

  3. Activez l'écouteur sur le serveur où votre application Web s'exécute. Étant donné que votre écouteur est une application console, l'exécution de votre application se fera à partir de la ligne de commande.

  4. Accédez à n'importe quelle page du site Web surveillé dans un navigateur Web.

  5. Vérifiez que les événements d'état publiés par le site Web sont capturés par l'écouteur.

Création de l'écouteur d'événements WMI

Un écouteur d'événements WMI traite des événements d'état ASP.NET après qu'ils ont été transmis à WMI.

L'exemple de code dans la procédure suivante est pour une application console d'écouteur d'événements WMI qui accède aux objets WMI qui sont associés aux événements d'état ASP.NET. La liste suivante décrit les étapes principales effectuées par cette application :

  • Obtenez le nom de l'ordinateur sur lequel l'écouteur et l'application Web s'exécutent.

  • Définissez le chemin d'accès WMI pour les entités ASP.NET.

  • Créez un observateur d'objet managé comme défini dans l'espace de noms System.Management.

  • Définissez la portée des événements à observer de façon à ce qu'elle corresponde au chemin d'accès WMI précédent.

  • Faites une boucle indéfiniment pour intercepter les événements WMI.

Pour créer un écouteur d'événements WMI pour les événements d'état ASP.NET

  1. Créez un fichier source pour une application console et collez-le dans le code suivant. Ce code écoute les événements WMI associés aux événements de contrôle d'état ASP.NET sur l'ordinateur local qui est le même ordinateur où l'application Web surveillée s'exécute.

    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. Générez l'application console. Vous devrez peut-être inclure une référence pour l'espace de noms System.Management.

Configuration de l'application pour les événements WMI

Le fournisseur WmiWebEventProvider standard contient la logique pour générer les événements WMI associés aux événements d'état ASP.NET.

Pour configurer une application ASP.NET afin d'utiliser WMI pour écouter les événements de contrôle d'état ASP.NET

  1. Créez ou ouvrez un fichier Web.config à la racine de votre application.

    Un fichier Web.config de base ressemble à l'exemple de code suivant.

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

  2. Activez le contrôle d'état en ajoutant les lignes de code suivantes à l'intérieur de la section system.web.

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

  3. Configurez l'application afin d'utiliser le fournisseur WmiWebEventProvider pour remettre des données de contrôle d'état en ajoutant les lignes de code suivantes à l'intérieur de la section healthMonitoring. Notez que le fournisseur WmiWebEventProvider est déjà configuré. Pour autoriser le traitement d'événements Web, il vous suffit de définir une règle comme suit.

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

    L'attribut eventName de la règle ajoutée permet de distribuer tous les événements Web au fournisseur WmiWebEventProvider.

Test de votre application écouteur

Après avoir créé et généré votre application écouteur et configuré un site Web pour activer le contrôle d'état via les événements WMI, vous pouvez vérifier que les événements d'état sont capturés en exécutant votre application écouteur pendant que vous demandez une page de votre site Web.

Pour tester votre application console d'écoute

  1. Créez une page ASP.NET dans l'application Web que vous avez configurée pour activer le contrôle d'état.

  2. À partir de la ligne de commande, exécutez votre application écouteur.

    La fenêtre de commande change la couleur de l'arrière-plan en bleu avec le texte jaune suivant affiché :

    Listener started. Enter CntlC to terminate

  3. Dans un navigateur Web, demandez la page de votre application Web.

    Avant que la page ne finisse le rendu, la fenêtre de commande qui exécute votre application écouteur affiche le texte suivant :

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

    Cela permet de vérifier que votre écouteur a intercepté l'événement d'autorisation d'URL et l'événement d'autorisation du fichier d'ASP.NET.

Étapes suivantes

L'écouteur WMI indiqué est une application console simple, mais il illustre les étapes fondamentales pour générer un écouteur WMI et configurer une application pour distribuer des événements d'état. À partir de là, vous pouvez commencer à explorer des manières supplémentaires de surveiller vos applications Web. Voici quelques suggestions pour une exploration plus approfondie :

  • Étudiez l'utilisation des applications Windows pour collecter les événements WMI.

  • Explorez l'utilisation de fonctions de traitement plus complexes selon le type d'événement.

  • Découvrez WMI et comment le .NET Framework intègre ses fonctionnalités. Pour plus d'informations, consultez System.Management, System.Management.Instrumentation.

  • Recherchez Windows Management Instrumentation (WMI) et MOF (Managed Object Format) dans MSDN Library.

Voir aussi

Référence

healthMonitoring, élément (Schéma des paramètres ASP.NET)

WmiWebEventProvider

System.Management

System.Management.Instrumentation

Autres ressources

Utilisation de WMI pour émettre des événements de contrôle d'état ASP.NET