Мониторинг с Prometheus в PHP

# HELP http_requests_total Общее количество HTTP запросов
# TYPE http_requests_total counter
http_requests_total{method="get",endpoint="/api"} 1234

use Prometheus\CollectorRegistry;
use Prometheus\Storage\APC;
 
$registry = new CollectorRegistry(new APC());
 
// Создаём счётчик HTTP-запросов
$counter = $registry->getOrRegisterCounter('app', 'http_requests_total', 'desc');
$counter->inc(); // Увеличиваем счётчик при каждом запросе

use Prometheus\Client\Gauge;
use Prometheus\Client\Storage\Redis;
 
$storage = new Redis(['host' => 'localhost']);
$gauge = new Gauge('memory_usage', 'Memory usage in bytes', ['type']);
 
// Отслеживаем использование памяти
$gauge->set(memory_get_usage(true), ['real']);
$gauge->set(memory_get_usage(false), ['allocated']);

class PrometheusMiddleware
{
    private $registry;
    private $requestsCounter;
    
    public function __construct(CollectorRegistry $registry)
    {
        $this->registry = $registry;
        $this->requestsCounter = $registry->getOrRegisterCounter(
            'http',
            'requests_total',
            'HTTP requests count',
            ['method', 'path', 'status']
        );
    }
    
    public function __invoke($request, $response, $next)
    {
        $start = microtime(true);
        $response = $next($request, $response);
        
        $this->requestsCounter->inc([
            $request->getMethod(),
            $request->getUri()->getPath(),
            $response->getStatusCode()
        ]);
        
        return $response;
    }
}

class MetricsBuffer
{
    private $buffer = [];
    private $maxSize = 100;
    
    public function add($metric, $value, $labels = [])
    {
        $this->buffer[] = [$metric, $value, $labels];
        
        if (count($this->buffer) >= $this->maxSize) {
            $this->flush();
        }
    }
    
    public function flush()
    {
        foreach ($this->buffer as [$metric, $value, $labels]) {
            $metric->set($value, $labels);
        }
        $this->buffer = [];
    }
}

// Плохой пример - слишком много уникальных значений
$counter->inc(['user_id' => $userId]);
 
// Хороший пример - ограниченное число значений
$counter->inc(['user_type' => $userType]);

class AsyncMetricsCollector
{
    private $redis;
    
    public function recordJobStart($jobId, $type)
    {
        $this->redis->hSet(
            'job_metrics',
            $jobId,
            json_encode([
                'start_time' => microtime(true),
                'type' => $type
            ])
        );
    }
    
    public function recordJobEnd($jobId, $status)
    {
        $data = json_decode($this->redis->hGet('job_metrics', $jobId), true);
        $duration = microtime(true) - $data['start_time'];
        
        // Записываем метрики в Prometheus
        $this->jobDuration->observe($duration, [$data['type'], $status]);
        $this->redis->hDel('job_metrics', $jobId);
    }
}

namespace App\Metrics;
 
class MetricsRegistry
{
    public static function getHttpMetrics($registry)
    {
        return [
            'requests' => $registry->getOrRegisterCounter(
                'http',
                'requests_total',
                'Total HTTP requests',
                ['service', 'method', 'path']
            ),
            'duration' => $registry->getOrRegisterHistogram(
                'http',
                'request_duration_seconds',
                'Request duration in seconds',
                ['service'],
                [0.1, 0.3, 1.0, 3.0]
            )
        ];
    }
}

class MetricsAspect
{
    private $registry;
    
    public function beforeMethod($method)
    {
        $timer = $this->registry->getOrRegisterHistogram(
            'method_duration_seconds',
            'Method execution time',
            ['class', 'method']
        );
        
        $timer->startTimer([
            get_class($method->getObject()),
            $method->getName()
        ]);
    }
    
    public function afterMethod($method)
    {
        $timer->endTimer();
    }
}

trait PrometheusMetricsTrait 
{
    protected function recordMetric($name, $value, array $labels = [])
    {
        $metric = $this->getMetricRegistry()->getOrRegisterGauge(
            $this->getMetricNamespace(),
            $name,
            'Description',
            array_keys($labels)
        );
        
        $metric->set($value, array_values($labels));
    }
    
