Les filtres vous permettent de réduire et de contrôler les données renvoyées par une requête, en n'affichant que les enregistrements qui répondent à des conditions spécifiques. Ils sont l'un des outils les plus importants du générateur de requêtes, car ils vous aident à passer de grands volumes de journaux à des informations concrètes et compréhensibles.
Chaque filtre est appliqué à un champ de la collection sélectionnée et utilise un opérateur qui définit comment la valeur du champ est comparée à la valeur que vous saisissez.
Comment fonctionnent les filtres
Un filtre se compose toujours de trois parties :
- Champ : la donnée que vous filtrez (IP, code de statut, domaine, date, utilisateur, etc.)
- Opérateur : comment la valeur est comparée (égal, contient, supérieur à, etc.)
- Valeur : ce que vous voulez rechercher ou exclure
Exemple :
- Champ : code de statut
- Opérateur : =
- Valeur : 500
Résultat : seuls les enregistrements avec l'erreur 500 sont affichés.
Comment les filtres sont combinés
Tous les filtres dans ConnectiLogs fonctionnent comme une condition cumulative (ET logique) :
- Un enregistrement n'est affiché que s'il répond à tous les filtres en même temps
Exemple :
- code de statut = 500
- domaine = mondomaine.com
Résultat : vous ne verrez que les erreurs 500 de ce domaine spécifique.
Types de filtres
Filtre Égal (=)
L'opérateur égal (=) est le filtre le plus basique et aussi l'un des plus importants dans ConnectiLogs. Il est utilisé pour sélectionner uniquement les enregistrements dont la valeur correspond exactement à la valeur que vous avez définie, sans autoriser de variations, de correspondances partielles ou d'interprétations.
C'est un opérateur de comparaison stricte : ce que vous tapez est exactement ce qui est recherché.
Lorsque vous appliquez un filtre avec l'opérateur égal, ConnectiLogs parcourt tous les enregistrements du champ sélectionné et ne renvoie que ceux qui répondent à cette condition exacte :
- valeur du champ = valeur du filtre
Les différences de format, le texte supplémentaire, les espaces supplémentaires ou les variations ne sont pas autorisés.
Exemple basique :
Si vous travaillez avec la collection des journaux d'accès et que vous souhaitez voir uniquement les erreurs serveur :
- Champ : code de statut
- Opérateur : =
- Valeur : 500
Le résultat sera :
Vous ne verrez que les enregistrements dont le code de statut est exactement 500.
Les éléments suivants sont automatiquement exclus :
- 404 (non trouvé)
- 200 (ok)
- 301 (redirection)
- toute autre valeur
Caractéristiques
- Correspondance exacte (100 %)
- Ne permet pas de variations ou de motifs
- Ne reconnaît pas les correspondances "partiellement correctes"
- Réduit l'ensemble de données de manière très contrôlée
Erreurs courantes lors de l'utilisation de "="
Lorsque vous travaillez avec cet opérateur, certaines erreurs sont souvent commises :
- Penser qu'il inclut des correspondances partielles (ce n'est pas le cas)
- Ne pas tenir compte des différences de format (www vs sans www, majuscules, etc.)
- L'utiliser alors que vous avez en réalité besoin d'un filtre de type "like"
- Oublier que la valeur doit correspondre exactement à celle stockée dans la collection
Filtre Différent de (!=)
L'opérateur différent de (!=) est le complément direct de l'opérateur égal. Il est utilisé pour exclure tous les enregistrements dont la valeur correspond exactement à la valeur que vous spécifiez, en n'affichant que ceux qui sont différents.
C'est un opérateur de filtrage négatif : au lieu de définir ce que vous voulez voir, vous définissez ce que vous voulez retirer du résultat.
Comment fonctionne-t-il ?
Lorsque vous appliquez un filtre avec !=, ConnectiLogs évalue chaque enregistrement du champ sélectionné et ne l'inclut que si :
- valeur du champ != valeur du filtre
En d'autres termes, toute correspondance exacte avec la valeur spécifiée est automatiquement exclue de la requête.
Exemple basique :
Si vous analysez les codes de statut dans les journaux d'accès :
- Champ : code de statut
- Opérateur : !=
- Valeur : 500
Le résultat sera :
Vous verrez tous les enregistrements sauf ceux avec l'erreur 500.
Cela inclut :
- 200 (ok)
- 404 (non trouvé)
- 301 (redirection)
- tout autre code autre que 500
Caractéristiques :
- Exclusion exacte de valeurs
- Fonctionne comme un filtre inverse de "="
- Réduit l'ensemble de données en éliminant le bruit connu
- Très utile pour l'analyse comparative
- Ne permet pas de correspondances partielles
Erreurs courantes lors de l'utilisation de !=
- L'utiliser alors que vous voulez en réalité exclure plusieurs valeurs (mieux vaut utiliser not in)
- Le confondre avec des filtres partiels (il ne fonctionne pas avec des correspondances de type "like")
- Oublier qu'il n'exclut que les correspondances exactes, pas les variations de la valeur
Filtre Contient (like) et Ne contient pas (not like)
Les opérateurs like et not like sont utilisés pour filtrer les champs textuels lorsque vous ne recherchez pas une correspondance exacte, mais plutôt des motifs ou des fragments de texte à l'intérieur d'une valeur. Ils sont particulièrement utiles dans ConnectiLogs car de nombreux champs (comme les domaines, les chemins, les utilisateurs ou les user agents) contiennent des informations structurées où vous ne connaissez pas toujours la valeur complète.
Comment fonctionnent-ils ?
Contrairement à l'opérateur égal (=) qui nécessite une correspondance exacte, like permet des correspondances partielles, c'est-à-dire de trouver des enregistrements où le texte apparaît dans la valeur du champ.
- like : inclut les correspondances qui contiennent le motif
- not like : exclut les correspondances qui contiennent le motif
Utilisation du caractère générique %
Le comportement de like et not like est contrôlé par le symbole %, qui agit comme un caractère générique. Cela indique que n'importe quel texte peut exister à cette position.
Cela vous permet de définir trois types de recherches :
Contient du texte à n'importe quelle position
- Motif : %texte%
Recherche les enregistrements où "texte" apparaît n'importe où dans la valeur.
Exemple :
- filtre : domaine like %mondomaine%
Résultat :
- mondomaine.com
- api.mondomaine.net
- test.mondomaine123.es
Commence par du texte
- Motif : texte%
Recherche les valeurs qui commencent exactement par ce texte.
Exemple :
- filtre : domaine like mondomaine%
Résultat :
- mondomaine.com
- mondomaine.net
- mondomaine-api.com
N'inclurait pas :
- api.mondomaine.com
- testmondomaine.com
Se termine par du texte
- Motif : %texte
Recherche les valeurs qui se terminent par ce texte.
Exemple :
- filtre : domaine like %mondomaine
Résultat :
- api.mondomaine
- test.mondomaine
- logs.mondomaine
N'inclurait pas :
- mondomaine.com
- mondomaine.net
Que fait not like ?
L'opérateur not like fonctionne exactement comme like, mais à l'inverse : il exclut tous les enregistrements qui contiennent le motif spécifié.
Exemple de not like
- Champ : user agent
- Opérateur : not like
- Valeur : %bot%
Résultat :
Tous les enregistrements dont l'user agent contient "bot" seront exclus, par exemple :
- googlebot
- bingbot
- tout crawler ou script automatisé
Et les suivants seront conservés :
- les vrais navigateurs
- le trafic humain
- d'autres agents non liés aux bots
Quand utiliser like et not like ?
Utilisez like lorsque :
- Vous ne connaissez pas la valeur exacte du champ
- Vous voulez regrouper des variantes d'un même concept
- Vous analysez des textes structurés (domaines, chemins, journaux)
- Vous avez besoin de rechercher des motifs dans des champs longs
Utilisez not like lorsque :
- Vous voulez éliminer le bruit des données
- Vous devez exclure des motifs connus (bots, spam, tests…)
- Vous nettoyez les résultats pour une analyse plus précise
- Vous voulez conserver le trafic "humain" ou pertinent
Différences importantes par rapport aux autres opérateurs
- = : correspondance exacte
- like : correspondance partielle (motif)
- != : exclusion exacte
- not like : exclusion par motif
Erreurs courantes
- Oublier d'utiliser % et ne pas obtenir les résultats attendus
- Utiliser like alors que vous connaissez en réalité la valeur exacte (mieux vaut utiliser =)
- Abuser de not like et éliminer trop de données utiles
- Ne pas considérer que de petites variations de texte modifient le résultat
Filtre Dans (in) et Pas dans (not in)
Les opérateurs in et not in sont utilisés lorsque vous avez besoin de travailler avec des listes de valeurs, plutôt que de comparer une valeur unique. Ils sont particulièrement utiles dans ConnectiLogs car ils vous permettent de simplifier plusieurs filtres en une seule condition, rendant les requêtes plus faciles.
Comment fonctionnent-ils ?
Ces opérateurs comparent la valeur d'un champ à un ensemble d'options :
- in : l'enregistrement est inclus si sa valeur est dans la liste
- not in : l'enregistrement est inclus si sa valeur n'est PAS dans la liste
Opérateur Dans (in)
L'opérateur in renvoie tous les enregistrements dont la valeur correspond à n'importe lequel des éléments de la liste définie.
Exemple basique :
Si vous analysez les codes de statut :
- Champ : code de statut
- Opérateur : in
- Valeurs : 404, 500
Résultat :
Seuls les enregistrements dont le code de statut est :
- 404
- 500
Tout le reste est exclu de la requête.
Opérateur Pas dans (not in)
L'opérateur not in fait l'inverse : il exclut tous les enregistrements dont la valeur est dans la liste spécifiée.
Exemple basique
- Champ : code de statut
- Opérateur : not in
- Valeurs : [200, 301]
Résultat :
Tous les enregistrements seront affichés sauf :
- 200 (OK)
- 301 (redirection)
Ceci est utile lorsque vous voulez vous concentrer sur les erreurs ou les comportements anormaux.
Quand utiliser in et not in ?
Utilisez in lorsque :
- Vous voulez filtrer plusieurs valeurs spécifiques en même temps
- Vous travaillez avec des états, codes ou catégories limités
- Vous devez simplifier plusieurs conditions OU en une seule règle
- Vous voulez vous concentrer sur un ensemble spécifique d'événements
Utilisez not in lorsque :
- Vous voulez exclure plusieurs valeurs connues
- Vous nettoyez le bruit (bots, trafic interne, tests…)
- Vous avez besoin d'analyser "tout sauf…"
- Vous voulez réduire les résultats sans perdre le contexte global
Erreurs courantes
- Utiliser in alors qu'il n'y a qu'une seule valeur (mieux vaut utiliser =)
- Confondre in avec like (il n'y a pas de correspondances partielles ici)
- Inclure trop de valeurs sans critère clair
- Ne pas valider que toutes les valeurs de la liste existent réellement dans les données
Filtres Supérieur à (>), Supérieur ou égal à (>=), Inférieur à (<) et Inférieur ou égal à (<=)
Ces opérateurs sont utilisés pour les comparaisons numériques ou temporelles dans ConnectiLogs. Ils sont importants lorsque vous devez travailler avec des seuils, des plages ou des limites, en particulier dans des champs tels que les dates, les temps de réponse, les tailles de fichiers ou toute valeur quantifiable.
Contrairement aux filtres textuels, ces opérateurs ne recherchent pas de correspondances exactes ou de motifs, mais des relations d'ordre entre les valeurs.
Comment fonctionnent-ils ?
Tous ces opérateurs comparent la valeur d'un champ avec une valeur de référence :
- > (supérieur à) : la valeur du champ doit être strictement supérieure
- >= (supérieur ou égal à) : la valeur du champ doit être supérieure ou égale
- < (inférieur à) : la valeur du champ doit être strictement inférieure
- <= (inférieur ou égal à) : la valeur du champ doit être inférieure ou égale
Supérieur à (>)
L'opérateur > renvoie uniquement les enregistrements dont la valeur est supérieure à la valeur indiquée, sans l'inclure.
Exemple
- Champ : temps de réponse
- Opérateur : >
- Valeur : 1
Résultat :
Les enregistrements avec un temps de réponse supérieur à 1 seconde seront affichés :
- 1,2 s
- 2 s
- 5 s
N'inclut pas :
- exactement 1 s
Supérieur ou égal à (>=)
L'opérateur >= est similaire au précédent, mais il inclut la valeur limite.
Exemple
- Champ : taille
- Opérateur : >=
- Valeur : 4000
Résultat :
Tous les enregistrements avec une taille :
- 4000 Ko
- 4500 Ko
- 10000 Ko
Inférieur à (<)
L'opérateur < renvoie les enregistrements dont la valeur est inférieure à la valeur indiquée, sans l'inclure.
Exemple
- Champ : temps de réponse
- Opérateur : <
- Valeur : 1
Résultat :
Seuls les enregistrements avec des temps de réponse inférieurs à 1 seconde seront affichés :
- 0,2 s
- 0,5 s
- 0,9 s
N'inclut pas :
- exactement 1 s
Inférieur ou égal à (<=)
L'opérateur <= inclut toutes les valeurs inférieures ou égales à la valeur définie.
Exemple
- Champ : taille
- Opérateur : <=
- Valeur : 1000
Résultat :
Les enregistrements avec une taille seront inclus :
- 1000 Ko
- 800 Ko
- 200 Ko
Utilisation combinée (plages)
Ces opérateurs sont particulièrement puissants lorsqu'ils sont combinés pour créer des plages de valeurs.
Exemple de plage
- temps de réponse >= 1
- temps de réponse <= 3
Résultat :
Seuls les enregistrements avec des temps de réponse entre 1 et 3 secondes (y compris les deux extrémités) sont affichés.
Cela vous permet d'analyser le comportement dans un intervalle spécifique.
Différences clés
- > et < → excluent la valeur limite
- >= et <= → incluent la valeur limite
- Ils ne fonctionnent qu'avec des données numériques ou temporelles, pas du texte
- Ils sont la base pour construire des plages d'analyse précises
Erreurs courantes
- Les utiliser sur des champs de texte (non valide)
- Confondre > avec >= et perdre la valeur limite
- Ne pas définir correctement les plages (laisser des écarts entre les conditions)
Conseils pratiques pour l'utilisation des filtres
Dans ConnectiLogs, les filtres sont plus puissants lorsqu'ils sont utilisés avec une stratégie claire et progressive, plutôt que d'essayer de construire une requête parfaite dès le départ.
Il est fortement recommandé de toujours commencer par des filtres basiques et faciles à valider (par exemple, par domaine, code de statut ou plage de dates) et de vérifier que la requête renvoie des données avant d'ajouter d'autres conditions. À partir de là, vous pouvez affiner progressivement jusqu'à atteindre le niveau de détail dont vous avez besoin.
Il est essentiel de choisir le bon opérateur en fonction du type de données. Pour les correspondances exactes, utilisez =, pour les exclusions spécifiques !=, pour les listes de valeurs in / not in, pour les recherches textuelles flexibles like / not like, et pour les plages numériques ou temporelles >, >=, <, <=. Utiliser le mauvais opérateur est l'une des causes les plus courantes de résultats vides ou inattendus.
Il est également important de comprendre que tous les filtres se combinent entre eux de manière cumulative (ET), ce qui signifie que chaque condition réduit l'ensemble de données. Par conséquent, ajouter trop de filtres restrictifs dès le départ peut vous faire perdre des informations pertinentes ou même aboutir à une requête sans résultats.
Lorsque vous travaillez avec plusieurs valeurs connues, utilisez in / not in plutôt que de répéter plusieurs filtres égaux, car cela simplifie la requête et améliore la lisibilité. Si vous avez besoin de rechercher des motifs dans du texte, utilisez like / not like avec soin en utilisant le caractère générique %, en évitant des interprétations trop larges ou trop restrictives.
En résumé, la clé est d'équilibrer précision et étendue : commencez par des filtres simples, validez les résultats et affinez progressivement, en vous assurant toujours d'utiliser l'opérateur approprié pour chaque type de données.