cdeftutorial - Online nel cloud

PROGRAMMA:

NOME

cdeftutorial - Tutorial CDEF di Alex van den Bogaerdt

DESCRIZIONE

Intenzione di questo documento: fornire alcuni esempi delle parti comunemente usate di
Il linguaggio CDEF di RRDtool.

Se pensi che qualche caratteristica importante non sia spiegata correttamente e se la aggiungi a questo
documento andrebbe a beneficio della maggior parte degli utenti, per favore chiedimi di aggiungerlo. allora cercherò di fornire
una risposta nella prossima versione di questo tutorial. Nessun feedback equivale a nessun cambiamento! aggiunte
a questo documento sono anche i benvenuti. -- Alex van den Bogaerdt[email protected]>

Perché questo tutorial?
Una delle parti potenti di RRDtool è la sua capacità di eseguire tutti i tipi di calcoli sul
dati recuperati dai suoi database. Tuttavia, le molte opzioni e la sintassi di RRDtool lo rendono
difficile da capire per l'utente medio. I manuali sono bravi a spiegare cosa
queste opzioni lo fanno; tuttavia non spiegano (e non dovrebbero) spiegare in dettaglio perché lo sono
utile. Come con il mio tutorial RRDtool: se vuoi un documento semplice in un linguaggio semplice tu
dovrebbe leggere questo tutorial. Se sei soddisfatto della documentazione ufficiale, potresti trovare
questo documento troppo semplice o addirittura noioso. Se scegli di leggere questo tutorial, anche io
mi aspetto che tu abbia letto e compreso appieno il mio altro tutorial.

Più lettura
Se hai difficoltà con il modo in cui cerco di spiegarlo, per favore leggi Steve Rader's
rpntutoriale. Potrebbe aiutarti a capire come funziona tutto questo.

Che sono CDEF?

Quando si recuperano dati da un RRD, si utilizza un "DEF" per lavorare con quei dati. Pensa a
esso come una variabile che cambia nel tempo (dove il tempo è l'asse x). Il valore di questo
variabile è ciò che si trova nel database in quel particolare momento e non puoi fare nulla
modifiche su di esso. Ecco a cosa servono i CDEF: prendono i valori dai DEF e si comportano
calcoli su di essi.

Sintassi

DEF:var_name_1=some.rrd:ds_name:CF
CDEF:var_name_2=espressione_RPN

Prima definisci "var_name_1" come dati raccolti dall'origine dati "ds_name" trovata in RRD
"some.rrd" con funzione di consolidamento "CF".

Supponiamo che il contatore SNMP ifInOctets sia salvato in mrtg.rrd come DS "in". Poi il
il seguente DEF definisce una variabile per la media di quella fonte di dati:

DEF:inbytes=mrtg.rrd:in:MEDIA

Supponiamo che tu voglia visualizzare i bit al secondo (invece dei byte al secondo memorizzati nel
database.) Devi definire un calcolo (quindi "CDEF") sulla variabile "inbytes" e usare
quella variabile (inbit) invece dell'originale:

CDEF:inbit=inbyte,8,*

Questo dice a RRDtool di moltiplicare gli inbyte per otto per ottenere gli inbit. Spiegherò più tardi come questo
lavori. Nelle funzioni di rappresentazione grafica o di stampa, ora puoi usare gli inbit dove useresti
inbyte altrimenti.

Si noti che il nome della variabile utilizzato nel CDEF (inbit) non deve essere lo stesso della variabile
nominato nel DEF (inbyte)!

Espressioni RPN

RPN è l'abbreviazione di notazione polacca inversa. Funziona come segue. Tu metti le variabili
o numeri su una pila. Metti anche le operazioni (cose da fare) sullo stack e su questo stack
viene quindi elaborato. Il risultato verrà messo in pila. Alla fine dovrebbe esserci
esattamente un numero rimasto: l'esito della serie di operazioni. Se non c'è esattamente
un numero rimasto, RRDtool si lamenterà ad alta voce.

Sopra la moltiplicazione per otto sarà simile a:

1. Inizia con una pila vuota

2. Metti il ​​contenuto delle variabili inbyte nello stack

3. Metti il ​​numero otto in pila

4. Metti in pila l'operazione moltiplica

5. Elabora lo stack

6. Recupera il valore dallo stack e inseriscilo nella variabile inbits

Faremo ora un esempio con i numeri reali. Supponiamo che la variabile inbytes abbia valore
10, lo stack sarebbe:

1. ||

2. |10|

3. |10|8|

4. |10|8|*|

5. |80|

6. ||

L'elaborazione dello stack (passaggio 5) recupererà un valore dallo stack (da destra in
passaggio 4). Questa è l'operazione di moltiplicazione e questo prende due valori dallo stack come input.
Il risultato viene rimesso in pila (il valore 80 in questo caso). Per la moltiplicazione il
l'ordine non ha importanza, ma per altre operazioni come la sottrazione e la divisione sì.
In generale hai il seguente ordine:

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

