Cómo obtener más información sobre StatsD y Graphite
Para comprender completamente cómo funciona StatsD, leí su código fuente. Había oído que StatsD era una aplicación sencilla, pero después de leer el código fuente me di cuenta de lo sencilla que es. Hay poco más de 300 líneas de código en el archivo de script principal y el backend de Graphite solo tiene alrededor de 150 líneas de código.
Conceptos en StatsD
En este documento, se enumeran algunos conceptos de StatsD que deben comprenderse.
Bucket
Cuando se crea un archivo Whisper, el tamaño del archivo es fijo. Puede haber varios "depósitos" en el archivo, correspondientes a diferentes tasas de puntos de datos, y cada depósito también tiene un atributo de retención que especifica durante cuánto tiempo se retienen los puntos de datos en el depósito. Whisper realiza algunos cálculos simples para determinar cuántos puntos de datos se retienen realmente en cada depósito.
Valores
Cada estado tiene un valor, y cómo se interpreta depende del modificador generalmente, el valor debe ser un número entero;
Intervalo de actualización
Una vez transcurrido el intervalo de actualización (normalmente 10 segundos), las estadísticas se agregan y se pasan al servicio backend ascendente.
Categorías de medidas
Contadores
Los contadores son simples. Agrega el valor a la ranura de correo y lo almacena en la memoria hasta que finaliza el intervalo de actualización.
Echemos un vistazo al código fuente que genera las estadísticas del contador que se envían al backend.
for (ingrese contadores) {
var valor = contadores[clave];
var valorPorSecondo = valor / (flushInterval / 1000); la tasa "por segundo"
statString = 'stats_key ' ' valuePerSecond ' ts "\n"
statString = 'stats_counts ' value ' ts "\n. ";
numStats = 1;
}
Primero, StatsD itera sobre todos los contadores que recibe y asigna dos variables a cada contador. Luego agrega estos valores a statString e incrementa el valor de la variable numStats.
Si usas el intervalo de actualización predeterminado (10 segundos) y envías 7 incrementos a StatsD a través de algún contador en cada intervalo.
Temporizador
El temporizador se utiliza para recopilar números. No es necesario que contengan valores de tiempo. Puede recopilar la cantidad de bytes, objetos o cualquier número en alguna memoria. Una de las mejores cosas de los temporizadores es que puedes obtener promedios, totales, recuentos y límites superior e inferior. Configurar un temporizador para StatsD puede calcular automáticamente estas cantidades antes de que los datos se envíen a Graphite.
El código fuente del temporizador es un poco más complicado que el código fuente del contador.
longitud;
var min = valores[0];
var max = valores[count - 1];
var cumulativeValues = [min];
var max = valores[count - 1];
var cumulativeValues = [min];
p>
for (var i = 1; i lt.count; i ) {
cumulativeValues.push(valores[i] cumulativeValues[i-1]);
}
var suma = min;
var media = min;
var maxAtThreshold = max;
var mensaje = "";
var key2;
for (clave2 en pctThreshold) {
var pct = pctThreshold[key2];
if (count gt; 1) {
var umbralIndex = Math.round(((100 - pct) / 100) * recuento);
var numInThreshold = recuento - umbralIndex;
maxAtThreshold = valores[numInThreshold - 1] ;
suma = acumulativeValues[numInThreshold - 1];
media = suma / numInThreshold;
}
var clean_pct = '' pct
p>clean_pct.replace('.' , '_');
mensaje = 'stats.timers. key '.mean_' clean_pct ' significa ' ' ts "\n"; p>
message = 'stats.timers.key '.upper_' clean_pct ' ' maxAtThreshold ' ' ts "\n";
message = 'stats .timers key '.sum_' clean_pct ' suma ' ' ts "\n";
}
suma = valores acumulativos[count-1];
media = suma / recuento;
mensaje = 'stats.timers.key '.upper ' max ' ts "\n";
mensaje = 'stats.timers.' .lower ' min ' ts "\n" ;
mensaje = 'estadísticas.' clave '.sum ' suma ' ts "\n";
mensaje = 'estadísticas.timers clave '.mean ' significa ' ts ". \n";
p>
statString = mensaje;
numStats = 1;
}
}
Si configura la actualización predeterminada. intervalo El siguiente valor de contador se pasa a StatsD:
450
120
553
994
334
844
675
496
StatsD calculará los siguientes valores:
media_90 496 p>
superior_90 844
suma_90 3472
superior 994
inferior 120
cuenta 8
suma 4466
media 558,25
Gauges
Gauges representa cualquier valor en un momento determinado y es el tipo más simple en StatsD. Puede pasarle cualquier valor y también se pasará al fondo. El código fuente de las estadísticas de Gauge tiene solo cuatro líneas. for (ingrese indicadores) { statString = 'stats.gauges. key ' ' calibres[clave] ' ' ts "\n"; numStats = 1; pase un número a StatsD, y pasará el número al fondo, sin procesamiento. Vale la pena señalar que durante el intervalo de actualización, solo el último valor del medidor pasará al fondo. Por lo tanto, si pasa el siguiente valor del medidor a StatsD durante el intervalo de actualización:
643
754
583
solo será pasado al fondo El valor es 583. El valor del medidor se mantendrá en la memoria hasta que finalice el intervalo de actualización.
Graphite
Ahora que entendemos cómo se generan los datos desde StatsD, veamos cómo se almacenan y procesan los datos en Graphite.
Descripción general
En la documentación de Graphite podemos encontrar la descripción general de Graphite, que resume dos puntos clave de Graphite:
Graphite almacena datos numéricos a través de series de tiempo.
Graphite puede dibujar gráficos bajo demanda.
Graphite consta de tres partes:
carbon: un programa en segundo plano que escucha datos de series temporales.
whisper: una biblioteca de base de datos sencilla para almacenar datos de series temporales.
webapp: una aplicación web de Django que utiliza Cairo para renderizar gráficos según sea necesario.
Graphite maneja datos de series temporales en el siguiente formato: lt;keygt;lt;numeric valuegt;lt;timestampgt;
Modo de almacenamiento
Graphite utiliza un formato configurable. Modo de almacenamiento para definir la tasa de retención de los datos almacenados. Compara patrones específicos con rutas de datos para determinar con qué frecuencia y dónde se almacenan los datos.
Los siguientes ejemplos de configuración están tomados de la documentación de StatsD.
[estadísticas]
patrón = ^estadísticas\...*
retención = 10:2160, 60:10080, 600:262974
Este ejemplo muestra que a los datos que coincidan con el patrón anterior se les aplicarán estas reservas. El formato conservado es frecuencia:historial.
Por tanto, la configuración nos permite almacenar 10 segundos de datos durante 6 horas, 1 minuto de datos durante 1 semana y 10 minutos de datos durante 5 años.
Mostrar temporizadores en Graphite
Ahora que sabemos todo esto, echemos un vistazo a un script Ruby simple que recopila los tiempos de solicitud HTTP.
#! /usr/bin/env ruby
requiere 'rubygems' si RUBY_VERSION lt; '1.9.0'
requiere './statsdclient.rb'
requiere 'typhoeus'
Statsd.host = 'localhost'
Statsd.port = 8125
def to_ms tiempo
(1000 * tiempo ).to_i
end
mientras es verdadero
start_time = Time.now.to_f
resp = Typhoeus::Request.get ' http://www.example.org/system/ information'
end_time = Hora.
tiempo_elapsed = (1000 * end_time) - (to_ms start_time)
tiempo_respuesta = to_ms resp.time
start_transfer_time = to_ms resp.start_transfer_time
app_connect_time = to_ms resp.app_connect_time
pretransfer_time = to_ms resp.preransfer_time
connect_time = to_ms resp.connect_time
resp.request.get 'información'
end_time = Time.now.to_f
tiempo_elapsed = (1000 * end_time) - (to_ms start_time)
response_time = to_ms resp.app_connect_time', app_ connect_time)
Statsd.timing('http_request.pretransfer_time', pretransfer_time) p>
p>
Statsd.timing('http_request.connect_time', connect_time)
Statsd.timing('http_request.name_lookup_time', name_lookup_time)
dormir 10
end
Echemos un vistazo al gráfico de Graphite. Los datos son de hace 2 minutos y el tiempo transcurrido es del script anterior.
Generación de imágenes
URL de renderizado
URL de renderizado de la imagen siguiente
/render/?width=586amp;height=308amp; de =-2minutosamp;target=stats.timers.http_request.elapsed_time.sum