Est-ce que je comprends correctement les fonctions taux vs augmentation de Prometheus?
J'ai lu attentivement la documentation Prometheus , mais elle est encore un peu floue pour moi, donc je suis ici pour obtenir une confirmation de ma compréhension.
(Veuillez noter que pour les exemples les plus simples possibles, j'ai utilisé la seconde pour l'intervalle de rebut, timerange - même si ce n'est pas possible dans la pratique)
Malgré le fait que nous supprimons un compteur à chaque seconde, la valeur du compteur est actuellement de 30. Pour cela, nous avons les séries temporelles suivantes:
second counter_value increase calculated by hand(call it ICH from now)
1 1 1
2 3 2
3 6 3
4 7 1
5 10 3
6 14 4
7 17 3
8 21 4
9 25 4
10 30 5
Nous voulons exécuter une requête sur cet ensemble de données.
1.rate ()
Le document officiel indique:
"taux (v plage-vecteur): calcule le taux moyen d'augmentation par seconde de la série chronologique dans le vecteur plage."
Avec les termes d'un profane, cela signifie que nous obtiendrons l'augmentation pour chaque seconde et la valeur pour la seconde donnée sera l'incrément moyen dans la plage donnée?
Voici ce que je veux dire:
taux (compteur [1s]): correspondra à ICH car la moyenne sera calculée à partir d'une seule valeur .
rate (counter [2s]): obtiendra la moyenne de l'incrément en 2 sec et la répartira entre les secondes
Donc, dans les 2 premières secondes, nous avons obtenu un incrément de 3 au total, ce qui signifie que la moyenne est de 1,5/sec. résultat final:
second result
1 1,5
2 1,5
3 2
4 2
5 3,5
6 3,5
7 3,5
8 3,5
9 4,5
10 4,5
rate (counter [5s]): obtiendra la moyenne de l'incrément en 5 sec et la répartira entre les secondes
Identique à [2s] mais nous calculons la moyenne à partir de l'incrément total de 5sec. résultat final:
second result
1 2
2 2
3 2
4 2
5 2
6 4
7 4
8 4
9 4
10 4
Donc, plus la minuterie est élevée, plus le résultat sera lisse. Et la somme de ces augmentations correspondra au compteur réel.
2. augmenter ()
Le document officiel indique:
"augmentation (v plage-vecteur): calcule l'augmentation de la série chronologique dans le vecteur plage."
Pour moi, cela signifie qu'il ne distribuera pas la moyenne entre les secondes, mais affichera plutôt l'incrément unique pour la plage donnée (avec extrapolation).
augmentation (compteur [1s]): Dans mon terme, cela correspondra au ICH et au taux pendant 1 s, simplement parce que la plage totale et la granularité de base du taux correspondent.
augmentation (compteur [2s]): Les 2 premières secondes nous ont donné un incrément de 3 au total, donc 2 secondes auront la valeur de 3 et ainsi de suite ...
second result
1 3*
2 3
3 4*
4 4
5 7*
6 7
7 7*
8 7
9 9*
10 9
* Selon mes termes, ces valeurs signifient les valeurs extrapolées pour couvrir chaque seconde.
Est-ce que je comprends bien ou suis-je loin de cela?
Dans un monde idéal (où les horodatages de vos échantillons sont exactement sur la seconde et votre évaluation de règle se produit exactement sur la seconde) rate(counter[1s]) retournerait exactement votre ICH valeur et rate(counter[5s]) retournerait la moyenne de cela ICH et les 4. précédents. Sauf le ICH au deuxième 1 est 0, pas 1, parce que personne sait quand votre compteur était nul: peut-être qu'il a incrémenté juste là, peut-être qu'il a été incrémenté hier et qu'il est resté à 1 depuis. (C'est la raison pour laquelle vous ne verrez pas d'augmentation la première fois qu'un compteur apparaît avec une valeur de 1 - parce que votre code vient de le créer et de l'incrémenter.)
increase(counter[5s]) est exactement rate(counter[5s]) * 5 (et increase(counter[2s]) est exactement rate(counter[2s]) * 2).
Maintenant, ce qui se passe dans le monde réel, c'est que vos échantillons ne sont pas collectés exactement chaque seconde sur la seconde et l'évaluation des règles ne se produit pas exactement sur la seconde non plus. Donc, si vous avez un tas d'échantillons qui sont (plus ou moins) à 1 seconde d'intervalle et que vous utilisez rate(counter[1s]) de Prometheus, vous n'obtiendrez aucune sortie. En effet, ce que Prometheus fait, c'est qu'il prend tous les échantillons dans la plage de 1 seconde [now() - 1s, now()] (qui serait un seul échantillon dans la grande majorité des cas), essaie de calculer un taux et échoue.
Si vous interrogez rate(counter[5s]) OTOH, Prometheus sélectionnera tous les échantillons de la plage [now() - 5s, now] (5 échantillons, couvrant environ 4 secondes en moyenne, disons [t1, v1], [t2, v2], [t3, v3], [t4, v4], [t5, v5]) Et (en supposant votre compteur ne se réinitialise pas dans l'intervalle) renverra (v5 - v1) / (t5 - t1). C'est à dire. il calcule en fait le taux d'augmentation sur ~ 4s au lieu de 5s.
increase(counter[5s]) renverra (v5 - v1) / (t5 - t1) * 5, donc le taux d'augmentation sur ~ 4 secondes, extrapolé à 5 secondes.
Étant donné que les échantillons ne sont pas exactement espacés, rate et increase renvoient souvent des valeurs à virgule flottante pour les compteurs entiers (ce qui est évident pour rate, mais pas tant pour increase).