Questo non è molto intuitivo (almeno la maggior parte delle persone non la pensa così). Per la funzione f(A,B)
si inverte la posizione di "f", ma non si inverte l'ordine delle variabili.

Conversione il tuo auguri a RPN

Innanzitutto, ottieni un'immagine chiara di ciò che vuoi fare. Scomponi il problema in più piccoli
porzioni fino a quando non possono più essere divise. Quindi è piuttosto semplice convertire il tuo
idee in RPN.

Supponiamo di avere diversi RRD e di voler sommare alcuni contatori in essi. Questi potrebbero
essere, ad esempio, i contatori per ogni collegamento WAN che stai monitorando.

Avete:

router1.rrd con link1in link2in
router2.rrd con link1in link2in
router3.rrd con link1in link2in

Supponiamo di voler sommare tutti questi contatori, ad eccezione di link2in inside
router2.rrd. Devi fare:

(in questo esempio, "router1.rrd:link1in" indica il DS link1in all'interno del router RRD1.rrd)

router1.rrd: link1in
router1.rrd: link2in
router2.rrd: link1in
router3.rrd: link1in
router3.rrd: link2in
-------------------- +
(risultato della somma)

Come funzione matematica, questo potrebbe essere scritto:

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

Con RRDtool e RPN definire innanzitutto gli ingressi:

DEF:a=router1.rrd:link1in:MEDIA
DEF:b=router1.rrd:link2in:MEDIA
DEF:c=router2.rrd:link1in:MEDIA
DEF:d=router3.rrd:link1in:MEDIA
DEF:e=router3.rrd:link2in:MEDIA

Ora, la funzione matematica diventa: "add(a,b,c,d,e)"

In RPN, non esiste un operatore che somma più di due valori, quindi devi farne diversi
aggiunte. Aggiungi a e b, aggiungi c al risultato, aggiungi d al risultato e aggiungi e al
risultato.

push a: uno stack contiene il valore di a
premi b e aggiungi: b,+ stack contiene il risultato di a+b
premi c e aggiungi: c,+ stack contiene il risultato di a+b+c
premi d e aggiungi: d,+ stack contiene il risultato di a+b+c+d
premi e e aggiungi: e,+ stack contiene il risultato di a+b+c+d+e

Ciò che è stato calcolato qui sarebbe scritto come:

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

Questo è in RPN: "CDEF:risultato=a,b,+,c,+,d,+,e,+"

Questo è corretto, ma può essere reso più chiaro agli umani. Non importa se aggiungi un
a b e poi aggiungi c al risultato o prima aggiungi b a c e poi aggiungi a al risultato. Questo
permette di riscrivere l'RPN in "CDEF:result=a,b,c,d,e,+,+,+,+" che è
valutati diversamente:

push valore della variabile a sullo stack: a
push valore della variabile b nello stack: ab
push valore della variabile c sullo stack: abc
push valore della variabile d sullo stack: abcd
push valore della variabile e sullo stack: abcde
operatore push + sullo stack: abcde +
ed elaborarlo: abc P (dove P == d+e)
operatore push + sullo stack: abc P +
ed elaborarlo: ab Q (dove Q == c+P)
operatore push + sullo stack: ab Q +
ed elaborarlo: a R (dove R == b+Q)
operatore push + sullo stack: a R +
ed elaborarlo: S (dove S == a+R)

Come puoi vedere l'espressione RPN "a,b,c,d,e,+,+,+,+,+" valuterà in
"((((d+e)+c)+b)+a)" e ha lo stesso risultato di "a,b,+,c,+,d,+,e,+". Questo è chiamato
la legge commutativa dell'addizione, ma puoi dimenticarla subito, purché tu
ricorda cosa significa.

Ora guarda un'espressione che contiene una moltiplicazione:

Primo in matematica normale: "let result = a+b*c". In questo caso non puoi scegliere l'ordine
te stesso, devi iniziare con la moltiplicazione e poi aggiungere a. potresti alterare
la posizione di b e c, non devi alterare la posizione di a e b.

Devi tenerlo in considerazione quando converti questa espressione in RPN. Leggilo
come: "Aggiungi il risultato di b*c a a" e quindi è facile scrivere l'espressione RPN:
"risultato=a,b,c,*,+" Un'altra espressione che restituirebbe lo stesso: "risultato=b,c,*,a,+"

Nella matematica normale, potresti incontrare qualcosa come "a*(b+c)" e anche questo può essere convertito
in RPN. Le parentesi ti dicono solo di aggiungere prima b e c, e poi moltiplicare a con il
risultato. Di nuovo, ora è facile scriverlo in RPN: "risultato=a,b,c,+,*". Nota che questo è
molto simile a una delle espressioni del paragrafo precedente, solo la moltiplicazione
e l'aggiunta ha cambiato posto.

Quando hai problemi con RPN o quando RRDtool si lamenta, di solito è una buona cosa
per scrivere la pila su un pezzo di carta e vedere cosa succede. Tieni pronto il manuale
e fingere di essere RRDtool. Basta fare tutti i calcoli a mano per vedere cosa succede, ne sono sicuro
questo risolverà la maggior parte, se non tutti, i problemi che incontri.

Alcuni la nostra speciale numeri

I Sconosciuto APPREZZIAMO
A volte la raccolta dei dati fallisce. Questo può essere molto comune, specialmente quando
interrogazione su collegamenti occupati. RRDtool può essere configurato per consentire uno (o anche più)
valori sconosciuti e calcolare l'aggiornamento mancante. Puoi, ad esempio, interrogare il tuo
dispositivo ogni minuto. Questo sta creando un cosiddetto PDP o punto dati primario al minuto.
Se hai definito il tuo RRD per contenere un RRA che memorizza valori di 5 minuti, hai bisogno di cinque di
quei PDP per creare un CDP (punto dati consolidato). Questi PDP possono diventare sconosciuti in
due casi:

1. Gli aggiornamenti sono troppo distanti. Questo viene sintonizzato utilizzando l'impostazione "heartbeat".

2. L'aggiornamento è stato impostato su sconosciuto di proposito non inserendo alcun valore (usando il modello
opzione) o utilizzando "U" come valore da inserire.

