Thoughtful Performance

Dot it early

Concurrent requests

BAD

$responses[] = Http::post('https://...');
$responses[] = Http::post('https://...');
$responses[] = Http::post('https://...');

GOOD

$responses = Http::pool(fn ($pool) => [
  $pool->get('https://...');
  $pool->get('https://...');
  $pool->get('https://...');
]);

• Documentation

Concurrent processes

BAD

$results[] = Process::run('./reindex.sh');
$results[] = Process::run('./cleanup.sh');

GOOD

$results = Process::concurrently(fn ($pool) => [
  $pool->command('./reindex.sh');
  $pool->command('./cleanup.sh');
]);

• Documentation

Run code concurrently

BAD

$attachments[] = GeneratePdf::dispatchSync($invoice);
$attachments[] = GenerateExcelSpeadsheet::dispatchSync($invoice);
$attachments[] = MarketingCatalogue::latest()->first();

GOOD

$attachments = Fork::new()->run(
  fn () => GeneratePdf::dispatchSync($invoice),
  fn () => GenerateExcelSpeadsheet::dispatchSync($invoice),
  fn () => MarketingCatalogue::latest()->first(),
);

• spatie/fork

Http timeout

BAD

Http::get('https://...');

GOOD

Http::connectTimeout(2)->timeout(5)->get('https://...');

For packages who use Guzzle and not the Http Facade, we can also bind an instance of the Guzzle Client with a specific configuration.

use GuzzleHttp\Client

App::bind(Client:class, fn () => new Client([
  'connect_timeout' => 2,
  'timeout' => 5,
]))

Dot it later

Dispatch after response

BAD

$post->delete();

Activity::log(new PostDeleted($post));

return Redirect::route('dashboard');

• The user has to wait for the activity to be logged before being redirected to the dashboard.

GOOD

$post->delete();

dispatch(function () use ($post) {
  Activity::log(new PostDeleted($post))
})->afterResponse();

return Redirect::route('dashboard');

• Documentation

Hit the cache

Use cache for long db queries

BAD

View::make('home', [
  'sales' => Transaction::sum('amount'),
]);

NOT BAD

$sales = Cache::remember(
  key: 'sales',
  ttl: Interval::hour(),
  callback: fn () => Transaction::sum('amount'),
)

GOOD

public function schedule(Schedule $schedule)
{
  $schedule->warm([
    TotalSales::class,
    // ...
  ])->everyHour();
}

Here is how to implement this :

1. Create a macro

Schedule::macro('warm', function ($classes) {
  return $this->call(function () use ($classes) {
    foreach($classes as $class) {
      App::make($class)->warm();
    }
  });
});

2. Create a class responsible to warm each data we want

class TotalSales
{
  public function warm()
  {
    Cache::put(
      key: 'sales',
      ttl: Interval::hour()->minutes(10),
      callback: $this->resolve(),
    )
  }

  public function resolve()
  {
    return Transaction::sum('amount');
  }

  public function __invoke()
  {
    return Cache::remember(
      key: 'sales',
      ttl: Interval::hour(),
      callback: $this->resolve(...),
    );
  }
}

3. Use it where you need

public function home(TotalSales $sales)
{
  return View::make('home', [
    'sales' => $sales(),
  ])
}

All content written above is coming from the “Thoughtfull Performance” talk given at Laracon EU 2024 by Tim MacDonald.