cdeftutorial - En ligne dans le Cloud

PROGRAMME:

Nom

cdeftutorial - Le tutoriel CDEF d'Alex van den Bogaerdt

DESCRIPTION

Intention de ce document : fournir quelques exemples des parties couramment utilisées de
Le langage CDEF de RRDtool.

Si vous pensez qu'une fonctionnalité importante n'est pas expliquée correctement, et si vous l'ajoutez à ceci
document bénéficierait à la plupart des utilisateurs, veuillez me demander de l'ajouter. je vais alors essayer de fournir
une réponse dans la prochaine version de ce tutoriel. Aucun retour n'équivaut à aucun changement ! Ajouts
à ce document sont également les bienvenus. -- Alex van den Bogaerdt[email protected]>

Constat this Didacticiel?
L'un des éléments puissants de RRDtool est sa capacité à effectuer toutes sortes de calculs sur le
données extraites de ses bases de données. Cependant, les nombreuses options et la syntaxe de RRDtool le rendent
difficile à comprendre pour l'utilisateur moyen. Les manuels sont bons pour expliquer ce que
ces options le font ; cependant, ils n'expliquent pas (et ne devraient pas) expliquer en détail pourquoi ils sont
utile. Comme avec mon tutoriel RRDtool : si vous voulez un document simple dans un langage simple vous
devrait lire ce tutoriel. Si vous êtes satisfait de la documentation officielle, vous pouvez trouver
ce document trop simple voire ennuyeux. Si vous choisissez de lire ce tutoriel, je
attendez-vous à avoir lu et bien compris mon autre tutoriel.

Plus lire
Si vous avez des difficultés avec la façon dont j'essaie de l'expliquer, veuillez lire l'article de Steve Rader
rpntutorial. Cela peut vous aider à comprendre comment tout cela fonctionne.

Quoi CDEF ?