Quando viene calcolata una CDP, un altro meccanismo determina se questa CDP è valida o meno. Se
ci sono troppi PDP sconosciuti, anche il CDP è sconosciuto. Questo è determinato da
fattore xff. Tieni presente che un aggiornamento del contatore sconosciuto può causare due PDP sconosciuti! Se
consenti solo un PDP sconosciuto per CDP, questo rende il CDP sconosciuto!

Supponiamo che il contatore aumenti di uno al secondo e lo recuperi ogni minuto:

valore del contatore tasso risultante
10'000
10'060 1; (10'060-10'000)/60 == 1
10'120 1; (10'120-10'060)/60 == 1
sconosciuto sconosciuto; non conosci l'ultimo valore
10'240 sconosciuto; non conosci il valore precedente
10'300 1; (10'300-10'240)/60 == 1

Se il CDP dovesse essere calcolato dagli ultimi cinque aggiornamenti, otterrebbe due PDP sconosciuti
e tre noti PDP. Se xff fosse stato impostato su 0.5, che tra l'altro è comunemente
fattore utilizzato, il CDP avrebbe un valore noto di 1. Se xff fosse stato impostato su 0.2 allora
il CDP risultante sarebbe sconosciuto.

Devi decidere i valori corretti per il battito cardiaco, il numero di PDP per CDP e xff
fattore. Come puoi vedere dal testo precedente, definiscono il comportamento della tua RRA.

lavoro con Sconosciuto dati in il tuo banca dati
Come hai letto nel capitolo precedente, le voci in un RRA possono essere impostate sull'incognita
valore. Se si eseguono calcoli con questo tipo di valore, anche il risultato deve essere sconosciuto.
Ciò significa che un'espressione come "risultato=a,b,+" sarà sconosciuta se aob è
sconosciuto. Sarebbe sbagliato ignorare semplicemente il valore sconosciuto e restituire il valore di
altro parametro. In tal modo, assumeresti che "sconosciuto" significhi "zero" e questo non lo è
vero.

C'è stato un caso in cui qualcuno ha raccolto dati per oltre un anno. Un nuovo pezzo di
è stata installata l'attrezzatura, è stato creato un nuovo RRD e gli script sono stati modificati per aggiungere a
contatore dal vecchio database e un contatore dal nuovo database. Il risultato è stato
deludente, gran parte delle statistiche sembrava essere svanita misteriosamente...
Ovviamente no, i valori del vecchio database (valori noti) sono stati aggiunti ai valori
dal nuovo database (valori sconosciuti) e il risultato era sconosciuto.

In questo caso, è abbastanza ragionevole utilizzare un CDEF che altera i dati sconosciuti in zero.
I contatori del dispositivo erano sconosciuti (dopotutto, non era ancora installato!) ma si sa
che la velocità dei dati attraverso il dispositivo doveva essere zero (per lo stesso motivo: era
non installato).

Di seguito sono riportati alcuni esempi che apportano questa modifica.

