Use event to handle error formatting

Author: Jeremiah VALERIE

DependencyInjection/Configuration.php

@@ -5,12 +5,16 @@
 use GraphQL\Type\Schema;
 use Overblog\GraphQLBundle\CacheWarmer\CompileCacheWarmer;
 use Overblog\GraphQLBundle\Config\Processor\BuilderProcessor;
+use Overblog\GraphQLBundle\Error\ErrorHandler;
 use Overblog\GraphQLBundle\Event\Events;
 use Overblog\GraphQLBundle\EventListener\ClassLoaderListener;
 use Overblog\GraphQLBundle\EventListener\DebugListener;
+use Overblog\GraphQLBundle\EventListener\ErrorHandlerListener;
+use Overblog\GraphQLBundle\EventListener\ErrorLoggerListener;
 use Symfony\Component\Cache\Adapter\ArrayAdapter;
 use Symfony\Component\Config\FileLocator;
 use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\ContainerInterface;
 use Symfony\Component\DependencyInjection\Definition;
 use Symfony\Component\DependencyInjection\Extension\PrependExtensionInterface;
 use Symfony\Component\DependencyInjection\Loader\YamlFileLoader;
@@ -34,7 +38,7 @@ public function load(array $configs, ContainerBuilder $container)
  $this->setServicesAliases($config, $container);
  $this->setSchemaBuilderArguments($config, $container);
  $this->setSchemaArguments($config, $container);
- $this->setErrorHandlerArguments($config, $container);
+ $this->setErrorHandler($config, $container);
  $this->setSecurity($config, $container);
  $this->setConfigBuilders($config, $container);
  $this->setDebugListener($config, $container);
@@ -58,7 +62,7 @@ public function prepend(ContainerBuilder $container)
 
  public function getAlias()
  {
- return 'overblog_graphql';
+ return Configuration::NAME;
  }
 
  public function getConfiguration(array $config, ContainerBuilder $container)
@@ -167,28 +171,44 @@ private function setSecurity(array $config, ContainerBuilder $container)
  }
  }
 