Lors de la récupération de données à partir d'un RRD, vous utilisez un "DEF" pour travailler avec ces données. Penser à
comme une variable qui change dans le temps (où le temps est l'axe des x). La valeur de ce
la variable est ce qui se trouve dans la base de données à ce moment précis et vous ne pouvez rien faire
des modifications dessus. C'est à cela que servent les CDEF : ils prennent les valeurs des DEF et effectuent
calculs sur eux.

Syntaxe

DEF:var_name_1=some.rrd:ds_name:CF
CDEF :nom_var_2=expression_RPN

Vous définissez d'abord "var_name_1" comme étant les données collectées à partir de la source de données "ds_name" trouvée dans RRD
"some.rrd" avec la fonction de consolidation "CF".

Supposons que le compteur SNMP ifInOctets soit enregistré dans mrtg.rrd en tant que DS "in". Puis le
DEF suivant définit une variable pour la moyenne de cette source de données :

DEF:inbytes=mrtg.rrd:in:MOYENNE

Supposons que vous vouliez afficher les bits par seconde (au lieu des octets par seconde tels qu'ils sont stockés dans le
base de données.) Il faut définir un calcul (d'où "CDEF") sur la variable "inbytes" et utiliser
cette variable (inbits) au lieu de l'original :

CDEF:inbits=inbytes,8,*

Cela indique à RRDtool de multiplier les inoctets par huit pour obtenir des inbits. J'expliquerai plus tard comment cela
travaux. Dans les fonctions graphiques ou d'impression, vous pouvez maintenant utiliser des bits là où vous utiliseriez
inoctets sinon.

Notez que le nom de variable utilisé dans le CDEF (inbits) ne doit pas être le même que la variable
nommé dans le DEF (en octets) !

Expressions RPN

RPN est l'abréviation de la notation polonaise inversée. Cela fonctionne comme suit. tu mets les variables
ou des nombres sur une pile. Vous mettez également des opérations (choses à faire) sur la pile et cette pile
est ensuite traité. Le résultat sera placé sur la pile. À la fin, il devrait y avoir
il ne reste qu'un seul chiffre : le résultat de la série d'opérations. S'il n'y a pas exactement
un numéro à gauche, RRDtool se plaindra bruyamment.

Ci-dessus, la multiplication par huit ressemblera à :

1. Commencez avec une pile vide

2. Mettez le contenu de la variable inbytes sur la pile

3. Mettez le numéro huit sur la pile

4. Mettez l'opération multiplier sur la pile

5. Traiter la pile

6. Récupérez la valeur de la pile et placez-la dans des bits variables

Nous allons maintenant faire un exemple avec des nombres réels. Supposons que la variable inbytes ait la valeur
10, la pile serait :

1. ||

2. |10|

3. |10|8|

4. |10|8|*|

5. |80|

6. ||

Le traitement de la pile (étape 5) récupérera une valeur de la pile (à partir de la droite à
étape 4). C'est l'opération de multiplication et cela prend deux valeurs de la pile comme entrée.
Le résultat est remis sur la pile (la valeur 80 dans ce cas). Pour la multiplication le
l'ordre n'a pas d'importance, mais pour d'autres opérations comme la soustraction et la division, c'est le cas.
De manière générale, vous avez l'ordre suivant :

y = A - B --> y=moins(A,B) --> CDEF:y=A,B,-

Ce n'est pas très intuitif (du moins la plupart des gens ne le pensent pas). Pour la fonction f(A,B)
vous inversez la position de "f", mais vous n'inversez pas l'ordre des variables.

Façonnage Un flux efficace peut augmenter vœux à RPN

Tout d'abord, obtenez une image claire de ce que vous voulez faire. Décomposez le problème en plus petit
portions jusqu'à ce qu'elles ne puissent plus être divisées. Ensuite, il est assez simple de convertir votre
idées dans RPN.

Supposons que vous ayez plusieurs RRD et que vous vouliez y ajouter quelques compteurs. Ceux-ci pourraient
être, par exemple, les compteurs pour chaque lien WAN que vous surveillez.

Vous avez:

router1.rrd avec link1in link2in
router2.rrd avec link1in link2in
router3.rrd avec link1in link2in

Supposons que vous vouliez additionner tous ces compteurs, à l'exception de link2in à l'intérieur
routeur2.rrd. Tu as besoin de faire:

(dans cet exemple, "router1.rrd:link1in" signifie le DS link1in à l'intérieur du RRD router1.rrd)

routeur1.rrd: lien1in
routeur1.rrd: lien2in
routeur2.rrd: lien1in
routeur3.rrd: lien1in
routeur3.rrd: lien2in
-------------------- +
(résultat de la somme)

En tant que fonction mathématique, cela pourrait s'écrire :

"add(router1.rrd:link1in , router1.rrd:link2in , router2.rrd:link1in , router3.rrd:link1in
, router3.rrd:link2.in)"

Avec RRDtool et RPN, commencez par définir les entrées :

DEF:a=routeur1.rrd:link1in:AVERAGE
DEF:b=routeur1.rrd:link2in:AVERAGE
DEF:c=routeur2.rrd:link1in:AVERAGE
DEF:d=routeur3.rrd:link1in:AVERAGE
DEF:e=routeur3.rrd:link2in:AVERAGE

Maintenant, la fonction mathématique devient : "add(a,b,c,d,e)"

Dans RPN, il n'y a pas d'opérateur qui additionne plus de deux valeurs, vous devez donc en faire plusieurs
ajouts. Vous ajoutez a et b, ajoutez c au résultat, ajoutez d au résultat et ajoutez e au
résultat.

push a : une pile contient la valeur d'un
poussez b et ajoutez : b,+ la pile contient le résultat de a+b
poussez c et ajoutez : c,+ stack contient le résultat de a+b+c
poussez d et ajoutez : d,+ la pile contient le résultat de a+b+c+d
poussez e et ajoutez : e,+ stack contient le résultat de a+b+c+d+e

Ce qui a été calculé ici serait écrit comme :

( ( ( (a+b) + c) + d) + e) ​​>

C'est en RPN : "CDEF:result=a,b,+,c,+,d,+,e,+"

C'est correct, mais cela peut être rendu plus clair pour les humains. Ce n'est pas grave si vous ajoutez un
à b puis ajoutez c au résultat ou ajoutez d'abord b à c puis ajoutez a au résultat. Cette
permet de réécrire le RPN en "CDEF:result=a,b,c,d,e,+,+,+,+" qui est
évalué différemment :

pousser la valeur de la variable a sur la pile : a
pousser la valeur de la variable b sur la pile : ab
pousser la valeur de la variable c sur la pile : abc
pousser la valeur de la variable d sur la pile : abcd
pousser la valeur de la variable e sur la pile : abcde
opérateur push + sur la pile : abcde +
et le traiter : abc P (où P == d+e)
opérateur push + sur la pile : abc P +
et le traiter : ab Q (où Q == c+P)
opérateur push + sur la pile : ab Q +
et le traiter : a R (où R == b+Q)
opérateur push + sur la pile : un R+
et le traiter : S (où S == a+R)

Comme vous pouvez le voir, l'expression RPN "a,b,c,d,e,+,+,+,+,+" sera évaluée dans
"((((d+e)+c)+b)+a)" et il a le même résultat que "a,b,+,c,+,d,+,e,+". C'est appelé
la loi commutative de l'addition, mais vous pouvez l'oublier tout de suite, tant que vous
rappelez-vous ce que cela signifie.

Maintenant, regardez une expression qui contient une multiplication :

D'abord en maths normales : "let result = a+b*c". Dans ce cas, vous ne pouvez pas choisir la commande
vous-même, vous devez commencer par la multiplication, puis y ajouter un. Vous pouvez modifier
la position de b et c, vous ne devez pas modifier la position de a et b.

Vous devez en tenir compte lors de la conversion de cette expression en RPN. Lis le
comme : "Ajouter le résultat de b*c à a" et il est alors facile d'écrire l'expression RPN :
"result=a,b,c,*,+" Une autre expression qui renverrait le même : "result=b,c,*,a,+"

En mathématiques normales, vous pouvez rencontrer quelque chose comme "a*(b+c)" et cela peut également être converti
en RPN. La parenthèse vous dit simplement d'ajouter d'abord b et c, puis de multiplier a avec le
résultat. Encore une fois, il est maintenant facile de l'écrire en RPN : "result=a,b,c,+,*". Notez que c'est
très similaire à l'une des expressions du paragraphe précédent, seule la multiplication
et l'addition a changé de place.

Lorsque vous avez des problèmes avec RPN ou lorsque RRDtool se plaint, c'est généralement une bonne chose
d'écrire la pile sur une feuille de papier et de voir ce qui se passe. Préparez le manuel
et prétendre être RRDtool. Fais tout le calcul à la main pour voir ce qui se passe, j'en suis sûr
cela résoudra la plupart, sinon tous les problèmes que vous rencontrez.

Certain spécial numéros

Les inconnu Plus-value
Parfois, la collecte de vos données échouera. Cela peut être très fréquent, surtout lorsque
interrogation sur des liens occupés. RRDtool peut être configuré pour permettre un (ou même plusieurs)
valeur(s) inconnue(s) et calculez la mise à jour manquante. Vous pouvez, par exemple, interroger votre
appareil toutes les minutes. Cela crée un soi-disant PDP ou point de données principal par minute.
Si vous avez défini votre RRD pour contenir un RRA qui stocke des valeurs de 5 minutes, vous avez besoin de cinq des
ces PDP pour créer un CDP (point de données consolidé). Ces PDP peuvent devenir inconnus dans
deux cas :

1. Les mises à jour sont trop éloignées. Ceci est réglé à l'aide du paramètre « battement de cœur ».

2. La mise à jour a été volontairement définie comme inconnue en n'insérant aucune valeur (à l'aide du modèle
option) ou en utilisant "U" comme valeur à insérer.

Lorsqu'un CDP est calculé, un autre mécanisme détermine si ce CDP est valide ou non. Si
il y a trop de PDP inconnus, le CDP est également inconnu. Ceci est déterminé par le
facteur xff. Veuillez noter qu'une mise à jour de compteur inconnue peut entraîner deux PDP inconnus ! Si
vous n'autorisez qu'un seul PDP inconnu par CDP, cela rend le CDP inconnu !

Supposons que le compteur s'incrémente d'un par seconde et que vous le récupérez toutes les minutes :

valeur du compteur taux résultant
10'000
10'060 1; (10'060-10'000)/60 == 1
10'120 1; (10'120-10'060)/60 == 1
inconnu inconnu; tu ne connais pas la dernière valeur
10'240 inconnu ; vous ne connaissez pas la valeur précédente
10'300 1; (10'300-10'240)/60 == 1

Si le CDP devait être calculé à partir des cinq dernières mises à jour, il obtiendrait deux PDP inconnus
et trois PDP connus. Si xff avait été défini sur 0.5, ce qui est d'ailleurs couramment
facteur utilisé, le CDP aurait une valeur connue de 1. Si xff avait été défini sur 0.2, alors
le CDP résultant serait inconnu.

Vous devez décider des valeurs appropriées pour le rythme cardiaque, le nombre de PDP par CDP et le xff
facteur. Comme vous pouvez le voir dans le texte précédent, ils définissent le comportement de votre RRA.

Working : un espace de travail commun comprenant inconnu données in Un flux efficace peut augmenter base de données
Comme vous l'avez lu dans le chapitre précédent, les entrées d'un RRA peuvent être définies sur l'inconnu
valeur. Si vous faites des calculs avec ce type de valeur, le résultat doit également être inconnu.
Cela signifie qu'une expression telle que "résultat=a,b,+" sera inconnue si a ou b est
inconnu. Il serait erroné d'ignorer simplement la valeur inconnue et de renvoyer la valeur du
autre paramètre. Ce faisant, vous supposeriez que « inconnu » signifie « zéro » et ce n'est pas
vrai.

Il y a eu un cas où quelqu'un recueillait des données depuis plus d'un an. Un nouveau morceau de
l'équipement a été installé, un nouveau RRD a été créé et les scripts ont été modifiés pour ajouter un
compteur de l'ancienne base de données et un compteur de la nouvelle base de données. Le résultat était
décevant, une grande partie des statistiques semblaient s'être mystérieusement évanouies...
Ils ne l'ont bien sûr pas fait, les valeurs de l'ancienne base de données (valeurs connues) ont été ajoutées aux valeurs
de la nouvelle base de données (valeurs inconnues) et le résultat était inconnu.

Dans ce cas, il est assez raisonnable d'utiliser un CDEF qui modifie les données inconnues en zéro.
Les compteurs de l'appareil étaient inconnus (après tout, il n'était pas encore installé !) mais vous savez
que le débit de données à travers l'appareil devait être nul (pour la même raison : il était
pas installé).

