Some work has to happen on every page view — recording an analytic, touching a cache, noting that something was seen — and none of it should make the visitor wait. Invision Community supports this, but the pieces are not obvious and the method that looks right is the wrong one.

core/Loader is the only per-request extension point

Dispatcher\Front invokes exactly one extension point on every front-end request, and it invokes it three times:

// early, while building the page
foreach ( Application::allExtensions( 'core', 'Loader' ) as $loader )
{
    foreach ( $loader->js() as $js )   { ... }
    foreach ( $loader->css() as $css ) { ... }
}

// before dispatch, first one wins
foreach ( Application::allExtensions( 'core', 'Loader' ) as $loader )
{
    if ( $redirect = $loader->checkForRedirect() ) { Output::i()->redirect( $redirect ); }
}

// at the end
foreach ( Application::allExtensions( 'core', 'Loader' ) as $loader )
{
    $loader->onFinish();
}

Despite the name, core/Loader is not only for assets. onFinish() is a general end-of-request hook, and it is the supported place for per-request work.

onFinish() does NOT run after the response

This is the trap. Front::finish() calls onFinish() and then calls parent::finish(), which is what actually sends the page:

foreach ( Application::allExtensions( 'core', 'Loader' ) as $loader )
{
    $loader->onFinish();
}

parent::finish();   // <- Output::sendOutput() happens in here

So anything done directly inside onFinish() delays the response. A database write there is time the visitor spends looking at a blank tab.

The part that makes it work

Output::sendOutput() ends like this:

/* Flush and exit */
@ob_end_flush();
@flush();

/* If using PHP-FPM, close the request so that __destruct tasks are run after
    data is flushed to the browser */
if( function_exists( 'fastcgi_finish_request' ) )
{
    fastcgi_finish_request();
}

exit;

Core deliberately releases the connection and keeps executing — and exit still runs shutdown functions and destructors. So the pattern is:

Gather what you need in onFinish() from data already in memory, and register a shutdown function to do the writing.

public function onFinish(): void
{
    try
    {
        $row = array( /* ... built from Request/Member/$_SERVER, no queries ... */ );

        register_shutdown_function( static function () use ( $row ) {
            try
            {
                \IPS\Db::i()->insert( 'myapp_events', $row );
            }
            catch ( \Throwable $e )
            {
                /* the visitor already has their page */
            }
        } );
    }
    catch ( \Throwable $e )
    {
        /* never break a page */
    }
}

Under PHP-FPM the write happens after the browser has the page. Without FPM the shutdown function still runs after the output has been flushed, so it is never worse than doing the work inline.

Rules for anything on this hook

• Do no reads. Use what is already in memory — Request::i(), Member::loggedIn(), $_SERVER. A query here runs on every page on the site.
• Swallow everything. This code runs during somebody reading a topic. An uncaught exception is their broken page.
• Guard against running twice with a static flag, in case the hook fires more than once in one request.
• Skip AJAX if you are counting page views — Request::i()->isAjax() — or every figure you produce will be inflated.
• One statement. Even after the response, the PHP-FPM worker is still occupied and cannot serve anyone else until the script ends.

🚨 And the one that takes the whole site down

If you register a core/Loader extension you must implement js() and css() correctly even when you have no assets, because the dispatcher merges each returned element:

foreach ( $loader->js() as $js ) { $jsFiles = array_merge( $jsFiles, $js ); }

Each element must itself be an array. Returning array( $url ) throws inside the dispatcher and every front page on the site returns a 500 — not just yours, and with nothing in the trace naming the application responsible.

public function js(): array  { return array(); }               // safe: no assets
public function css(): array { return array( array( $url ) ); } // an array OF arrays

An empty array is safe, because the loop simply does not run.

Verified against

Invision Community 5.0.19, by reading system/Dispatcher/Front.php, system/Dispatcher/Dispatcher.php, system/Output/Output.php and system/Extensions/LoaderAbstract.php.

Related: Your background task is running inside a visitor's page load, The core/Queue extension in Invision Community 5, The report that shows nothing: only_full_group_by, and why catching the exception is the real bug, A realtime gateway will let any member join any channel unless you sign the channel into the token

Related application: Pulse — Pulse records page views with this pattern, gathering the row in onFinish() and writing it from a shutdown function once the response has gone.