Thresholds

¿Qué es un Threshold?

Thresholds es una funcionalidad que permite definir las expectativas de rendimiento del sistema sometido a prueba. Thresholds establecen el criterio por el cual un test se considera correcto o un error.

Ejemplos de expectativas (Thresholds):

El sistema no produce más de un 1% de errores
El tiempo de respuesta para el 95% de las solicitudes debe ser inferior a 200ms.
El tiempo de respuesta para el 99% de las solicitudes debe ser inferior a 400 ms.
El punto final específico debe responder siempre antes de 300ms.
Cualquier condición en una métrica personalizada.

Thresholds analizan las métricas de rendimiento y determinan el resultado final de la prueba (pasa/no pasa). Thresholds son esenciales para la automatización de las pruebas de carga.

A continuación se muestra un script de ejemplo que especifica dos thresholds, un evaluando la tasa de errores de peticiones HTTP (http_req_failed) y una que usa el percentil del tiempo de reqspuesta de todas las peticiones ( http_req_duration).

1import http from 'k6/http';
2
3export const options = {
4  thresholds: {
5    http_req_failed: ['rate<0.01'], // http errors should be less than 1%
6    http_req_duration: ['p(95)<200'], // 95% of requests should be below 200ms
7  },
8};
9
10export default function () {
11  http.get('https://test-api.k6.io/public/crocodiles/1/');
12}

Cuando se ejecute el test anterior, el resultado de k6 es similar a:

   ✓ http_req_duration..............: avg=151.06ms min=151.06ms med=151.06ms max=151.06ms p(90)=151.06ms p(95)=151.06ms
       { expected_response:true }...: avg=151.06ms min=151.06ms med=151.06ms max=151.06ms p(90)=151.06ms p(95)=151.06ms
   ✓ http_req_failed................: 0.00%  ✓ 0 ✗ 1

El threshold de peticiones fallidas, específica que queremos que nuestra prueba de carga se considere un fracaso (que resulte en que k6 salga con un código de salida distinto de cero) si el 10% o más de las peticiones resultan en error. El threshold http_req_duration especifica que el 95% de las peticiones deben completarse en 200ms.

Al ejecutar ese script, k6 mostrará algo similar a esto:

En el caso anterior, se han cumplido los criterios de ambos thresholds. Se considera que toda la prueba de carga es un pass, lo que significa que k6 saldrá con el código de salida cero.
Si alguno de los thresholds ha fallado, la marca de verificación de color verde ✓ junto al nombre del threshold (http_req_failed, http_req_duration) se mostrara con una cruz de color rojo ✗ en su lugar, y k6 debera generar un código de salida distinto de cero.

Copiar y pegar ejemplos de Thresholds

La forma más rápida de empezar con los thresholds es utilizar las métricas estándares incorporadas en k6. A continuación se muestran algunos ejemplos para copiar y pegar que puede empezar a utilizar de inmediato.

1import http from 'k6/http';
2import { sleep } from 'k6';
3
4export const options = {
5  thresholds: {
6    // 90% of requests must finish within 400ms.
7    http_req_duration: ['p(90) < 400'],
8  },
9};
10
11export default function () {
12  const res1 = http.get('https://test-api.k6.io/public/crocodiles/1/');
13  sleep(1);
14}

1import http from 'k6/http';
2import { sleep } from 'k6';
3
4export const options = {
5  thresholds: {
6    // During the whole test execution, the error rate must be lower than 1%.
7    http_req_failed: ['rate<0.01'],
8  },
9};
10
11export default function () {
12  http.get('https://test-api.k6.io/public/crocodiles/1/');
13  sleep(1);
14}

Múltiples thresholds en una sola métrica

1import http from 'k6/http';
2import { sleep } from 'k6';
3
4export const options = {
5  thresholds: {
6    // 90% of requests must finish within 400ms, 95% within 800, and 99.9% within 2s.
7    http_req_duration: ['p(90) < 400', 'p(95) < 800', 'p(99.9) < 2000'],
8  },
9};
10
11export default function () {
12  const res1 = http.get('https://test-api.k6.io/public/crocodiles/1/');
13  sleep(1);
14}

Threshold de duración del grupo

1import http from 'k6/http';
2import { group, sleep } from 'k6';
3
4export const options = {
5  thresholds: {
6    'group_duration{group:::individualRequests}': ['avg < 200'],
7    'group_duration{group:::batchRequests}': ['avg < 200'],
8  },
9  vus: 1,
10  duration: '10s',
11};
12
13export default function () {
14  group('individualRequests', function () {
15    http.get('https://test-api.k6.io/public/crocodiles/1/');
16    http.get('https://test-api.k6.io/public/crocodiles/2/');
17    http.get('https://test-api.k6.io/public/crocodiles/3/');
18  });
19
20  group('batchRequests', function () {
21    http.batch([
22      ['GET', `https://test-api.k6.io/public/crocodiles/1/`],
23      ['GET', `https://test-api.k6.io/public/crocodiles/2/`],
24      ['GET', `https://test-api.k6.io/public/crocodiles/3/`],
25    ]);
26  });
27
28  sleep(1);
29}

