7 Éléments calculés

Présentation

Ce type d’élément permet d’effectuer des calculs sur des métriques qui existent déjà. Un élément calculé ne collecte aucune donnée par lui-même.

Par exemple, vous pouvez vouloir :

  • Compter deux valeurs.
  • Calculer la moyenne de plusieurs valeurs d’élément.
  • Calculer la valeur totale pour un groupe d’éléments.

La valeur résultante est stockée dans la base de données Zabbix comme pour tout autre élément ; les valeurs d’historique et de tendance sont toutes deux stockées et des graphiques peuvent être générés.

Le calcul est basé sur une formule. La syntaxe de la formule est partagée avec les expressions de déclencheur.

En fait, il est possible de garder les déclencheurs simples en plaçant une logique complexe de mise en forme des données dans un élément calculé, puis de référencer l’élément calculé dans un déclencheur à l’aide de la clé d’élément.

Il existe deux possibilités pour spécifier la source de données des calculs :

  1. Spécifier les éléments dans la formule.
  2. Effectuer une agrégation de données basée sur un filtre qui sélectionne des éléments.

La deuxième option permet de calculer des moyennes de groupe, des totaux, etc.

Tous les calculs sont effectués par le serveur Zabbix ; le proxy ou les agents ne sont pas impliqués du tout. Notez qu’une utilisation intensive d’éléments calculés avec de longues périodes peut affecter les performances du serveur.

Champs configurables

Pour utiliser des éléments calculés, choisissez le type d'élément Calculated.

La clé est un identifiant unique d'élément (par hôte). Vous pouvez créer n'importe quel nom de clé à l'aide des symboles pris en charge. La clé permet de référencer l'élément calculé dans les déclencheurs.

La définition du calcul doit être saisie dans le champ Formula.

Il n'existe aucun lien entre la formule et la clé. Les paramètres de la clé ne sont en aucune façon utilisés dans la formule.

Contrairement aux expressions de déclencheur, Zabbix traite les éléments calculés en fonction de l'intervalle de mise à jour de l'élément, et non à la réception d'une nouvelle valeur.

Notez que si vous sélectionnez Numeric (unsigned) comme type d'information et que le résultat du calcul est une valeur flottante, celle-ci est tronquée en entier.

Formule de calcul simple

La syntaxe d'une formule simple est :

fonction(/hôte/clé,<paramètre1>,<paramètre2>,...)

où :

