type
  TGenericLogger = class(TObject)
  private
    FEventEnabled : boolean;
    FEnableLevel : integer;
    FEnableFlags : cardinal;
    FTraceSession : TRACEHANDLE;
    FRegistrationHandle : TRACEHANDLE;
    FProviderGUID : TGUID;
    FEventClass : TGUID;
    FRegistrationEventClass : TRACE_GUID_REGISTRATION;
  protected
    // Indique si le message de niveau Level doit être écrit dans la trace en
    // cours. Cette fonction teste si une trace a été activée ainsi que son
    // niveau d'activation.
    function MessageEnabled(Level : byte) : boolean;

    // Active la génération des événements.
    procedure EnableEvents(Header : pointer);

    // Désactive la génération des événements.
    procedure DisableEvents(Header : pointer);

    // Handle de la session de trace active.
    property TraceSession : TRACEHANDLE read FTraceSession;

    // Handle d'enregistrement du provider.
    property RegistrationHandle : TRACEHANDLE read FRegistrationHandle;
  public
    // Déclare le provider auprès de ETW.
    // <aProviderGUID> : GUID du provider.
    // <aEventClass> : GUID de la classe des événements générés par le provider.
    constructor Create(aProviderGUID : TGUID; aEventClass : TGUID);

    // Détruit la classe et annule l'enregistrement du provider auprès de ETW.
    destructor Destroy; override;

    // Ecrit le message <msg> dans la trace.
    procedure Trace(msg : string); overload;

    // Ecrit le message <msg> dans la trace.
    // Le message sera mémorisé avec le type d'événement <EventType>, pour le
    // niveau de trace <msgLevel>, avec une information de durée <OperationTime>
    procedure Trace(EventType : integer; msg : string;
      msgLevel : integer = TRACE_LEVEL_INFORMATION;
      OperationTime : int64=0); overload;

    // Ecrit le début d'une opération dans la trace :
    // Le message <msg> est écrit dans la trace, avec le type d'événement
    // <EventType> et le niveau de trace <msgLevel>.
    // En sortie, currentTime est initialisée avec un TimeStamp correspondant à
    // l'heure courante au moment de l'appel.
    procedure TraceBegin(EventType : integer; msg : string;
      var currentTime : int64;
      msgLevel : integer = TRACE_LEVEL_INFORMATION);

    // Ecrit la fin d'une opération dans la trace :
    // Le message <msg> est écrit dans la trace, avec le type d'événement
    // <EventType> et le niveau de trace <msgLevel>.
    // TraceEnd doit avoir été précédé d'un appel à TraceBegin pour définir le
    // début de l'opération. <currentTime> doit contenir la valeur retournée par
    // le paramètre <currentTime> de TraceBegin.
    // TraceEnd calcule alors le temps écoulé (en ms) entre TraceEnd et
    // TraceBegin et écrit ce temps passé dans le champ OperationTime de la
    // trace.
    // En sortie, currentTime contient le temps écoulé depuis l'appel à
    // TraceBegin
    procedure TraceEnd(EventType : integer; msg : string; var currentTime : int64;
      msgLevel : integer = TRACE_LEVEL_INFORMATION);

    // Ecrit l'exception <e> dans la trace, avec le niveau de trace <msgLevel>
    procedure TraceException(e : exception;
      msgLevel : integer = TRACE_LEVEL_ERROR);

    // Identifiant du provider.
    property ProviderGUID : TGUID read FPRoviderGUID;

    // Classe de l'événement généré par le provider.
    property EventClass : TGUID read FEventClass;

    // Indique si la trace est actuellement active
    property EventEnabled : boolean read FEventEnabled write FEventEnabled;

    // Indique le niveau de trace qui a été défini au moment de l'activation
    // de la trace.
    property EnableLevel : integer read FEnableLevel;

    // Indique les flags définis au moment de l'activation de la trace
    property EnableFlags : cardinal read FEnableFlags;
  end;

// Déclare le provider auprès de ETW.
// <aProviderGUID> : GUID du provider.
// <aEventClass> : GUID de la classe d'événements généré par le provider.
constructor TGenericLogger.Create(aProviderGUID: TGUID; aEventClass : TGUID);
begin
  FProviderGUID := aProviderGUID;
  FEventClass := aEventClass;
  FRegistrationEventClass.Guid := @FEventClass;
  FRegistrationEventClass.RegHandle := 0;

  // la déclaration du provider consiste à appeler RegisterTraceGuids.
  if RegisterTraceGuids(@TraceControlCallBack, // Méthode callback pour
                                               // contrôler la trace
    Self, // On définit le pointeur sur l'instance comme contexte utilisateur.
    @FProviderGUID, // Pointeur sur l'identifiant du provider
    1, // Nombre d'événements déclarés
    @FRegistrationEventClass, // Pointeur sur la liste des classes d'événements
                              // générés par le provider
    nil, // On ne définit pas d'informations MOF
    nil, // On ne définit pas d'informations MOF
    FRegistrationHandle)<>ERROR_SUCCESS
  then RaiseLastOSError;
