Exception\NotFoundHttpException error ?

@jmpalacios Unfortunately I did not find any solution for this issue still facing it!

@Jean_ali Thanks for the confirmation! I'll keep searching and post here whatever solution I find.

@jmpalacios You should not need to log 404 errors. These will happen all the time, from malicious probes, web crawlers and even your browser trying to load source maps for compiled assets.

@Snapey So what is the code that I make 404 error not sent to log!?

@Jean_ali @snapey I think I figured it out!

I'm aware that 404 errors will happen all the time, and I'm also aware 4xx HTTP errors shouldn't be reported in the error log, and what's confusing me precisely is the fact they're being reported, which in my case only just started happening rather recently for my application.

And where I think the mystery lies is in the exception handler's reporting facilities. Recently, for a number of reasons, I decided to log token mismatch errors for a specific route in my application, for which I overrode Illuminate\Foundation\Exceptions\Handler's $internalDontReport array in App\Exceptions\Handler, to remove Illuminate\Session\TokenMismatchException from it while keeping its other entries, which as of Laravel 8.x includes Symfony\Component\HttpKernel\Exception\HttpException, parent to Symfony\Component\HttpKernel\Exception\NotFoundHttpException.

But what's most probably going on in my case is that in App\Exceptions\Handler I failed to import the symbols for those other exceptions in $internalDontReport, so now the symbol name HttpException::class is resolving to App\Exceptions\HttpException, rather than the intended Symfony\Component\HttpKernel\Exception\HttpException, and hence failing the $e instanceof $type test in Illuminate\Foundation\Exceptions->shouldntReport().

If that's correct, which I'm about to test, my application should continue producing 404 errors, of course, but it should no longer report them. I'll inform here once I gather data for that.

Indeed, my presumption was right! I wrote a test (which I can share if anyone likes) that failed right away, and turned to green just upon importing the correct symbols in App\Exceptions\Handler.

So, with this deployed to my application, HTTP 4xx errors will hopefully no longer be reported.

@jmpalacios Can you share it please

@Jean_ali If you mean the test, here you go:

<?php

declare(strict_types=1);

namespace App\Exceptions;

(…)

class Handler extends ExceptionHandler
{

(…)

    /**
     * A list of the internal exception types that should not be reported.
     * Overridden to remove TokenMismatchException.
     *
     * @var string[]
     */
    protected $internalDontReport = [
        AuthenticationException::class,
        AuthorizationException::class,
        HttpException::class,
        HttpResponseException::class,
        ModelNotFoundException::class,
        MultipleRecordsFoundException::class,
        RecordsNotFoundException::class,
        SuspiciousOperationException::class,
        ValidationException::class,
    ];

    /**
     * Determine if the exception should be reported.
     * Overridden solely to change the method's visibility.
     */
    public function shouldntReport(Throwable $e): bool
    {
        return parent::shouldntReport($e);
    }
}

<?php

declare(strict_types=1);

namespace Tests\Unit;

use App\Exceptions\Handler;
use Illuminate\Auth\Access\AuthorizationException;
use Illuminate\Auth\AuthenticationException;
use Illuminate\Contracts\Container\Container;
use Illuminate\Database\Eloquent\ModelNotFoundException;
use Illuminate\Database\MultipleRecordsFoundException;
use Illuminate\Database\RecordsNotFoundException;
use Illuminate\Http\Exceptions\HttpResponseException;
use Illuminate\Session\TokenMismatchException;
use Illuminate\Validation\ValidationException;
use stdClass;
use Symfony\Component\HttpFoundation\Exception\SuspiciousOperationException;
use Symfony\Component\HttpKernel\Exception\HttpException;
use Symfony\Component\HttpFoundation\Response;
use Tests\TestCase;
use Throwable;

class ExceptionHandlerTest extends TestCase
{
    protected array $internalDontReport = [
        AuthenticationException::class,
        AuthorizationException::class,
        HttpException::class,
        HttpResponseException::class,
        ModelNotFoundException::class,
        MultipleRecordsFoundException::class,
        RecordsNotFoundException::class,
        SuspiciousOperationException::class,
        ValidationException::class,
    ];

    protected array $shouldReport = [
        TokenMismatchException::class,
    ];

    protected Handler $handler;

    protected function setUp(): void
    {
        parent::setUp();
        $this->handler = new Handler($this->createMock(Container::class));
    }

    protected function newThrowable(string $type): Throwable
    {
        switch ($type) {
            case HttpException::class:
                $e = new $type(500);
                break;

            case HttpResponseException::class:
                $e = new $type(new Response());
                break;

            case ValidationException::class:
                $e = new $type(new stdClass());
                break;

            default:
                $e = new $type();
        }

        return $e;
    }

    /**
     * @test
     */
    public function selectExceptionsShouldNotBeReported(): void
    {
        collect($this->internalDontReport)->each(function (string $type, int $key): void {
            $this->assertTrue($this->handler->shouldntReport($this->newThrowable($type)));
        });
    }

    /**
     * @test
     */
    public function selectExceptionsShouldBeReported(): void
    {
        collect($this->shouldReport)->each(function (string $type, int $key): void {
            $this->assertTrue($this->handler->shouldReport($this->newThrowable($type)));
        });
    }
}

That test fails if you don't import the exception symbols in App\Exceptions\Handler, but as soon as you do it goes right back to green and, at least in my case, HTTP 4xx exceptions stopped being reported in the error log.

@jmpalacios Can I put your exceptions in dontReport? & what is different with your way?

protected $dontReport = [
        //your exceptions 
    ];

@Jean_ali Thing is, in the case of Illuminate\Session\TokenMismatchException, I did want to report it (not always, just under very specific circumstances), so registering a handler for it with Illuminate\Foundation\Exceptions->reportable() was not sufficient because it's by default in $internalDontReport[], and Illuminate\Foundation\Exceptions->report() always checks that first through Illuminate\Foundation\Exceptions->shouldntReport(), so the only workaround I found was to override the $internalDontReport array to remove TokenMismatchException.

But if there's a better way, please, I'm all ears!

@Snapey I link with slack like this:

in  App\Exceptions\Handler

public function report(Throwable $exception)
    {
        Log::channel('slack')->error($exception);
    }

@Jean_ali What do you have in dontReport ?

@Snapey

class Handler extends ExceptionHandler
{
 
    protected $dontReport = [
        //
    ];

    protected $dontFlash = [
        'password',
        'password_confirmation',
    ];

    public function report(Throwable $exception)
    {
        Log::channel('slack')->error($exception);
    }
}

@Jean_ali add into the don't report array

    \Symfony\Component\HttpKernel\Exception\HttpException::class,

However, I note in the error handler docs;

Behind the scenes, Laravel already ignores some types of errors for you, such as exceptions resulting from 404 HTTP "not found" errors or 419 HTTP responses generated by invalid CSRF tokens.

So, it sounds like this is broken in some way.

@YassineEl204 Please do not reply to old & solved threads. If you have a question create a new forum post & detail your issue, so we can help you. By responding to an old thread like this, no one will help you.