1 Fonctions de macro

Aperçu

Les fonctions de macro permettent de personnaliser les valeurs des macros (par exemple, raccourcir ou extraire des sous-chaînes spécifiques), ce qui les rend plus faciles à utiliser.

La syntaxe d'une fonction de macro est la suivante :

{macro.func(params)}

où

• macro - la macro à personnaliser ;
• func - la fonction à appliquer (voir les fonctions prises en charge) ;
• params - une liste de paramètres de fonction séparés par des virgules, qui doivent être placés entre guillemets doubles s'ils :
  • commencent par un espace ou des guillemets doubles ;
  • contiennent une parenthèse fermante ou une virgule.

Par exemple :

{{TIME}.fmttime(format,time_shift)}
{{ITEM.VALUE}.regsub(pattern, output)}
{{$USERMACRO}.regsub(pattern, output)}
{{#LLDMACRO}.regsub(pattern, output)}

Les fonctions de macro sont prises en charge pour

• les macros intégrées
• les macros utilisateur
• les macros de découverte de bas niveau
• les macros d'expression

Les fonctions de macro peuvent être utilisées dans tous les emplacements prenant en charge les macros listées. Cela s'applique sauf s'il est explicitement indiqué qu'une macro seule est attendue (par exemple, lors de la configuration des macros d'hôte ou des filtres de règle de découverte de bas niveau).

Une seule fonction par macro est prise en charge ; plusieurs fonctions de macro chaînées ne sont pas prises en charge.

Fonctions prises en charge

Les fonctions sont répertoriées sans informations supplémentaires. Cliquez sur la fonction pour voir tous les détails.

Détails de la fonction

Les paramètres de fonction facultatifs sont indiqués par < >.

btoa

Encodage d'une valeur de macro en Base64. L'encodage Base64 est une méthode permettant de représenter des données binaires sous forme de texte, utile pour le stockage et la transmission sécurisée de contenu binaire via des protocoles basés sur du texte.

Exemple :

{{ITEM.VALUE}.btoa()} - encodera en Base64 une valeur comme "zabbix" en "emFiYml4"

fmtnum(digits)

Formatage des nombres pour contrôler le nombre de chiffres affichés après la virgule.

Paramètres :

• digits - le nombre de chiffres après la virgule. Plage valide : 0-20. Aucun zéro final ne sera produit.

Exemples :

{{ITEM.VALUE}.fmtnum(2)} - retournera "24.35" à partir d'une valeur reçue de "24.3483523"
{{ITEM.VALUE}.fmtnum(0)} - retournera "24" à partir d'une valeur reçue de "24.3483523"

fmttime(format,<time_shift>)

Formatage de l’heure.
Notez que cette fonction peut être utilisée avec des macros qui se résolvent en une valeur dans l’un des formats d’heure suivants :

• hh:mm:ss
• yyyy-mm-ddThh:mm:ss[tz] (norme ISO8601)
• Horodatage UNIX

Paramètres :

• format - chaîne de format obligatoire, compatible avec le formatage de la fonction strftime ;
• time_shift (facultatif) - le décalage temporel appliqué à l’heure avant le formatage ; doit commencer par -<N><time_unit> ou +<N><time_unit>, où :
  • N - le nombre d’unités de temps à ajouter ou à soustraire ;
  • time_unit - h (heure), d (jour), w (semaine), M (mois) ou y (année).

Commentaires :

• Le paramètre time_shift prend en charge les opérations temporelles en plusieurs étapes et peut inclure /<time_unit> pour décaler au début de l’unité de temps (/d - minuit, /w - 1er jour de la semaine (lundi), /M - 1er jour du mois, etc.). Exemples : -1w - exactement 7 jours en arrière ; -1w/w - lundi de la semaine précédente ; -1w/w+1d - mardi de la semaine précédente.
• Les opérations temporelles sont calculées de gauche à droite sans priorité. Par exemple, -1M/d+1h/w sera interprété comme ((-1M/d)+1h)/w.

Exemples :

{{TIME}.fmttime(%B)} - renverra "October" à partir d’une valeur reçue de "1633098961"
{{TIME}.fmttime(%d %B,-1M/M)} - renverra "1 September" à partir d’une valeur reçue de "1633098961"

htmldecode

Décodage d’une valeur de macro à partir de l’encodage HTML.

Les caractères suivants sont pris en charge :

Exemple :

{{ITEM.VALUE}.htmldecode()} - décodera en HTML une valeur telle que "&lt;" en "<"

htmlencode

Encodage d'une valeur de macro au format HTML.

Les caractères suivants sont pris en charge :

Exemple :

{{ITEM.VALUE}.htmlencode()} - encodera en HTML un caractère comme "<" en "&lt;"

iregsub(pattern,output)

Extraction d’une sous-chaîne par correspondance avec une expression régulière (insensible à la casse).

Paramètres :

• pattern - l’expression régulière à faire correspondre ;
• output - les options de sortie. Les espaces réservés \1 - \9 sont pris en charge pour les groupes de capture. \0 renvoie le texte correspondant.

Commentaires :

• S’il n’y a aucune correspondance pour l’expression régulière, la fonction renvoie une chaîne vide.
• Si le modèle de la fonction est une expression régulière incorrecte, alors la macro est évaluée à 'UNKNOWN' (sauf pour les macros de découverte de bas niveau, auquel cas la fonction sera ignorée et la macro restera non résolue).
• Les références à des groupes de capture inexistants dans la chaîne de remplacement sont remplacées par une chaîne vide.

Exemple :

{{ITEM.VALUE}.iregsub("fail|error|fault|problem","ERROR")} - sera résolu en "ERROR" si les sous-chaînes "fail", "error", "fault" ou "problem" sont reçues (sans tenir compte de la casse) ; renverra une chaîne vide s’il n’y a aucune correspondance

minuscules

Transformation de tous les caractères de la valeur de la macro en minuscules.
Fonctionne avec des jeux de caractères à un seul octet (tels que l’ASCII) et ne prend pas en charge l’UTF-8.

Exemple :

{{ITEM.VALUE}.lowercase()} - transformera une valeur telle que "Zabbix SERVER" en "zabbix server" (minuscules)

regrepl(pattern,replacement,<pattern2>,<replacement2>,...)

Remplacement de caractère/sous-chaîne dans la valeur de macro.

Paramètres :

• pattern - l'expression régulière à faire correspondre ;
• replacement - la chaîne de remplacement. Les espaces réservés \1 - \9 sont pris en charge dans les chaînes de remplacement pour les groupes de capture.

Commentaires :

• Les motifs et les remplacements sont traités séquentiellement, chaque paire suivante étant appliquée conformément au résultat du remplacement précédent ;
• Les références à des groupes de capture inexistants dans la chaîne de remplacement sont remplacées par une chaîne vide.

Exemples :

{{ITEM.VALUE}.regrepl("oldParam", "newParam")} - remplacera "oldParam" par "newParam"
{{ITEM.VALUE}.regrepl("([^a-z])","\\\1")} - tous les caractères non alphabétiques seront échappés avec une barre oblique inverse
{$THRESHOLD:"{{#FSNAME}.regrepl(\"\\$\",\"\")}"} - supprimera une barre oblique inverse finale (par exemple, pour remplacer "C:\" par "C:")
{{ITEM.VALUE}.regrepl("_v1\.0", "_v2.0", "\(final\)", "")} - remplacera plusieurs parties dans la valeur de l'élément

regsub(pattern,output)

Extraction de sous-chaîne par correspondance avec une expression régulière (sensible à la casse).

Paramètres :

• pattern - l’expression régulière à faire correspondre ;
• output - les options de sortie. Les espaces réservés \1 - \9 sont pris en charge pour les groupes de capture. \0 renvoie le texte correspondant.

Commentaires :

• S’il n’y a aucune correspondance pour l’expression régulière, la fonction renvoie une chaîne vide.
• Si le modèle de la fonction est une expression régulière incorrecte, alors la macro est évaluée à 'UNKNOWN' (sauf pour les macros de découverte de bas niveau, auquel cas la fonction sera ignorée et la macro restera non résolue).
• Les références à des groupes de capture inexistants dans la chaîne de remplacement sont remplacées par une chaîne vide.

Exemples :

{{ITEM.VALUE}.regsub("^([0-9]+)", Problem ID: \1)} - sera résolu en "Problem ID: 123" si une valeur telle que "123 Log line" est reçue
{{ITEM.VALUE}.regsub("fail|error|fault|problem","ERROR")} - sera résolu en "ERROR" si les sous-chaînes "fail", "error", "fault" ou "problem" sont reçues (sensible à la casse) ; renverra une chaîne vide s’il n’y a aucune correspondance

Voir plus d’exemples.

tr(caractères,remplacement)

Translittération des caractères de la valeur de macro.

• caractères - l’ensemble des caractères à remplacer ;
• remplacement - l’ensemble des caractères de remplacement correspondants par position.

Exemples :

{{ITEM.VALUE}.tr(abc, xyz)} - remplacera toutes les occurrences de "a" par "x", de "b" par "y", de "c" par "z"
{{ITEM.VALUE}.tr(abc, xyzq)} - remplacera toutes les occurrences de "a" par "x", de "b" par "y", de "c" par "z" ("q" est ignoré)
{{ITEM.VALUE}.tr(abcde, xyz)} - remplacera toutes les occurrences de "a" par "x", de "b" par "y", de "c" par "z", de "d" par "z", de "e" par "z" (c.-à-d. xyzzz)
{{ITEM.VALUE}.tr("\\\'", "\/\"")} - remplacera toutes les occurrences de barre oblique inverse par barre oblique, et les guillemets simples par des guillemets doubles
{{ITEM.VALUE}.tr(A-Z,a-z)} - convertira toutes les lettres en minuscules
{{ITEM.VALUE}.tr(0-9a-z,*)} - remplacera tous les chiffres et toutes les lettres minuscules par "*"
{{ITEM.VALUE}.tr(0-9,ab)} - remplacera toutes les occurrences de 0 par "a", et toutes les occurrences de 1, 2, 3, 4, 5, 6, 7, 8 et 9 par "b"
{{ITEM.VALUE}.tr(0-9abcA-L,*)} - remplacera tous les chiffres, les caractères "abc" et la plage A-L par "*"
{{ITEM.VALUE}.tr("\n","*")} - remplacera les occurrences de fin de ligne par *
{{ITEM.VALUE}.tr("e", "\n")} - remplacera tous les "e" par une fin de ligne

Pour inclure des caractères littéraux :

barre oblique inverse - doit être échappée comme \\
guillemet simple - doit être échappé comme \'
guillemet double - doit être échappé comme \"

Séquences d’échappement prises en charge avec la barre oblique inverse :

\\\\ => \\ - double barre oblique inverse vers barre oblique inverse simple
\\a  => \a - alerte
\\b  => \b - retour arrière
\\f  => \f - saut de page
\\n  => \n - nouvelle ligne
\\r  => \r - retour chariot
\\t  => \t - tabulation horizontale
\\v  => \v - tabulation verticale

uppercase

Transformation de tous les caractères de la valeur de la macro en majuscules.
Fonctionne avec des jeux de caractères à un seul octet (tels que l’ASCII) et ne prend pas en charge l’UTF-8.

Exemple :

{{ITEM.VALUE}.uppercase()} - transformera une valeur telle que "Zabbix Server" en "ZABBIX SERVER" (majuscules)

urldecode

Décodage d'une valeur de macro à partir d'un encodage URL.

Exemple :

{{ITEM.VALUE}.urldecode()} - décodera une valeur URL-encodée telle que "%2F" en "/"

urlencode

Encodage d'une valeur de macro au format URL.

Exemple :

{{ITEM.VALUE}.urlencode()} - encodera en URL un caractère comme "/" en "%2F"

Exemples supplémentaires

Le tableau ci-dessous présente d'autres exemples d'utilisation des fonctions de macro.

:::noteinfo {#IFALIAS} est une macro LLD et n'est définie que dans les contextes de découverte de bas niveau (règles de découverte, prototypes et éléments/déclencheurs créés à partir de ceux-ci). Son utilisation en dehors de la LLD laissera le jeton non développé. :::

Affichage des valeurs complètes des éléments

Les valeurs longues des macros résolues {ITEM.VALUE} et {ITEM.LASTVALUE} pour les éléments de type texte/log sont tronquées à 20 caractères dans certains emplacements du frontend. Pour voir les valeurs complètes de ces macros, vous pouvez utiliser des fonctions de macro, par exemple :

{{ITEM.VALUE}.regsub("(.*)", \1)}
{{ITEM.LASTVALUE}.regsub("(.*)", \1)}

Voir aussi : détails des macros {ITEM.VALUE} et {ITEM.LASTVALUE} macro details.