infinito
I dati infiniti sono un'altra forma di un numero speciale. Non può essere rappresentato graficamente perché da
definizione non raggiungeresti mai il valore infinito. Puoi pensare positivo e
infinito negativo a seconda della posizione rispetto allo zero.

RRDtool è in grado di rappresentare (non rappresentare graficamente!) l'infinito fermandosi alla sua corrente
massimo (per infinito positivo) o minimo (per infinito negativo) senza saperlo
massimo (minimo).

Infinity in RRDtool viene utilizzato principalmente per disegnare un'AREA senza conoscerne la verticale
dimensioni. Puoi pensarlo come disegnare un'AREA con un'altezza infinita e visualizzare
solo la parte visibile nel grafico corrente. Questo è probabilmente un buon modo per
infinito approssimativo e sicuramente consente alcuni trucchi accurati. Vedi sotto per esempi.

lavoro con Sconosciuto dati ed infinito
A volte vorresti scartare dati sconosciuti e fingere che siano zero (o qualsiasi altro
valore se è per questo) e a volte vorresti fingere che i dati noti siano sconosciuti
(per scartare i dati noti per essere errati). Questo è il motivo per cui i CDEF supportano i dati sconosciuti.
Sono disponibili anche esempi che mostrano dati sconosciuti utilizzando l'infinito.

Alcuni Esempi

Esempio: utilizzando a recentemente creato RRD
Conservi le statistiche sul tuo router da più di un anno. Recentemente hai installato un
router aggiuntivo e desideri mostrare il throughput combinato per questi due dispositivi.

Se sommi semplicemente i contatori di router.rrd e router2.rrd, aggiungerai dati noti
(da router.rrd) a dati sconosciuti (da router2.rrd) per la maggior parte delle tue statistiche.
Potresti risolverlo in alcuni modi:

· Durante la creazione del nuovo database, riempirlo con zeri dall'inizio ad ora. Hai
per avviare il database in corrispondenza o prima dell'ora meno recente nell'altro database.

· In alternativa, è possibile utilizzare CDEF e modificare i dati sconosciuti a zero.

Entrambi i metodi hanno i loro pro e contro. Il primo metodo è problematico e se vuoi
fallo devi capirlo da solo. Non è possibile creare un database pieno
con gli zeri, devi inserirli manualmente. Viene descritta l'implementazione del secondo metodo
prossimo:

Quello che vogliamo è: "se il valore è sconosciuto, sostituiscilo con zero". Questo potrebbe essere scritto in
pseudo-codice come: if (il valore è sconosciuto) then (zero) else (valore). Quando si legge il grafico rrd
manuale si nota la funzione "UN" che restituisce zero o uno. Si nota anche il "SE"
funzione che accetta zero o uno come input.

Prima guarda la funzione "SE". Prende tre valori dallo stack, il primo valore è
il punto di decisione, il secondo valore viene restituito allo stack se la valutazione è "vera"
e in caso contrario, il terzo valore viene restituito allo stack. Vogliamo che la funzione "UN" decida
cosa succede quindi combiniamo queste due funzioni in un CDEF.

Scriviamo i due possibili percorsi per la funzione "IF":

se vero ritorna a
se falso ritorna b

In RPN: "risultato=x,a,b,IF" dove "x" è vero o falso.

Ora dobbiamo compilare "x", questa dovrebbe essere la parte "(il valore è sconosciuto)" e questa è in
RPN: "risultato=valore,UN"

Ora li combiniamo: "risultato=valore,UN,a,b,IF" e quando compiliamo le cose appropriate
per "a" e "b" abbiamo finito:

"CDEF:risultato=valore,UN,0,valore,IF"

Potresti voler leggere la guida RPN di Steve Rader se hai difficoltà con il modo in cui I
spiegato quest'ultimo esempio.

Se vuoi controllare questa espressione RPN, imita semplicemente il comportamento di RRDtool:

Per qualsiasi valore noto, l'espressione valuta come segue:
CDEF:risultato=valore,UN,0,valore,IF (valore,UN) non è vero quindi diventa 0
CDEF:result=0,0,value,IF "IF" restituirà il 3° valore
CDEF:risultato=valore Viene restituito il valore noto

Per il valore sconosciuto, accade questo:
CDEF:risultato=valore,UN,0,valore,IF (valore,UN) è vero quindi diventa 1
CDEF:risultato=1,0,valore,IF "IF" vede 1 e restituisce il 2° valore
CDEF:risultato=0 Viene restituito zero

Naturalmente, se desideri vedere un altro valore invece di zero, puoi usare quell'altro
valore.

Alla fine, quando tutti i dati sconosciuti vengono rimossi dall'RRD, potresti voler rimuovere questo
regola in modo che i dati sconosciuti vengano visualizzati correttamente.