Threshold Syntax

Los thresholds pueden especificarse en formato corto o completo.

1export const options = {
2  thresholds: {
3    metric_name1: ['threshold_expression' /* ...*/], // short format
4    metric_name1: [
5      {
6        threshold: 'threshold_expression',
7        abortOnFail: true, // boolean
8        delayAbortEval: '10s', // string
9      },
10    ], // full format
11  },
12};

La declaración anterior dentro de un script k6 significa que habrá un threshold configurado para la métrica metric_name1. Para determinar si el threshold ha fallado o ha sido superado, se evaluará la cadena threshold_expression. La expresión_threshold debe seguir el siguiente formato.

aggregation_method operator value

Ejemplos:

avg < 200 // la duración media no puede ser superior a 200ms
count >= 500 // el recuento debe ser mayor o igual a 500
p(90) < 300 // El 90% de las muestras debe ser inferior a 300

Una expresión de threshold se evalúa como verdadero o falso.

Cada uno de los cuatro tipos de métrica incluidos en k6 proporciona su propio conjunto de métodos de agregación utilizables en las expresiones de threshold.

Tipo de métrica	Métodos agregados
Counter	count y rate
Gauge	value
Rate	rate
Trend	avg, min, max, med and p(N) donde N es un número entre 0,0 y 100,0 que significa el valor del percentil a mirar, por ejemplo, p(99,99) significa el percentil 99,99. La unidad para estos valores es el milisegundos.

Aquí hay un script de muestra (ligeramente artificial) que utiliza todos los diferentes tipos de métricas, y establece diferentes tipos de thresholds para ellos:

1import http from 'k6/http';
2import { Trend, Rate, Counter, Gauge } from 'k6/metrics';
3import { sleep } from 'k6';
4
5export const TrendRTT = new Trend('RTT');
6export const RateContentOK = new Rate('Content OK');
7export const GaugeContentSize = new Gauge('ContentSize');
8export const CounterErrors = new Counter('Errors');
9export const options = {
10  thresholds: {
11    'RTT': ['p(99)<300', 'p(70)<250', 'avg<200', 'med<150', 'min<100'],
12    'Content OK': ['rate>0.95'],
13    'ContentSize': ['value<4000'],
14    'Errors': ['count<100'],
15  },
16};
17
18export default function () {
19  const res = http.get('https://test-api.k6.io/public/crocodiles/1/');
20  const contentOK = res.json('name') === 'Bert';
21
22  TrendRTT.add(res.timings.duration);
23  RateContentOK.add(contentOK);
24  GaugeContentSize.add(res.body.length);
25  CounterErrors.add(!contentOK);
26
27  sleep(1);
28}

Tenemos estos thresholds:

Una métrica de tendencia que se alimenta con muestras de tiempo de respuesta, y que tiene los siguientes criterios de threshold:
- El tiempo de respuesta del percentil 99 debe ser inferior a 300 ms
- El tiempo de respuesta del percentil 70 debe ser inferior a 250 ms
- El tiempo de respuesta medio debe ser inferior a 200 ms
- La mediana del tiempo de respuesta debe ser inferior a 150 ms
- El tiempo de respuesta mínimo debe ser inferior a 100 ms
Una métrica de tasa que lleva la cuenta de la frecuencia con la que el contenido devuelto estaba bien. Esta métrica tiene un criterio de éxito: el contenido debe estar bien más del 95% de las veces.
Una métrica de calibre que contiene el último tamaño del contenido devuelto. El criterio de éxito para esta métrica es que el contenido devuelto debe ser menor de 4000 bytes.
Una métrica de contador que lleva la cuenta del número total de veces que el contenido devuelto no estaba bien. El criterio de éxito aquí implica que el contenido no puede haber sido malo más de 99 veces.

Thresholds en tags

A menudo es útil especificar thresholds sólo en una única URL o en una etiqueta específica. En k6, las solicitudes etiquetadas crean sub métricas que pueden utilizarse en los thresholds, como se muestra a continuación.

export const options = {
  thresholds: {
    'metric_name{tag_name:tag_value}': ['threshold_expression'],
  },
};

Y aquí hay un ejemplo completo.

