vendor/doctrine/doctrine-bundle/DataCollector/DoctrineDataCollector.php line 76

  1. <?php
  3. namespace Doctrine\Bundle\DoctrineBundle\DataCollector;
  5. use Doctrine\DBAL\Types\Type;
  6. use Doctrine\ORM\Cache\CacheConfiguration;
  7. use Doctrine\ORM\Cache\Logging\CacheLoggerChain;
  8. use Doctrine\ORM\Cache\Logging\StatisticsCacheLogger;
  9. use Doctrine\ORM\Configuration;
  10. use Doctrine\ORM\EntityManagerInterface;
  11. use Doctrine\ORM\Mapping\ClassMetadataInfo;
  12. use Doctrine\ORM\Tools\SchemaValidator;
  13. use Doctrine\Persistence\ManagerRegistry;
  14. use Doctrine\Persistence\Mapping\AbstractClassMetadataFactory;
  15. use Symfony\Bridge\Doctrine\DataCollector\DoctrineDataCollector as BaseCollector;
  16. use Symfony\Bridge\Doctrine\Middleware\Debug\DebugDataHolder;
  17. use Symfony\Component\HttpFoundation\Request;
  18. use Symfony\Component\HttpFoundation\Response;
  19. use Throwable;
  21. use function array_map;
  22. use function array_sum;
  23. use function assert;
  24. use function count;
  25. use function usort;
  27. /**
  28.  * @psalm-type QueryType = array{
  29.  *    executionMS: float,
  30.  *    explainable: bool,
  31.  *    sql: string,
  32.  *    params: ?array<array-key, mixed>,
  33.  *    runnable: bool,
  34.  *    types: ?array<array-key, Type|int|string|null>,
  35.  * }
  36.  * @psalm-type DataType = array{
  37.  *    caches: array{
  38.  *       enabled: bool,
  39.  *       counts: array<"puts"|"hits"|"misses", int>,
  40.  *       log_enabled: bool,
  41.  *       regions: array<"puts"|"hits"|"misses", array<string, int>>,
  42.  *    },
  43.  *    connections: list<string>,
  44.  *    entities: array<string, array<class-string, class-string>>,
  45.  *    errors: array<string, array<class-string, list<string>>>,
  46.  *    managers: list<string>,
  47.  *    queries: array<string, list<QueryType>>,
  48.  * }
  49.  * @psalm-property DataType $data
  50.  */
  51. class DoctrineDataCollector extends BaseCollector
  52. {
  53.     private ManagerRegistry $registry;
  54.     private ?int $invalidEntityCount = null;
  56.     /**
  57.      * @var mixed[][]|null
  58.      * @psalm-var ?array<string, list<QueryType&array{count: int, index: int, executionPercent: float}>>
  59.      */
  60.     private ?array $groupedQueries = null;
  62.     private bool $shouldValidateSchema;
  64.     public function __construct(ManagerRegistry $registry, bool $shouldValidateSchema = true, ?DebugDataHolder $debugDataHolder = null)
  65.     {
  66.         $this->registry             = $registry;
  67.         $this->shouldValidateSchema = $shouldValidateSchema;
  69.         if ($debugDataHolder === null) {
  70.             parent::__construct($registry);
  71.         } else {
  72.             parent::__construct($registry, $debugDataHolder);
  73.         }
  74.     }
  76.     public function collect(Request $request, Response $response, ?Throwable $exception = null): void
  77.     {
  78.         parent::collect($request, $response, $exception);
  80.         $errors   = [];
  81.         $entities = [];
  82.         $caches   = [
  83.             'enabled' => false,
  84.             'log_enabled' => false,
  85.             'counts' => [
  86.                 'puts' => 0,
  87.                 'hits' => 0,
  88.                 'misses' => 0,
  89.             ],
  90.             'regions' => [
  91.                 'puts' => [],
  92.                 'hits' => [],
  93.                 'misses' => [],
  94.             ],
  95.         ];
  97.         foreach ($this->registry->getManagers() as $name => $em) {
  98.             assert($em instanceof EntityManagerInterface);
  99.             if ($this->shouldValidateSchema) {
  100.                 $entities[$name] = [];
  102.                 $factory   = $em->getMetadataFactory();
  103.                 $validator = new SchemaValidator($em);
  105.                 assert($factory instanceof AbstractClassMetadataFactory);
  107.                 foreach ($factory->getLoadedMetadata() as $class) {
  108.                     assert($class instanceof ClassMetadataInfo);
  109.                     if (isset($entities[$name][$class->getName()])) {
  110.                         continue;
  111.                     }
  113.                     $classErrors                        = $validator->validateClass($class);
  114.                     $r                                  = $class->getReflectionClass();
  115.                     $entities[$name][$class->getName()] = [
  116.                         'class' => $class->getName(),
  117.                         'file' => $r->getFileName(),
  118.                         'line' => $r->getStartLine(),
  119.                     ];
  121.                     if (empty($classErrors)) {
  122.                         continue;
  123.                     }
  125.                     $errors[$name][$class->getName()] = $classErrors;
  126.                 }
  127.             }
  129.             $emConfig = $em->getConfiguration();
  130.             assert($emConfig instanceof Configuration);
  131.             $slcEnabled = $emConfig->isSecondLevelCacheEnabled();
  133.             if (! $slcEnabled) {
  134.                 continue;
  135.             }
  137.             $caches['enabled'] = true;
  139.             $cacheConfiguration = $emConfig->getSecondLevelCacheConfiguration();
  140.             assert($cacheConfiguration instanceof CacheConfiguration);
  141.             $cacheLoggerChain = $cacheConfiguration->getCacheLogger();
  142.             assert($cacheLoggerChain instanceof CacheLoggerChain || $cacheLoggerChain === null);
  144.             if (! $cacheLoggerChain || ! $cacheLoggerChain->getLogger('statistics')) {
  145.                 continue;
  146.             }
  148.             $cacheLoggerStats = $cacheLoggerChain->getLogger('statistics');
  149.             assert($cacheLoggerStats instanceof StatisticsCacheLogger);
  150.             $caches['log_enabled'] = true;
  152.             $caches['counts']['puts']   += $cacheLoggerStats->getPutCount();
  153.             $caches['counts']['hits']   += $cacheLoggerStats->getHitCount();
  154.             $caches['counts']['misses'] += $cacheLoggerStats->getMissCount();
  156.             foreach ($cacheLoggerStats->getRegionsPut() as $key => $value) {
  157.                 if (! isset($caches['regions']['puts'][$key])) {
  158.                     $caches['regions']['puts'][$key] = 0;
  159.                 }
  161.                 $caches['regions']['puts'][$key] += $value;
  162.             }
  164.             foreach ($cacheLoggerStats->getRegionsHit() as $key => $value) {
  165.                 if (! isset($caches['regions']['hits'][$key])) {
  166.                     $caches['regions']['hits'][$key] = 0;
  167.                 }
  169.                 $caches['regions']['hits'][$key] += $value;
  170.             }
  172.             foreach ($cacheLoggerStats->getRegionsMiss() as $key => $value) {
  173.                 if (! isset($caches['regions']['misses'][$key])) {
  174.                     $caches['regions']['misses'][$key] = 0;
  175.                 }
  177.                 $caches['regions']['misses'][$key] += $value;
  178.             }
  179.         }
  181.         $this->data['entities'] = $entities;
  182.         $this->data['errors']   = $errors;
  183.         $this->data['caches']   = $caches;
  184.         $this->groupedQueries   = null;
  185.     }
  187.     /** @return array<string, array<string, string>> */
  188.     public function getEntities()
  189.     {
  190.         return $this->data['entities'];
  191.     }
  193.     /** @return array<string, array<string, list<string>>> */
  194.     public function getMappingErrors()
  195.     {
  196.         return $this->data['errors'];
  197.     }
  199.     /** @return int */
  200.     public function getCacheHitsCount()
  201.     {
  202.         return $this->data['caches']['counts']['hits'];
  203.     }
  205.     /** @return int */
  206.     public function getCachePutsCount()
  207.     {
  208.         return $this->data['caches']['counts']['puts'];
  209.     }
  211.     /** @return int */
  212.     public function getCacheMissesCount()
  213.     {
  214.         return $this->data['caches']['counts']['misses'];
  215.     }
  217.     /** @return bool */
  218.     public function getCacheEnabled()
  219.     {
  220.         return $this->data['caches']['enabled'];
  221.     }
  223.     /**
  224.      * @return array<string, array<string, int>>
  225.      * @psalm-return array<"puts"|"hits"|"misses", array<string, int>>
  226.      */
  227.     public function getCacheRegions()
  228.     {
  229.         return $this->data['caches']['regions'];
  230.     }
  232.     /** @return array<string, int> */
  233.     public function getCacheCounts()
  234.     {
  235.         return $this->data['caches']['counts'];
  236.     }
  238.     /** @return int */
  239.     public function getInvalidEntityCount()
  240.     {
  241.         return $this->invalidEntityCount ??= array_sum(array_map('count', $this->data['errors']));
  242.     }
  244.     /**
  245.      * @return string[][]
  246.      * @psalm-return array<string, list<QueryType&array{count: int, index: int, executionPercent: float}>>
  247.      */
  248.     public function getGroupedQueries()
  249.     {
  250.         if ($this->groupedQueries !== null) {
  251.             return $this->groupedQueries;
  252.         }
  254.         $this->groupedQueries = [];
  255.         $totalExecutionMS     = 0;
  256.         foreach ($this->data['queries'] as $connection => $queries) {
  257.             $connectionGroupedQueries = [];
  258.             foreach ($queries as $i => $query) {
  259.                 $key = $query['sql'];
  260.                 if (! isset($connectionGroupedQueries[$key])) {
  261.                     $connectionGroupedQueries[$key]                = $query;
  262.                     $connectionGroupedQueries[$key]['executionMS'] = 0;
  263.                     $connectionGroupedQueries[$key]['count']       = 0;
  264.                     $connectionGroupedQueries[$key]['index']       = $i; // "Explain query" relies on query index in 'queries'.
  265.                 }
  267.                 $connectionGroupedQueries[$key]['executionMS'] += $query['executionMS'];
  268.                 $connectionGroupedQueries[$key]['count']++;
  269.                 $totalExecutionMS += $query['executionMS'];
  270.             }
  272.             usort($connectionGroupedQueries, static function ($a, $b) {
  273.                 if ($a['executionMS'] === $b['executionMS']) {
  274.                     return 0;
  275.                 }
  277.                 return $a['executionMS'] < $b['executionMS'] ? 1 : -1;
  278.             });
  279.             $this->groupedQueries[$connection] = $connectionGroupedQueries;
  280.         }
  282.         foreach ($this->groupedQueries as $connection => $queries) {
  283.             foreach ($queries as $i => $query) {
  284.                 $this->groupedQueries[$connection][$i]['executionPercent'] =
  285.                     $this->executionTimePercentage($query['executionMS'], $totalExecutionMS);
  286.             }
  287.         }
  289.         return $this->groupedQueries;
  290.     }
  292.     private function executionTimePercentage(float $executionTimeMS, float $totalExecutionTimeMS): float
  293.     {
  294.         if (! $totalExecutionTimeMS) {
  295.             return 0;
  296.         }
  298.         return $executionTimeMS / $totalExecutionTimeMS * 100;
  299.     }
  301.     /** @return int */
  302.     public function getGroupedQueryCount()
  303.     {
  304.         $count = 0;
  305.         foreach ($this->getGroupedQueries() as $connectionGroupedQueries) {
  306.             $count += count($connectionGroupedQueries);
  307.         }
  309.         return $count;
  310.     }
  311. }