Profiling de rendimiento granular con User Timing API en PHP

En el desarrollo de aplicaciones PHP complejas, identificar cuellos de botella en el rendimiento puede ser un desafío. Tradicionalmente, dependemos de herramientas de profiling como Xdebug o Blackfire.io. Sin embargo, existe una alternativa menos invasiva y más granular: la User Timing API, originalmente diseñada para el frontend pero adaptable al backend con PHP y un poco de ingeniería.

La User Timing API permite definir marcas (marks) y medidas (measures) dentro del código para registrar el tiempo transcurrido entre ellas. Esta información puede ser enviada al navegador (en el caso de una aplicación web) o analizada directamente en el backend para generar informes de rendimiento precisos.

La clave para usar esta API en PHP reside en replicar su funcionalidad a través de clases y funciones personalizadas. A continuación, un ejemplo de implementación básica:

<?php

class UserTiming
{
    private static $marks = [];

    public static function mark(string $name): void
    {
        self::$marks[$name] = microtime(true);
    }

    public static function measure(string $name, string $startMark, string $endMark): float
    {
        if (!isset(self::$marks[$startMark]) || !isset(self::$marks[$endMark])) {
            throw new InvalidArgumentException("Marks '$startMark' or '$endMark' not found.");
        }

        $startTime = self::$marks[$startMark];
        $endTime = self::$marks[$endMark];

        return ($endTime - $startTime) * 1000; // Tiempo en milisegundos
    }

    public static function getMarks(): array
    {
        return self::$marks;
    }
}

// Ejemplo de uso
UserTiming::mark('start_db_query');
// ... realizar consulta a la base de datos ...
usleep(rand(100, 500)); //Simulamos una operación que toma tiempo
UserTiming::mark('end_db_query');

$duration = UserTiming::measure('db_query_time', 'start_db_query', 'end_db_query');
echo "Tiempo de consulta a la base de datos: " . $duration . " ms\n";
print_r(UserTiming::getMarks());
?>
    

Este código define una clase `UserTiming` con métodos para registrar marcas (`mark`), calcular la duración entre marcas (`measure`), y obtener todas las marcas registradas (`getMarks`). El ejemplo muestra cómo medir el tiempo de una consulta a la base de datos (simulada con `usleep`).

Para integrar esto con tu aplicación, puedes modificar la clase para almacenar la información de las medidas en un array y luego generar un informe detallado al final de la ejecución. También puedes enviar estos datos a un servicio de monitoreo de rendimiento.

<?php
// Extensión del ejemplo anterior para almacenar medidas
class UserTiming
{
    // (Código de UserTiming anterior)
    private static $measures = [];
    public static function measure(string $name, string $startMark, string $endMark): float
    {
        //(Código de measure anterior)
        $startTime = self::$marks[$startMark];
        $endTime = self::$marks[$endMark];

        $duration =  ($endTime - $startTime) * 1000;
        self::$measures[$name] = $duration;
        return $duration;
    }

    public static function getMeasures(): array {
        return self::$measures;
    }

    public static function generateReport(): void {
        echo "<h2>Performance Report</h2>";
        echo "<ul>";
        foreach(self::$measures as $name => $duration){
            echo "<li>$name: $duration ms</li>";
        }
        echo "</ul>";

    }

}
//Uso

UserTiming::mark('inicio');
usleep(rand(100,500));
UserTiming::mark('fin');

UserTiming::measure('operacion', 'inicio', 'fin');
UserTiming::generateReport();
print_r(UserTiming::getMeasures());
?>
    

La User Timing API, replicada en PHP, ofrece una manera flexible y no intrusiva de obtener métricas de rendimiento precisas en tu código, permitiendo una optimización más dirigida y efectiva.