1import http from 'k6/http';
2import { sleep } from 'k6';
3import { Rate } from 'k6/metrics';
4
5export const options = {
6  thresholds: {
7    'http_req_duration{type:API}': ['p(95)<500'], // threshold on API requests only
8    'http_req_duration{type:staticContent}': ['p(95)<200'], // threshold on static content only
9  },
10};
11
12export default function () {
13  const res1 = http.get('https://test-api.k6.io/public/crocodiles/1/', {
14    tags: { type: 'API' },
15  });
16  const res2 = http.get('https://test-api.k6.io/public/crocodiles/2/', {
17    tags: { type: 'API' },
18  });
19
20  const responses = http.batch([
21    ['GET', 'https://test-api.k6.io/static/favicon.ico', null, { tags: { type: 'staticContent' } }],
22    [
23      'GET',
24      'https://test-api.k6.io/static/css/site.css',
25      null,
26      { tags: { type: 'staticContent' } },
27    ],
28  ]);
29
30  sleep(1);
31}

Abortar una prueba cuando se cruza un thresholds

Si desea abortar una prueba en cuanto se cruza un threshold, antes de que la prueba haya finalizado, existe un formato de especificación de threshold ampliado que tiene el siguiente aspecto:

1export const options = {
2  thresholds: {
3    metric_name: [
4      {
5        threshold: 'p(99) < 10', // string
6        abortOnFail: true, // boolean
7        delayAbortEval: '10s', // string
8        /*...*/
9      },
10    ],
11  },
12};

Como puede ver en el ejemplo anterior, la especificación del thresholds se ha ampliado para admitir alternativamente un objeto JS con parámetros para controlar el comportamiento de la interrupción. Los campos son los siguientes:

Nombre	Tipo	Descripción
threshold	string	Es la cadena de expresión de threshold que especifica la condición de threshold a evaluar.
abortOnFail	boolean	Si se aborta la prueba si el threshold se evalúa como falso antes de que la prueba haya finalizado.
delayAbortEval	string	Si desea retrasar la evaluación del threshold durante algún tiempo, para permitir que se recojan algunas muestras métricas, puede especificar la cantidad de tiempo a retrasar utilizando cadenas de tiempo relativas como 10s, 1m y así sucesivamente.

A continuación un ejemplo:

1import http from 'k6/http';
2
3export const options = {
4  vus: 30,
5  duration: '2m',
6  thresholds: {
7    http_req_duration: [{ threshold: 'p(99) < 10', abortOnFail: true }],
8  },
9};
10
11export default function () {
12  http.get('https://test-api.k6.io/public/crocodiles/1/');
13}

⚠️ Retraso de la evaluación en k6 Cloud
Cuando k6 se ejecuta en la nube, los thresholds se evalúan cada 60 segundos, por lo que la función "abortOnFail" puede retrasarse hasta 60 segundos.

Fallo de una prueba de carga mediante comprobaciones

Los checks son buenas para codificar aserciones, pero a diferencia de los thresholds, las checks no afectarán al estado de salida de k6.

Si sólo utilizas checks para verificar que las cosas funcionan como se espera, no podrás suspender toda la prueba basándote en los resultados de esas checks.

A menudo puede ser útil combinar checks y thresholds, para obtener lo mejor de ambos:

1import http from 'k6/http';
2import { check, sleep } from 'k6';
3
4export const options = {
5  vus: 50,
6  duration: '10s',
7  thresholds: {
8    // the rate of successful checks should be higher than 90%
9    checks: ['rate>0.9'],
10  },
11};
12
13export default function () {
14  const res = http.get('http://httpbin.test.k6.io');
15
16  check(res, {
17    'status is 500': (r) => r.status == 500,
18  });
19
20  sleep(1);
21}

En este ejemplo, el threshold se configura en la métrica de los checks, estableciendo que la tasa de checks con éxito debe ser superior al 90%.

Además, puede utilizar etiquetas en los controles si desea definir un threshold basado en un control o grupo de controles concreto. Por ejemplo:

1import http from 'k6/http';
2import { check, sleep } from 'k6';
3
4export const options = {
5  vus: 50,
6  duration: '10s',
7  thresholds: {
8    'checks{myTag:hola}': ['rate>0.9'],
9  },
10};
11
12export default function () {
13  let res;
14
15  res = http.get('http://httpbin.test.k6.io');
16  check(res, {
17    'status is 500': (r) => r.status == 500,
18  });
19
20  res = http.get('http://httpbin.test.k6.io');
21  check(
22    res,
23    {
24      'status is 200': (r) => r.status == 200,
25    },
26    { myTag: 'hola' }
27  );
28
29  sleep(1);
30}

Empezando

Usando k6

Creación de pruebas

Visualización de resultados

Tipos de prueba

Guías de prueba

Misc

Thresholds

¿Qué es un Threshold?

Copiar y pegar ejemplos de Thresholds

Múltiples thresholds en una sola métrica

Threshold de duración del grupo

Threshold Syntax

Thresholds en tags

Abortar una prueba cuando se cruza un thresholds

Fallo de una prueba de carga mediante comprobaciones

Product

Resources

Community

About