Buzz React Laravel Package

Getting Started

Minimal Setup

1. Installation

   composer require clue/buzz-react
   

   Ensure your project uses ReactPHP (v1.0+) as the event loop.

2. Basic Request

   use Buzz\Client\React\Client;
   use React\EventLoop\Factory;
   
   $loop = Factory::create();
   $client = new Client($loop);
   
   $promise = $client->get('https://api.example.com/data');
   $promise->then(
       function ($response) {
           echo $response->getBody();
       },
       function ($error) {
           echo "Error: " . $error->getMessage();
       }
   );
   
   $loop->run();
   

3. First Use Case Fetch multiple endpoints concurrently:

   $promises = [
       $client->get('https://api1.example.com'),
       $client->get('https://api2.example.com'),
   ];
   
   \React\Promise\all($promises)->then(
       function ($responses) {
           foreach ($responses as $response) {
               echo $response->getBody();
           }
       }
   );
   

Implementation Patterns

Async Workflows

• Chaining Requests Use then() to chain dependent requests:

  $client->get('https://api.example.com/token')
      ->then(function ($response) {
          $token = json_decode($response->getBody(), true)['token'];
          return $client->get('https://api.example.com/protected', [
              'headers' => ['Authorization' => "Bearer $token"]
          ]);
      });
  

• Retry Logic Implement exponential backoff with React\Promise\retry:

  use React\Promise\Timer\TimeoutException;
  
  $retry = \React\Promise\retry(
      3,
      function ($attempt) use ($client) {
          return $client->get('https://api.example.com')
              ->otherwise(function ($error) {
                  throw new TimeoutException("Retry $attempt failed", 0, $error);
              });
      }
  );
  

Integration with Laravel

• Service Provider Bind Client to Laravel’s container:

  public function register()
  {
      $this->app->singleton(Client::class, function ($app) {
          $loop = Factory::create();
          return new Client($loop);
      });
  }
  

• Queue Workers Use ReactPHP with Laravel Queues (via spatie/react-queue):

  $loop = Factory::create();
  $client = new Client($loop);
  
  $loop->addPeriodicTimer(1, function () use ($client) {
      $client->get('https://api.example.com/queue')->then(...);
  });
  

• Middleware Attach middleware for logging/headers:

  $client = new Client($loop);
  $client->setMiddleware(function ($request, $next) {
      $request = $request->withHeader('X-Custom-Header', 'value');
      return $next($request);
  });
  

Gotchas and Tips

Common Pitfalls

1. Event Loop Management

   • Issue: Forgetting to run $loop->run() blocks execution.
   • Fix: Use ReactPHP in CLI commands or Laravel’s Artisan with a custom loop:

     $loop = Factory::create();
     $loop->run();
     

2. Memory Leaks

   • Issue: Unclosed responses or promises can leak memory.
   • Fix: Always chain .done() or use React\Promise\Timer for cleanup:

     $promise->done(); // Ensures promise is settled
     

3. Deprecation Warning

   • Issue: Package is deprecated (last release: 2020). Consider alternatives like:
     • react/http (modern ReactPHP client).
     • guzzlehttp/guzzle with async adapters.

Debugging Tips

• Enable ReactPHP Debug Mode

  $loop->addPeriodicTimer(0.1, function () {
      echo "Loop running...\n";
  });
  

• Log Promises Use React\Promise\Timer\TimeoutException to catch hangs:

  $promise->otherwise(function ($error) {
      \Log::error("Promise failed: " . $error->getMessage());
  });
  

Extension Points

1. Custom Transports Override Client to use a proxy or custom transport:

   class CustomClient extends Client {
       protected function createTransport() {
           return new CustomTransport($this->loop);
       }
   }
   

2. Response Transformers Decorate responses for consistency:

   $client->setMiddleware(function ($request, $next) {
       return $next($request)->then(function ($response) {
           return new class($response) implements \Psr\Http\Message\ResponseInterface {
               // Custom logic
           };
       });
   });
   

3. Rate Limiting Use React\Promise\Timer to throttle requests:

   $lastRequest = 0;
   $client->get('https://api.example.com')->then(function () use (&$lastRequest) {
       $lastRequest = time();
   });
   
   // Throttle to 1 request per second
   $loop->addPeriodicTimer(1, function () use ($client, &$lastRequest) {
       if (time() - $lastRequest > 1) {
           $client->get('https://api.example.com');
       }
   });