    protected function incrementCounter($name, array $labels = [])
    {
        $counter = $this->getMetricRegistry()->getOrRegisterCounter(
            $this->getMetricNamespace(),
            $name,
            'Description',
            array_keys($labels)
        );
        
        $counter->inc(array_values($labels));
    }
}

class MetricsPool
{
    private $metrics = [];
    private $registry;
    
    public function getMetric($type, $name, array $labels = [])
    {
        $key = sprintf('%s_%s_%s', $type, $name, implode('_', $labels));
        
        if (!isset($this->metrics[$key])) {
            $this->metrics[$key] = $this->createMetric($type, $name, $labels);
        }
        
        return $this->metrics[$key];
    }
    
    private function createMetric($type, $name, array $labels)
    {
        switch ($type) {
            case 'counter':
                return $this->registry->getOrRegisterCounter(
                    'app',
                    $name,
                    'Description',
                    $labels
                );
            case 'gauge':
                return $this->registry->getOrRegisterGauge(
                    'app',
                    $name,
                    'Description',
                    $labels
                );
        }
    }
}

class MetricsSafetyNet
{
    private $metrics = [];
    
    public function __construct()
    {
        register_shutdown_function([$this, 'flush']);
    }
    
    public function addMetric($metric)
    {
        $this->metrics[] = $metric;
    }
    
    public function flush()
    {
        foreach ($this->metrics as $metric) {
            try {
                $metric->flush();
            } catch (Exception $e) {
                error_log('Failed to flush metric: ' . $e->getMessage());
            }
        }
    }
}

class DistributedMetricsContext
{
    private $labels = [];
    
    public function __construct()
    {
        $this->labels = [
            'host' => gethostname(),
            'instance' => getenv('INSTANCE_ID'),
            'datacenter' => getenv('DC_NAME')
        ];
    }
    
    public function enrichMetric($metric, array $additionalLabels = [])
    {
        return array_merge($this->labels, $additionalLabels);
    }
}

class MetricsSampler
{
    private $sampleRate;
    
    public function __construct($sampleRate = 0.1)
    {
        $this->sampleRate = $sampleRate;
    }
    
    public function shouldRecord()
    {
        return (random_int(0, 100) / 100) <= $this->sampleRate;
    }
    
    public function recordWithSampling($metric, $value, $labels = [])
    {
        if ($this->shouldRecord()) {
            $adjustedValue = $value / $this->sampleRate;
            $metric->observe($adjustedValue, $labels);
        }
    }
}

class MetricsValidator
{
    public function validateMetricName($name)
    {
        if (!preg_match('/^[a-zA-Z_:][a-zA-Z0-9_:]*$/', $name)) {
            throw new InvalidArgumentException(
                'Invalid metric name: ' . $name
            );
        }
    }
    
    public function validateLabelName($name)
    {
        if (!preg_match('/^[a-zA-Z_][a-zA-Z0-9_]*$/', $name)) {
            throw new InvalidArgumentException(
                'Invalid label name: ' . $name
            );
        }
    }
    
    public function validateLabelValue($value)
    {
        if (strlen($value) > 1000) {
            throw new InvalidArgumentException('Label value too long');
        }
    }
}

class MetricsCircuitBreaker
{
    private $failures = 0;
    private $threshold = 3;
    private $timeout = 60;
    private $lastFailure;
    
    public function recordMetricSafely($callback)
    {
        if ($this->isOpen()) {
            if (time() - $this->lastFailure > $this->timeout) {
                $this->reset();
            } else {
                return;
            }
        }
        
        try {
            $callback();
            $this->reset();
        } catch (Exception $e) {
            $this->failures++;
            $this->lastFailure = time();
            throw $e;
        }
    }
    
    private function isOpen()
    {
        return $this->failures >= $this->threshold;
    }
    
    private function reset()
    {
        $this->failures = 0;
        $this->lastFailure = null;
    }
}

class PerformanceMonitor 
{
    private $histogram;
    
    public function __construct(CollectorRegistry $registry) 
    {
        $this->histogram = $registry->getOrRegisterHistogram(
            'app',
            'operation_duration_seconds',
            'Operation duration in seconds',
            ['operation_type'],
            [0.01, 0.05, 0.1, 0.5, 1, 5]
        );
    }
    