Esempio: better manipolazione of Sconosciuto dati, by utilizzando tempo
L'esempio sopra ha un inconveniente. Se registri dati sconosciuti nel tuo database dopo
installando la tua nuova attrezzatura, anche questa si tradurrà in zero e quindi tu
non vedrà che c'è stato un problema. Questo non va bene e quello che vuoi veramente fare è:

· Se sono presenti dati sconosciuti, guardare l'ora in cui è stato prelevato questo campione.

· Se il valore sconosciuto è prima dell'ora xxx, azzerarlo.

· Se è dopo l'ora xxx, lasciarlo come dati sconosciuti.

Questo è fattibile: puoi confrontare il tempo in cui il campione è stato prelevato con un tempo noto.
Supponendo che tu abbia iniziato a monitorare il tuo dispositivo venerdì 17 settembre 1999, 00:35:57 MET
ora legale. Traduci questa volta in secondi dal 1970/01/01 e diventa 937'521'357. Se tu
elaborare valori sconosciuti che sono stati ricevuti dopo questo tempo, vuoi lasciarli sconosciuti
e se sono stati "ricevuti" prima di questo momento, vuoi tradurli in zero (quindi tu
può effettivamente ignorarli mentre li aggiunge ai contatori degli altri router).

La traduzione di venerdì 17 settembre 1999, 00:35:57 MET DST in 937'521'357 può essere eseguita da,
per esempio, usando gnu date:

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

Puoi anche scaricare il database e vedere dove iniziano a essere conosciuti i dati. Ci sono
molti altri modi per farlo, scegline uno.

Ora dobbiamo creare la magia che ci permette di elaborare valori sconosciuti diversi
a seconda del momento in cui è stato prelevato il campione. Questo è un processo in tre fasi:

1. Se il timestamp del valore è successivo a 937'521'357, lasciarlo così com'è.

2. Se il valore è un valore noto, lasciarlo così com'è.

3. Modificare il valore sconosciuto in zero.

Diamo un'occhiata alla prima parte:

se (vero) restituisce il valore originale

Riscriviamo questo:

se (vero) restituisce "a"
se (falso) restituisce "b"

Dobbiamo calcolare vero o falso dal passaggio 1. C'è una funzione disponibile che restituisce
il timestamp per il campione corrente. Si chiama, sorprendentemente, "TIME". Questa volta
deve essere confrontato con un numero costante, abbiamo bisogno di "GT". L'output di "GT" è vero o falso
e questo è un buon input per "IF". Vogliamo "if (time > 937521357) then (return a) else
(ritorno b)".

Questo processo è già stato descritto approfonditamente nel capitolo precedente, quindi facciamolo velocemente:

se (x) allora un altro b
dove x rappresenta "time>937521357"
dove a rappresenta il valore originale
dove b rappresenta il risultato dell'esempio precedente

tempo>937521357 --> TEMPO,937521357,GT

se (x) allora a else b -> x,a,b,IF
sostituire x --> TIME,937521357,GT,a,b,IF
sostituire a --> TIME,937521357,GT,value,b,IF
sostituire b --> TEMPO,937521357,GT,valore,valore,UN,0,valore,SE,SE

Finiamo con: "CDEF:result=TIME,937521357,GT,value,value,UN,0,value,IF,IF"

Questo sembra molto complesso, tuttavia, come puoi vedere, non è stato troppo difficile da inventare.

Esempio: Fingendo strano dati non è ci
Supponiamo che tu abbia un problema che si presenta come enormi picchi nel tuo grafico. Lo sai
accade e perché, quindi decidi di aggirare il problema. Forse stai usando il tuo
rete per fare un backup di notte e così facendo ottieni quasi 10mb/s mentre il resto
la tua attività di rete non produce numeri superiori a 100 kb/s.

Ci sono due opzioni:

1. Se il numero supera i 100kb/s è sbagliato e lo vuoi mascherare modificandolo
nell'ignoto.

2. Non vuoi che il grafico mostri più di 100kb/s.

Pseudo codice: if (numero > 100) then unknown else numero o Pseudo codice: if (numero > 100)
poi 100 altro numero.

Il secondo "problema" può essere risolto anche utilizzando l'opzione rigida del grafico RRDtool,
tuttavia questo non ha lo stesso risultato. In questo esempio puoi finire con un grafico che
esegue la scalabilità automatica. Inoltre, se usi i numeri per visualizzare i massimi, verranno impostati su
100 kb/s.