Il y a quelques exemples ci-dessous qui font ce changement.

Infinity
Les données infinies sont une autre forme d'un nombre spécial. Il ne peut pas être représenté graphiquement parce que par
définition vous n'atteindriez jamais la valeur infinie. Vous pouvez penser au positif et
infini négatif selon la position par rapport à zéro.

RRDtool est capable de représenter (-pas- de représenter graphiquement !) l'infini en s'arrêtant à sa valeur actuelle
maximum (pour l'infini positif) ou minimum (pour l'infini négatif) sans le savoir
maximum minimum).

Infinity dans RRDtool est principalement utilisé pour dessiner une ZONE sans connaître sa verticale
dimensions. Vous pouvez penser à cela comme dessiner une ZONE avec une hauteur infinie et afficher
uniquement la partie visible dans le graphe courant. C'est probablement un bon moyen de
l'infini approximatif et cela permet bien sûr quelques astuces intéressantes. Voir ci-dessous pour des exemples.

Working : un espace de travail commun comprenant inconnu données ainsi que infini
Parfois, vous souhaitez supprimer des données inconnues et prétendre qu'il s'agit de zéro (ou de tout autre
valeur d'ailleurs) et parfois vous aimeriez prétendre que les données connues sont inconnues
(pour éliminer les données dont on sait qu'elles sont fausses). C'est pourquoi les CDEF prennent en charge les données inconnues.
Il existe également des exemples disponibles qui montrent des données inconnues en utilisant l'infini.

Certain exemples

Mise en situation : en utilisant a récemment créée DRR
Vous gardez des statistiques sur votre routeur depuis plus d'un an maintenant. Vous avez récemment installé un
routeur supplémentaire et vous souhaitez afficher le débit combiné de ces deux appareils.

Si vous ajoutez simplement les compteurs de router.rrd et router2.rrd, vous ajouterez des données connues
(de router.rrd) aux données inconnues (de router2.rrd) pour la plus grande partie de vos statistiques.
Vous pouvez résoudre ce problème de plusieurs manières :

· Lors de la création de la nouvelle base de données, remplissez-la de zéros depuis le début jusqu'à maintenant. Tu as
pour que la base de données démarre au plus tard à l'heure la moins récente dans l'autre base de données.

· Alternativement, vous pouvez utiliser CDEF et modifier les données inconnues à zéro.

Les deux méthodes ont leurs avantages et leurs inconvénients. La première méthode est gênante et si vous voulez
faites cela, vous devez le découvrir vous-même. Il n'est pas possible de créer une base de données remplie
avec des zéros, vous devez les mettre manuellement. La mise en œuvre de la deuxième méthode est décrite
suivant:

Ce que nous voulons, c'est : "si la valeur est inconnue, remplacez-la par zéro". Cela pourrait être écrit en
pseudo-code comme : if (valeur inconnue) then (zéro) else (valeur). Lors de la lecture du rrdgraph
manuel, vous remarquez la fonction "UN" qui renvoie zéro ou un. Vous remarquez également le "SI"
fonction qui prend zéro ou un en entrée.

Regardez d'abord la fonction "SI". Il prend trois valeurs de la pile, la première valeur est
le point de décision, la deuxième valeur est renvoyée à la pile si l'évaluation est « vrai »
et sinon, la troisième valeur est renvoyée à la pile. Nous voulons que la fonction « ONU » décide
ce qui se passe donc nous combinons ces deux fonctions dans un CDEF.

Notons les deux chemins possibles pour la fonction "SI":

si vrai retourne un
si faux retour b

Dans RPN : "result=x,a,b,IF" où "x" est soit vrai, soit faux.

Maintenant, nous devons remplir "x", cela devrait être la partie "(la valeur est inconnue)" et c'est dans
RPN : "résultat=valeur,UN"

Nous les combinons maintenant: "result=value,UN,a,b,IF" et quand nous remplissons les choses appropriées
pour "a" et "b" c'est fini :

"CDEF:résultat=valeur,UN,0,valeur,SI"

Vous voudrez peut-être lire le guide RPN de Steve Rader si vous avez des difficultés avec la façon dont je
expliqué ce dernier exemple.

Si vous souhaitez vérifier cette expression RPN, imitez simplement le comportement de RRDtool :

Pour toute valeur connue, l'expression s'évalue comme suit :
CDEF:résultat=valeur,UN,0,valeur,SI (valeur,UN) n'est pas vrai donc il devient 0
CDEF:result=0,0,value,IF "IF" renverra la 3ème valeur
CDEF:result=value La valeur connue est renvoyée

Pour la valeur inconnue, cela se produit :
CDEF:résultat=valeur,UN,0,valeur,SI (valeur,UN) est vrai donc il devient 1
CDEF:résultat=1,0,valeur,SI "SI" voit 1 et renvoie la 2ème valeur
CDEF:résultat=0 Zéro est retourné

Bien sûr, si vous souhaitez voir une autre valeur au lieu de zéro, vous pouvez utiliser cette autre
valeur.

Finalement, lorsque toutes les données inconnues sont supprimées du RRD, vous souhaiterez peut-être supprimer ce
règle pour que les données inconnues soient correctement affichées.

Mise en situation : mieux manipulation of inconnu données, by en utilisant fiable
L'exemple ci-dessus a un inconvénient. Si vous enregistrez des données inconnues dans votre base de données après
l'installation de votre nouvel équipement, il sera également traduit en zéro et donc vous
ne verra pas qu'il y avait un problème. Ce n'est pas bon et ce que vous voulez vraiment faire, c'est :

· S'il y a des données inconnues, regardez l'heure à laquelle cet échantillon a été prélevé.

· Si la valeur inconnue est antérieure à l'heure xxx, mettez-la à zéro.

· Si c'est après l'heure xxx, laissez-le comme donnée inconnue.

C'est faisable : vous pouvez comparer l'heure à laquelle l'échantillon a été prélevé à une heure connue.
En supposant que vous ayez commencé à surveiller votre appareil le vendredi 17 septembre 1999, 00:35:57 MET
DST. Traduisez ce temps en secondes depuis 1970-01-01 et il devient 937'521'357. Si tu
traiter les valeurs inconnues reçues après ce délai, vous souhaitez les laisser inconnues
et s'ils ont été "reçus" avant cette heure, vous voulez les traduire en zéro (donc vous
pouvez effectivement les ignorer tout en les ajoutant à vos autres compteurs de routeurs).

La traduction du vendredi 17 septembre 1999, 00:35:57 MET DST en 937'521'357 peut être effectuée par,
par exemple, en utilisant gnu date :

date -d "19990917 00:35:57" +%s

Vous pouvez également vider la base de données et voir où les données commencent à être connues. Il y a
plusieurs autres façons de le faire, choisissez-en une.

Maintenant, nous devons créer la magie qui nous permet de traiter des valeurs inconnues différentes
en fonction de l'heure à laquelle l'échantillon a été prélevé. Il s'agit d'un processus en trois étapes :

1. Si l'horodatage de la valeur est après 937'521'357, laissez-le tel quel.

2. Si la valeur est une valeur connue, laissez-la telle quelle.

3. Changez la valeur inconnue en zéro.

Regardons la première partie :

si (vrai) renvoie la valeur d'origine

Nous réécrivons ceci :

si (vrai) renvoie "a"
si (faux) renvoie "b"

Nous devons calculer vrai ou faux à partir de l'étape 1. Il existe une fonction disponible qui renvoie
l'horodatage de l'échantillon actuel. Il s'appelle, de façon surprenante, « TEMPS ». Cette fois
doit être comparé à un nombre constant, nous avons besoin de "GT". La sortie de "GT" est vraie ou fausse
et c'est une bonne entrée pour "IF". On veut "si (temps > 937521357) alors (retour a) sinon
(retour b)".

Ce processus a déjà été décrit en détail dans le chapitre précédent, alors allons-y vite :

si (x) alors a sinon b
où x représente "temps>937521357"
où a représente la valeur d'origine
où b représente le résultat de l'exemple précédent

heure>937521357 --> HEURE,937521357,GT

si (x) alors a else b --> x,a,b,IF
remplacer x --> TIME,937521357,GT,a,b,IF
remplacer a --> TIME,937521357,GT,value,b,IF
remplacer b --> TIME,937521357,GT,valeur,valeur,UN,0,valeur,SI,SI

On se retrouve avec : "CDEF:result=TIME,937521357,GT,value,value,UN,0,value,IF,IF"

Cela semble très complexe, cependant, comme vous pouvez le voir, ce n'était pas trop difficile à trouver.

Mise en situation : Prétendre bizarre données n'est pas là
Supposons que vous ayez un problème qui se manifeste par d'énormes pics dans votre graphique. Tu sais ça
se produit et pourquoi, alors vous décidez de contourner le problème. Peut-être que vous utilisez votre
réseau pour faire une sauvegarde la nuit et ce faisant, vous obtenez près de 10 Mo/s tandis que le reste de
votre activité réseau ne produit pas de nombres supérieurs à 100kb/s.

Il y a deux options:

1. Si le nombre dépasse 100kb/s c'est faux et vous voulez qu'il soit masqué en le changeant
en inconnu.

2. Vous ne voulez pas que le graphique affiche plus de 100 Ko/s.

Pseudo code : si (nombre > 100) alors inconnu else nombre ou Pseudo code : si (nombre > 100)
puis 100 autres nombres.

Le deuxième "problème" peut également être résolu en utilisant l'option rigide du graphe RRDtool,
cependant cela n'a pas le même résultat. Dans cet exemple, vous pouvez obtenir un graphique qui
fait l'autoscaling. De plus, si vous utilisez les nombres pour afficher les maxima, ils seront définis sur
100kb / s.

Nous utilisons à nouveau "IF" et "GT". "si (x) alors (y) sinon (z)" s'écrit
"CDEF:résultat=x,y,z,SI" ; remplissez maintenant x, y et z. Pour x, vous remplissez "nombre supérieur à
100kb/s" devenant "number,100000,GT" (le kilo c'est 1'000 et b/s c'est ce que l'on mesure !). Le "z"
la partie est "numéro" dans les deux cas et la partie "y" est soit "UNKN" pour inconnu ou "100000"
pour 100kb/s.

Les deux expressions CDEF seraient :

CDEF:résultat=nombre,100000,GT,UNKN,nombre,SI
CDEF:résultat=nombre,100000,GT,100000,nombre,SI

Mise en situation : de travail on a certaines fiable envergure
Si vous voulez un graphique qui s'étend sur quelques semaines, mais que vous ne voudriez voir que les données de certains routeurs
pendant une semaine, vous devez « masquer » le reste du délai. Ne me demande pas quand cela serait
être utile, c'est juste ici pour l'exemple :)