    public function measureOperation(callable $operation, string $type) 
    {
        $timer = $this->histogram->startTimer(['type' => $type]);
        try {
            return $operation();
        } finally {
            $timer->observe();
        }
    }
}

class BusinessMetrics 
{
    private $orderCounter;
    private $revenueGauge;
    
    public function trackOrder($amount, $status) 
    {
        $this->orderCounter->inc(['status' => $status]);
        
        if ($status === 'completed') {
            $this->revenueGauge->add($amount);
        }
    }
    
    public function trackUserActivity($type) 
    {
        $this->activityCounter->inc(['type' => $type]);
    }
}

class QueueMonitor 
{
    private $queueSize;
    private $processTime;
    
    public function trackMessageProcessing($queueName, callable $processor) 
    {
        $this->queueSize->set(
            $this->getQueueLength($queueName),
            ['queue' => $queueName]
        );
        
        $start = microtime(true);
        $result = $processor();
        
        $this->processTime->observe(
            microtime(true) - $start,
            ['queue' => $queueName]
        );
        
        return $result;
    }
}

class TrendAnalyzer 
{
    private $baseline;
    private $current;
    
    public function detectAnomaly($metric, $window = '1h') 
    {
        $query = sprintf(
            'abs(rate(%s[%s]) / avg_over_time(%s[24h]) - 1) > 0.2',
            $metric,
            $window,
            $metric
        );
        
        return $this->evaluateQuery($query);
    }
}

class ErrorTracker 
{
    private $errorCounter;
    private $lastError;
    
    public function trackError(\Throwable $e) 
    {
        $type = get_class($e);
        $this->errorCounter->inc(['type' => $type]);
        
        $this->lastError->set(
            time(),
            [
                'type' => $type,
                'message' => substr($e->getMessage(), 0, 100)
            ]
        );
    }
}

class ServiceCallTracker 
{
    private $latency;
    private $failures;
    
    public function trackCall($from, $to, callable $call) 
    {
        $timer = $this->latency->startTimer([
            'from_service' => $from,
            'to_service' => $to
        ]);
        
        try {
            return $call();
        } catch (\Exception $e) {
            $this->failures->inc([
                'from_service' => $from,
                'to_service' => $to,
                'error_type' => get_class($e)
            ]);
            throw $e;
        } finally {
            $timer->observe();
        }
    }
}

class DashboardGenerator 
{
    public function generateQueries() 
    {
        return [
            'error_rate' => 'sum(rate(http_errors_total[5m])) by (service)',
            'latency_p95' => 'histogram_quantile(0.95, sum(rate(http_request_duration_bucket[5m])) by (le, service))',
            'throughput' => 'sum(rate(http_requests_total[5m])) by (service)'
        ];
    }
}

class HierarchicalCollector 
{
    private $aggregator;
    
    public function aggregateMetrics($sources) 
    {
        foreach ($sources as $source) {
            $metrics = $this->fetchMetrics($source);
            $this->aggregator->addMetrics(
                $metrics,
                ['datacenter' => $source->getDatacenter()]
            );
        }
    }
}

class DashboardMetrics
{
    private $queries = [
        'memory' => 'process_resident_memory_bytes{job="php"}',
        'gc_runs' => 'rate(php_gc_runs_total[5m])',
        'opcache_hits' => 'rate(php_opcache_hit_total[5m])'
    ];
    
    public function getMemoryUsagePanel()
    {
        return [
            'title' => 'PHP Memory Usage',
            'type' => 'graph',
            'metrics' => [
                $this->queries['memory'],
                'deriv(' . $this->queries['memory'] . '[5m])'
            ]
        ];
    }
}

class FailurePrediction
{
    public function detectAnomalies($metric, $threshold = 2)
    {
        $query = sprintf(
            'abs(
                (rate(%s[1h]) - rate(%s[12h]))
                / rate(%s[12h])
            ) > %f',
            $metric, $metric, $metric, $threshold
        );
        
        return $this->queryPrometheus($query);
    }
}

class MetricsCorrelator
{
    private $logReader;
    private $metricsClient;
    
    public function correlateErrors($timeWindow)
    {
        $errors = $this->logReader->getErrors($timeWindow);
        $metrics = $this->metricsClient->getMetrics($timeWindow);
        
        return array_map(function($error) use ($metrics) {
            return [
                'error' => $error,
                'metrics' => $this->findRelatedMetrics($error, $metrics)
            ];
        }, $errors);
    }
}