Usiamo ancora "IF" e "GT". "se (x) allora (y) altrimenti (z)" è scritto come
"CDEF:risultato=x,y,z,IF"; ora inserisci x, y e z. Per x inserisci "numero maggiore di
100kb/s" che diventa "number,100000,GT" (kilo è 1'000 e b/s è ciò che misuriamo!). La "z"
la parte è "numero" in entrambi i casi e la parte "y" è "UNKN" per sconosciuto o "100000"
per 100 kb/s.

Le due espressioni CDEF sarebbero:

CDEF:risultato=numero,100000,GT,UNKN,numero,IF
CDEF:risultato=numero,100000,GT,100000,numero,IF

Esempio: lavoro on a certo tempo campata
Se vuoi un grafico che abbraccia alcune settimane, ma vorresti vedere solo i dati di alcuni router
per una settimana, devi "nascondere" il resto del lasso di tempo. Non chiedermi quando questo sarebbe
essere utile, è solo qui per l'esempio :)

Dobbiamo confrontare il timestamp con una data di inizio e una data di fine. Il confronto non è
difficile:

TEMPO,inizio,GE
ORA,ora di fine,LE

Queste due parti del CDEF producono 0 per falso o 1 per vero. Ora possiamo verificare se
sono entrambi 0 (o 1) usando alcune istruzioni IF ma, come ha sottolineato Wataru Satoh, possiamo
utilizzare le funzioni "*" o "+" come AND logico e OR logico.

Per "*", il risultato sarà zero (false) se uno dei due operatori è zero. Per
"+", il risultato sarà falso (0) solo quando verranno aggiunti due operatori falsi (0).
Attenzione: *qualsiasi* numero diverso da 0 sarà considerato "vero". Ciò significa che, per
esempio, "-1,1,+" (che dovrebbe essere "vero o vero") diventerà FALSO... In altre parole,
usa "+" solo se sai per certo di avere solo numeri positivi (o zero).

Compiliamo il CDEF completo:

DEF:ds0=router1.rrd:MEDIA
CDEF:ds0modified=TIME,ora di inizio,GT,TIME,ora di fine,LE,*,ds0,UNKN,IF

Ciò restituirà il valore di ds0 se entrambi i confronti restituiscono true. Potresti anche farlo
viceversa:

DEF:ds0=router1.rrd:MEDIA
CDEF:ds0modified=TIME,ora di inizio,LT,TIME,ora di fine,GT,+,UNKN,ds0,IF

Questo restituirà un UNKNOWN se uno dei due confronti restituisce true.

Esempio: Tu sospettare a avere problemi ed volere a vedere Sconosciuto dati.
Supponiamo di sommare il numero di utenti attivi su più terminal server. Se uno di loro
non dà una risposta (o una risposta errata) si ottiene "NaN" nel database ("Not a
Number") e NaN viene valutato come Sconosciuto.

In questo caso, vorresti essere avvisato e la somma dei valori rimanenti è di
nessun valore per te

Sarebbe qualcosa come:

DEF:utenti1=posizione1.rrd:onlineTS1:LAST
DEF:utenti2=posizione1.rrd:onlineTS2:LAST
DEF:utenti3=posizione2.rrd:onlineTS1:LAST
DEF:utenti4=posizione2.rrd:onlineTS2:LAST
CDEF:allusers=utenti1,utenti2,utenti3,utenti4,+,+,+

Se ora tracci tutti gli utenti, i dati sconosciuti in uno degli utenti1..utenti4 verranno visualizzati come un vuoto in
il tuo grafico Vuoi modificarlo per mostrare una linea rossa brillante, non uno spazio vuoto.

Definisci un CDEF extra che è sconosciuto se tutto va bene ed è infinito se c'è uno sconosciuto
valore:

CDEF: dati errati = tutti gli utenti, UN, INF, UNKN, IF

"allusers,UN" valuterà true o false, è la parte (x) di "IF"
funzione e controlla se allusers è sconosciuto. La parte (y) della funzione "IF" è impostata
su "INF" (che significa infinito) e la parte (z) della funzione restituisce "UNKN".

La logica è: if (allusers == unknown) then return INF else return UNKN.

Ora puoi utilizzare AREA per visualizzare questi "dati errati" in rosso brillante. Se è sconosciuto (perché
allusers è noto) quindi l'AREA rossa non verrà visualizzata. Se il valore è INF (perché allusers
è sconosciuto) allora l'AREA rossa sarà compilata sul grafico in quel particolare momento.

AREA:allusers#0000FF:conteggio utenti combinato
AREA:dati errati#FF0000:dati sconosciuti