end;

// Cette fonction est appelée automatiquement par ETW pour controler la trace :
// <RequestCode> indique le type d'opération désirée :
// - WMI_ENABLE_EVENTS : Nous informe que le provider vient d'être activé.
// - WMI_DISABLE_EVENTS : Nous informe que le provider vient d'être arrêté.
// <RequestContext> Contient un pointeur sur les données utilisateur fournies
//                  au moment de l'enregistrement de la trace avec
//                  RegisterTraceGuid.
//                  On l'utilise pour connaitre l'instance de TGenericLogger
//                  concernée.
// <BufferSize> Spécifique Vista. On l'ignore.
// <Buffer> pointe sur une structure WNODE_HEADER contenant des informations
//          sur la trace concernée.
// En retour cette fonction doit renvoyer ERROR_SUCCESS pour indiquer que tout
// s'est bien passé.
function TraceControlCallBack(RequestCode : WMIDPREQUESTCODE;
    RequestContext : pointer;
    BufferSize : cardinal;
    Buffer : pointer) : cardinal; stdcall;
begin
  // En fonction de l'opération demandée, on active ou désactive la trace.
  case RequestCode of
    WMI_ENABLE_EVENTS: TGenericLogger(RequestContext).EnableEvents(Buffer);
    WMI_DISABLE_EVENTS: TGenericLogger(RequestContext).DisableEvents(Buffer);
  end;
  result := ERROR_SUCCESS;
end;

type
  TGenericEvent = packed record
    Header : EVENT_TRACE_HEADER; // en-tête du message
    Data : array[0..1] of MOF_FIELD; // Informations à écrire dans la trace.
  end;

// Ecrit le message <msg> dans la trace.
// Le message sera mémorisé avec le type d'événement <EventType>, pour le
// niveau de trace <msgLevel>, avec une information de durée <OperationTime>
procedure TGenericLogger.Trace(EventType: integer; msg: string;
    msgLevel: integer;
    OperationTime: int64);
    const EmptyStr : char = #0;
    var Event : TGenericEvent;
    EventSize : cardinal;
begin
  // Il faut commencer par tester si la trace a été activée et si le niveau de
  // trace défini est compatible avec le message à tracer. Sinon on
  // n'enregistre pas le message dans la trace.
  if MessageEnabled(msgLevel)
  then begin
    // Initialisation d'une structure TGenericEvent qui sera écrite dans la
    // trace.
    EventSize := Sizeof(Event);
    fillchar(Event, EventSize, 0);

    // Initialisation de l'en-tête de l'événement.
    Event.Header.Size := EventSize; // Taille de la structure.

    // On indique que le champs Guid a été défini et qu'on utilise un tableau
    // de structure MOF_FIELD pour définir les informations écrites dans la
    // trace.
    Event.Header.Flags := WNODE_FLAG_TRACED_GUID or WNODE_FLAG_USE_MOF_PTR;

    // On définit les identifiants de l'événement qui sera généré dans la trace.
    // Ces identfiants permettront au programme client de décoder les
    // informations définies dans Data.
    Event.Header.Guid := FEventClass; // Définition de la classe d'événement
    Event.Header.Version := 0; // Numéro de version de l'événement
    Event.Header.Type_ := EventType; // Définition du type de l'événement

    Event.Header.Level := msgLevel; // Niveau de trace de l'événement.

    // Une fois l'en-tête définie, on définit les informations à écrire dans la
    // trace.
    // On veut écrire un enregistrement composé des champs <OperationTime,
    // msg> Pour celà, on initialise l'adresse et la longueur de chaque champ.
    Event.Data[0].DataPtr := @OperationTime;
    Event.Data[0].Length := sizeof(OperationTime);
    if msg<>''
    then begin
      Event.Data[1].DataPtr := @msg[1];
      Event.Data[1].Length := length(msg)+1; // Longueur de la chaîne plus zéro
                                             // terminal.
    end
    else begin
      // Si msg est une chaine vide, msg est en réalité un pointeur qui vaut nil
      // Il ne s'agit donc plus d'une chaine asciiz et la chaine ne s'enregistre
      // pas correctement. Il faut donc qu'on écrive explicitement un zéro
      // terminal.
      Event.Data[1].DataPtr := @EmptyStr;
      Event.Data[1].Length := 1;
    end;

    // Enfin on écrit le message dans la trace.
    TraceEvent(TraceSession, @Event);
  end;
end;