feat(Production): Complete production deployment infrastructure

- Add comprehensive health check system with multiple endpoints
- Add Prometheus metrics endpoint
- Add production logging configurations (5 strategies)
- Add complete deployment documentation suite:
  * QUICKSTART.md - 30-minute deployment guide
  * DEPLOYMENT_CHECKLIST.md - Printable verification checklist
  * DEPLOYMENT_WORKFLOW.md - Complete deployment lifecycle
  * PRODUCTION_DEPLOYMENT.md - Comprehensive technical reference
  * production-logging.md - Logging configuration guide
  * ANSIBLE_DEPLOYMENT.md - Infrastructure as Code automation
  * README.md - Navigation hub
  * DEPLOYMENT_SUMMARY.md - Executive summary
- Add deployment scripts and automation
- Add DEPLOYMENT_PLAN.md - Concrete plan for immediate deployment
- Update README with production-ready features

All production infrastructure is now complete and ready for deployment.

tests/Database/QueryOptimization/NPlusOneDetectionServiceTest.php

@@ -0,0 +1,208 @@
+<?php
+
+declare(strict_types=1);
+
+use App\Framework\Database\QueryOptimization\Analysis\EagerLoadingAnalyzer;
+use App\Framework\Database\QueryOptimization\Analysis\NPlusOneDetector;
+use App\Framework\Database\QueryOptimization\NPlusOneDetectionService;
+use App\Framework\Database\QueryOptimization\QueryLogger;
+use App\Framework\Database\QueryOptimization\ValueObjects\QueryLog;
+use App\Framework\Logging\Logger;
+
+describe('NPlusOneDetectionService', function () {
+    beforeEach(function () {
+        $this->queryLogger = new QueryLogger();
+        $this->detector = new NPlusOneDetector();
+        $this->analyzer = new EagerLoadingAnalyzer();
+        $this->logger = $this->createMock(Logger::class);
+
+        $this->service = new NPlusOneDetectionService(
+            $this->queryLogger,
+            $this->detector,
+            $this->analyzer,
+            $this->logger
+        );
+    });
+
+    it('starts and stops logging', function () {
+        expect($this->queryLogger->isEnabled())->toBeFalse();
+
+        $this->service->startLogging();
+        expect($this->queryLogger->isEnabled())->toBeTrue();
+
+        $this->service->stopLogging();
+        expect($this->queryLogger->isEnabled())->toBeFalse();
+    });
+
+    it('analyzes logged queries', function () {
+        // Enable logging
+        $this->service->startLogging();
+
+        // Simulate N+1 queries
+        for ($i = 1; $i <= 10; $i++) {
+            $this->queryLogger->logQuery(
+                sql: 'SELECT * FROM posts WHERE user_id = ?',
+                bindings: [$i],
+                executionTimeMs: 5.0,
+                rowCount: 1
+            );
+        }
+
+        // Analyze
+        $result = $this->service->analyze();
+
+        expect($result)->toHaveKeys(['detections', 'strategies', 'statistics']);
+        expect($result['detections'])->not->toBeEmpty();
+        expect($result['statistics']['total_queries'])->toBe(10);
+    });
+
+    it('generates formatted report', function () {
+        $this->service->startLogging();
+
+        // Simulate N+1 queries
+        for ($i = 1; $i <= 10; $i++) {
+            $this->queryLogger->logQuery(
+                sql: 'SELECT * FROM posts WHERE user_id = ?',
+                bindings: [$i],
+                executionTimeMs: 5.0,
+                rowCount: 1
+            );
+        }
+
+        $report = $this->service->analyzeAndReport();
+
+        expect($report)->toContain('N+1 Query Detection Report');
+        expect($report)->toContain('Query Statistics');
+        expect($report)->toContain('N+1 Problems Detected');
+    });
+
+    it('profiles code execution', function () {
+        $executedCallable = false;
+
+        $analysis = $this->service->profile(function () use (&$executedCallable) {
+            $executedCallable = true;
+            return 'result';
+        });
+
+        expect($executedCallable)->toBeTrue();
+        expect($analysis)->toHaveKey('execution_time_ms');
+        expect($analysis)->toHaveKey('callback_result');
+        expect($analysis['callback_result'])->toBe('result');
+    });
+
+    it('returns critical problems only', function () {
+        $this->service->startLogging();
+
+        // Add critical N+1 (high execution count)
+        for ($i = 1; $i <= 50; $i++) {
+            $this->queryLogger->logQuery(
+                sql: 'SELECT * FROM posts WHERE user_id = ?',
+                bindings: [$i],
+                executionTimeMs: 10.0,
+                rowCount: 1
+            );
+        }
+
+        // Add low severity N+1
+        for ($i = 1; $i <= 6; $i++) {
+            $this->queryLogger->logQuery(
+                sql: 'SELECT * FROM comments WHERE post_id = ?',
+                bindings: [$i],
+                executionTimeMs: 1.0,
+                rowCount: 1
+            );
+        }
+
+        $critical = $this->service->getCriticalProblems();
+
+        // Should only contain the high-severity posts pattern
+        expect($critical)->toHaveCount(1);
+        expect($critical[0]->isCritical())->toBeTrue();
+    });
+
+    it('quick check detects N+1 problems', function () {
+        $this->service->startLogging();
+
+        for ($i = 1; $i <= 10; $i++) {
+            $this->queryLogger->logQuery(
+                sql: 'SELECT * FROM posts WHERE user_id = ?',
+                bindings: [$i],
+                executionTimeMs: 5.0,
+                rowCount: 1
+            );
+        }
+
+        expect($this->service->hasNPlusOneProblems())->toBeTrue();
+    });
+
+    it('returns query statistics', function () {
+        $this->service->startLogging();
+
+        $this->queryLogger->logQuery('SELECT * FROM users', [], 5.0, 10);
+        $this->queryLogger->logQuery('INSERT INTO logs (message) VALUES (?)', ['test'], 2.0, 1);
+        $this->queryLogger->logQuery('UPDATE users SET name = ? WHERE id = ?', ['John', 1], 3.0, 1);
+
+        $stats = $this->service->getQueryStatistics();
+
+        expect($stats['total_queries'])->toBe(3);
+        expect($stats['select_count'])->toBe(1);
+        expect($stats['insert_count'])->toBe(1);
+        expect($stats['update_count'])->toBe(1);
+    });
+
+    it('clears query logs', function () {
+        $this->service->startLogging();
+
+        $this->queryLogger->logQuery('SELECT * FROM users', [], 5.0);
+        expect($this->service->getQueryLogs())->toHaveCount(1);
+
+        $this->service->clearLogs();
+        expect($this->service->getQueryLogs())->toBeEmpty();
+    });
+
+    it('integrates detections with eager loading strategies', function () {
+        $this->service->startLogging();
+
+        // Create N+1 pattern
+        for ($i = 1; $i <= 15; $i++) {
+            $this->queryLogger->logQuery(
+                sql: 'SELECT * FROM posts WHERE user_id = ?',
+                bindings: [$i],
+                executionTimeMs: 8.0,
+                rowCount: 1
+            );
+        }
+
+        $result = $this->service->analyze();
+
+        expect($result['detections'])->toHaveCount(1);
+        expect($result['strategies'])->toHaveCount(1);
+
+        $strategy = $result['strategies'][0];
+        expect($strategy->tableName)->toBe('posts');
+        expect($strategy->codeExample)->toContain('eager loading');
+    });
+
+    it('handles empty query logs gracefully', function () {
+        $this->service->startLogging();
+
+        $result = $this->service->analyze();
+
+        expect($result['detections'])->toBeEmpty();
+        expect($result['strategies'])->toBeEmpty();
+        expect($result['statistics']['total_queries'])->toBe(0);
+    });
+
+    it('logs analysis completion', function () {
+        $this->logger->expects($this->once())
+            ->method('info')
+            ->with(
+                $this->stringContains('Analysis completed'),
+                $this->anything()
+            );
+
+        $this->service->startLogging();
+        $this->queryLogger->logQuery('SELECT * FROM users', [], 5.0);
+        $this->service->analyze();
+    });
+});

