Utilisation de fenêtres d'événement

Dans les applications qui traitent des événements en temps réel, une condition courante consiste à effectuer un calcul basé sur un ensemble (agrégation), ou d'autres opérations, sur des sous-ensembles d'événements se produisant durant une période donnée. Dans StreamInsight, ces sous-ensembles d'événements sont définis via des fenêtres. Cette rubrique donne une description des fenêtres et de leur mode de définition, identifie les types de fenêtre pris en charge dans StreamInsight et explique comment utiliser les fenêtres avec différents opérateurs.

Dans cette section

Type de fenêtres

• Fenêtres utilisant des nombres

• Fenêtres récurrentes

• Fenêtres d'instantané

Opérations effectuées sur les fenêtres

• Agrégations

• TopK

• Agrégats et opérateurs définis par l'utilisateur

Fonctionnement des fenêtres

Une fenêtre contient les données d'événements d'une chronologie et vous permet d'effectuer diverses opérations sur les événements de cette fenêtre. Il est possible, par exemple, d'additionner les valeurs de champs de charge utile dans une fenêtre donnée, comme indiqué dans l'illustration suivante.

L'illustration précédente montre comment une fenêtre récurrente est appliquée à un flux d'événements et comment un agrégat est appliqué au flux de données de fenêtre. La forme des événements qui contiennent les résultats de l'agrégation dépend de la stratégie de sortie de fenêtre. Ici, ils sont représentés par des événements point à la fin de la fenêtre.

L'opération de fenêtrage transforme le flux d'événements en un flux de données de fenêtre (CepWindowStream<T>) lequel pourra alors servir de base pour une opération reposant sur un jeu. Chaque fenêtre de la chronologie représente un jeu d'événements. Le type de fenêtre que vous utilisez détermine la façon dont les événements sont colocalisés : les fenêtres peuvent avoir des contraintes d'heure ou de nombre. Chaque type de fenêtre est représenté par un opérateur de fenêtrage.

L'opération reposant sur un jeu reconvertit un flux de données de fenêtres en flux d'événements (CepStream<T>). Ces opérations reposant sur un jeu sont réparties en deux groupes :

• Agrégations qui génèrent un résultat scalaire pour un jeu d'événements d'entrée.

• Opérations qui génèrent zéro, un ou plusieurs événements de sortie pour un jeu d'événements d'entrée.

Quelques exemples du premier groupe sont sum, avg, count et les agrégats définis par l'utilisateur. Une ou plusieurs de ces agrégations peuvent être appliquées à un flux de données fenêtré, de sorte qu'un événement de résultat correspond à chaque fenêtre d'entrée et les résultats scalaires de l'agrégation apparaissent en tant que champs dans la charge utile de l'événement qui en résulte. Par exemple, il est possible d'additionner les valeurs d'un ou de plusieurs champs de charge utile d'une fenêtre et, en fonction de ces valeurs, d'exécuter d'autres traitements ou de créer un autre flux d'événements contenant ces données agrégées.

Quelques exemples du second groupe sont TopK et les opérateurs définis par l'utilisateur. Ils sont définis sur un flux de données fenêtré et génèrent zéro, un ou plusieurs événements multiples par fenêtre, comme résultat de leur calcul. Par exemple, l'opérateur TopK permet de sélectionner les cinq principaux événements de chaque fenêtre d'instantané définie pour un flux d'entrée spécifique et de générer un nouveau flux d'événements en vue de procéder à d'autres traitements.

Lorsque les événements d'un flux de données fenêtré sont passés à un opérateur qui repose sur un ensemble, mais aussi, lorsqu'ils ressortent d'un opérateur qui repose sur un ensemble et qu'ils réintègrent le flux de données, leurs horodateurs peuvent être transformés. Ces transformations sont appelées stratégie d'entrée et stratégie de sortie, respectivement. Ces stratégies déterminent la façon dont les événements s'affichent dans les fenêtres et dont le résultat de l'opération reposant sur un ensemble est émis.

StreamInsight prend en charge les types de fenêtres suivants :

• Fenêtres récurrentes

• Fenêtres d'instantané

• Fenêtres utilisant des nombres

Spécification de fenêtres

Comme indiqué dans l'illustration suivante, une spécification de fenêtre comporte trois éléments :

• Définition de la fenêtre (intervalles de temps pour une fenêtre récurrente, nombre pour les fenêtres utilisant des nombres, aucun paramètre pour une fenêtre d'instantané)

• Transformation temporelle de l'entrée (stratégie d'entrée)

• Transformation temporelle de la sortie (stratégie de sortie)

L'illustration décrit sur le plan conceptuel les transformations d'un flux de données lorsqu'il passe par une opération reposant sur un jeu en sus d'une fenêtre.

1. Au point A, un flux de données d'événement arrive à l'opérateur de fenêtre.