Stesso esempio utile con IMPILATE dati:
Se usi lo stack nell'esempio precedente (come farei io), non sommi i valori.
Pertanto, non esiste alcuna relazione tra i quattro valori e non ne ottieni uno solo
valore da provare. Supponiamo che gli utenti3 siano sconosciuti ad un certo punto nel tempo: gli utenti1 sono tracciati,
utenti2 è sovrapposto a utenti1, utenti3 è sconosciuto e quindi non succede nulla,
utenti4 è impilato sopra utenti2. Aggiungi comunque i CDEF extra e usali per sovrapporre
il grafico "normale":

DEF:utenti1=posizione1.rrd:onlineTS1:LAST
DEF:utenti2=posizione1.rrd:onlineTS2:LAST
DEF:utenti3=posizione2.rrd:onlineTS1:LAST
DEF:utenti4=posizione2.rrd:onlineTS2:LAST
CDEF:allusers=utenti1,utenti2,utenti3,utenti4,+,+,+
CDEF: dati errati = tutti gli utenti, UN, INF, UNKN, IF
AREA:utenti1#0000FF:utenti su ts1
STACK:utenti2#00FF00:utenti su ts2
STACK:users3#00FFFF:utenti su ts3
STACK:users4#FFFF00:utenti su ts4
AREA:dati errati#FF0000:dati sconosciuti

Se ci sono dati sconosciuti in uno degli utenti1..utenti4, verrà disegnata l'AREA "dati errati" e
poiché inizia dall'asse X e ha un'altezza infinita, sovrascriverà effettivamente il
Parti impilate.

Se lo desideri, puoi combinare le due linee CDEF in una (non usiamo "allusers"). Ma
ci sono buone ragioni per scrivere due CDEFS:

· Migliora la leggibilità dello script.

· Può essere utilizzato all'interno di GPRINT per visualizzare il numero totale di utenti.

Se scegli di combinarli, puoi sostituire "allusers" nel secondo CDEF con
la parte dopo il segno di uguale dalla prima riga:

CDEF: dati errati=utenti1,utenti2,utenti3,utenti4,+,+,+,UN,INF,UNKN,IF

Se lo fai, non sarai in grado di utilizzare questi prossimi GPRINT:

COMMENTO:"Numero totale di utenti visti"
GPRINT:allusers:MAX:"Massimo: %6.0lf"
GPRINT:allusers:MIN:"Minimo: %6.0lf"
GPRINT:allusers:AVERAGE:"Media: %6.0lf"
GPRINT:allusers:LAST:"Attuale: %6.0lf\n"

I Esempi da , il RRD grafico Manuale pagina

Gradi Centigrado vs. Gradi Fahrenheit
Per convertire Celsius in Fahrenheit usa la formula F=9/5*C+32

rrdtool grafico demo.png --title="Grafico demo" \
DEF:cel=demo.rrd:scarico:MEDIA \
CDEF:lontano=9,5,/,cel,*,32,+ \
RIGA2:cel#00a000:"C. Celsius" \
LINE2:far#ff0000:"D. Fahrenheit\c"

Questo esempio ottiene il DS chiamato "scarico" dal database "demo.rrd" e inserisce i valori in
variabile "cel". Il CDEF utilizzato viene valutato come segue:

CDEF:lontano=9,5,/,cel,*,32,+
1. premi 9, premi 5
2. premi la funzione "dividi" ed elaborala
lo stack ora contiene 9/5
3. premere la variabile "cel"
4. premere la funzione "moltiplica" ed elaborarla
lo stack ora contiene 9/5*cel
5. premi 32
6. premere la funzione "più" ed elaborarla
lo stack ora contiene la temperatura in Fahrenheit

Cambiare Sconosciuto ai miglioramenti zero
rrdtool grafico demo.png --title="Grafico demo" \
DEF:idat1=interface1.rrd:ds0:MEDIA \
DEF:idat2=interface2.rrd:ds0:MEDIA \
DEF:odat1=interface1.rrd:ds1:MEDIA \
DEF:odat2=interface2.rrd:ds1:MEDIA \
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:Ingresso Aggregato \
LINE1:aggoutput#0000FF:Output Aggregato

Questi due CDEF sono costituiti da diverse funzioni. Aiuta a dividerli durante la visualizzazione di cosa
loro fanno. Partendo dal primo CDEF otterremmo:

idat1,UN --> a
0 --> b
idat1 --> c
se (a) allora (b) altrimenti (c)

Il risultato è quindi "0" se è vero che "idat1" è uguale a "UN". In caso contrario, l'originale
il valore di "idat1" viene rimesso in pila. Chiamiamo questa risposta "d". Il processo è
ripetuto per i successivi cinque elementi in pila, viene eseguito lo stesso e restituirà risposta
"h". Lo stack risultante è quindi "d,h". L'espressione è stata semplificata in
"d,h,+,8,*" e ora sarà facile vedere che aggiungiamo "d" e "h", e moltiplichiamo il
risultato con otto.