Élément Description
function L'une des fonctions prises en charge : last, min, max, avg, count, etc.
host Hôte de l'élément utilisé pour le calcul.
L'hôte actuel peut être omis (c'est-à-dire comme dans function(//key,parameter,...)).
key Clé de l'élément utilisé pour le calcul.
Les éléments renvoyant des valeurs avec le type de données binaire ou JSON ne sont pas pris en charge.
Si vous modifiez la clé d'élément d'un élément référencé, la clé doit être mise à jour manuellement dans la formule.
Tous les éléments référencés par des fonctions d'historique doivent exister et collecter des données.
parameter(s) Paramètres de la fonction, si nécessaire.
Les suffixes de temps et les suffixes de taille mémoire sont pris en charge.

Une formule plus complexe peut utiliser une combinaison de fonctions, d'opérateurs et de parenthèses.

Voir des exemples de formules d'éléments calculés :

Certaines variables peuvent être transmises à la formule à l'aide de macros utilisateur. Notez que les macros utilisateur :

  • seront résolues - si elles sont utilisées pour référencer un paramètre de fonction, un paramètre de filtre d'élément ou une constante.
  • ne seront pas résolues - si elles référencent une fonction, un nom d'hôte, une clé d'élément, un paramètre de clé d'élément ou un opérateur.

La comparaison avec des chaînes est autorisée.

S'il n'y a pas de données récentes dans le cache et qu'aucune période d'interrogation n'est définie dans la fonction, Zabbix remontera par défaut jusqu'à une semaine dans le passé pour interroger la base de données à la recherche de valeurs historiques.

Un élément calculé peut devenir non pris en charge dans plusieurs cas :

  • élément référencé
    • introuvable
    • désactivé, ou appartenant à un hôte désactivé
    • non pris en charge (sauf avec la fonction nodata() et les opérateurs avec des valeurs inconnues)
  • aucune donnée pour calculer une fonction
  • division par zéro
  • syntaxe incorrecte utilisée

Agrégations de données

Les agrégations de données sont basées sur un filtre qui sélectionne plusieurs éléments. Les agrégations de données sont également un type d’élément calculé, mais vous utilisez une syntaxe légèrement différente dans la formule.

Pour récupérer des agrégats, utilisez l’une des fonctions d’agrégation prises en charge : avg, max, min, sum, etc. Ajoutez ensuite la fonction foreach comme seul paramètre ainsi que son filtre d’élément pour sélectionner les éléments requis :

aggregate_function(function_foreach(/host/key?[group="host group"],timeperiod))

Une fonction foreach (par exemple avg_foreach, count_foreach, etc.) renvoie une valeur agrégée pour chaque élément sélectionné. Les éléments sont sélectionnés à l’aide du filtre d’élément (/host/key?[group="host group"]), à partir de l’historique des éléments. Pour plus de détails, voir fonctions foreach.

Si certains éléments n’ont pas de données pour la période demandée, ils sont ignorés dans le calcul. Si aucun élément n’a de données, la fonction renverra une erreur.

Vous pouvez également lister plusieurs éléments comme paramètres de l’agrégation :

aggregate_function(function(/host/key,parameter),function(/host2/key2,parameter),...)

Notez que function doit ici être une fonction d’historique/tendance.

Voir des exemples de calculs agrégés :

Les macros utilisateur et les macros de découverte de bas niveau sont prises en charge dans :

  • les paramètres de clé d’élément
  • les paramètres de fonction
  • les conditions de filtre (nom du groupe d’hôtes et nom du tag)
  • les constantes d’expression

Un calcul agrégé peut devenir non pris en charge si :

  • aucun des éléments référencés n’est trouvé (ce qui peut se produire si la clé d’élément est incorrecte, si aucun des éléments n’existe ou si tous les groupes inclus sont incorrects)
  • aucune donnée n’est disponible pour calculer une fonction

Exemples d’éléments calculés

(1) Trafic total sur l’interface
last(//net.if.in[eth0,bytes])+last(//net.if.out[eth0,bytes])

Calcule la bande passante totale sur eth0.

(2) Pourcentage d'espace disque libre
100*last(//vfs.fs.size[/,free])/last(//vfs.fs.size[/,total])

Zabbix prendra les dernières valeurs des espaces disque libre et total (sur /) et calculera le pourcentage selon la formule donnée.

(3) Pourcentage du trafic entrant
100*last(//net.if.in[eth0,bytes])/(last(//net.if.in[eth0,bytes])+last(//net.if.out[eth0,bytes]))

Calcule le pourcentage du trafic entrant par rapport au trafic total.

(4) Nombre moyen de valeurs traitées
avg(/Zabbix server/zabbix[wcache,values],10m)

Calcule une moyenne sur 10 minutes du nombre de valeurs traitées par Zabbix.

(5) Trafic entrant total pour l’hôte
sum(last_foreach(/host/net.if.in[*]))

Calcule le total de tous les éléments correspondant à net.if.in[*] sur l’hôte.

(6) Espace disque total pour le groupe
sum(last_foreach(/*/vfs.fs.size[/,total]?[group="MySQL Servers"]))

Calcule l’espace disque total pour tous les MySQL Servers.

(7) Charge processeur moyenne pour le groupe
avg(last_foreach(/*/system.cpu.load[,avg1]?[group="MySQL Servers"]))

Calcule la charge processeur moyenne pour tous les MySQL Servers.

(8) Charge processeur moyenne pour le groupe et le tag
avg(last_foreach(/*/system.cpu.load?[(group="Servers A" or group="Servers B" or group="Servers C") and (tag="Service:" or tag="Importance:High")]))

Calcule la charge CPU moyenne sur tous les hôtes de plusieurs groupes d’hôtes ayant des tags spécifiques.

(9) Nombre moyen de requêtes pour le groupe
avg(avg_foreach(/*/mysql.qps?[group="MySQL Servers"],5m))

Calcule la moyenne sur 5 minutes du nombre de requêtes par seconde pour MySQL Servers.

(10) Nombre total de vérifications DNS réussies
sum(last_foreach(/*/net.dns[*,*,*]))

Calcule le nombre total de vérifications DNS réussies sur tous les hôtes. La forme d’élément affichée est net.dns[192.0.2.0,example.com,A], comme exemple d’une clé possible.

Notez que les caractères génériques doivent correspondre au nombre de paramètres dans la clé (ici, net.dns comporte trois paramètres : ip, name, type).

(11) Nombre total d’éléments non pris en charge pour le groupe
sum(last_foreach(/*/zabbix[host,,items_unsupported]?[group="Zabbix servers"]))

Calcule le nombre total d’éléments non pris en charge pour Zabbix servers.

(12) Statistiques de l’interface pour le groupe
sum(last_foreach(/*/net.if.out[eth0,bytes]?[group="video"])) / sum(last_foreach(/*/nginx_stat.sh[active]?[group="video"]))

Calcule les statistiques de l’interface pour le groupe video.

Exemples de syntaxe correcte/incorrecte

Les expressions (y compris les appels de fonction) ne peuvent pas être utilisées comme paramètres de fonction d'historique, de tendance ou foreach. Cependant, ces fonctions elles-mêmes peuvent être utilisées dans d'autres paramètres de fonction (non historiques).

Expression Example
Valide avg(last(/host/key1),last(/host/key2)*10,last(/host/key1)*100)

max(avg(avg_foreach(/*/system.cpu.load?[group="Servers A"],5m)),avg(avg_foreach(/*/system.cpu.load?[group="Servers B"],5m)),avg(avg_foreach(/*/system.cpu.load?[group="Servers C"],5m)))
Invalide sum(/host/key,10+2)

sum(/host/key, avg(10,2))

sum(/host/key,last(/host/key2))

Notez que dans une expression comme :

sum(sum_foreach(//resptime[*],5m))/sum(count_foreach(//resptime[*],5m))

il n'est pas possible de garantir que les deux parties de l'équation auront toujours le même ensemble de valeurs. Pendant l'évaluation d'une partie de l'expression, une nouvelle valeur pour la période demandée peut arriver, et l'autre partie de l'expression aura alors un ensemble de valeurs différent.