src/Shared/Infrastructure/EventSubscriber/EntityNotManagedDebugSubscriber.php line 42

Open in your IDE?
  1. <?php
  3. declare(strict_types=1);
  5. namespace App\Shared\Infrastructure\EventSubscriber;
  7. use App\Shared\Infrastructure\Observability\ObservabilityLogger;
  8. use Doctrine\ORM\EntityManagerInterface;
  9. use Doctrine\ORM\ORMInvalidArgumentException;
  10. use Doctrine\ORM\UnitOfWork;
  11. use Symfony\Component\EventDispatcher\EventSubscriberInterface;
  12. use Symfony\Component\HttpKernel\Event\ExceptionEvent;
  13. use Symfony\Component\HttpKernel\KernelEvents;
  14. use Throwable;
  16. /**
  17.  * FIX-260601-008 — Captura kernel.exception específica para
  18.  * ORMInvalidArgumentException "is not managed". Vuelca estado del UoW al
  19.  * momento del catch (identityMap class counts + scheduled inserts/updates/
  20.  * deletes + clases de entidades visibles) + ruta + stack trace formateado
  21.  * para identificar el listener / método que detacha la entity.
  22.  *
  23.  * NO modifica el flujo (read-only sobre UoW). NO suprime la exception
  24.  * (sigue propagando al handler estándar). Prioridad alta (1024) para
  25.  * correr antes que cualquier exception handler que envuelva la traza.
  26.  */
  27. final class EntityNotManagedDebugSubscriber implements EventSubscriberInterface
  28. {
  29.     public function __construct(
  30.         private EntityManagerInterface $em,
  31.         private ObservabilityLogger $observabilityLogger
  32.     ) {
  33.     }
  35.     public static function getSubscribedEvents(): array
  36.     {
  37.         return [
  38.             KernelEvents::EXCEPTION => ['onKernelException', 1024],
  39.         ];
  40.     }
  42.     public function onKernelException(ExceptionEvent $event): void
  43.     {
  44.         try {
  45.             $e = $event->getThrowable();
  46.             if (!$e instanceof ORMInvalidArgumentException) {
  47.                 return;
  48.             }
  49.             $msg = $e->getMessage();
  50.             if (stripos($msg, 'is not managed') === false) {
  51.                 return;
  52.             }
  54.             $uow = $this->em->getUnitOfWork();
  56.             $context = [
  57.                 'route'         => $event->getRequest()->attributes->get('_route'),
  58.                 'path'          => $event->getRequest()->getPathInfo(),
  59.                 'method'        => $event->getRequest()->getMethod(),
  60.                 'message_head'  => mb_substr($msg, 0, 240),
  61.                 'identity_map'  => $this->summarizeIdentityMap($uow),
  62.                 'scheduled'     => $this->summarizeScheduled($uow),
  63.                 'stack_top'     => $this->topStackFrames($e, 25),
  64.             ];
  66.             $this->observabilityLogger->safeLog(
  67.                 'critical',
  68.                 '[OBS-DETACHED-CATCH] orm_entity_not_managed',
  69.                 $context
  70.             );
  71.         } catch (Throwable $inner) {
  72.             // swallow.
  73.         }
  74.     }
  76.     /**
  77.      * Cuenta entities por clase + estado al momento del exception.
  78.      */
  79.     private function summarizeIdentityMap(UnitOfWork $uow): array
  80.     {
  81.         $counts = [];
  82.         foreach ($uow->getIdentityMap() as $className => $entities) {
  83.             $byState = ['managed' => 0, 'new' => 0, 'detached' => 0, 'removed' => 0, 'unknown' => 0];
  84.             foreach ($entities as $entity) {
  85.                 try {
  86.                     $state = $uow->getEntityState($entity);
  87.                     switch ($state) {
  88.                         case UnitOfWork::STATE_MANAGED:  $byState['managed']++;  break;
  89.                         case UnitOfWork::STATE_NEW:      $byState['new']++;      break;
  90.                         case UnitOfWork::STATE_DETACHED: $byState['detached']++; break;
  91.                         case UnitOfWork::STATE_REMOVED:  $byState['removed']++;  break;
  92.                         default:                         $byState['unknown']++;
  93.                     }
  94.                 } catch (Throwable $t) {
  95.                     $byState['unknown']++;
  96.                 }
  97.             }
  98.             $counts[$className] = $byState;
  99.         }
  100.         return $counts;
  101.     }
  103.     private function summarizeScheduled(UnitOfWork $uow): array
  104.     {
  105.         $sum = static fn(array $a) => array_count_values(array_map(
  106.             static fn($e) => is_object($e) ? get_class($e) : gettype($e),
  107.             $a
  108.         ));
  109.         return [
  110.             'insertions' => $sum($uow->getScheduledEntityInsertions()),
  111.             'updates'    => $sum($uow->getScheduledEntityUpdates()),
  112.             'deletions'  => $sum($uow->getScheduledEntityDeletions()),
  113.         ];
  114.     }
  116.     /**
  117.      * Top frames del stack trace, filtradas: app + listeners + sonata.
  118.      */
  119.     private function topStackFrames(Throwable $e, int $max): array
  120.     {
  121.         $out = [];
  122.         foreach ($e->getTrace() as $i => $frame) {
  123.             if (count($out) >= $max) break;
  124.             $file = $frame['file'] ?? '';
  125.             $line = $frame['line'] ?? '?';
  126.             $cls  = $frame['class'] ?? '';
  127.             $fn   = $frame['function'] ?? '';
  128.             // Filtramos los irrelevantes (kernel symfony interno reiterativo).
  129.             if (str_contains($file, '/vendor/symfony/http-kernel/HttpKernel.php')) continue;
  130.             $short = preg_replace('#^/var/www/[^/]+/[^/]+/httpdocs/#', '', $file);
  131.             $out[] = sprintf('%s:%s %s%s%s', $short, $line, $cls, $cls ? '::' : '', $fn);
  132.         }
  133.         return $out;
  134.     }
  135. }