tests/Database/QueryOptimization/NPlusOneDetectorTest.php

@@ -0,0 +1,228 @@
+<?php
+
+declare(strict_types=1);
+
+use App\Framework\Database\QueryOptimization\Analysis\NPlusOneDetector;
+use App\Framework\Database\QueryOptimization\ValueObjects\QueryLog;
+
+describe('NPlusOneDetector', function () {
+    it('detects N+1 pattern with multiple executions', function () {
+        $detector = new NPlusOneDetector(minExecutionCount: 5, minSeverityScore: 4.0);
+
+        $queryLogs = [];
+
+        // 10 queries with same pattern
+        for ($i = 1; $i <= 10; $i++) {
+            $queryLogs[] = new QueryLog(
+                sql: 'SELECT * FROM posts WHERE user_id = ?',
+                bindings: [$i],
+                executionTimeMs: 8.0,
+                stackTrace: 'UserController::index',
+                callerClass: 'UserController',
+                callerMethod: 'index',
+                callerLine: 42
+            );
+        }
+
+        $detections = $detector->analyze($queryLogs);
+
+        expect($detections)->toHaveCount(1);
+        expect($detections[0]->pattern->getTableName())->toBe('posts');
+        expect($detections[0]->pattern->getExecutionCount())->toBe(10);
+    });
+
+    it('ignores patterns with too few executions', function () {
+        $detector = new NPlusOneDetector(minExecutionCount: 10);
+
+        $queryLogs = [];
+
+        // Only 5 queries
+        for ($i = 1; $i <= 5; $i++) {
+            $queryLogs[] = new QueryLog(
+                sql: 'SELECT * FROM posts WHERE user_id = ?',
+                bindings: [$i],
+                executionTimeMs: 5.0,
+                stackTrace: ''
+            );
+        }
+
+        $detections = $detector->analyze($queryLogs);
+
+        expect($detections)->toBeEmpty();
+    });
+
+    it('ignores patterns with low severity', function () {
+        $detector = new NPlusOneDetector(minExecutionCount: 5, minSeverityScore: 8.0);
+
+        $queryLogs = [];
+
+        // 6 queries with low severity
+        for ($i = 1; $i <= 6; $i++) {
+            $queryLogs[] = new QueryLog(
+                sql: 'SELECT * FROM posts WHERE user_id = ?',
+                bindings: [$i],
+                executionTimeMs: 1.0,
+                stackTrace: '',
+                callerClass: 'Different' . $i,
+                callerMethod: 'method' . $i
+            );
+        }
+
+        $detections = $detector->analyze($queryLogs);
+
+        expect($detections)->toBeEmpty();
+    });
+
+    it('generates recommendations for detected N+1', function () {
+        $detector = new NPlusOneDetector();
+
+        $queryLogs = [];
+
+        for ($i = 1; $i <= 10; $i++) {
+            $queryLogs[] = new QueryLog(
+                sql: 'SELECT * FROM posts WHERE user_id = ?',
+                bindings: [$i],
+                executionTimeMs: 5.0,
+                stackTrace: 'UserController::index',
+                callerClass: 'UserController',
+                callerMethod: 'index',
+                callerLine: 42
+            );
+        }
+
+        $detections = $detector->analyze($queryLogs);
+
+        expect($detections[0]->recommendation)->toContain('eager loading');
+        expect($detections[0]->recommendation)->toContain('batch loading');
+        expect($detections[0]->recommendation)->toContain('JOIN');
+    });
+
+    it('detects multiple N+1 patterns', function () {
+        $detector = new NPlusOneDetector();
+
+        $queryLogs = [];
+
+        // Pattern 1: Posts
+        for ($i = 1; $i <= 10; $i++) {
+            $queryLogs[] = new QueryLog(
+                sql: 'SELECT * FROM posts WHERE user_id = ?',
+                bindings: [$i],
+                executionTimeMs: 5.0,
+                stackTrace: '',
+                callerClass: 'UserController',
+                callerMethod: 'index'
+            );
+        }
+
+        // Pattern 2: Comments
+        for ($i = 1; $i <= 8; $i++) {
+            $queryLogs[] = new QueryLog(
+                sql: 'SELECT * FROM comments WHERE post_id = ?',
+                bindings: [$i],
+                executionTimeMs: 3.0,
+                stackTrace: '',
+                callerClass: 'PostController',
+                callerMethod: 'show'
+            );
+        }
+
+        $detections = $detector->analyze($queryLogs);
+
+        expect($detections)->toHaveCount(2);
+
+        $tables = array_map(fn($d) => $d->pattern->getTableName(), $detections);
+        expect($tables)->toContain('posts');
+        expect($tables)->toContain('comments');
+    });
+
+    it('calculates statistics correctly', function () {
+        $detector = new NPlusOneDetector();
+
+        $queryLogs = [];
+
+        // 10 N+1 queries
+        for ($i = 1; $i <= 10; $i++) {
+            $queryLogs[] = new QueryLog(
+                sql: 'SELECT * FROM posts WHERE user_id = ?',
+                bindings: [$i],
+                executionTimeMs: 10.0,
+                stackTrace: '',
+                callerClass: 'UserController',
+                callerMethod: 'index'
+            );
+        }
+
+        // 5 normal queries
+        for ($i = 1; $i <= 5; $i++) {
+            $queryLogs[] = new QueryLog(
+                sql: 'INSERT INTO logs (message) VALUES (?)',
+                bindings: ["log{$i}"],
+                executionTimeMs: 2.0,
+                stackTrace: ''
+            );
+        }
+
+        $stats = $detector->getStatistics($queryLogs);
+
+        expect($stats['total_queries'])->toBe(15);
+        expect($stats['n_plus_one_patterns'])->toBe(1);
+        expect($stats['n_plus_one_queries'])->toBe(10);
+        expect($stats['n_plus_one_time_ms'])->toBe(100.0);
+        expect($stats['n_plus_one_percentage'])->toBeGreaterThan(50.0);
+    });
+
+    it('quick check detects N+1 problems', function () {
+        $detector = new NPlusOneDetector();
+
+        $queryLogs = [];
+
+        for ($i = 1; $i <= 10; $i++) {
+            $queryLogs[] = new QueryLog(
+                sql: 'SELECT * FROM posts WHERE user_id = ?',
+                bindings: [$i],
+                executionTimeMs: 5.0,
+                stackTrace: '',
+                callerClass: 'UserController',
+                callerMethod: 'index'
+            );
+        }
+
+        expect($detector->hasNPlusOne($queryLogs))->toBeTrue();
+    });
+
+    it('quick check returns false for no N+1', function () {
+        $detector = new NPlusOneDetector();
+
+        $queryLogs = [
+            new QueryLog('SELECT * FROM users', [], 5.0, ''),
+            new QueryLog('SELECT * FROM posts WHERE id = ?', [1], 3.0, ''),
+        ];
+
+        expect($detector->hasNPlusOne($queryLogs))->toBeFalse();
+    });
+
+    it('generates metadata with query details', function () {
+        $detector = new NPlusOneDetector();
+
+        $queryLogs = [];
+
+        for ($i = 1; $i <= 10; $i++) {
+            $queryLogs[] = new QueryLog(
+                sql: 'SELECT * FROM posts WHERE user_id = ?',
+                bindings: [$i],
+                executionTimeMs: 5.0,
+                stackTrace: '',
+                callerClass: 'UserController',
+                callerMethod: 'index'
+            );
+        }
+
+        $detections = $detector->analyze($queryLogs);
+
+        expect($detections[0]->metadata)->toHaveKey('execution_count');
+        expect($detections[0]->metadata)->toHaveKey('total_time_ms');
+        expect($detections[0]->metadata)->toHaveKey('average_time_ms');
+        expect($detections[0]->metadata)->toHaveKey('table_name');
+        expect($detections[0]->metadata)->toHaveKey('first_query_sql');
+    });
+});

