Chaos Engineering para C++: cómo fortalecer tu software

El caos no es un error, sino una característica: introducción a Chaos Engineering en C++

Imagine: su servicio C++ funcionó durante meses sin fallos. Y luego, ¡pum! — fallo del disco, pérdida de paquetes o un SIGKILL repentino. Y todo se acaba. El sistema se cae, los usuarios están furiosos, y usted busca frenéticamente el error en los registros. ¿Le suena familiar?

Estamos acostumbrados a probar el software en condiciones ideales: red estable, disco rápido, memoria ilimitada. Pero la realidad es cruel. Aquí es donde entra en juego Chaos Engineering, una disciplina que nos enseña a romper intencionalmente el sistema para hacerlo más fuerte. Y hoy hablaremos de cómo aplicar este enfoque a las aplicaciones C++.

Chaos Engineering para C++ no se trata de "ejecutar chaos monkey y rezar". Se trata de experimentos controlados que revelan puntos débiles antes de que los usuarios los encuentren. Aprenderemos a inyectar fallos de memoria, emular E/S lenta y romper conexiones de red, todo con código C++ puro.

¿Por qué C++ necesita especialmente la ingeniería del caos?

El lenguaje C++ otorga al desarrollador un enorme poder: gestión manual de memoria, acceso de bajo nivel a los recursos, ausencia de recolector de basura. Pero este poder es un arma de doble filo. Un error en delete[], una fuga en un envoltorio RAII o un reinterpret_cast incorrecto pueden convertir un sistema estable en un frágil castillo de naipes.

Las pruebas unitarias tradicionales rara vez verifican cómo se comportará el código cuando:

\n
• Falta de memoria RAM (std::bad_alloc)
\n
• Cierre repentino de un descriptor de archivo
\n
• Retrasos en la red (picos de latencia)
\n
• Corrupción de datos en memoria compartida
\n

Chaos Engineering para C++ cubre estas brechas. No solo escribimos pruebas, sino que provocamos errores en el sistema y observamos si sobrevive.

Herramientas: cómo introducir caos en el código C++

Para realizar experimentos necesitaremos herramientas de Fault Injection (inyección de fallos). En C++ podemos actuar a diferentes niveles:

\n
• A nivel de código: interceptación de llamadas al sistema mediante LD_PRELOAD o dlsym
\n
• A nivel de bibliotecas: sustitución de asignadores y sockets estándar
\n
• A nivel de SO: uso de ptrace o eBPF para interferir en el proceso
\n

Seguiremos el camino más práctico: escribiremos nuestra propia biblioteca para inyectar fallos, que se pueda integrar fácilmente en cualquier proyecto C++.

Ejemplo 1: Simulación de fallo de asignación de memoria

Uno de los problemas más comunes en C++ es un std::bad_alloc inesperado. ¿Cómo se comportará su código si new lanza una excepción? Vamos a comprobarlo.

// chaos_memory.h\n#pragma once\n#include <new>\n#include <cstdlib>\n#include <atomic>\n#include <cstddef>\n\nclass ChaosAllocator {\npublic:\n    // Establecemos la probabilidad de fallo (0.0 - 1.0)\n    static void set_failure_probability(double prob) {\n        failure_probability_ = prob;\n    }\n\n    static void* allocate(std::size_t size) {\n        if (should_fail()) {\n            throw std::bad_alloc();\n        }\n        return std::malloc(size);\n    }\n\n    static void deallocate(void* ptr) {\n        std::free(ptr);\n    }\n\nprivate:\n    static bool should_fail() {\n        // Generador de números aleatorios simple para demostración\n        static std::atomic<unsigned int> seed = 42;\n        seed = seed * 1103515245 + 12345;\n        return (seed / 65536) % 100 < failure_probability_ * 100;\n    }\n\n    inline static double failure_probability_ = 0.0;\n};

Ahora podemos sustituir el asignador estándar y verificar cómo nuestro código maneja los fallos de memoria:

// main.cpp\n#include <iostream>\n#include <vector>\n#include "chaos_memory.h"\n\n// Asignador personalizado