Il risultato finale è che abbiamo aggiunto "idat1" e "idat2" e nel processo abbiamo effettivamente
valori sconosciuti ignorati. Il risultato viene moltiplicato per otto, molto probabilmente per convertire byte/s
a bit/s.

infinito dimostrazione
rrdtool graph example.png --title="INF demo" \
DEF:val1=qualche.rrd:ds0:MEDIA \
DEF:val2=qualche.rrd:ds1:MEDIA \
DEF:val3=qualche.rrd:ds2:MEDIA \
DEF:val4=altro.rrd:ds0:MEDIA \
CDEF:sfondo=val4,POP,TIME,7200,%,3600,LE,INF,UNKN,IF \
CDEF:wipeout=val1,val2,val3,val4,+,+,+,UN,INF,UNKN,IF \
AREA:sfondo#F0F0F0 \
AREA:val1#0000FF:Valore1 \
STACK:val2#00C000:Valore2 \
STACK:val3#FFFF00:Valore3 \
STACK:val4#FFC000:Valore4 \
AREA:whipeout#FF0000:Sconosciuto

Questa demo mostra due modi per usare l'infinito. È un po' complicato vedere cosa succede in
il CDEF "di fondo".

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

Questo RPN prende il valore di "val4" come input e poi lo rimuove immediatamente dallo stack
utilizzando "POP". Lo stack ora è vuoto ma come effetto collaterale ora sappiamo l'ora in cui questo
campione è stato prelevato. Questa volta viene messo in pila dalla funzione "TIME".

"TIME,7200,%" prende il modulo di tempo e 7'200 (che sono due ore). Il risultato
il valore nello stack sarà un numero nell'intervallo da 0 a 7199.

Per chi non conosce la funzione modulo: è il resto dopo un intero
divisione. Se dividi 16 per 3, la risposta sarebbe 5 e il resto sarebbe 1. Quindi,
"16,3,%" restituisce 1.

Abbiamo il risultato di "TIME,7200,%" nello stack, chiamiamolo "a". L'inizio dell'RPN
è diventato "a,3600,LE" e questo controlla se "a" è minore o uguale a "3600". È vero
metà del tempo. Ora dobbiamo elaborare il resto dell'RPN e questo è solo un semplice
Funzione "IF" che restituisce "INF" o "UNKN" a seconda dell'ora. Questo è restituito
alla variabile "sfondo".

Il secondo CDEF è stato discusso in precedenza in questo documento, quindi non lo faremo qui.

Ora puoi disegnare i diversi livelli. Inizia con lo sfondo che è sconosciuto
(niente da vedere) o infinito (l'intera parte positiva del grafico viene riempita).

Quindi disegna i dati su questo sfondo, si sovrapporrà allo sfondo. supponiamo
uno di val1..val4 sarebbe sconosciuto, in tal caso ti ritroverai con solo tre barre impilate
uno sopra l'altro. Non vuoi vederlo perché i dati sono validi solo quando tutto
quattro variabili sono valide. Questo è il motivo per cui usi il secondo CDEF, si sovrapporrà ai dati
con un'AREA in modo che i dati non siano più visibili.

Se i tuoi dati possono avere anche valori negativi devi sovrascrivere anche l'altra metà di
il tuo grafico Questo può essere fatto in un modo relativamente semplice: ciò di cui hai bisogno è il "wipeout"
variabile e inserire un segno negativo prima di essa: "CDEF:wipeout2=wipeout,-1,*"

Filtraggio dati
Puoi eseguire un filtraggio dei dati complesso:

FILTRO MEDIANO: filtra il rumore di ripresa

DEF:var=database.rrd:traffic:MEDIA
CDEF:prec1=PREC(var)
CDEF:prec2=PREC(prec1)
CDEF:mediana=var,prec1,prev2,3,SORT,POP,EXC,POP
LINE3:mediana#000077:filtrata
LINE1:prev2#007700:'dati grezzi'

DERIVATA:

DEF:var=database.rrd:traffic:MEDIA
CDEF:prec1=PREC(var)
CDEF:ora=var,POP,ORA
CDEF:ora precedente=ora precedente(ora)
CDEF:derivato=var,prev1,-,time,prevtime,-,/
LINE3:derivare#000077:derivare
LINE1:var#007700:'dati grezzi'

Fuori of idee per adesso

Questo documento è stato creato da domande poste da me stesso o da altre persone sul
Mailing list di RRDtool. Per favore fatemi sapere se trovate errori o se avete problemi
capirlo. Se pensi che ci dovrebbe essere un'aggiunta, scrivimi:
<[email protected]>

Ricorda: Non feedback uguale no i cambiamenti!

Usa cdeftutorial online utilizzando i servizi onworks.net