Nous devons comparer l'horodatage à une date de début et une date de fin. Comparer n'est pas
difficile:

HEURE, heure de début, GE
HEURE,heure de fin,LE

Ces deux parties du CDEF produisent soit 0 pour faux, soit 1 pour vrai. Nous pouvons maintenant vérifier si
ils sont tous les deux à 0 (ou 1) en utilisant quelques instructions IF mais, comme l'a souligné Wataru Satoh, nous pouvons
utilisez les fonctions "*" ou "+" comme ET logique et OU logique.

Pour "*", le résultat sera zéro (faux) si l'un des deux opérateurs est à zéro. Pour
"+", le résultat ne sera faux (0) que lorsque deux opérateurs faux (0) seront ajoutés.
Attention : *tout* nombre différent de 0 sera considéré comme "vrai". Cela signifie que, pour
exemple, "-1,1,+" (qui devrait être "vrai ou vrai") deviendra FAUX... En d'autres termes,
n'utilisez "+" que si vous savez avec certitude que vous n'avez que des nombres positifs (ou zéro).

Compilons le CDEF complet :

DEF:ds0=routeur1.rrd:AVERAGE
CDEF:ds0modified=HEURE,heure de début,GT,HEURE,heure de fin,LE,*,ds0,UNKN,IF

