Update to use PHPStan

.github/workflows/test.yml

@@ -40,3 +40,6 @@ jobs:
 
       - name: Run test suite
         run: composer run-script test
+
+      - name: Run PHPStan
+        run: vendor/bin/phpstan analyse --ansi

composer.json

@@ -26,7 +26,7 @@
   },
   "require-dev": {
     "phpunit/phpunit": "9.*",
-    "phpstan/phpstan": "^1.0"
+    "phpstan/phpstan": "^1"
   },
   "suggest": {
     "monolog/monolog": "Allows more advanced logging of the application flow"

phpstan.neon

@@ -0,0 +1,11 @@
+parameters:
+	level: 8
+	paths:
+		- src
+
+	excludePaths:
+		- src/Assignment/AssignmentConfigBuilder.php
+		- src/EvaluationCore
+
+	scanFiles:
+		- src/EvaluationCore/Util.php

src/Amplitude/Amplitude.php

@@ -13,26 +13,29 @@
 class Amplitude
 {
     private string $apiKey;
+    /**
+     * @var array<array<string,mixed>>
+     */
     protected array $queue = [];
     protected FetchClientInterface $httpClient;
     private LoggerInterface $logger;
-    private ?AmplitudeConfig $config;
+    private AmplitudeConfig $config;
 
     public function __construct(string $apiKey, LoggerInterface $logger, AmplitudeConfig $config = null)
     {
         $this->apiKey = $apiKey;
         $this->logger = $logger;
         $this->config = $config ?? AmplitudeConfig::builder()->build();
-        $this->httpClient = $config->fetchClient ?? $this->config->fetchClient ?? new GuzzleFetchClient($this->config->guzzleClientConfig);
+        $this->httpClient = $this->config->fetchClient ?? $this->config->fetchClient ?? new GuzzleFetchClient($this->config->guzzleClientConfig);
     }
 
-    public function flush()
+    public function flush(): void
     {
         $payload = ["api_key" => $this->apiKey, "events" => $this->queue, "options" => ["min_id_length" => $this->config->minIdLength]];
         $this->post($this->config->serverUrl, $payload);
     }
 
-    public function logEvent(Event $event)
+    public function logEvent(Event $event): void
     {
         $this->queue[] = $event->toArray();
         if (count($this->queue) >= $this->config->flushQueueSize) {
@@ -50,10 +53,17 @@ public function __destruct()
         }
     }
 
-    private function post(string $url, array $payload)
+    /**
+     * @param array<string,mixed> $payload
+     */
+    private function post(string $url, array $payload): void
     {
         $fetchClient = $this->httpClient->getClient();
         $payloadJson = json_encode($payload);
+        if ($payloadJson === false) {
+            $this->logger->error('[Amplitude] Failed to encode payload: ' . json_last_error());
+            return;
+        }
         $request = $this->httpClient->createRequest('POST', $url)->withHeader('json', $payloadJson);
         try {
             $response = $fetchClient->sendRequest($request);

src/Amplitude/AmplitudeConfig.php

@@ -32,8 +32,11 @@ class AmplitudeConfig
     /**
      * True to use batch API endpoint, False to use HTTP V2 API endpoint.
      */
-    public string $useBatch;
+    public bool $useBatch;
     public ?FetchClientInterface $fetchClient;
+    /**
+     * @var array<string, mixed>
+     */
     public array $guzzleClientConfig;
 
     const DEFAULTS = [
@@ -56,6 +59,9 @@ class AmplitudeConfig
         'guzzleClientConfig' => []
     ];
 
+    /**
+     * @param array<string, mixed> $guzzleClientConfig
+     */
     public function __construct(
         int    $flushQueueSize,
         int    $minIdLength,

src/Amplitude/AmplitudeConfigBuilder.php

@@ -12,6 +12,9 @@ class AmplitudeConfigBuilder
     protected ?string $serverUrl = null;
     protected bool $useBatch = AmplitudeConfig::DEFAULTS['useBatch'];
     protected ?FetchClientInterface $fetchClient = AmplitudeConfig::DEFAULTS['fetchClient'];
+    /**
+     * @var array<string, mixed>
+     */
     protected array $guzzleClientConfig = AmplitudeConfig::DEFAULTS['guzzleClientConfig'];
 
     public function __construct()
@@ -54,13 +57,16 @@ public function fetchClient(FetchClientInterface $fetchClient): AmplitudeConfigB
         return $this;
     }
 
+    /**
+     * @param array<string, mixed> $guzzleClientConfig
+     */
     public function guzzleClientConfig(array $guzzleClientConfig): AmplitudeConfigBuilder
     {
         $this->guzzleClientConfig = $guzzleClientConfig;
         return $this;
     }
 
-    public function build()
+    public function build(): AmplitudeConfig
     {
         if (!$this->serverUrl) {
             if ($this->useBatch) {

src/Amplitude/Event.php

@@ -5,7 +5,13 @@
 class Event
 {
     public ?string $eventType = null;
+    /**
+     * @var ?array<mixed>
+     */
     public ?array $eventProperties = null;
+    /**
+     * @var ?array<mixed>
+     */
     public ?array $userProperties = null;
     public ?string $userId = null;
     public ?string $deviceId = null;
@@ -16,6 +22,9 @@ public function __construct(string $eventType)
         $this->eventType = $eventType;
     }
 
+    /**
+     * @return array<string, mixed>
+     */
     public function toArray(): array
     {
         return array_filter([

src/AmplitudeCookie.php

@@ -37,25 +37,24 @@ public static function cookieName(string $amplitudeApiKey, bool $newFormat = fal
     /**
      * @param string $amplitudeCookie A string from the amplitude cookie
      * @param bool $newFormat True if the cookie is in the Browser SDK 2.0 format
-     * @return array An array containing device_id and user_id (if available)
+     * @return array<mixed> An array containing device_id and user_id (if available)
      */
     public static function parse(string $amplitudeCookie, bool $newFormat = false): array
     {
         if ($newFormat) {
             $decoding = base64_decode($amplitudeCookie);
             $decoded = urldecode($decoding);
 
-            try {
-                $userSession = json_decode($decoded, true);
-                return [
-                    'deviceId' => $userSession['deviceId'],
-                    'userId' => $userSession['userId'] ?? null,
-                ];
-            } catch (\Exception $e) {
+            $userSession = json_decode($decoded, true);
+            if ($userSession === null) {
                 $logger = new InternalLogger(new DefaultLogger(), LogLevel::INFO);
-                $logger->error("Error parsing the Amplitude cookie: '{$amplitudeCookie}'. " . $e->getMessage());
+                $logger->error("Error parsing the Amplitude cookie: '{$amplitudeCookie}'.");
                 return [];
             }
+            return [
+                'deviceId' => $userSession['deviceId'],
+                'userId' => $userSession['userId'] ?? null,
+            ];
         }
 
         $values = explode('.', $amplitudeCookie);
@@ -92,6 +91,9 @@ public static function generate(string $deviceId, bool $newFormat = false): stri
         ];
 
         $json_data = json_encode($userSessionHash);
+        if ($json_data === false) {
+            return '';
+        }
         $encoded_json = urlencode($json_data);
         return base64_encode($encoded_json);
     }

src/Assignment/Assignment.php

@@ -3,18 +3,25 @@
 namespace AmplitudeExperiment\Assignment;
 
 use AmplitudeExperiment\User;
+use AmplitudeExperiment\Variant;
 
 class Assignment
 {
     public User $user;
+    /**
+     * @var array<string, Variant>
+     */
     public array $variants;
     public int $timestamp;
 
+    /**
+     * @param array<string, Variant> $variants
+     */
     public function __construct(User $user, array $variants)
     {
         $this->user = $user;
         $this->variants = $variants;
-        $this->timestamp = floor(microtime(true) * 1000);
+        $this->timestamp = (int) floor(microtime(true) * 1000);
     }
 
     public function canonicalize(): string

src/Assignment/AssignmentConfigBuilder.php

@@ -2,16 +2,17 @@
 
 namespace AmplitudeExperiment\Assignment;
 
+use AmplitudeExperiment\Amplitude\AmplitudeConfig;
 use AmplitudeExperiment\Amplitude\AmplitudeConfigBuilder;
 
 /**
  * Extends AmplitudeConfigBuilder to allow configuration {@link AmplitudeConfig} of underlying {@link Amplitude} client.
  */
-
 class AssignmentConfigBuilder extends AmplitudeConfigBuilder
 {
     protected string $apiKey;
     protected int $cacheCapacity = AssignmentConfig::DEFAULTS['cacheCapacity'];
+
     public function __construct(string $apiKey)
     {
         parent::__construct();
@@ -24,7 +25,7 @@ public function cacheCapacity(int $cacheCapacity): AssignmentConfigBuilder
         return $this;
     }
 
-    public function build(): AssignmentConfig
+    public function build()
     {
         return new AssignmentConfig(
             $this->apiKey,