tests/Database/QueryOptimization/QueryLogTest.php

@@ -0,0 +1,166 @@
+<?php
+
+declare(strict_types=1);
+
+use App\Framework\Database\QueryOptimization\ValueObjects\QueryLog;
+
+describe('QueryLog Value Object', function () {
+    it('creates query log with all properties', function () {
+        $log = new QueryLog(
+            sql: 'SELECT * FROM users WHERE id = ?',
+            bindings: [123],
+            executionTimeMs: 5.5,
+            stackTrace: 'UserController::index',
+            rowCount: 1,
+            callerClass: 'UserController',
+            callerMethod: 'index',
+            callerLine: 42
+        );
+
+        expect($log->sql)->toBe('SELECT * FROM users WHERE id = ?');
+        expect($log->bindings)->toBe([123]);
+        expect($log->executionTimeMs)->toBe(5.5);
+        expect($log->rowCount)->toBe(1);
+        expect($log->callerClass)->toBe('UserController');
+        expect($log->callerMethod)->toBe('index');
+        expect($log->callerLine)->toBe(42);
+    });
+
+    it('normalizes SQL pattern correctly', function () {
+        $log = new QueryLog(
+            sql: "SELECT * FROM users WHERE id = 123 AND email = 'test@example.com'",
+            bindings: [],
+            executionTimeMs: 1.0,
+            stackTrace: ''
+        );
+
+        $pattern = $log->getPattern();
+
+        expect($pattern)->toBe('SELECT * FROM users WHERE id = ? AND email = ?');
+    });
+
+    it('normalizes IN clauses', function () {
+        $log = new QueryLog(
+            sql: 'SELECT * FROM users WHERE id IN (1, 2, 3, 4, 5)',
+            bindings: [],
+            executionTimeMs: 1.0,
+            stackTrace: ''
+        );
+
+        $pattern = $log->getPattern();
+
+        expect($pattern)->toBe('SELECT * FROM users WHERE id IN (?)');
+    });
+
+    it('detects SELECT queries', function () {
+        $log = new QueryLog(
+            sql: 'SELECT * FROM users',
+            bindings: [],
+            executionTimeMs: 1.0,
+            stackTrace: ''
+        );
+
+        expect($log->isSelect())->toBeTrue();
+        expect($log->isInsert())->toBeFalse();
+        expect($log->isUpdate())->toBeFalse();
+        expect($log->isDelete())->toBeFalse();
+    });
+
+    it('detects INSERT queries', function () {
+        $log = new QueryLog(
+            sql: 'INSERT INTO users (name, email) VALUES (?, ?)',
+            bindings: ['John', 'john@example.com'],
+            executionTimeMs: 2.0,
+            stackTrace: ''
+        );
+
+        expect($log->isInsert())->toBeTrue();
+        expect($log->isSelect())->toBeFalse();
+    });
+
+    it('extracts table name from SELECT', function () {
+        $log = new QueryLog(
+            sql: 'SELECT * FROM users WHERE id = ?',
+            bindings: [1],
+            executionTimeMs: 1.0,
+            stackTrace: ''
+        );
+
+        expect($log->getTableName())->toBe('users');
+    });
+
+    it('extracts table name from INSERT', function () {
+        $log = new QueryLog(
+            sql: 'INSERT INTO orders (user_id, total) VALUES (?, ?)',
+            bindings: [1, 100],
+            executionTimeMs: 1.0,
+            stackTrace: ''
+        );
+
+        expect($log->getTableName())->toBe('orders');
+    });
+
+    it('detects WHERE clause', function () {
+        $log = new QueryLog(
+            sql: 'SELECT * FROM users WHERE id = ?',
+            bindings: [1],
+            executionTimeMs: 1.0,
+            stackTrace: ''
+        );
+
+        expect($log->hasWhereClause())->toBeTrue();
+    });
+
+    it('detects missing WHERE clause', function () {
+        $log = new QueryLog(
+            sql: 'SELECT * FROM users',
+            bindings: [],
+            executionTimeMs: 1.0,
+            stackTrace: ''
+        );
+
+        expect($log->hasWhereClause())->toBeFalse();
+    });
+
+    it('detects JOIN queries', function () {
+        $log = new QueryLog(
+            sql: 'SELECT * FROM users LEFT JOIN profiles ON users.id = profiles.user_id',
+            bindings: [],
+            executionTimeMs: 1.0,
+            stackTrace: ''
+        );
+
+        expect($log->hasJoin())->toBeTrue();
+    });
+
+    it('detects slow queries', function () {
+        $log = new QueryLog(
+            sql: 'SELECT * FROM users',
+            bindings: [],
+            executionTimeMs: 150.0,
+            stackTrace: ''
+        );
+
+        expect($log->isSlow(100.0))->toBeTrue();
+        expect($log->isSlow(200.0))->toBeFalse();
+    });
+
+    it('throws on negative execution time', function () {
+        new QueryLog(
+            sql: 'SELECT * FROM users',
+            bindings: [],
+            executionTimeMs: -5.0,
+            stackTrace: ''
+        );
+    })->throws(InvalidArgumentException::class, 'Execution time cannot be negative');
+
+    it('throws on negative row count', function () {
+        new QueryLog(
+            sql: 'SELECT * FROM users',
+            bindings: [],
+            executionTimeMs: 1.0,
+            stackTrace: '',
+            rowCount: -1
+        );
+    })->throws(InvalidArgumentException::class, 'Row count cannot be negative');
+});

