[comment]: # ({c34725dc-f445d963})
# Funzioni predittive dei trigger

[comment]: # ({/c34725dc-f445d963})

[comment]: # ({9dac6d6d-9dac6d6d})
#### Panoramica

A volte ci sono segnali di un problema imminente. Questi segnali possono essere
individuati in modo da poter intraprendere azioni in anticipo per prevenire o almeno
ridurre al minimo l'impatto del problema.

Zabbix dispone di strumenti per prevedere il comportamento futuro del sistema monitorato
sulla base dei dati storici. Questi strumenti sono realizzati tramite funzioni predittive dei
trigger.

[comment]: # ({/9dac6d6d-9dac6d6d})

[comment]: # ({827f1d5f-24b155a7})
#### Funzioni

Prima di impostare un trigger, è necessario definire che cosa sia uno stato di problema e quanto
tempo sia necessario per intervenire. Esistono quindi due modi per configurare un
trigger che segnali una potenziale situazione indesiderata. Primo: il
trigger deve attivarsi quando è previsto che il sistema si trovi
in uno stato di problema dopo il "tempo per intervenire". Secondo: il trigger deve attivarsi quando il sistema
raggiungerà lo stato di problema in meno del "tempo per intervenire".
Le corrispondenti funzioni di trigger da utilizzare sono **forecast** e
**timeleft**. Si noti che l'analisi statistica sottostante è sostanzialmente
identica per entrambe le funzioni. È possibile configurare un trigger nel modo che si
preferisce, ottenendo risultati simili.

[comment]: # ({/827f1d5f-24b155a7})

[comment]: # ({9f0f6aee-c80922f6})
#### Parametri

