Enable Discovery debug logging for production troubleshooting

- Add DISCOVERY_LOG_LEVEL=debug
- Add DISCOVERY_SHOW_PROGRESS=true
- Temporary changes for debugging InitializerProcessor fixes on production

src/Framework/Discovery/ValueObjects/CompressionLevel.php

@@ -0,0 +1,116 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Discovery\ValueObjects;
+
+/**
+ * Compression level enumeration for cache data compression
+ *
+ * Defines different compression strategies with trade-offs between
+ * compression ratio and CPU usage.
+ */
+enum CompressionLevel: string
+{
+    case NONE = 'none';         // No compression
+    case LOW = 'low';           // Fast compression, lower ratio
+    case MEDIUM = 'medium';     // Balanced compression
+    case HIGH = 'high';         // Good compression, higher CPU
+    case MAXIMUM = 'maximum';   // Best compression, highest CPU
+
+    /**
+     * Get the gzip compression level integer
+     */
+    public function getGzipLevel(): int
+    {
+        return match ($this) {
+            self::NONE => 0,
+            self::LOW => 1,
+            self::MEDIUM => 6,
+            self::HIGH => 8,
+            self::MAXIMUM => 9
+        };
+    }
+
+    /**
+     * Get expected compression ratio (approximate)
+     */
+    public function getExpectedRatio(): float
+    {
+        return match ($this) {
+            self::NONE => 1.0,      // No compression
+            self::LOW => 0.8,       // 20% compression
+            self::MEDIUM => 0.6,    // 40% compression
+            self::HIGH => 0.4,      // 60% compression
+            self::MAXIMUM => 0.3    // 70% compression
+        };
+    }
+
+    /**
+     * Get CPU cost relative to no compression
+     */
+    public function getCpuCostMultiplier(): float
+    {
+        return match ($this) {
+            self::NONE => 1.0,
+            self::LOW => 1.2,
+            self::MEDIUM => 1.5,
+            self::HIGH => 2.0,
+            self::MAXIMUM => 3.0
+        };
+    }
+
+    /**
+     * Get minimum data size threshold for this compression level
+     */
+    public function getMinimumDataSize(): int
+    {
+        return match ($this) {
+            self::NONE => 0,
+            self::LOW => 1024,      // 1KB
+            self::MEDIUM => 512,    // 512 bytes
+            self::HIGH => 256,      // 256 bytes
+            self::MAXIMUM => 128    // 128 bytes
+        };
+    }
+
+    /**
+     * Check if compression is beneficial for given data size
+     */
+    public function isBeneficialFor(int $dataSize): bool
+    {
+        return $this !== self::NONE && $dataSize >= $this->getMinimumDataSize();
+    }
+
+    /**
+     * Get description of this compression level
+     */
+    public function getDescription(): string
+    {
+        return match ($this) {
+            self::NONE => 'No compression applied',
+            self::LOW => 'Fast compression with minimal CPU overhead',
+            self::MEDIUM => 'Balanced compression with moderate CPU usage',
+            self::HIGH => 'Good compression with higher CPU cost',
+            self::MAXIMUM => 'Maximum compression with highest CPU cost'
+        };
+    }
+
+    /**
+     * Suggest compression level based on data size and memory pressure
+     */
+    public static function suggest(int $dataSize, float $memoryPressure): self
+    {
+        if ($dataSize < 128) {
+            return self::NONE; // Too small to compress effectively
+        }
+
+        return match (true) {
+            $memoryPressure >= 0.95 => self::MAXIMUM,
+            $memoryPressure >= 0.85 => self::HIGH,
+            $memoryPressure >= 0.75 => self::MEDIUM,
+            $memoryPressure >= 0.50 => self::LOW,
+            default => self::NONE
+        };
+    }
+}