Puntos importantes

Antes de continuar para aprender en detalle sobre el manejo de errores en Laravel, tenga en cuenta los siguientes puntos importantes:

• Para cualquier proyecto nuevo, Laravel registra errores y excepciones en la clase App \ Exceptions \ Handler, de forma predeterminada. Luego se envían de nuevo al usuario para su análisis.
• Cuando su aplicación Laravel está configurada en modo de depuración, se mostrarán mensajes de error detallados con rastros de pila en cada error que ocurra dentro de su aplicación web.

Registro de errores

El registro de los errores en una aplicación web ayuda a rastrearlos y a planificar una estrategia para eliminarlos. La información de registro se puede configurar en la aplicación web en el archivo config/app.php. Tenga en cuenta los siguientes puntos al tratar con el registro de errores en Laravel:

• Laravel usa la biblioteca de registro PHP monolog.
• Los parámetros de registro que se utilizan para el seguimiento de errores son single, daily, syslog y errorlog.
• Por ejemplo, si desea registrar los mensajes de error en los archivos de registro, debe establecer el valor de registro en la configuración de su aplicación a daily como se muestra en el siguiente comando:

'log' => env('APP_LOG','daily'),'log_max_files' => 25;

Niveles de gravedad

Como Laravel usa la biblioteca de registro PHP monolog, existen varios parámetros que se usan para analizar los niveles de gravedad. Varios niveles de gravedad disponibles son mensajes de error, critical, alert y emergency. Puede establecer el nivel de gravedad como se muestra en el siguiente comando:

'log_level' => env('APP_LOG_LEVEL', 'error')

Para Laravel 8 actualizado así

Para Laravel 8 encontramos nuevos métodos en el handler.php. Comparto este código para manejar excepciones en el proyecto Laravel.

Por defecto, el proyecto Laravel viene con el nuevo método de registro.

/**
 * Register the exception handling callbacks for the application.
 *
 * @return void
 */
public function register()
{

    $this->reportable(function (Throwable $e){

    });
}

Debemos agregar un nuevo método aquí para manejar excepciones.

public function handleException( Throwable $e){
    if ($e instanceof HttpException) {
        $code = $e->getStatusCode();
        $defaultMessage = \Symfony\Component\HttpFoundation\Response::$statusTexts[$code];
        $message = $e->getMessage() == "" ? $defaultMessage : $e->getMessage();
        return $this->errorResponse($message, $code);
    } else if ($e instanceof ModelNotFoundException) {
        $model = strtolower(class_basename($e->getModel()));
        return $this->errorResponse("Does not exist any instance of {$model} with the given id", Response::HTTP_NOT_FOUND);
    } else if ($e instanceof AuthorizationException) {
        return $this->errorResponse($e->getMessage(), Response::HTTP_FORBIDDEN);
    } else if ($e instanceof TokenBlacklistedException) {
        return $this->errorResponse($e->getMessage(), Response::HTTP_UNAUTHORIZED);
    } else if ($e instanceof AuthenticationException) {
        return $this->errorResponse($e->getMessage(), Response::HTTP_UNAUTHORIZED);
    } else if ($e instanceof ValidationException) {
        $errors = $e->validator->errors()->getMessages();
        return $this->errorResponse($errors, Response::HTTP_UNPROCESSABLE_ENTITY);
    } else {
        if (config('app.debug'))
            return $this->dataResponse($e->getMessage());
        else {
            return $this->errorResponse('Try later', Response::HTTP_INTERNAL_SERVER_ERROR);
        }
    }
}

Verá métodos para la respuesta como se llama. Por ejemplo

return $this->errorResponse('Try later', Response::HTTP_INTERNAL_SERVER_ERROR);

Creo un rasgo para las respuestas. Usted también puede hacerlo. Comparto el rasgo:

/**
 * Data Response
 * @param $data
 * @return JsonResponse
 */
public function dataResponse($data): JsonResponse
{
    return response()->json(['content' => $data], Response::HTTP_OK);
}

/**
 * Success Response
 * @param string $message
 * @param int $code
 * @return JsonResponse
 */
public function successResponse(string $message, $code = Response::HTTP_OK): JsonResponse
{
    return response()->json(['success' => $message, 'code' => $code], $code);
}

/**
 * Error Response
 * @param $message
 * @param int $code
 * @return JsonResponse
 *
 */
public function errorResponse($message, $code = Response::HTTP_BAD_REQUEST): JsonResponse
{
    return response()->json(['error' => $message, 'code' => $code], $code);
}

Después de crear este rasgo y crear la función handleException, agrega código al método de register.

$this->renderable(function (Throwable $e) {
    return $this->handleException($e);
});

Después de eso, el cuerpo de la función se verá así.

public function register()
{

    $this->reportable(function (Throwable $e){

    });

    $this->renderable(function (Throwable $e) {
        return $this->handleException($e);
    });
}

Y después de todo, su manejo de excepciones y errores funciona muy bien.

¡Gracias por leer!