2. Au point B, l'opérateur de fenêtre produit un flux de fenêtres. Chaque fenêtre contient un jeu d'événements. Il est possible que les durées de vie de ces événements aient été modifiées en fonction de la stratégie d'entrée. Le flux de données d'événement est passé à un opérateur reposant sur un jeu tel qu'une agrégation, ou un opérateur défini par l'utilisateur.

3. Au point C, l'opérateur reposant sur un jeu traite chaque fenêtre et produit un flux d'événements en tant que sortie.

   • Pour les agrégats, un événement est créé pour chaque jeu (ou aucun événement n'est créé si la fenêtre est vide). Étant donné que l'agrégation spécifie seulement une valeur scalaire, la durée de vie de l'événement de sortie est définie par défaut sur l'intervalle de temps de la fenêtre. Cela s'applique aux agrégations intégrées ainsi qu'au résultat d'agrégats définis par l'utilisateur.

   • Pour les opérateurs définis par l'utilisateur et les TopK, zéro, un ou plusieurs événements sont produits. Les opérateurs définis par l'utilisateur basés sur le temps spécifient également les durées de vie des événements de sortie. Pour les opérateurs définis par l'utilisateur et les opérateurs TopK, la durée de vie de l'événement de sortie est définie par défaut sur l'intervalle de temps de la fenêtre.

4. Au point D, une stratégie de sortie peut être appliquée aux événements de sortie. Cela permet à l'auteur de la requête de modifier les propriétés temporelles des événements et de remplacer les valeurs de durée de vie par défaut produites par l'opérateur reposant sur un jeu.

Dans le programme, les trois zones blanches dans l'illustration sont représentées par des paramètres pour les opérateurs de fenêtre.

Stratégies de fenêtres

Les opérateurs de fenêtre créent les flux de fenêtres requis pour toute opération reposant sur un jeu. Au-delà de la définition de la fenêtre elle-même (en termes d'heure ou de nombre), l'auteur de la requête peut choisir 1) la façon dont l'opération de fenêtrage affecte les durées de vie des événements contenus dans la fenêtre lorsqu'ils sont transmis à l'opération de fenêtrage et 2) le mode d'ajustement des durées de vie des événements de résultat de l'opération.

Les deux stratégies sont spécifiées par l'auteur de la requête dans le cadre de l'opérateur de fenêtre, dans le but de contrôler ou de remplacer les horodateurs par défaut de l'agrégation ou de l'opérateur défini par l'utilisateur en haut de la fenêtre.

Stratégies d'entrée

Dans cette version, StreamInsight prend en charge la stratégie d'entrée qui consiste à faire coïncider à la fois l'heure de début et de fin des événements de la fenêtre à l'heure de début et de fin de la fenêtre. Autrement dit, toute opération reposant sur un jeu (basée sur le temps) consultera uniquement les horodateurs d'événements à l'intérieur de la fenêtre, même en cas de chevauchement des événements d'origine à l'extérieur de la fenêtre avant application de la stratégie d'entrée.

La spécification de la stratégie d'entrée est facultative. Par commodité, le classe WindowInputPolicy fournit une propriété statique qui retourne une instance correspondante (WindowInputPolicy.ClipToWindow).

Stratégies de sortie

Dans cette version, StreamInsight prend en charge les stratégies de sortie suivantes :

• Fenêtres d'instantané : les heures de fin des événements obtenus coïncident avec l'heure de fin de la fenêtre.

• Les fenêtres récurrentes prennent en charge les 2 stratégies de sortie suivantes :

  • Les événements obtenus sont des événements point alignés sur l'heure de fin de la fenêtre.

  • Les heures de fin des événements obtenus coïncident avec l'heure de fin de la fenêtre.

• Fenêtres utilisant des nombres : l'événement obtenu est converti en événement point à la fin de la fenêtre.

À chaque type de fenêtre correspondent une ou des classes de stratégies de sortie spécifiques. Par commodité, les classes de stratégies de sortie fournissent chacune une propriété statique qui renvoie une instance correspondante :

• SnapshotWindowOutputPolicy.Clip (valeur par défaut, en l'absence de toute spécification)

• HoppingWindowOutputPolicy.ClipToWindowEnd

• HoppingWindowOutputPolicy.PointAlignToWindowEnd (valeur par défaut, en l'absence de toute spécification)

• CountWindowOutputPolicy.PointAlignToWindowEnd (valeur par défaut, en l'absence de toute spécification)

Voici un résumé de toutes les fenêtres disponibles et leur effet sur le résultat de l'opération reposant sur un jeu :

Fenêtre d'instantané :

Stratégie de sortie : toujours faire correspondre à la fin de la fenêtre

Durées de vie de sortie :

Fenêtre récurrente :

Stratégie de sortie : faire correspondre à la fin de la fenêtre ou PointAlignToWindowEnd

Durées de vie de sortie :

Fenêtre utilisant des nombres :

Stratégie de sortie : toujours pointer à la fin de la fenêtre

Durées de vie de sortie :

Voir aussi

Concepts

Agrégations

TopK

Agrégats et opérateurs définis par l'utilisateur