tests/Database/QueryOptimization/QueryLoggerTest.php

@@ -0,0 +1,186 @@
+<?php
+
+declare(strict_types=1);
+
+use App\Framework\Database\QueryOptimization\QueryLogger;
+
+describe('QueryLogger', function () {
+    beforeEach(function () {
+        $this->logger = new QueryLogger();
+    });
+
+    it('starts disabled by default', function () {
+        expect($this->logger->isEnabled())->toBeFalse();
+    });
+
+    it('enables and disables logging', function () {
+        $this->logger->enable();
+        expect($this->logger->isEnabled())->toBeTrue();
+
+        $this->logger->disable();
+        expect($this->logger->isEnabled())->toBeFalse();
+    });
+
+    it('ignores queries when disabled', function () {
+        $this->logger->disable();
+
+        $this->logger->logQuery('SELECT * FROM users', [], 5.0);
+
+        expect($this->logger->getQueryCount())->toBe(0);
+    });
+
+    it('logs queries when enabled', function () {
+        $this->logger->enable();
+
+        $this->logger->logQuery('SELECT * FROM users WHERE id = ?', [1], 5.5, 1);
+
+        expect($this->logger->getQueryCount())->toBe(1);
+
+        $logs = $this->logger->getQueryLogs();
+        expect($logs)->toHaveCount(1);
+        expect($logs[0]->sql)->toBe('SELECT * FROM users WHERE id = ?');
+        expect($logs[0]->bindings)->toBe([1]);
+        expect($logs[0]->executionTimeMs)->toBe(5.5);
+        expect($logs[0]->rowCount)->toBe(1);
+    });
+
+    it('captures stack trace', function () {
+        $this->logger->enable();
+
+        $this->logger->logQuery('SELECT * FROM users', [], 5.0);
+
+        $logs = $this->logger->getQueryLogs();
+        expect($logs[0]->stackTrace)->not->toBeEmpty();
+    });
+
+    it('identifies caller class and method', function () {
+        $this->logger->enable();
+
+        $this->logger->logQuery('SELECT * FROM users', [], 5.0);
+
+        $logs = $this->logger->getQueryLogs();
+        expect($logs[0]->callerClass)->not->toBeNull();
+        expect($logs[0]->callerMethod)->not->toBeNull();
+    });
+
+    it('calculates total execution time', function () {
+        $this->logger->enable();
+
+        $this->logger->logQuery('SELECT * FROM users', [], 5.0);
+        $this->logger->logQuery('SELECT * FROM posts', [], 10.0);
+        $this->logger->logQuery('SELECT * FROM comments', [], 3.5);
+
+        expect($this->logger->getTotalExecutionTime())->toBe(18.5);
+    });
+
+    it('groups queries by pattern', function () {
+        $this->logger->enable();
+
+        $this->logger->logQuery('SELECT * FROM users WHERE id = ?', [1], 5.0);
+        $this->logger->logQuery('SELECT * FROM users WHERE id = ?', [2], 4.5);
+        $this->logger->logQuery('SELECT * FROM posts WHERE user_id = ?', [1], 3.0);
+
+        $grouped = $this->logger->getGroupedByPattern();
+
+        expect($grouped)->toHaveCount(2);
+        expect($grouped['SELECT * FROM users WHERE id = ?'])->toHaveCount(2);
+        expect($grouped['SELECT * FROM posts WHERE user_id = ?'])->toHaveCount(1);
+    });
+
+    it('identifies slow queries', function () {
+        $this->logger->enable();
+
+        $this->logger->logQuery('SELECT * FROM users', [], 50.0);
+        $this->logger->logQuery('SELECT * FROM posts', [], 150.0);
+        $this->logger->logQuery('SELECT * FROM comments', [], 5.0);
+
+        $slowQueries = $this->logger->getSlowQueries(100.0);
+
+        expect($slowQueries)->toHaveCount(1);
+        expect($slowQueries[0]->sql)->toContain('posts');
+        expect($slowQueries[0]->executionTimeMs)->toBe(150.0);
+    });
+
+    it('clears logged queries', function () {
+        $this->logger->enable();
+
+        $this->logger->logQuery('SELECT * FROM users', [], 5.0);
+        $this->logger->logQuery('SELECT * FROM posts', [], 3.0);
+
+        expect($this->logger->getQueryCount())->toBe(2);
+
+        $this->logger->clear();
+
+        expect($this->logger->getQueryCount())->toBe(0);
+        expect($this->logger->getQueryLogs())->toBeEmpty();
+    });
+
+    it('generates query statistics', function () {
+        $this->logger->enable();
+
+        $this->logger->logQuery('SELECT * FROM users', [], 5.0);
+        $this->logger->logQuery('SELECT * FROM posts', [], 10.0);
+        $this->logger->logQuery('INSERT INTO logs (message) VALUES (?)', ['test'], 2.0);
+        $this->logger->logQuery('UPDATE users SET name = ? WHERE id = ?', ['John', 1], 3.0);
+        $this->logger->logQuery('DELETE FROM logs WHERE id = ?', [1], 1.5);
+        $this->logger->logQuery('SELECT * FROM users', [], 150.0); // Slow query
+
+        $stats = $this->logger->getStatistics();
+
+        expect($stats['total_queries'])->toBe(6);
+        expect($stats['total_time_ms'])->toBe(171.5);
+        expect($stats['select_count'])->toBe(3);
+        expect($stats['insert_count'])->toBe(1);
+        expect($stats['update_count'])->toBe(1);
+        expect($stats['delete_count'])->toBe(1);
+        expect($stats['slow_queries'])->toBe(1);
+        expect($stats['unique_patterns'])->toBe(5);
+    });
+
+    it('calculates average execution time', function () {
+        $this->logger->enable();
+
+        $this->logger->logQuery('SELECT * FROM users', [], 10.0);
+        $this->logger->logQuery('SELECT * FROM posts', [], 20.0);
+        $this->logger->logQuery('SELECT * FROM comments', [], 30.0);
+
+        $stats = $this->logger->getStatistics();
+
+        expect($stats['average_time_ms'])->toBe(20.0);
+    });
+
+    it('handles empty query logs in statistics', function () {
+        $this->logger->enable();
+
+        $stats = $this->logger->getStatistics();
+
+        expect($stats['total_queries'])->toBe(0);
+        expect($stats['average_time_ms'])->toBe(0.0);
+    });
+
+    it('skips framework internals when finding caller', function () {
+        $this->logger->enable();
+
+        $this->logger->logQuery('SELECT * FROM users', [], 5.0);
+
+        $logs = $this->logger->getQueryLogs();
+
+        // Caller should not be from /Framework/Database/ or /vendor/
+        if ($logs[0]->callerClass) {
+            expect($logs[0]->callerClass)->not->toContain('Framework\\Database');
+            expect($logs[0]->callerClass)->not->toContain('vendor');
+        }
+    });
+
+    it('formats stack trace correctly', function () {
+        $this->logger->enable();
+
+        $this->logger->logQuery('SELECT * FROM users', [], 5.0);
+
+        $logs = $this->logger->getQueryLogs();
+        $stackTrace = $logs[0]->stackTrace;
+
+        // Stack trace should contain class/method and file:line format
+        expect($stackTrace)->toMatch('/.+\(.+:\d+\)/');
+    });
+});