- private function setErrorHandlerArguments(array $config, ContainerBuilder $container)
+ private function setErrorHandler(array $config, ContainerBuilder $container)
  {
- $errorHandlerDefinition = $container->getDefinition($this->getAlias().'.error_handler');
-
- if (isset($config['definitions']['internal_error_message'])) {
- $errorHandlerDefinition->replaceArgument(0, $config['definitions']['internal_error_message']);
- }
-
- if (isset($config['definitions']['map_exceptions_to_parent'])) {
- $errorHandlerDefinition->replaceArgument(
- 3,
- $config['definitions']['map_exceptions_to_parent']
- );
- }
+ if ($config['errors_handler']['enabled']) {
+ $id = $this->getAlias().'.error_handler';
+ $errorHandlerDefinition = $container->setDefinition($id, new Definition(ErrorHandler::class));
+ $errorHandlerDefinition->setPublic(false)
+ ->setArguments(
+ [
+ new Reference('event_dispatcher'),
+ $config['errors_handler']['internal_error_message'],
+ $this->buildExceptionMap($config['errors_handler']['exceptions']),
+ $config['errors_handler']['map_exceptions_to_parent'],
+ ]
+ )
+ ->addMethodCall('setUserWarningClass', [$config['errors_handler']['exceptions']['types']['warnings']])
+ ->addMethodCall('setUserErrorClass', [$config['errors_handler']['exceptions']['types']['errors']])
+ ;
 
- if (isset($config['definitions']['exceptions'])) {
- $errorHandlerDefinition
- ->replaceArgument(2, $this->buildExceptionMap($config['definitions']['exceptions']))
- ->addMethodCall('setUserWarningClass', [$config['definitions']['exceptions']['types']['warnings']])
- ->addMethodCall('setUserErrorClass', [$config['definitions']['exceptions']['types']['errors']])
- ->addMethodCall('setErrorFormatter', [$config['definitions']['error_formatter']])
+ $errorHandlerListenerDefinition = $container->setDefinition(ErrorHandlerListener::class, new Definition(ErrorHandlerListener::class));
+ $errorHandlerListenerDefinition->setPublic(true)
+ ->setArguments([new Reference($id), $config['errors_handler']['rethrow_internal_exceptions'], $config['errors_handler']['debug']])
+ ->addTag('kernel.event_listener', ['event' => Events::POST_EXECUTOR, 'method' => 'onPostExecutor'])
  ;
+
+ if ($config['errors_handler']['log']) {
+ $loggerServiceId = $config['errors_handler']['logger_service'];
+ $invalidBehavior = ErrorLoggerListener::DEFAULT_LOGGER_SERVICE === $loggerServiceId ? ContainerInterface::NULL_ON_INVALID_REFERENCE : ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE;
+ $errorHandlerListenerDefinition = $container->setDefinition(ErrorLoggerListener::class, new Definition(ErrorLoggerListener::class));
+ $errorHandlerListenerDefinition->setPublic(true)
+ ->setArguments([
+ new Reference($loggerServiceId, $invalidBehavior),
+ $config['errors_handler']['exceptions']['types']['errors'],
+ $config['errors_handler']['exceptions']['types']['warnings'],
+ ]
+ )
+ ->addTag('kernel.event_listener', ['event' => Events::ERROR_FORMATTING, 'method' => 'onErrorFormatting'])
+ ;
+ }
  }
  }
 

DependencyInjection/OverblogGraphQLExtension.php

@@ -2,24 +2,24 @@
 
 namespace Overblog\GraphQLBundle\Error;
 
+use GraphQL\Error\ClientAware;
+use GraphQL\Error\Debug;
 use GraphQL\Error\Error as GraphQLError;
 use GraphQL\Error\FormattedError;
 use GraphQL\Error\UserError as GraphQLUserError;
 use GraphQL\Executor\ExecutionResult;
-use Psr\Log\LoggerInterface;
-use Psr\Log\LogLevel;
-use Psr\Log\NullLogger;
+use Overblog\GraphQLBundle\Event\ErrorFormattingEvent;
+use Overblog\GraphQLBundle\Event\Events;
+use Symfony\Component\EventDispatcher\EventDispatcherInterface;
 
 class ErrorHandler
 {
  const DEFAULT_ERROR_MESSAGE = 'Internal server Error';
  const DEFAULT_USER_WARNING_CLASS = UserWarning::class;
  const DEFAULT_USER_ERROR_CLASS = UserError::class;
- /** callable */
- const DEFAULT_ERROR_FORMATTER = [FormattedError::class, 'createFromException'];
 
- /** @var LoggerInterface */
- private $logger;
+ /** @var EventDispatcherInterface */
+ private $dispatcher;
 
  /** @var string */
  private $internalErrorMessage;
@@ -33,19 +33,16 @@ class ErrorHandler
  /** @var string */
  private $userErrorClass = self::DEFAULT_USER_ERROR_CLASS;
 
- /** @var callable|null */
- private $errorFormatter;
-
  /** @var bool */
  private $mapExceptionsToParent;
 
  public function __construct(
+ EventDispatcherInterface $dispatcher,
  $internalErrorMessage = null,
- LoggerInterface $logger = null,
  array $exceptionMap = [],
  $mapExceptionsToParent = false
  ) {
- $this->logger = (null === $logger) ? new NullLogger() : $logger;
+ $this->dispatcher = $dispatcher;
  if (empty($internalErrorMessage)) {
  $internalErrorMessage = self::DEFAULT_ERROR_MESSAGE;
  }
@@ -68,43 +65,32 @@ public function setUserErrorClass($userErrorClass)
  return $this;
  }
 
- public function setErrorFormatter(callable $errorFormatter = null)
- {
- $this->errorFormatter = $errorFormatter;
-
- return $this;
- }
-
- /**
- * @param \Exception|\Error $exception
- * @param string $errorLevel
- */
- public function logException($exception, $errorLevel = LogLevel::ERROR)
- {
- $message = sprintf(
- '%s: %s[%d] (caught exception) at %s line %s.',
- get_class($exception),
- $exception->getMessage(),
- $exception->getCode(),
- $exception->getFile(),
- $exception->getLine()
- );
-
- $this->logger->$errorLevel($message, ['exception' => $exception]);
- }
-
- public function handleErrors(ExecutionResult $executionResult, $throwRawException = false)
+ public function handleErrors(ExecutionResult $executionResult, $throwRawException = false, $debug = false)
  {
- $errorFormatter = $this->errorFormatter ? $this->errorFormatter : self::DEFAULT_ERROR_FORMATTER;
+ $errorFormatter = $this->createErrorFormatter($debug);
  $executionResult->setErrorFormatter($errorFormatter);
- FormattedError::setInternalErrorMessage($this->internalErrorMessage);
  $exceptions = $this->treatExceptions($executionResult->errors, $throwRawException);
  $executionResult->errors = $exceptions['errors'];
  if (!empty($exceptions['extensions']['warnings'])) {
  $executionResult->extensions['warnings'] = array_map($errorFormatter, $exceptions['extensions']['warnings']);
  }
  }
 
+ private function createErrorFormatter($debug = false)
+ {
+ $debugMode = false;
+ if ($debug) {
+ $debugMode = Debug::INCLUDE_TRACE | Debug::INCLUDE_DEBUG_MESSAGE;
+ }
+
+ return function (GraphQLError $error) use ($debugMode) {
+ $event = new ErrorFormattingEvent($error, FormattedError::createFromException($error, $debugMode, $this->internalErrorMessage));
+ $this->dispatcher->dispatch(Events::ERROR_FORMATTING, $event);
+
+ return $event->getFormattedError()->getArrayCopy();
+ };
+ }
+
  /**
  * @param GraphQLError[] $errors
  * @param bool $throwRawException
@@ -145,18 +131,12 @@ private function treatExceptions(array $errors, $throwRawException)
  // user error
  if ($rawException instanceof $this->userErrorClass) {
  $treatedExceptions['errors'][] = $errorWithConvertedException;
- if ($rawException->getPrevious()) {
- $this->logException($rawException->getPrevious());
- }
  continue;
  }
 
  // user warning
  if ($rawException instanceof $this->userWarningClass) {
  $treatedExceptions['extensions']['warnings'][] = $errorWithConvertedException;
- if ($rawException->getPrevious()) {
- $this->logException($rawException->getPrevious(), LogLevel::WARNING);
- }
  continue;
  }
 
@@ -165,8 +145,6 @@ private function treatExceptions(array $errors, $throwRawException)
  throw $rawException;
  }
 
- $this->logException($rawException, LogLevel::CRITICAL);
-
  $treatedExceptions['errors'][] = $errorWithConvertedException;
  }
 
@@ -208,8 +186,8 @@ private function flattenErrors(array $errors)
  */
  private function convertException($rawException = null)
  {
- if (null === $rawException) {
- return;
+ if (null === $rawException || $rawException instanceof ClientAware) {
+ return $rawException;
  }
 
  $errorClass = $this->findErrorClass($rawException);

Error/ErrorHandler.php

@@ -0,0 +1,34 @@
+<?php
+
+namespace Overblog\GraphQLBundle\Event;
+
+use GraphQL\Error\Error;
+use Symfony\Component\EventDispatcher\Event;
+
+final class ErrorFormattingEvent extends Event
+{
+ /** @var Error */
+ private $error;
+
+ /** @var \ArrayObject */
+ private $formattedError;
+
+ public function __construct(Error $error, array $formattedError)
+ {
+ $this->error = $error;
+ $this->formattedError = new \ArrayObject($formattedError);
+ }
+
+ public function getError()
+ {
+ return $this->error;
+ }
+
+ /**
+ * @return \ArrayObject
+ */
+ public function getFormattedError()
+ {
+ return $this->formattedError;
+ }
+}

Event/ErrorFormattingEvent.php

@@ -7,4 +7,5 @@ final class Events
  const EXECUTOR_CONTEXT = 'graphql.executor.context';
  const PRE_EXECUTOR = 'graphql.pre_executor';
  const POST_EXECUTOR = 'graphql.post_executor';
+ const ERROR_FORMATTING = 'graphql.error_formatting';
 }

Event/Events.php

@@ -4,7 +4,7 @@
 
 use Symfony\Component\EventDispatcher\Event;
 
-class ExecutorContextEvent extends Event
+final class ExecutorContextEvent extends Event
 {
  /** @var \ArrayObject */
  private $executorContext;

Event/ExecutorContextEvent.php

@@ -5,7 +5,7 @@
 use GraphQL\Type\Schema;
 use Symfony\Component\EventDispatcher\Event;
 
-class ExecutorEvent extends Event
+final class ExecutorEvent extends Event
 {
  /** @var Schema */
  private $schema;

Event/ExecutorEvent.php

@@ -5,7 +5,7 @@
 use GraphQL\Executor\ExecutionResult;
 use Symfony\Component\EventDispatcher\Event;
 
-class ExecutorResultEvent extends Event
+final class ExecutorResultEvent extends Event
 {
  /** @var ExecutionResult */
  private $result;

Event/ExecutorResultEvent.php

@@ -4,7 +4,7 @@
 
 use Overblog\GraphQLBundle\Generator\TypeGenerator;
 
-class ClassLoaderListener
+final class ClassLoaderListener
 {
  private $typeGenerator;
 

EventListener/ClassLoaderListener.php

@@ -4,7 +4,7 @@
 
 use Overblog\GraphQLBundle\Event\ExecutorResultEvent;
 
-class DebugListener
+final class DebugListener
 {
  /** @var float */
  private $startTime;