Cela renverra la valeur de ds0 si les deux comparaisons renvoient vrai. tu pourrais aussi le faire
à l'envers :

DEF:ds0=routeur1.rrd:AVERAGE
CDEF:ds0modified=HEURE,heure de début,LT,HEURE,heure de fin,GT,+,UNKN,ds0,IF

Cela renverra un INCONNU si l'une des comparaisons renvoie vrai.

Mise en situation : Vous suspect à avons d'ouvrabilité ainsi que souhaitez à sur le lien inconnu revendre.
Supposons que vous additionnez le nombre d'utilisateurs actifs sur plusieurs serveurs de terminaux. Si l'un d'eux
ne donne pas de réponse (ou une réponse incorrecte) vous obtenez "NaN" dans la base de données ("Pas un
Number") et NaN est évalué comme Inconnu.

Dans ce cas, vous souhaitez en être alerté et la somme des valeurs restantes est de
aucune valeur pour vous.

Ce serait quelque chose comme :

DEF:users1=location1.rrd:onlineTS1:LAST
DEF:users2=location1.rrd:onlineTS2:LAST
DEF:users3=location2.rrd:onlineTS1:LAST
DEF:users4=location2.rrd:onlineTS2:LAST
CDEF : tous les utilisateurs = utilisateurs1, utilisateurs2, utilisateurs3, utilisateurs4,+,+,+

Si vous tracez maintenant tous les utilisateurs, les données inconnues dans l'un des utilisateurs1..utilisateurs4 apparaîtront comme un écart dans
votre graphique. Vous souhaitez modifier cela pour afficher une ligne rouge vif, pas un espace.

Définir un CDEF supplémentaire qui est inconnu si tout va bien et est infini s'il y a un inconnu
valeur:

CDEF:données erronées=tous les utilisateurs,UN,INF,UNKN,IF

"allusers,UN" évaluera soit vrai soit faux, c'est la partie (x) du "IF"
fonction et il vérifie si allusers est inconnu. La partie (y) de la fonction "SI" est définie
à "INF" (ce qui signifie l'infini) et la partie (z) de la fonction renvoie "UNKN".

La logique est : if (allusers == unknown) then return INF else return UNKN.

Vous pouvez maintenant utiliser AREA pour afficher ces « données erronées » en rouge vif. S'il est inconnu (parce que
allusers est connu), la ZONE rouge n'apparaîtra pas. Si la valeur est INF (car allusers
est inconnue), alors la ZONE rouge sera remplie sur le graphique à ce moment particulier.