Entrambe le funzioni utilizzano quasi lo stesso insieme di parametri. Utilizzare l'elenco delle
[funzioni supportate](/manual/config/triggers/expression#functions) come riferimento.

[comment]: # ({/9f0f6aee-c80922f6})

[comment]: # ({33e199b9-a93b071e})
##### Intervallo di tempo

Prima di tutto, è necessario specificare il periodo storico che Zabbix deve
analizzare per elaborare la previsione. Questo si fa nel modo consueto,
tramite il parametro `time period` e un eventuale spostamento temporale,
come avviene con le funzioni **avg**, **count**, **delta**, **max**, **min** e **sum**.

[comment]: # ({/33e199b9-a93b071e})

[comment]: # ({55d83c24-b922d0f2})
##### Orizzonte di previsione

(solo **forecast**)<br>
Il parametro `time` specifica quanto lontano nel futuro Zabbix deve
estrapolare le dipendenze che trova nei dati storici. Indipendentemente dal fatto che si utilizzi
`time_shift` o meno, `time` viene sempre conteggiato a partire dal momento attuale.

[comment]: # ({/55d83c24-b922d0f2})

[comment]: # ({1ccaacd1-625c0c85})
##### Soglia da raggiungere

(solo **timeleft**)<br>
Il parametro `threshold` specifica un valore che l'item analizzato deve raggiungere,
indipendentemente dal fatto che vi arrivi dall'alto o dal basso. Una volta determinata f(t)
(vedere sotto), si deve risolvere l'equazione f(t) = `threshold` e restituire la
radice più vicina al momento attuale e situata a destra di esso oppure
1.7976931348623158E+308 se non esiste alcuna radice di questo tipo.

::: notetip
Quando i valori dell'item si avvicinano alla soglia e poi la superano,
**timeleft** presume che l'intersezione sia già nel passato e
pertanto passa all'intersezione successiva con il livello `threshold`, se
presente. La procedura consigliata è utilizzare le previsioni come complemento alla
normale diagnostica dei problemi, non come sostituzione.^[1](#footnotes)^
:::

[comment]: # ({/1ccaacd1-625c0c85})

[comment]: # ({4d1deb86-976bd98e})
##### Funzioni di adattamento

La funzione `fit` predefinita è quella *lineare*. Ma se il sistema monitorato è
più complesso, hai a disposizione più opzioni tra cui scegliere.

|`fit`|x = f(t)|
|-----|--------|
|*linear*|x = a + b\*t|
|*polynomialN*^[2](#footnotes)^|x = a~0~ + a~1~\*t + a~2~\*t^2^ + ... + a~n~\*t^n^|
|*exponential*|x = a\*exp(b\*t)|
|*logarithmic*|x = a + b\*log(t)|
|*power*|x = a\*t^b^|

[comment]: # ({/4d1deb86-976bd98e})

[comment]: # ({3c1c1442-add67840})
##### Modalità

(solo **forecast**)<br>
Ogni volta che una funzione trigger viene valutata, ottiene i dati dal
periodo di storico specificato e adatta ai dati una funzione
specificata. Quindi, se i dati sono leggermente diversi, la funzione
adattata sarà leggermente diversa. Se calcoliamo semplicemente il valore
della funzione adattata in un momento specificato nel futuro, non saprai
nulla su come ci si aspetta che l'item analizzato si comporti tra ora e
quel momento nel futuro. Per alcune opzioni di `fit` (come *polynomial*)
un semplice valore futuro può essere fuorviante.

|`mode`|Risultato di **forecast**|
|------|-------------------------|
|*value*|f(now + `time`)|
|*max*|max~now\ <=\ t\ <=\ now\ +\ `time`~ f(t)|
|*min*|min~now\ <=\ t\ <=\ now\ +\ `time`~ f(t)|
|*delta*|*max* - *min*|
|*avg*|media di f(t) (now <= t <= now + `time`) secondo la [definizione](https://en.wikipedia.org/wiki/Mean_of_a_function)|

[comment]: # ({/3c1c1442-add67840})

[comment]: # ({3f946ebf-5ff2285e})
#### Dettagli

Per evitare calcoli con numeri enormi, consideriamo il timestamp del
primo valore nel periodo specificato più 1 ns come un nuovo tempo zero
corrente (il tempo epoch corrente è dell'ordine di 10^9^, l'epoch al
quadrato è 10^18^, la precisione double è circa 10^-16^). Viene aggiunto
1 ns per fornire tutti i valori di tempo positivi per gli adattamenti
*logaritmici* e *di potenza*, che comportano il calcolo di log(t). Lo
spostamento temporale non influisce sugli adattamenti *lineari*,
*polinomiali* ed *esponenziali* (a parte rendere i calcoli più semplici e
precisi), ma modifica la forma delle funzioni *logaritmiche* e *di
potenza*.

[comment]: # ({/3f946ebf-5ff2285e})

[comment]: # ({d180bad2-660cda6b})
#### Errori potenziali

Le funzioni restituiscono -1 nelle seguenti situazioni:

-   il periodo di valutazione specificato non contiene dati;
-   il risultato dell'operazione matematica non è definito^[3](#footnotes)^;
-   complicazioni numeriche (purtroppo, per alcuni insiemi di dati di input,
    l'intervallo e la precisione del formato in virgola mobile a doppia precisione diventano
    insufficienti)^[4](#footnotes)^.

::: notetip
Non vengono segnalati avvisi o errori se l'adattamento scelto descrive male
i dati forniti oppure se i dati sono semplicemente troppo pochi per una
previsione accurata.
:::

[comment]: # ({/d180bad2-660cda6b})

[comment]: # ({e57d3e18-06e0a230})
#### Esempi e gestione degli errori

Per ricevere un avviso quando stai per esaurire lo spazio libero su disco
del tuo host, puoi usare un'espressione trigger come questa:

    timeleft(/host/vfs.fs.size[/,free],1h,0)<1h

Tuttavia, il codice di errore -1 può entrare in gioco e portare il trigger in
uno stato di problema. In generale è una buona cosa, perché ricevi un avviso
che le tue previsioni non funzionano correttamente e dovresti esaminarle più
a fondo per capire il motivo. Ma a volte è un male, perché -1 può semplicemente
significare che nell'ultima ora non sono stati ottenuti dati sullo spazio libero
su disco dell'host. Se ricevi troppi avvisi di falsi positivi,
considera l'uso di un'espressione trigger più complessa ^[5](#footnotes)^:

    timeleft(/host/vfs.fs.size[/,free],1h,0)<1h and timeleft(/host/vfs.fs.size[/,free],1h,0)<>-1

La situazione è un po' più difficile con **forecast**. Prima di tutto,
-1 può o meno portare il trigger in uno stato di problema a seconda del fatto
che tu abbia un'espressione come `forecast(/host/item,(...))<...` oppure
come `forecast(/host/item,(...))>...`

Inoltre, -1 può essere una previsione valida se è normale che il valore
dell'item sia negativo. Ma la probabilità di questa situazione nel mondo reale
è trascurabile (vedi
[come](/manual/config/triggers/expression) funziona l'operatore **=**). Quindi
aggiungi `... or forecast(/host/item,(...))=-1` oppure
`... and forecast(/host/item,(...))<>-1` se vuoi o non vuoi
trattare rispettivamente -1 come un problema.

#### Note

^**1**^ Ad esempio, un semplice trigger come
    `timeleft(/host/item,1h,X) < 1h` può entrare in stato di problema quando il
    valore dell'item si avvicina a X e poi improvvisamente riprendersi una volta
    raggiunto il valore X. Se il problema è che il valore dell'item è inferiore a X, usa:
    `last(/host/item) < X or timeleft(/host/item,1h,X) < 1h` Se il
    problema è che il valore dell'item è superiore a X usa:
    `last(/host/item) > X or timeleft(/host/item,1h,X) < 1h`

^**2**^ Il grado del polinomio può andare da 1 a 6, *polynomial1* è equivalente
    a *linear*. Tuttavia, usa polinomi di grado superiore [con
    cautela](https://en.wikipedia.org/wiki/Runge's_phenomenon). Se il periodo di
    valutazione contiene meno punti di quelli necessari per determinare i
    coefficienti del polinomio, il grado del polinomio verrà ridotto (ad esempio,
    viene richiesto *polynomial5*, ma ci sono solo 4 punti, quindi verrà adattato
    *polynomial3*).

^**3**^ Ad esempio, l'adattamento di funzioni *exponential* o *power* comporta
    il calcolo di log() dei valori dell'item. Se i dati contengono zeri o numeri
    negativi, otterrai un errore poiché log() è definito solo per valori positivi.

^**4**^ Per gli adattamenti *linear*, *exponential*, *logarithmic* e *power* tutti
    i calcoli necessari possono essere scritti esplicitamente. Per *polynomial*
    solo *value* può essere calcolato senza passaggi aggiuntivi.
    Il calcolo di *avg* comporta il calcolo della primitiva del polinomio
    (analiticamente). Il calcolo di *max*, *min* e *delta* comporta
    il calcolo della derivata del polinomio (analiticamente) e la ricerca delle sue radici
    (numericamente). La risoluzione di f(t) = 0 comporta la ricerca delle radici del polinomio
    (numericamente).

^**5**^ Ma in questo caso -1 può far sì che il trigger esca dallo
    stato di problema. Per essere completamente protetti usa:
    `timeleft(/host/vfs.fs.size[/,free],1h,0)<1h and ({TRIGGER.VALUE}=0 and timeleft(/host/vfs.fs.size[/,free],1h,0)<>-1 or {TRIGGER.VALUE}=1)`

[comment]: # ({/e57d3e18-06e0a230})