fix: lazy load Redis connection to prevent boot-time errors

sylvesterdamgaard · sylvesterdamgaard · commit 58dbd606a312 · 2025-11-19T00:11:24.000+01:00
Redis connection is now initialized on first use instead of in constructor.
This prevents connection errors during package discovery and composer install
when Redis is not available.
diff --git a/src/Support/RedisMetricsStore.php b/src/Support/RedisMetricsStore.php
@@ -11,28 +11,46 @@
  * Simple wrapper around Laravel's Redis for queue metrics storage.
  * Uses Laravel's Redis connection directly instead of abstraction layer.
  */
-final readonly class RedisMetricsStore
+final class RedisMetricsStore
 {
-    private Connection $redis;
+    private ?Connection $redis = null;
 
-    private string $prefix;
+    private ?string $prefix = null;
 
-    public function __construct()
+    /**
+     * Get Redis connection (lazy loaded).
+     */
+    private function getRedis(): Connection
+    {
+        if ($this->redis === null) {
+            /** @var string $connection */
+            $connection = config('queue-metrics.storage.connection', 'default');
+            $this->redis = Redis::connection($connection);
+        }
+
+        return $this->redis;
+    }
+
+    /**
+     * Get prefix (lazy loaded).
+     */
+    private function getPrefix(): string
     {
-        /** @var string $connection */
-        $connection = config('queue-metrics.storage.connection', 'default');
-        $this->redis = Redis::connection($connection);
-        /** @var string $prefix */
-        $prefix = config('queue-metrics.storage.prefix', 'queue_metrics');
-        $this->prefix = $prefix;
+        if ($this->prefix === null) {
+            /** @var string $prefix */
+            $prefix = config('queue-metrics.storage.prefix', 'queue_metrics');
+            $this->prefix = $prefix;
+        }
+
+        return $this->prefix;
     }
 
     /**
      * Build a Redis key from segments.
      */
     public function key(string ...$segments): string
     {
-        return $this->prefix.':'.implode(':', $segments);
+        return $this->getPrefix().':'.implode(':', $segments);
     }
 
     /**
@@ -49,7 +67,7 @@ public function getTtl(string $type): int
      */
     public function connection(): Connection
     {
-        return $this->redis;
+        return $this->getRedis();
     }
 
     /**
@@ -67,10 +85,11 @@ public function driver(): self
      */
     public function setHash(string $key, array $data, ?int $ttl = null): void
     {
-        $this->redis->hmset($key, $data);
+        $redis = $this->getRedis();
+        $redis->hmset($key, $data);
 
         if ($ttl !== null) {
-            $this->redis->expire($key, $ttl);
+            $redis->expire($key, $ttl);
         }
     }
 
@@ -79,22 +98,23 @@ public function setHash(string $key, array $data, ?int $ttl = null): void
      */
     public function getHash(string $key): array
     {
-        $result = $this->redis->hgetall($key);
+        $result = $this->getRedis()->hgetall($key);
 
         return is_array($result) ? $result : [];
     }
 
     public function getHashField(string $key, string $field): mixed
     {
-        return $this->redis->hget($key, $field);
+        return $this->getRedis()->hget($key, $field);
     }
 
     public function incrementHashField(string $key, string $field, int|float $value): void
     {
+        $redis = $this->getRedis();
         if (is_float($value)) {
-            $this->redis->hincrbyfloat($key, $field, $value);
+            $redis->hincrbyfloat($key, $field, $value);
         } else {
-            $this->redis->hincrby($key, $field, $value);
+            $redis->hincrby($key, $field, $value);
         }
     }
 
@@ -103,10 +123,10 @@ public function incrementHashField(string $key, string $field, int|float $value)
      */
     public function addToSortedSet(string $key, array $membersWithScores, ?int $ttl = null): void
     {
-        $this->redis->zadd($key, $membersWithScores);
+        $this->getRedis()->zadd($key, $membersWithScores);
 
         if ($ttl !== null) {
-            $this->redis->expire($key, $ttl);
+            $this->getRedis()->expire($key, $ttl);
         }
     }
 
@@ -115,35 +135,35 @@ public function addToSortedSet(string $key, array $membersWithScores, ?int $ttl
      */
     public function getSortedSetByRank(string $key, int $start, int $stop): array
     {
-        return $this->redis->zrange($key, $start, $stop);
+        return $this->getRedis()->zrange($key, $start, $stop);
     }
 
     /**
      * @return array<int, string>
      */
     public function getSortedSetByScore(string $key, string $min, string $max): array
     {
-        return $this->redis->zrangebyscore($key, $min, $max);
+        return $this->getRedis()->zrangebyscore($key, $min, $max);
     }
 
     public function countSortedSetByScore(string $key, string $min, string $max): int
     {
-        return (int) $this->redis->zcount($key, $min, $max);
+        return (int) $this->getRedis()->zcount($key, $min, $max);
     }
 
     public function removeSortedSetByRank(string $key, int $start, int $stop): int
     {
-        return (int) $this->redis->zremrangebyrank($key, $start, $stop);
+        return (int) $this->getRedis()->zremrangebyrank($key, $start, $stop);
     }
 
     public function removeSortedSetByScore(string $key, string $min, string $max): int
     {
-        return (int) $this->redis->zremrangebyscore($key, $min, $max);
+        return (int) $this->getRedis()->zremrangebyscore($key, $min, $max);
     }
 
     public function removeFromSortedSet(string $key, string $member): void
     {
-        $this->redis->zrem($key, $member);
+        $this->getRedis()->zrem($key, $member);
     }
 
     /**
@@ -152,7 +172,7 @@ public function removeFromSortedSet(string $key, string $member): void
     public function addToSet(string $key, array $members): void
     {
         if (! empty($members)) {
-            $this->redis->sadd($key, $members);
+            $this->getRedis()->sadd($key, $members);
         }
     }
 
@@ -161,7 +181,7 @@ public function addToSet(string $key, array $members): void
      */
     public function getSetMembers(string $key): array
     {
-        return $this->redis->smembers($key);
+        return $this->getRedis()->smembers($key);
     }
 
     /**
@@ -170,22 +190,22 @@ public function getSetMembers(string $key): array
     public function removeFromSet(string $key, array $members): void
     {
         if (! empty($members)) {
-            $this->redis->srem($key, $members);
+            $this->getRedis()->srem($key, $members);
         }
     }
 
     public function set(string $key, mixed $value, ?int $ttl = null): void
     {
         if ($ttl !== null) {
-            $this->redis->setex($key, $ttl, $value);
+            $this->getRedis()->setex($key, $ttl, $value);
         } else {
-            $this->redis->set($key, $value);
+            $this->getRedis()->set($key, $value);
         }
     }
 
     public function get(string $key): mixed
     {
-        return $this->redis->get($key);
+        return $this->getRedis()->get($key);
     }
 
     /**
@@ -201,17 +221,17 @@ public function delete(array|string $keys): int
             return 0;
         }
 
-        return (int) $this->redis->del(...$keys);
+        return (int) $this->getRedis()->del(...$keys);
     }
 
     public function exists(string $key): bool
     {
-        return (bool) $this->redis->exists($key);
+        return (bool) $this->getRedis()->exists($key);
     }
 
     public function expire(string $key, int $seconds): bool
     {
-        return (bool) $this->redis->expire($key, $seconds);
+        return (bool) $this->getRedis()->expire($key, $seconds);
     }
 
     /**
@@ -221,10 +241,10 @@ public function scanKeys(string $pattern): array
     {
         // Get the underlying PhpRedis client - it includes Redis connection prefix
         /** @var \Redis $client */
-        $client = $this->redis->client();
+        $client = $this->getRedis()->client();
 
         // Get Laravel's Redis connection prefix (e.g., 'laravel_database_')
-        $connectionPrefix = $this->redis->_prefix('');
+        $connectionPrefix = $this->getRedis()->_prefix('');
 
         // Combine connection prefix with our pattern
         $fullPattern = $connectionPrefix.$pattern;
@@ -255,7 +275,7 @@ public function scanKeys(string $pattern): array
     public function pipeline(callable $callback): void
     {
         // @phpstan-ignore-next-line - PhpRedis pipeline accepts no parameters in newer versions
-        $this->redis->pipeline(function ($pipe) use ($callback) {
+        $this->getRedis()->pipeline(function ($pipe) use ($callback) {
             $wrapper = new PipelineWrapper($pipe);
             $callback($wrapper);
         });
@@ -270,19 +290,21 @@ public function pipeline(callable $callback): void
      */
     public function transaction(callable $callback): array
     {
+        $redis = $this->getRedis();
+
         // Laravel Redis uses multi() and exec() for transactions
-        $this->redis->multi();
+        $redis->multi();
 
         try {
             // @phpstan-ignore-next-line - Laravel Connection type is compatible with PipelineWrapper
-            $wrapper = new PipelineWrapper($this->redis);
+            $wrapper = new PipelineWrapper($redis);
             $callback($wrapper);
 
-            $results = $this->redis->exec();
+            $results = $redis->exec();
 
             return is_array($results) ? $results : [];
         } catch (\Throwable $e) {
-            $this->redis->discard();
+            $redis->discard();
             throw $e;
         }
     }
@@ -295,7 +317,7 @@ public function transaction(callable $callback): array
     public function eval(string $script, int $numKeys, ...$args): mixed
     {
         // @phpstan-ignore-next-line - Redis eval accepts variadic args but PHPStan expects array
-        return $this->redis->eval($script, $numKeys, ...$args);
+        return $this->getRedis()->eval($script, $numKeys, ...$args);
     }
 
     /**
@@ -305,6 +327,6 @@ public function eval(string $script, int $numKeys, ...$args): mixed
      */
     public function command(string $method, array $parameters = []): mixed
     {
-        return $this->redis->command($method, $parameters);
+        return $this->getRedis()->command($method, $parameters);
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -11,28 +11,46 @@`
`11`	`11`	`* Simple wrapper around Laravel's Redis for queue metrics storage.`
`12`	`12`	`* Uses Laravel's Redis connection directly instead of abstraction layer.`
`13`	`13`	`*/`
`14`		`-final readonly class RedisMetricsStore`
	`14`	`+final class RedisMetricsStore`
`15`	`15`	`{`
`16`		`- private Connection $redis;`
	`16`	`+ private ?Connection $redis = null;`
`17`	`17`
`18`		`- private string $prefix;`
	`18`	`+ private ?string $prefix = null;`
`19`	`19`
`20`		`- public function __construct()`
	`20`	`+ /**`
	`21`	`+ * Get Redis connection (lazy loaded).`
	`22`	`+ */`
	`23`	`+ private function getRedis(): Connection`
	`24`	`+ {`
	`25`	`+ if ($this->redis === null) {`
	`26`	`+ /** @var string $connection */`
	`27`	`+ $connection = config('queue-metrics.storage.connection', 'default');`
	`28`	`+ $this->redis = Redis::connection($connection);`
	`29`	`+ }`
	`30`	`+`
	`31`	`+ return $this->redis;`
	`32`	`+ }`
	`33`	`+`
	`34`	`+ /**`
	`35`	`+ * Get prefix (lazy loaded).`
	`36`	`+ */`
	`37`	`+ private function getPrefix(): string`
`21`	`38`	`{`
`22`		`- /** @var string $connection */`
`23`		`- $connection = config('queue-metrics.storage.connection', 'default');`
`24`		`- $this->redis = Redis::connection($connection);`
`25`		`- /** @var string $prefix */`
`26`		`- $prefix = config('queue-metrics.storage.prefix', 'queue_metrics');`
`27`		`- $this->prefix = $prefix;`
	`39`	`+ if ($this->prefix === null) {`
	`40`	`+ /** @var string $prefix */`
	`41`	`+ $prefix = config('queue-metrics.storage.prefix', 'queue_metrics');`
	`42`	`+ $this->prefix = $prefix;`
	`43`	`+ }`
	`44`	`+`
	`45`	`+ return $this->prefix;`
`28`	`46`	`}`
`29`	`47`
`30`	`48`	`/**`
`31`	`49`	`* Build a Redis key from segments.`
`32`	`50`	`*/`
`33`	`51`	`public function key(string ...$segments): string`
`34`	`52`	`{`
`35`		`- return $this->prefix.':'.implode(':', $segments);`
	`53`	`+ return $this->getPrefix().':'.implode(':', $segments);`
`36`	`54`	`}`
`37`	`55`
`38`	`56`	`/**`
`@@ -49,7 +67,7 @@ public function getTtl(string $type): int`
`49`	`67`	`*/`
`50`	`68`	`public function connection(): Connection`
`51`	`69`	`{`
`52`		`- return $this->redis;`
	`70`	`+ return $this->getRedis();`
`53`	`71`	`}`
`54`	`72`
`55`	`73`	`/**`
`@@ -67,10 +85,11 @@ public function driver(): self`
`67`	`85`	`*/`
`68`	`86`	`public function setHash(string $key, array $data, ?int $ttl = null): void`
`69`	`87`	`{`
`70`		`- $this->redis->hmset($key, $data);`
	`88`	`+ $redis = $this->getRedis();`
	`89`	`+ $redis->hmset($key, $data);`
`71`	`90`
`72`	`91`	`if ($ttl !== null) {`
`73`		`- $this->redis->expire($key, $ttl);`
	`92`	`+ $redis->expire($key, $ttl);`
`74`	`93`	`}`
`75`	`94`	`}`
`76`	`95`
`@@ -79,22 +98,23 @@ public function setHash(string $key, array $data, ?int $ttl = null): void`
`79`	`98`	`*/`
`80`	`99`	`public function getHash(string $key): array`
`81`	`100`	`{`
`82`		`- $result = $this->redis->hgetall($key);`
	`101`	`+ $result = $this->getRedis()->hgetall($key);`
`83`	`102`
`84`	`103`	`return is_array($result) ? $result : [];`
`85`	`104`	`}`
`86`	`105`
`87`	`106`	`public function getHashField(string $key, string $field): mixed`
`88`	`107`	`{`
`89`		`- return $this->redis->hget($key, $field);`
	`108`	`+ return $this->getRedis()->hget($key, $field);`
`90`	`109`	`}`
`91`	`110`
`92`	`111`	`public function incrementHashField(string $key, string $field, int\|float $value): void`
`93`	`112`	`{`
	`113`	`+ $redis = $this->getRedis();`
`94`	`114`	`if (is_float($value)) {`
`95`		`- $this->redis->hincrbyfloat($key, $field, $value);`
	`115`	`+ $redis->hincrbyfloat($key, $field, $value);`
`96`	`116`	`} else {`
`97`		`- $this->redis->hincrby($key, $field, $value);`
	`117`	`+ $redis->hincrby($key, $field, $value);`
`98`	`118`	`}`
`99`	`119`	`}`
`100`	`120`
`@@ -103,10 +123,10 @@ public function incrementHashField(string $key, string $field, int\|float $value)`
`103`	`123`	`*/`
`104`	`124`	`public function addToSortedSet(string $key, array $membersWithScores, ?int $ttl = null): void`
`105`	`125`	`{`
`106`		`- $this->redis->zadd($key, $membersWithScores);`
	`126`	`+ $this->getRedis()->zadd($key, $membersWithScores);`
`107`	`127`
`108`	`128`	`if ($ttl !== null) {`
`109`		`- $this->redis->expire($key, $ttl);`
	`129`	`+ $this->getRedis()->expire($key, $ttl);`
`110`	`130`	`}`
`111`	`131`	`}`
`112`	`132`
`@@ -115,35 +135,35 @@ public function addToSortedSet(string $key, array $membersWithScores, ?int $ttl`
`115`	`135`	`*/`
`116`	`136`	`public function getSortedSetByRank(string $key, int $start, int $stop): array`
`117`	`137`	`{`
`118`		`- return $this->redis->zrange($key, $start, $stop);`
	`138`	`+ return $this->getRedis()->zrange($key, $start, $stop);`
`119`	`139`	`}`
`120`	`140`
`121`	`141`	`/**`
`122`	`142`	`* @return array<int, string>`
`123`	`143`	`*/`
`124`	`144`	`public function getSortedSetByScore(string $key, string $min, string $max): array`
`125`	`145`	`{`
`126`		`- return $this->redis->zrangebyscore($key, $min, $max);`
	`146`	`+ return $this->getRedis()->zrangebyscore($key, $min, $max);`
`127`	`147`	`}`
`128`	`148`
`129`	`149`	`public function countSortedSetByScore(string $key, string $min, string $max): int`
`130`	`150`	`{`
`131`		`- return (int) $this->redis->zcount($key, $min, $max);`
	`151`	`+ return (int) $this->getRedis()->zcount($key, $min, $max);`
`132`	`152`	`}`
`133`	`153`
`134`	`154`	`public function removeSortedSetByRank(string $key, int $start, int $stop): int`
`135`	`155`	`{`
`136`		`- return (int) $this->redis->zremrangebyrank($key, $start, $stop);`
	`156`	`+ return (int) $this->getRedis()->zremrangebyrank($key, $start, $stop);`
`137`	`157`	`}`
`138`	`158`
`139`	`159`	`public function removeSortedSetByScore(string $key, string $min, string $max): int`
`140`	`160`	`{`
`141`		`- return (int) $this->redis->zremrangebyscore($key, $min, $max);`
	`161`	`+ return (int) $this->getRedis()->zremrangebyscore($key, $min, $max);`
`142`	`162`	`}`
`143`	`163`
`144`	`164`	`public function removeFromSortedSet(string $key, string $member): void`
`145`	`165`	`{`
`146`		`- $this->redis->zrem($key, $member);`
	`166`	`+ $this->getRedis()->zrem($key, $member);`
`147`	`167`	`}`
`148`	`168`
`149`	`169`	`/**`
`@@ -152,7 +172,7 @@ public function removeFromSortedSet(string $key, string $member): void`
`152`	`172`	`public function addToSet(string $key, array $members): void`
`153`	`173`	`{`
`154`	`174`	`if (! empty($members)) {`
`155`		`- $this->redis->sadd($key, $members);`
	`175`	`+ $this->getRedis()->sadd($key, $members);`
`156`	`176`	`}`
`157`	`177`	`}`
`158`	`178`
`@@ -161,7 +181,7 @@ public function addToSet(string $key, array $members): void`
`161`	`181`	`*/`
`162`	`182`	`public function getSetMembers(string $key): array`
`163`	`183`	`{`
`164`		`- return $this->redis->smembers($key);`
	`184`	`+ return $this->getRedis()->smembers($key);`
`165`	`185`	`}`
`166`	`186`
`167`	`187`	`/**`
`@@ -170,22 +190,22 @@ public function getSetMembers(string $key): array`
`170`	`190`	`public function removeFromSet(string $key, array $members): void`
`171`	`191`	`{`
`172`	`192`	`if (! empty($members)) {`
`173`		`- $this->redis->srem($key, $members);`
	`193`	`+ $this->getRedis()->srem($key, $members);`
`174`	`194`	`}`
`175`	`195`	`}`
`176`	`196`
`177`	`197`	`public function set(string $key, mixed $value, ?int $ttl = null): void`
`178`	`198`	`{`
`179`	`199`	`if ($ttl !== null) {`
`180`		`- $this->redis->setex($key, $ttl, $value);`
	`200`	`+ $this->getRedis()->setex($key, $ttl, $value);`
`181`	`201`	`} else {`
`182`		`- $this->redis->set($key, $value);`
	`202`	`+ $this->getRedis()->set($key, $value);`
`183`	`203`	`}`
`184`	`204`	`}`
`185`	`205`
`186`	`206`	`public function get(string $key): mixed`
`187`	`207`	`{`
`188`		`- return $this->redis->get($key);`
	`208`	`+ return $this->getRedis()->get($key);`
`189`	`209`	`}`
`190`	`210`
`191`	`211`	`/**`
`@@ -201,17 +221,17 @@ public function delete(array\|string $keys): int`
`201`	`221`	`return 0;`
`202`	`222`	`}`
`203`	`223`
`204`		`- return (int) $this->redis->del(...$keys);`
	`224`	`+ return (int) $this->getRedis()->del(...$keys);`
`205`	`225`	`}`
`206`	`226`
`207`	`227`	`public function exists(string $key): bool`
`208`	`228`	`{`
`209`		`- return (bool) $this->redis->exists($key);`
	`229`	`+ return (bool) $this->getRedis()->exists($key);`
`210`	`230`	`}`
`211`	`231`
`212`	`232`	`public function expire(string $key, int $seconds): bool`
`213`	`233`	`{`
`214`		`- return (bool) $this->redis->expire($key, $seconds);`
	`234`	`+ return (bool) $this->getRedis()->expire($key, $seconds);`
`215`	`235`	`}`
`216`	`236`
`217`	`237`	`/**`
`@@ -221,10 +241,10 @@ public function scanKeys(string $pattern): array`
`221`	`241`	`{`
`222`	`242`	`// Get the underlying PhpRedis client - it includes Redis connection prefix`
`223`	`243`	`/** @var \Redis $client */`
`224`		`- $client = $this->redis->client();`
	`244`	`+ $client = $this->getRedis()->client();`
`225`	`245`
`226`	`246`	`// Get Laravel's Redis connection prefix (e.g., 'laravel_database_')`
`227`		`- $connectionPrefix = $this->redis->_prefix('');`
	`247`	`+ $connectionPrefix = $this->getRedis()->_prefix('');`
`228`	`248`
`229`	`249`	`// Combine connection prefix with our pattern`
`230`	`250`	`$fullPattern = $connectionPrefix.$pattern;`
`@@ -255,7 +275,7 @@ public function scanKeys(string $pattern): array`
`255`	`275`	`public function pipeline(callable $callback): void`
`256`	`276`	`{`
`257`	`277`	`// @phpstan-ignore-next-line - PhpRedis pipeline accepts no parameters in newer versions`
`258`		`- $this->redis->pipeline(function ($pipe) use ($callback) {`
	`278`	`+ $this->getRedis()->pipeline(function ($pipe) use ($callback) {`
`259`	`279`	`$wrapper = new PipelineWrapper($pipe);`
`260`	`280`	`$callback($wrapper);`
`261`	`281`	`});`
`@@ -270,19 +290,21 @@ public function pipeline(callable $callback): void`
`270`	`290`	`*/`
`271`	`291`	`public function transaction(callable $callback): array`
`272`	`292`	`{`
	`293`	`+ $redis = $this->getRedis();`
	`294`	`+`
`273`	`295`	`// Laravel Redis uses multi() and exec() for transactions`
`274`		`- $this->redis->multi();`
	`296`	`+ $redis->multi();`
`275`	`297`
`276`	`298`	`try {`
`277`	`299`	`// @phpstan-ignore-next-line - Laravel Connection type is compatible with PipelineWrapper`
`278`		`- $wrapper = new PipelineWrapper($this->redis);`
	`300`	`+ $wrapper = new PipelineWrapper($redis);`
`279`	`301`	`$callback($wrapper);`
`280`	`302`
`281`		`- $results = $this->redis->exec();`
	`303`	`+ $results = $redis->exec();`
`282`	`304`
`283`	`305`	`return is_array($results) ? $results : [];`
`284`	`306`	`} catch (\Throwable $e) {`
`285`		`- $this->redis->discard();`
	`307`	`+ $redis->discard();`
`286`	`308`	`throw $e;`
`287`	`309`	`}`
`288`	`310`	`}`
`@@ -295,7 +317,7 @@ public function transaction(callable $callback): array`
`295`	`317`	`public function eval(string $script, int $numKeys, ...$args): mixed`
`296`	`318`	`{`
`297`	`319`	`// @phpstan-ignore-next-line - Redis eval accepts variadic args but PHPStan expects array`
`298`		`- return $this->redis->eval($script, $numKeys, ...$args);`
	`320`	`+ return $this->getRedis()->eval($script, $numKeys, ...$args);`
`299`	`321`	`}`
`300`	`322`
`301`	`323`	`/**`
`@@ -305,6 +327,6 @@ public function eval(string $script, int $numKeys, ...$args): mixed`
`305`	`327`	`*/`
`306`	`328`	`public function command(string $method, array $parameters = []): mixed`
`307`	`329`	`{`
`308`		`- return $this->redis->command($method, $parameters);`
	`330`	`+ return $this->getRedis()->command($method, $parameters);`
`309`	`331`	`}`
`310`	`332`	`}`