Profiler.php

Go to the documentation of this file.

<?php

namespace Elgg\Debug;

use Elgg\Project\Paths;
use Elgg\Timer;

class Profiler {

    protected $percentage_format = '%01.2f';
    
    protected $duration_format = '%01.6f';
    
    protected $minimum_percentage = 0.2;

    protected $total;
    
    public function __invoke(\Elgg\Event $event) {
        if (!_elgg_services()->config->enable_profiling) {
            return;
        }
        
        $profiler = new self();
        $min_percentage = _elgg_services()->config->profiling_minimum_percentage;
        if ($min_percentage !== null) {
            $profiler->minimum_percentage = $min_percentage;
        }
        
        $tree = $profiler->buildTree(_elgg_services()->timer);
        $tree = $profiler->formatTree($tree);
        $data = [
            'tree' => $tree,
            'total' => $tree['duration'] . ' seconds',
        ];
        
        $list = [];
        $profiler->flattenTree($list, $tree);
        
        $root = Paths::project();
        $list = array_map(function ($period) use ($root) {
            $period['name'] = str_replace("Closure {$root}", 'Closure ', $period['name']);
            return "{$period['percentage']}% ({$period['duration']}) {$period['name']}";
        }, $list);
        
        $data['list'] = $list;
        
        $html = $event->getValue();
        $html .= '<script>console.log(' . json_encode($data) . ');</script>';
        
        return $html;
    }
    
    protected function buildTree(Timer $timer) {
        $times = $timer->getTimes();

        if (!isset($times[Timer::MARKER_END])) {
            $times[Timer::MARKER_END] = microtime(true);
        }

        $begin = $this->findBeginTime($times);
        $end = $this->findEndTime($times);
        $this->total = $this->diffMicrotime($begin, $end);

        return $this->analyzePeriod('', $times);
    }

    protected function flattenTree(array &$list = [], array $tree = [], $prefix = '') {
        $is_root = empty($list);

        if (isset($tree['periods'])) {
            foreach ($tree['periods'] as $period) {
                $this->flattenTree($list, $period, "{$prefix}  {$period['name']}");
            }
            
            unset($tree['periods']);
        }
        
        $tree['name'] = trim($prefix);
        $list[] = $tree;

        if ($is_root) {
            usort($list, function ($a, $b) {
                if ($a['duration'] == $b['duration']) {
                    return 0;
                }
                
                return ($a['duration'] > $b['duration']) ? -1 : 1;
            });
        }
    }

    protected function formatTree(array $tree) {
        $tree['duration'] = sprintf($this->duration_format, $tree['duration']);
        if (isset($tree['percentage'])) {
            $tree['percentage'] = sprintf($this->percentage_format, $tree['percentage']);
        }
        
        if (isset($tree['periods'])) {
            $tree['periods'] = array_map([$this, 'formatTree'], $tree['periods']);
        }
        
        return $tree;
    }

    protected function analyzePeriod($name, array $times) {
        $begin = $this->findBeginTime($times);
        $end = $this->findEndTime($times);
        if ($begin === false || $end === false) {
            return false;
        }
        
        $has_own_markers = isset($times[Timer::MARKER_BEGIN], $times[Timer::MARKER_BEGIN]);
        unset($times[Timer::MARKER_BEGIN], $times[Timer::MARKER_END]);

        $total = $this->diffMicrotime($begin, $end);
        $ret = [
            'name' => $name,
            'percentage' => 100, // may be overwritten by parent
            'duration' => $total,
        ];

        foreach ($times as $times_key => $period) {
            $period = $this->analyzePeriod($times_key, $period);
            if ($period === false) {
                continue;
            }
            
            $period['percentage'] = 100 * $period['duration'] / $this->total;
            if ($period['percentage'] < $this->minimum_percentage) {
                continue;
            }
            
            $ret['periods'][] = $period;
        }

        if (isset($ret['periods'])) {
            if (!$has_own_markers) {
                // this is an aggregation of different non sequential timers (eg. SQL queries)
                $ret['duration'] = 0;
                foreach ($ret['periods'] as $period) {
                    $ret['duration'] += $period['duration'];
                }
                
                $ret['percentage'] = 100 * $ret['duration'] / $this->total;
            }
            
            usort($ret['periods'], function ($a, $b) {
                if ($a['duration'] == $b['duration']) {
                    return 0;
                }
                
                return ($a['duration'] > $b['duration']) ? -1 : 1;
            });
        }

        return $ret;
    }

    protected function findBeginTime(array $times) {
        if (isset($times[Timer::MARKER_BEGIN])) {
            return $times[Timer::MARKER_BEGIN];
        }
        
        unset($times[Timer::MARKER_BEGIN], $times[Timer::MARKER_END]);
        $first = reset($times);
        if (is_array($first)) {
            return $this->findBeginTime($first);
        }
        
        return false;
    }

    protected function findEndTime(array $times) {
        if (isset($times[Timer::MARKER_END])) {
            return $times[Timer::MARKER_END];
        }
        
        unset($times[Timer::MARKER_BEGIN], $times[Timer::MARKER_END]);
        $last = end($times);
        if (is_array($last)) {
            return $this->findEndTime($last);
        }
        
        return false;
    }

    protected function diffMicrotime($start, $end) {
        return (float) $end - $start;
    }
}