AREA:allusers#0000FF:nombre d'utilisateurs combiné
AREA:wrongdata#FF0000:données inconnues

Béton exemple incontournable comprenant EMPILÉ données:
Si vous utilisez stack dans l'exemple précédent (comme je le ferais), vous n'additionnez pas les valeurs.
Par conséquent, il n'y a pas de relation entre les quatre valeurs et vous n'obtenez pas un seul
valeur à tester. Supposons que users3 soit inconnu à un moment donné : users1 est tracé,
users2 est empilé sur users1, users3 est inconnu et donc rien ne se passe,
users4 est empilé sur users2. Ajoutez quand même les CDEF supplémentaires et utilisez-les pour superposer
le graphique "normal":

DEF:users1=location1.rrd:onlineTS1:LAST
DEF:users2=location1.rrd:onlineTS2:LAST
DEF:users3=location2.rrd:onlineTS1:LAST
DEF:users4=location2.rrd:onlineTS2:LAST
CDEF : tous les utilisateurs = utilisateurs1, utilisateurs2, utilisateurs3, utilisateurs4,+,+,+
CDEF:données erronées=tous les utilisateurs,UN,INF,UNKN,IF
AREA:users1#0000FF:utilisateurs à ts1
PILE : users2#00FF00 : utilisateurs sur ts2
PILE : users3#00FFFF : utilisateurs sur ts3
PILE : users4#FFFF00 : utilisateurs sur ts4
AREA:wrongdata#FF0000:données inconnues