class ServiceHealthCheck
{
    private $healthMetrics;
    
    public function checkServiceHealth($service)
    {
        $metrics = [
            'latency' => $this->getServiceLatency($service),
            'error_rate' => $this->getErrorRate($service),
            'dependencies' => $this->checkDependencies($service)
        ];
        
        return $this->evaluateHealth($metrics);
    }
}

class AutoscalingRules
{
    public function shouldScale($metrics)
    {
        return [
            'cpu' => $metrics['cpu_usage'] > 80,
            'memory' => $metrics['memory_usage'] > 85,
            'requests' => $metrics['request_rate'] > 1000
        ];
    }
}

class DatabaseMetrics
{
    private $slowQueryTracker;
    
    public function trackQuery($sql, $duration)
    {
        $hash = md5($sql);
        $this->slowQueryTracker->observe(
            $duration,
            ['query_hash' => $hash]
        );
        
        if ($duration > 1.0) {
            $this->logSlowQuery($sql, $duration);
        }
    }
}

class SessionMetrics
{
    public function trackSession($sessionId)
    {
        $this->activeUsers->inc();
        
        register_shutdown_function(function() {
            $this->activeUsers->dec();
        });
        
        $this->sessionDuration->startTimer(['session_id' => $sessionId]);
    }
}

class CacheMetrics
{
    private $hitRatio;
    private $missCount;
    
    public function recordCacheAccess($key, $hit)
    {
        $labels = ['cache_type' => $this->getCacheType()];
        
        if ($hit) {
            $this->hitRatio->inc($labels);
        } else {
            $this->missCount->inc($labels);
        }
    }
}

class ProfilingMetrics
{
    private $functionDuration;
    
    public function startProfiling($function)
    {
        return $this->functionDuration->startTimer([
            'function' => $function,
            'file' => $this->getCallerFile()
        ]);
    }
}

class MonitoringMigration
{
    private $legacySystem;
    private $prometheus;
    
    public function duplicateMetrics($metric, $value, $labels)
    {
        // Отправляем метрики в обе системы
        $this->legacySystem->send($metric, $value);
        $this->prometheus->record($metric, $value, $labels);
    }
}

class HighAvailability
{
    private $instances = [];
    
    public function recordMetric($metric, $value)
    {
        foreach ($this->instances as $instance) {
            try {
                $instance->record($metric, $value);
            } catch (Exception $e) {
                $this->handleFailure($instance, $e);
            }
        }
    }
}

class MonitoringHealth
{
    public function checkHealth()
    {
        return [
            'scrape_duration' => $this->getScrapeDuration(),
            'target_health' => $this->checkTargets(),
            'storage_usage' => $this->getStorageMetrics()
        ];
    }
}

class ApiMonitor 
{
    private $responseTime;
    private $errorRate;
    
    public function trackEndpoint($method, $path, callable $handler) 
    {
        $timer = $this->responseTime->startTimer([
            'method' => $method,
            'path' => $path
        ]);
        
        try {
            $result = $handler();
            return $result;
        } catch (ApiException $e) {
            $this->errorRate->inc([
                'method' => $method,
                'path' => $path,
                'code' => $e->getCode()
            ]);
            throw $e;
        } finally {
            $timer->observe();
        }
    }
}

class QueueMonitoring 
{
    private $queueSize;
    private $processRate;
    
    public function processMessage($queueName, $message) 
    {
        $size = $this->getQueueSize($queueName);
        $this->queueSize->set($size, ['queue' => $queueName]);
        
        $start = microtime(true);
        $this->processMessageContent($message);
        
        $duration = microtime(true) - $start;
        $this->processRate->observe($duration, ['queue' => $queueName]);
    }
}

class DashboardConfig 
{
    public function getLatencyPanel() 
    {
        return [
            'title' => 'API Latency',
            'type' => 'graph',
            'metrics' => [
                'histogram_quantile(0.95, sum(rate(http_request_duration_bucket[5m])) by (le))',
                'histogram_quantile(0.99, sum(rate(http_request_duration_bucket[5m])) by (le))'
            ]
        ];
    }
}