vendor/sentry/sentry-symfony/src/EventListener/LoginListener.php line 48

Open in your IDE?
  1. <?php
  3. declare(strict_types=1);
  5. namespace Sentry\SentryBundle\EventListener;
  7. use Sentry\State\HubInterface;
  8. use Sentry\State\Scope;
  9. use Sentry\UserDataBag;
  10. use Symfony\Component\HttpKernel\Event\RequestEvent;
  11. use Symfony\Component\Security\Core\Authentication\Token\Storage\TokenStorageInterface;
  12. use Symfony\Component\Security\Core\Authentication\Token\SwitchUserToken;
  13. use Symfony\Component\Security\Core\Authentication\Token\TokenInterface;
  14. use Symfony\Component\Security\Core\Event\AuthenticationSuccessEvent;
  15. use Symfony\Component\Security\Core\User\UserInterface;
  16. use Symfony\Component\Security\Http\Event\LoginSuccessEvent;
  18. final class LoginListener
  19. {
  20.     use KernelEventForwardCompatibilityTrait;
  22.     /**
  23.      * @var HubInterface The current hub
  24.      */
  25.     private $hub;
  27.     /**
  28.      * @var TokenStorageInterface|null The token storage
  29.      */
  30.     private $tokenStorage;
  32.     /**
  33.      * Constructor.
  34.      *
  35.      * @param HubInterface               $hub          The current hub
  36.      * @param TokenStorageInterface|null $tokenStorage The token storage
  37.      */
  38.     public function __construct(HubInterface $hub, ?TokenStorageInterface $tokenStorage)
  39.     {
  40.         $this->hub = $hub;
  41.         $this->tokenStorage = $tokenStorage;
  42.     }
  44.     /**
  45.      * This method is called for each request handled by the framework and
  46.      * fills the Sentry scope with information about the current user.
  47.      */
  48.     public function handleKernelRequestEvent(RequestEvent $event): void
  49.     {
  50.         if (null === $this->tokenStorage || !$this->isMainRequest($event)) {
  51.             return;
  52.         }
  54.         $token = $this->tokenStorage->getToken();
  56.         if (null !== $token) {
  57.             $this->updateUserContext($token);
  58.         }
  59.     }
  61.     /**
  62.      * This method is called after authentication was fully successful. It allows
  63.      * to set information like the username of the currently authenticated user
  64.      * and of the impersonator, if any, on the Sentry's context.
  65.      */
  66.     public function handleLoginSuccessEvent(LoginSuccessEvent $event): void
  67.     {
  68.         $this->updateUserContext($event->getAuthenticatedToken());
  69.     }
  71.     /**
  72.      * This method is called when an authentication provider authenticates the
  73.      * user. It is the event closest to {@see LoginSuccessEvent} in versions of
  74.      * the framework where it doesn't exist.
  75.      */
  76.     public function handleAuthenticationSuccessEvent(AuthenticationSuccessEvent $event): void
  77.     {
  78.         $this->updateUserContext($event->getAuthenticationToken());
  79.     }
  81.     private function updateUserContext(TokenInterface $token): void
  82.     {
  83.         if (!$this->isTokenAuthenticated($token)) {
  84.             return;
  85.         }
  87.         $client = $this->hub->getClient();
  89.         if (null === $client || !$client->getOptions()->shouldSendDefaultPii()) {
  90.             return;
  91.         }
  93.         $this->hub->configureScope(function (Scope $scope) use ($token): void {
  94.             $user = $scope->getUser() ?? new UserDataBag();
  96.             if (null === $user->getId()) {
  97.                 $user->setId($this->getUserIdentifier($token->getUser()));
  98.             }
  100.             $impersonatorUser = $this->getImpersonatorUser($token);
  102.             if (null !== $impersonatorUser) {
  103.                 $user->setMetadata('impersonator_username', $impersonatorUser);
  104.             }
  106.             $scope->setUser($user);
  107.         });
  108.     }
  110.     private function isTokenAuthenticated(TokenInterface $token): bool
  111.     {
  112.         if (method_exists($token, 'isAuthenticated') && !$token->isAuthenticated(false)) {
  113.             return false;
  114.         }
  116.         return null !== $token->getUser();
  117.     }
  119.     /**
  120.      * @param UserInterface|\Stringable|string|null $user
  121.      */
  122.     private function getUserIdentifier($user): ?string
  123.     {
  124.         if ($user instanceof UserInterface) {
  125.             if (method_exists($user, 'getUserIdentifier')) {
  126.                 return $user->getUserIdentifier();
  127.             }
  129.             if (method_exists($user, 'getUsername')) {
  130.                 return $user->getUsername();
  131.             }
  132.         }
  134.         if (\is_string($user)) {
  135.             return $user;
  136.         }
  138.         if (\is_object($user) && method_exists($user, '__toString')) {
  139.             return (string) $user;
  140.         }
  142.         return null;
  143.     }
  145.     private function getImpersonatorUser(TokenInterface $token): ?string
  146.     {
  147.         if ($token instanceof SwitchUserToken) {
  148.             return $this->getUserIdentifier($token->getOriginalToken()->getUser());
  149.         }
  151.         return null;
  152.     }
  153. }