S'il y a des données inconnues dans l'un des utilisateurs1..users4, la ZONE « données erronées » sera dessinée et
parce qu'il commence à l'axe X et a une hauteur infinie, il écrasera efficacement le
Pièces empilées.

Vous pouvez combiner les deux lignes CDEF en une seule (nous n'utilisons pas "allusers") si vous le souhaitez. Mais
il y a de bonnes raisons d'écrire deux CDEFS :

· Il améliore la lisibilité du script.

· Il peut être utilisé dans GPRINT pour afficher le nombre total d'utilisateurs.

Si vous choisissez de les combiner, vous pouvez remplacer les "allusers" dans le deuxième CDEF par
la partie après le signe égal de la première ligne :

CDEF : données erronées = utilisateurs1, utilisateurs2, utilisateurs3, utilisateurs4,+,+,+,UN,INF,UNKN,IF

Si vous le faites, vous ne pourrez pas utiliser ces prochaines GPRINT :

COMMENTAIRE : "Nombre total d'utilisateurs vus"
GPRINT:allusers:MAX:"Maximum : %6.0lf"
GPRINT:allusers:MIN:"Minimum : %6.0lf"
GPRINT:allusers:AVERAGE:"Moyenne : %6.0lf"
GPRINT:allusers:LAST:"Actuel : %6.0lf\n"

Les exemples de le DRR graphique Manuel page

Degrés Celsius vs. Degrés Fahrenheit
Pour convertir Celsius en Fahrenheit utilisez la formule F=9/5*C+32

rrdtool graph demo.png --title="Demo Graph" \
DEF:cel=demo.rrd:échappement:MOYENNE \
CDEF:far=9,5,/,cel,*,32,+ \
LINE2:cel#00a000:"D. Celsius" \
LINE2:far#ff0000:"D. Fahrenheit\c"

Cet exemple obtient le DS appelé "échappement" de la base de données "demo.rrd" et met les valeurs dans
variable "cel". Le CDEF utilisé est évalué comme suit :

CDEF:loin=9,5,/,cel,*,32,+
1. appuyez sur 9, appuyez sur 5
2. appuyez sur la fonction "diviser" et traitez-la
la pile contient maintenant 9/5
3. pousser la variable "cel"
4. appuyez sur la fonction "multiplier" et traitez-la
la pile contient maintenant 9/5*cel
5. poussez 32
6. appuyez sur la fonction "plus" et traitez-la
la pile contient maintenant la température en Fahrenheit

Changer inconnu développement zéro
rrdtool graph demo.png --title="Demo Graph" \
DEF:idat1=interface1.rrd:ds0:MOYENNE \
DEF:idat2=interface2.rrd:ds0:MOYENNE \
DEF:odat1=interface1.rrd:ds1:MOYENNE \
DEF:odat2=interface2.rrd:ds1:MOYENNE \
CDEF:agginput=idat1,UN,0,idat1,IF,idat2,UN,0,idat2,IF,+,8,* \
CDEF:aggoutput=odat1,UN,0,odat1,IF,odat2,UN,0,odat2,IF,+,8,* \
AREA:agginput#00cc00:Agrégat d'entrée \
LINE1:agoutput#0000FF:Agrégat de sortie

Ces deux CDEF sont construits à partir de plusieurs fonctions. Il est utile de les diviser lors de la visualisation de ce que
ils font. En partant du premier CDEF, nous obtiendrions :

idat1,UN --> un
0 --> b
idat1 --> c
si (a) alors (b) sinon (c)

Le résultat est donc "0" s'il est vrai que "idat1" vaut "UN". Sinon, l'original
la valeur de "idat1" est remise sur la pile. Appelons cette réponse "d". Le processus est
répété pour les cinq éléments suivants sur la pile, il est fait de même et renverra la réponse
"h". La pile résultante est donc "d,h". L'expression a été simplifiée en
"d,h,+,8,*" et il sera maintenant facile de voir que nous ajoutons "d" et "h", et multiplions le
résultat avec huit.

Le résultat final est que nous avons ajouté "idat1" et "idat2" et dans le processus nous avons effectivement
valeurs inconnues ignorées. Le résultat est multiplié par huit, le plus susceptible de convertir des octets/s
en bits/s.

Infinity demo
rrdtool graph example.png --title="Démo INF" \
DEF:val1=some.rrd:ds0:MOYENNE \
DEF:val2=some.rrd:ds1:MOYENNE \
DEF:val3=some.rrd:ds2:MOYENNE \
DEF:val4=autre.rrd:ds0:AVERAGE \
CDEF:background=val4,POP,TIME,7200,%,3600,LE,INF,UNKN,IF \
CDEF:wipeout=val1,val2,val3,val4,+,+,+,UN,INF,UNKN,IF \
ZONE : arrière-plan#F0F0F0 \
AREA:val1#0000FF:Valeur1 \
PILE:val2#00C000:Valeur2 \
PILE:val3#FFFF00:Valeur3 \
PILE:val4#FFC000:Valeur4 \
ZONE : whipeout#FF0000 : Inconnu

Cette démo montre deux façons d'utiliser l'infini. Il est un peu difficile de voir ce qui se passe dans
le CDEF "de fond".

"val4,POP,TIME,7200,%,3600,LE,INF,UNKN,IF"

Ce RPN prend la valeur de "val4" en entrée puis la supprime immédiatement de la pile
en utilisant "POP". La pile est maintenant vide mais comme effet secondaire, nous savons maintenant l'heure à laquelle cela
échantillon a été prélevé. Ce temps est mis sur la pile par la fonction "TIME".

"TIME,7200,%" prend le modulo du temps et 7'200 (ce qui correspond à deux heures). La résultante
valeur sur la pile sera un nombre compris entre 0 et 7199.

Pour ceux qui ne connaissent pas la fonction modulo : c'est le reste après un entier
division. Si vous divisez 16 par 3, la réponse serait 5 et le reste serait 1. Donc,
"16,3,%" renvoie 1.

Nous avons le résultat de "TIME,7200,%" sur la pile, appelons cela "a". Le début du RPN
est devenu "a,3600,LE" et ceci vérifie si "a" est inférieur ou égal à "3600". C'est vrai
la moitié du temps. Nous devons maintenant traiter le reste du RPN et ce n'est qu'un simple
Fonction "IF" qui renvoie soit "INF" soit "UNKN" selon l'heure. Ceci est retourné
à la variable « arrière-plan ».

Le deuxième CDEF a été discuté plus tôt dans ce document, nous ne le ferons donc pas ici.

Vous pouvez maintenant dessiner les différentes couches. Commencez par l'arrière-plan qui est soit inconnu
(rien à voir) ou infini (toute la partie positive du graphique est remplie).

Ensuite, vous dessinez les données au-dessus de cet arrière-plan, elles se superposeront à l'arrière-plan. Supposer
un de val1..val4 serait inconnu, dans ce cas vous vous retrouvez avec seulement trois barres empilées
l'un sur l'autre. Vous ne voulez pas voir cela car les données ne sont valides que lorsque tous
quatre variables sont valides. C'est pourquoi vous utilisez le deuxième CDEF, il va superposer les données
avec une ZONE pour que les données ne soient plus visibles.

Si vos données peuvent également avoir des valeurs négatives, vous devez également écraser l'autre moitié de
votre graphique. Cela peut être fait d'une manière relativement simple : ce dont vous avez besoin est le "wipeout"
variable et placez un signe négatif avant : "CDEF:wipeout2=wipeout,-1,*"

Filtration données
Vous pouvez effectuer des filtrages de données complexes :

FILTRE MÉDIAN : filtre le bruit de grenaille

DEF:var=base de données.rrd:trafic:AVERAGE
CDEF:prev1=PRÉV(var)
CDEF:préc2=PRÉV(préc1)
CDEF:médiane=var,prev1,prev2,3,SORT,POP,EXC,POP
LINE3:median#000077:filtré
LINE1:prev2#007700:'données brutes'

DÉRIVÉ :

DEF:var=base de données.rrd:trafic:AVERAGE
CDEF:prev1=PRÉV(var)
CDEF:temps=var,POP,TEMPS
CDEF:prevtime=PREV(heure)
CDEF : dérivé=var,prev1,-,time,prevtime,-,/
LINE3:dérivé#000077:dérivé
LINE1:var#007700:'données brutes'

de stock of et idées cadeaux en maintenant

Ce document a été créé à partir de questions posées par moi-même ou par d'autres personnes sur le
Liste de diffusion RRDtool. S'il vous plaît laissez-moi savoir si vous y trouvez des erreurs ou si vous avez des problèmes
le comprendre. Si vous pensez qu'il devrait y avoir un ajout, écrivez-moi:
<[email protected]>

Se souvenir Non Réactions équivaut à aucune changements!

Utilisez cdeftutorial en ligne en utilisant les services onworks.net