tests/Database/QueryOptimization/QueryPatternTest.php

@@ -0,0 +1,183 @@
+<?php
+
+declare(strict_types=1);
+
+use App\Framework\Database\QueryOptimization\ValueObjects\QueryLog;
+use App\Framework\Database\QueryOptimization\ValueObjects\QueryPattern;
+
+describe('QueryPattern Value Object', function () {
+    it('groups queries by pattern', function () {
+        $queries = [
+            new QueryLog('SELECT * FROM users WHERE id = ?', [1], 5.0, ''),
+            new QueryLog('SELECT * FROM users WHERE id = ?', [2], 4.5, ''),
+            new QueryLog('SELECT * FROM users WHERE id = ?', [3], 6.0, ''),
+        ];
+
+        $pattern = new QueryPattern('SELECT * FROM users WHERE id = ?', $queries);
+
+        expect($pattern->getExecutionCount())->toBe(3);
+        expect($pattern->getTotalExecutionTimeMs())->toBe(15.5);
+        expect($pattern->getAverageExecutionTimeMs())->toBe(5.166666666666667);
+    });
+
+    it('detects potential N+1 pattern', function () {
+        $queries = [];
+
+        for ($i = 1; $i <= 10; $i++) {
+            $queries[] = new QueryLog(
+                sql: 'SELECT * FROM posts WHERE user_id = ?',
+                bindings: [$i],
+                executionTimeMs: 5.0,
+                stackTrace: 'UserController::show'
+            );
+        }
+
+        $pattern = new QueryPattern('SELECT * FROM posts WHERE user_id = ?', $queries);
+
+        expect($pattern->isPotentialNPlusOne())->toBeTrue();
+    });
+
+    it('rejects pattern with too few executions', function () {
+        $queries = [
+            new QueryLog('SELECT * FROM users WHERE id = ?', [1], 5.0, ''),
+            new QueryLog('SELECT * FROM users WHERE id = ?', [2], 5.0, ''),
+        ];
+
+        $pattern = new QueryPattern('SELECT * FROM users WHERE id = ?', $queries);
+
+        expect($pattern->isPotentialNPlusOne())->toBeFalse();
+    });
+
+    it('rejects pattern without WHERE clause', function () {
+        $queries = [];
+
+        for ($i = 1; $i <= 10; $i++) {
+            $queries[] = new QueryLog(
+                sql: 'SELECT * FROM users',
+                bindings: [],
+                executionTimeMs: 5.0,
+                stackTrace: ''
+            );
+        }
+
+        $pattern = new QueryPattern('SELECT * FROM users', $queries);
+
+        expect($pattern->isPotentialNPlusOne())->toBeFalse();
+    });
+
+    it('rejects pattern with JOIN', function () {
+        $queries = [];
+
+        for ($i = 1; $i <= 10; $i++) {
+            $queries[] = new QueryLog(
+                sql: 'SELECT * FROM users LEFT JOIN posts ON users.id = posts.user_id WHERE users.id = ?',
+                bindings: [$i],
+                executionTimeMs: 5.0,
+                stackTrace: ''
+            );
+        }
+
+        $pattern = new QueryPattern(
+            'SELECT * FROM users LEFT JOIN posts ON users.id = posts.user_id WHERE users.id = ?',
+            $queries
+        );
+
+        expect($pattern->isPotentialNPlusOne())->toBeFalse();
+    });
+
+    it('calculates N+1 severity correctly', function () {
+        $queries = [];
+
+        // High execution count (20 queries)
+        for ($i = 1; $i <= 20; $i++) {
+            $queries[] = new QueryLog(
+                sql: 'SELECT * FROM posts WHERE user_id = ?',
+                bindings: [$i],
+                executionTimeMs: 10.0,
+                stackTrace: 'UserController::show',
+                callerClass: 'UserController',
+                callerMethod: 'show'
+            );
+        }
+
+        $pattern = new QueryPattern('SELECT * FROM posts WHERE user_id = ?', $queries);
+
+        $severity = $pattern->getNPlusOneSeverity();
+
+        // Should be high severity (execution count > 10, consistent caller, high total time)
+        expect($severity)->toBeGreaterThan(6);
+    });
+
+    it('classifies severity levels correctly', function () {
+        $highSeverityQueries = [];
+
+        for ($i = 1; $i <= 50; $i++) {
+            $highSeverityQueries[] = new QueryLog(
+                sql: 'SELECT * FROM posts WHERE user_id = ?',
+                bindings: [$i],
+                executionTimeMs: 15.0,
+                stackTrace: 'UserController::show',
+                callerClass: 'UserController',
+                callerMethod: 'show'
+            );
+        }
+
+        $pattern = new QueryPattern('SELECT * FROM posts WHERE user_id = ?', $highSeverityQueries);
+
+        expect($pattern->getSeverityLevel())->toBeIn(['CRITICAL', 'HIGH']);
+    });
+
+    it('identifies table name', function () {
+        $queries = [
+            new QueryLog('SELECT * FROM users WHERE id = ?', [1], 5.0, ''),
+        ];
+
+        $pattern = new QueryPattern('SELECT * FROM users WHERE id = ?', $queries);
+
+        expect($pattern->getTableName())->toBe('users');
+    });
+
+    it('checks for consistent caller', function () {
+        $queries = [];
+
+        for ($i = 1; $i <= 10; $i++) {
+            $queries[] = new QueryLog(
+                sql: 'SELECT * FROM posts WHERE user_id = ?',
+                bindings: [$i],
+                executionTimeMs: 5.0,
+                stackTrace: '',
+                callerClass: 'UserController',
+                callerMethod: 'show'
+            );
+        }
+
+        $pattern = new QueryPattern('SELECT * FROM posts WHERE user_id = ?', $queries);
+
+        expect($pattern->hasConsistentCaller())->toBeTrue();
+    });
+
+    it('detects inconsistent caller', function () {
+        $queries = [
+            new QueryLog('SELECT * FROM posts WHERE user_id = ?', [1], 5.0, '', callerClass: 'UserController', callerMethod: 'show'),
+            new QueryLog('SELECT * FROM posts WHERE user_id = ?', [2], 5.0, '', callerClass: 'PostController', callerMethod: 'index'),
+            new QueryLog('SELECT * FROM posts WHERE user_id = ?', [3], 5.0, '', callerClass: 'UserController', callerMethod: 'show'),
+        ];
+
+        $pattern = new QueryPattern('SELECT * FROM posts WHERE user_id = ?', $queries);
+
+        expect($pattern->hasConsistentCaller())->toBeFalse();
+    });
+
+    it('gets caller locations', function () {
+        $queries = [
+            new QueryLog('SELECT * FROM posts WHERE user_id = ?', [1], 5.0, '', callerClass: 'UserController', callerMethod: 'show', callerLine: 42),
+            new QueryLog('SELECT * FROM posts WHERE user_id = ?', [2], 5.0, '', callerClass: 'UserController', callerMethod: 'show', callerLine: 42),
+        ];
+
+        $pattern = new QueryPattern('SELECT * FROM posts WHERE user_id = ?', $queries);
+
+        $locations = $pattern->getCallerLocations();
+
+        expect($locations)->toContain('UserController::show:42');
+    });
+});