# Ubuntu с репозиторием Ondřej Surý
sudo add-apt-repository ppa:ondrej/php
sudo apt update
sudo apt install php8.2 php8.2-fpm php8.2-mysql php8.2-mbstring php8.2-xml php8.2-gd php8.2-curl

# CentOS/RHEL с репозиторием REMI
sudo dnf install https://rpms.remirepo.net/enterprise/remi-release-8.rpm
sudo dnf module reset php
sudo dnf module enable php:remi-8.2
sudo dnf install php php-fpm php-mysqlnd php-mbstring php-xml php-gd php-curl

# Проверка установленной версии
php -v

# Определение расположения используемого php.ini
php -i | grep "Loaded Configuration File"

# Создание phpinfo-файла для получения полной информации
echo "" > /var/www/html/phpinfo.php

# Проверка текущих настроек через CLI
php -r "echo ini_get('memory_limit');"

; Управление памятью
memory_limit = 256M          ; Увеличьте для сложных приложений
max_execution_time = 30      ; Установите в соответствии с требованиями

; Обработка файлов
upload_max_filesize = 20M    ; Устанавливайте по необходимости
post_max_size = 20M          ; Обычно равно или больше upload_max_filesize
max_file_uploads = 20        ; Максимальное количество файлов за один запрос

; Сессии
session.gc_maxlifetime = 1440 ; Время жизни сессий в секундах
session.save_handler = files  ; Измените на redis/memcached для высоконагруженных систем

; Логирование и отладка (для production)
display_errors = Off
display_startup_errors = Off
log_errors = On
error_log = /var/log/php_errors.log
error_reporting = E_ALL & ~E_DEPRECATED & ~E_STRICT

; Настройки для работы с кодировками
default_charset = "UTF-8"

; Включение интернационализации — используйте только если необходимо
extension=intl

; Отключение ненужных расширений — закомментируйте неиспользуемые
;extension=pdo_firebird
;extension=pdo_dblib

; Настройки для улучшения сетевого взаимодействия
default_socket_timeout = 60
zlib.output_compression = On      ; Сжатие ответов (если не используется на уровне веб-сервера)
zlib.output_compression_level = 6 ; Баланс между скоростью и степенью сжатия

; Настройки для фреймворков и CMS
realpath_cache_size = 4M          ; Увеличьте для больших проектов
realpath_cache_ttl = 600          ; Время хранения кэша путей к файлам

; Настройки PDO для работы с БД
pdo_mysql.cache_size = 2000       ; Кеш подготовленных запросов

; Разработка
display_errors = On
display_startup_errors = On
error_reporting = E_ALL
opcache.enable = 0               ; Может быть отключен для быстрого тестирования изменений
mysqlnd.collect_statistics = On  ; Сбор подробной статистики для отладки

; Продакшн
display_errors = Off
display_startup_errors = Off
error_reporting = E_ALL & ~E_DEPRECATED & ~E_STRICT
opcache.enable = 1
opcache.validate_timestamps = 0  ; Отключено для максимальной производительности
mysqlnd.collect_statistics = Off

; Включение OPcache
opcache.enable=1
opcache.enable_cli=1       ; Включить также для CLI (полезно для cron-задач)

; Настройки памяти
opcache.memory_consumption=128       ; Размер памяти для кэша (MB)
opcache.interned_strings_buffer=16   ; Кэш для интернированных строк
opcache.max_accelerated_files=10000  ; Максимальное количество файлов в кэше

; Оптимизация производительности
opcache.revalidate_freq=0            ; Интервал проверки изменений в файлах (в продакшене часто 0)
opcache.validate_timestamps=0        ; В продакшене отключают проверку изменений файлов
opcache.save_comments=0              ; Удаление комментариев для экономии памяти
opcache.fast_shutdown=1              ; Быстрое освобождение памяти

; Дополнительные оптимизации
opcache.optimization_level=0xffffffff ; Максимальный уровень оптимизации
opcache.jit_buffer_size=100M         ; Размер буфера JIT (PHP 8+)

; Настройка предварительной загрузки в php.ini
opcache.preload=/var/www/preload.php    ; Путь к скрипту предварительной загрузки
opcache.preload_user=www-data           ; Пользователь для выполнения скрипта предзагрузки

; Пример файла предварительной загрузки (preload.php)
isFile() && $file->getExtension() === 'php') {
            opcache_compile_file($file->getPathname());
        }
    }
}

preload_directory('/var/www/app/Core');

# Установка OPcache GUI
git clone https://github.com/amnuts/opcache-gui.git /var/www/html/opcache-gui
chmod 755 /var/www/html/opcache-gui

# Очистка кэша OPcache (полезно при обновлении кода)
php -r "opcache_reset();"

# Проверка статуса OPcache
php -r "print_r(opcache_get_status());"

# Скрипт для очистки кеша после деплоя
function clear_opcache() {
    echo "Clearing OPcache..."
    curl -s http://example.com/opcache-clear.php
}

# Содержимое opcache-clear.php (защитите доступ!)

                            

; Базовая конфигурация пула (www.conf)
[www]
user = www-data
group = www-data
listen = /run/php/php8.2-fpm.sock
listen.owner = www-data
listen.group = www-data

; Управление процессами
pm = dynamic                  ; Метод управления процессами (static, dynamic, ondemand)
pm.max_children = 50          ; Максимальное количество процессов
pm.start_servers = 5          ; Стартовое количество процессов
pm.min_spare_servers = 5      ; Минимальное количество простаивающих процессов
pm.max_spare_servers = 10     ; Максимальное количество простаивающих процессов
pm.max_requests = 500         ; Количество запросов до перезапуска процесса

; Логирование
php_admin_value[error_log] = /var/log/php8.2-fpm.www.log
php_admin_flag[log_errors] = on

; Настройки безопасности
php_admin_value[open_basedir] = /var/www/html
php_admin_value[disable_functions] = exec,passthru,shell_exec,system

; Настройки сессий и загрузки файлов
php_value[session.save_handler] = files
php_value[session.save_path] = /var/lib/php/sessions
php_value[upload_tmp_dir] = /var/lib/php/uploads

; Конфигурация для высоконагруженного сайта (static)
pm = static
pm.max_children = 50      ; Должно быть достаточно для обработки пиковой нагрузки

; Конфигурация для сайта со средней нагрузкой (dynamic)
pm = dynamic
pm.max_children = 50
pm.start_servers = 10
pm.min_spare_servers = 5
pm.max_spare_servers = 15
pm.max_requests = 1000

; Конфигурация для сайта с низкой нагрузкой (ondemand)
pm = ondemand
pm.max_children = 20
pm.process_idle_timeout = 10s
pm.max_requests = 500

# Расчёт оптимального значения pm.max_children
# Формула: RAM_доступно / Средний_размер_процесса_PHP = Max_Children

# Проверка среднего размера процесса PHP
ps -ylC php-fpm8.2 --sort:rss | awk '{ sum+=$8; n++ } END { print sum/n/1024 "MB" }'

# Пример:
# Доступно: 4 ГБ RAM
# Средний размер процесса PHP: 80 МБ
# 4000 МБ / 80 МБ = 50 процессов (это максимальное значение)

; Основной пул для высоконагруженного сайта
[main-site]
user = www-data
group = www-data
listen = /run/php/php8.2-fpm-main.sock
pm = dynamic
pm.max_children = 40
pm.start_servers = 10
pm.min_spare_servers = 5
pm.max_spare_servers = 15
php_admin_value[memory_limit] = 256M

; Пул для админ-панели с более высоким лимитом времени выполнения
[admin]
user = www-data
group = www-data
listen = /run/php/php8.2-fpm-admin.sock
pm = ondemand
pm.max_children = 10
php_admin_value[memory_limit] = 512M
php_admin_value[max_execution_time] = 300

; Отдельный пул для API
[api]
user = www-data
group = www-data
listen = /run/php/php8.2-fpm-api.sock
pm = static
pm.max_children = 30
php_admin_value[memory_limit] = 128M
php_admin_value[max_execution_time] = 30

; Включение JIT в PHP 8.0+
opcache.enable=1             ; JIT требует включенного OPcache
opcache.jit_buffer_size=100M ; Размер буфера для машинного кода JIT
opcache.jit=1255             ; Режим работы JIT-компилятора

; Рекомендуемые настройки JIT для разных сценариев
; Оптимальная производительность (tracing JIT)
opcache.jit=1255
opcache.jit_buffer_size=100M

; Для CPU с меньшим количеством ядер
opcache.jit=1205
opcache.jit_buffer_size=64M

; Максимальная оптимизация (compile everything on load)
opcache.jit=1255
opcache.jit_buffer_size=200M

// Неоптимально: использование array_push для добавления одного элемента
$array = [];
for ($i = 0; $i < 1000; $i++) {
    array_push($array, $i);
}

// Оптимально: использование синтаксиса [] для добавления элемента
$array = [];
for ($i = 0; $i < 1000; $i++) {
    $array[] = $i;
}

// Неоптимально: повторный расчёт длины массива в цикле
for ($i = 0; $i < count($array); $i++) {
    // ...
}

// Оптимально: расчёт длины один раз
$length = count($array);
for ($i = 0; $i < $length; $i++) {
    // ...
}

// Неоптимально: создание временного массива при слиянии
$result = array_merge($array1, $array2, $array3);

// Оптимально: использование spread оператора (PHP 7.4+)
$result = [...$array1, ...$array2, ...$array3];

// Неоптимально: foreach с копированием элементов
foreach ($largeArray as $item) {
    process($item);
}

// Оптимально: foreach с передачей по ссылке
foreach ($largeArray as &$item) {
    process($item);
}
unset($item); // Важно разорвать ссылку после цикла

// Неоптимально: вложенные циклы без оптимизации
foreach ($users as $user) {
    foreach ($posts as $post) {
        if ($post['user_id'] === $user['id']) {
            // ...
        }
    }
}

// Оптимально: предварительная индексация для быстрого поиска
$postsByUser = [];
foreach ($posts as $post) {
    $postsByUser[$post['user_id']][] = $post;
}

foreach ($users as $user) {
    if (isset($postsByUser[$user['id']])) {
        foreach ($postsByUser[$user['id']] as $post) {
            // ...
        }
    }
}

// Неоптимально: конкатенация в цикле
$html = '';
foreach ($items as $item) {
    $html .= '
' . $item . '
';
}

// Оптимально: создание массива и объединение один раз
$parts = [];
foreach ($items as $item) {
    $parts[] = '
' . $item . '
';
}
$html = implode('', $parts);

// Неоптимально: многократное использование str_replace
$text = str_replace('one', '1', $text);
$text = str_replace('two', '2', $text);
$text = str_replace('three', '3', $text);

// Оптимально: использование массивов для замены
$text = str_replace(['one', 'two', 'three'], ['1', '2', '3'], $text);

// Неоптимально: вложенные условия
function processData($data) {
    if ($data) {
        if (isValid($data)) {
            if (hasPermission($data)) {
                // Логика обработки
                return $result;
            } else {
                return null;
            }
        } else {
            return null;
        }
    } else {
        return null;
    }
}

// Оптимально: ранние возвраты
function processData($data) {
    if (!$data) {
        return null;
    }
    
    if (!isValid($data)) {
        return null;
    }
    
    if (!hasPermission($data)) {
        return null;
    }
    
    // Логика обработки
    return $result;
}

// Неоптимально: повторный вызов тяжелой функции
function getUserData($userId) {
    return fetchFromDatabase($userId); // Дорогая операция
}

// Оптимально: использование статического кеша
function getUserData($userId) {
    static $cache = [];
    
    if (!isset($cache[$userId])) {
        $cache[$userId] = fetchFromDatabase($userId);
    }
    
    return $cache[$userId];
}

// Для PHP 8.0+: использование именованных аргументов и memoization
function memoize(callable $func): callable {
    return function(...$args) use ($func) {
        static $cache = [];
        
        $key = md5(serialize($args));
        if (!isset($cache[$key])) {
            $cache[$key] = $func(...$args);
        }
        
        return $cache[$key];
    };
}

$getUserData = memoize(fn($userId) => fetchFromDatabase($userId));

// PHP 7.4+: Типизированные свойства класса
class User {
    public int $id;
    public string $name;
    public ?string $email = null;
}

// PHP 8.0+: Конструктор с продвижением свойств
class User {
    public function __construct(
        public int $id,
        public string $name,
        public ?string $email = null
    ) {}
}

// PHP 8.0+: Nullsafe оператор
$country = $user?->getAddress()?->country;

// PHP 8.0+: Match expression вместо switch
$result = match ($status) {
    'success' => handleSuccess(),
    'error' => handleError(),
    default => handleDefault(),
};

# Установка Xdebug
sudo apt install php8.2-xdebug

# Настройка Xdebug для профилирования (php.ini или xdebug.ini)
[xdebug]
zend_extension=xdebug.so
xdebug.mode=profile
xdebug.start_with_request=trigger
xdebug.output_dir=/tmp/xdebug
xdebug.profiler_output_name=profile.%p.%r.out

# Запуск профилирования через URL-параметр
http://example.com/?XDEBUG_PROFILE=1

# Анализ профиля с помощью KCachegrind/QCachegrind
sudo apt install kcachegrind
kcachegrind /tmp/xdebug/profile.*.out

// Пример простого профилировщика
function profile($name, callable $callback, ...$args) {
$start = microtime(true);
$memoryStart = memory_get_usage();

$result = $callback(...$args);

$time = microtime(true) - $start;
$memory = memory_get_usage() - $memoryStart;

echo sprintf(
    "Профиль [%s]: Время: %.6f сек., Память: %.2f КБ\n",
    $name,
    $time,
    $memory / 1024
);

return $result;
}

// Использование
$result = profile('getSalesData', function() {
// код, который нужно профилировать
return $data;
});

// Расширение PDO для профилирования запросов
class ProfilingPDO extends PDO {
private $queryLog = [];

public function query($statement, $mode = null, $arg3 = null, $arg4 = null) {
    $start = microtime(true);
    $result = parent::query($statement, $mode, $arg3, $arg4);
    $time = microtime(true) - $start;
    
    $this->queryLog[] = [
        'query' => $statement,
        'time' => $time
    ];
    
    return $result;
}

public function prepare($statement, $options = null) {
    $pdoStatement = parent::prepare($statement, $options);
    return new ProfilingPDOStatement($pdoStatement, $statement, $this->queryLog);
}

public function getQueryLog() {
    return $this->queryLog;
}
}

// Обёртка для подготовленных запросов
class ProfilingPDOStatement {
private $pdoStatement;
private $statement;
private &$queryLog;

public function __construct($pdoStatement, $statement, &$queryLog) {
    $this->pdoStatement = $pdoStatement;
    $this->statement = $statement;
    $this->queryLog = &$queryLog;
}

public function execute($params = null) {
    $start = microtime(true);
    $result = $this->pdoStatement->execute($params);
    $time = microtime(true) - $start;
    
    $this->queryLog[] = [
        'query' => $this->statement,
        'params' => $params,
        'time' => $time
    ];
    
    return $result;
}

// Другие методы PDOStatement с проксированием
}

// Использование
$pdo = new ProfilingPDO('mysql:host=localhost;dbname=test', 'user', 'pass');
// ... работа с базой данных ...
print_r($pdo->getQueryLog());

// Пример PHPUnit теста производительности
public function testPerformance()
{
// Установка базового времени выполнения
$maxExecutionTime = 0.05; // 50 мс

$start = microtime(true);

// Выполнение тестируемого кода
$result = $this->service->processData($this->testData);

$executionTime = microtime(true) - $start;

// Проверка, что время выполнения не превышает заданное
$this->assertLessThanOrEqual(
    $maxExecutionTime,
    $executionTime,
    "Метод занял {$executionTime} сек., что превышает порог {$maxExecutionTime} сек."
);
}

// Неоптимально: Создание нового запроса при каждом вызове
function getUserById($id) {
$db = getDatabaseConnection();
$result = $db->query("SELECT * FROM users WHERE id = {$id}");
return $result->fetch(PDO::FETCH_ASSOC);
}

// Оптимально: Использование подготовленных запросов
function getUserById($id) {
static $statement = null;
$db = getDatabaseConnection();

if ($statement === null) {
    $statement = $db->prepare("SELECT * FROM users WHERE id = ?");
}

$statement->execute([$id]);
return $statement->fetch(PDO::FETCH_ASSOC);
}

// Неоптимально: Множество отдельных запросов
foreach ($users as $user) {
$db->query("UPDATE users SET last_active = NOW() WHERE id = {$user['id']}");
}

// Оптимально: Batch-запрос
$ids = array_column($users, 'id');
$placeholders = implode(',', array_fill(0, count($ids), '?'));
$statement = $db->prepare("UPDATE users SET last_active = NOW() WHERE id IN ({$placeholders})");
$statement->execute($ids);

// Использование транзакций для множественных вставок
try {
$db->beginTransaction();

$statement = $db->prepare("INSERT INTO logs (user_id, action, timestamp) VALUES (?, ?, NOW())");

foreach ($actions as $action) {
    $statement->execute([$userId, $action]);
}

$db->commit();
} catch (Exception $e) {
$db->rollBack();
throw $e;
}

// Неоптимально: Выборка всех полей
$users = $db->query("SELECT * FROM users")->fetchAll();

// Оптимально: Выборка только нужных полей
$users = $db->query("SELECT id, name, email FROM users")->fetchAll();

// Неоптимально: Загрузка всех записей
$allUsers = $db->query("SELECT * FROM users")->fetchAll();
foreach ($allUsers as $user) {
if ($user['role'] === 'admin') {
    // Обработка админов
}
}

// Оптимально: Фильтрация на уровне БД
$admins = $db->query("SELECT * FROM users WHERE role = 'admin'")->fetchAll();

// Проблема N+1 запросов в ORM
// Неоптимально: Загрузка связанных данных в цикле
$posts = Post::all(); // 1 запрос
foreach ($posts as $post) {
$author = $post->author; // +1 запрос на каждую итерацию
echo $author->name;
}

// Оптимально: Предварительная загрузка связанных данных
$posts = Post::with('author')->get(); // 2 запроса вместо N+1
foreach ($posts as $post) {
echo $post->author->name; // Данные уже загружены
}

// Явное указание полей и использование пагинации
$users = User::select(['id', 'name', 'email'])
->where('active', true)
->orderBy('created_at', 'desc')
->limit(20)
->offset(40)
->get();

// Создание индексов для часто используемых полей
CREATE INDEX idx_users_email ON users(email);
CREATE INDEX idx_posts_user_id ON posts(user_id);
CREATE INDEX idx_products_category_status ON products(category_id, status);

// Неоптимально: Запрос не использует индекс
$products = $db->query("SELECT * FROM products WHERE LOWER(name) LIKE '%smartphone%'");

// Оптимально: Запрос использует индекс
$products = $db->query("SELECT * FROM products WHERE name LIKE 'smartphone%'");

// Полнотекстовый поиск для сложных запросов
CREATE FULLTEXT INDEX ft_products_name_description ON products(name, description);
$products = $db->query("SELECT * FROM products 
                   WHERE MATCH(name, description) AGAINST('smartphone' IN BOOLEAN MODE)");

function getPopularProducts($limit = 10) {
$cacheKey = "popular_products_{$limit}";
$cache = getCache(); // Redis, Memcached или другой механизм кеширования

// Попытка получить из кеша
$products = $cache->get($cacheKey);

if ($products === false) {
    // Данных в кеше нет, получаем из БД
    $db = getDatabaseConnection();
    $statement = $db->prepare("
        SELECT * FROM products 
        WHERE status = 'active'
        ORDER BY views_count DESC
        LIMIT ?
    ");
    $statement->execute([$limit]);
    $products = $statement->fetchAll(PDO::FETCH_ASSOC);
    
    // Сохраняем в кеш на 1 час
    $cache->set($cacheKey, $products, 3600);
}

return $products;
}

// Класс для работы с кешем Redis
class Cache {
private $redis;
private $defaultTtl;

public function __construct($host = 'localhost', $port = 6379, $defaultTtl = 3600) {
    $this->redis = new Redis();
    $this->redis->connect($host, $port);
    $this->defaultTtl = $defaultTtl;
}

public function get($key) {
    $result = $this->redis->get($key);
    return $result !== false ? json_decode($result, true) : false;
}

public function set($key, $value, $ttl = null) {
    $ttl = $ttl ?? $this->defaultTtl;
    return $this->redis->setex($key, $ttl, json_encode($value));
}

public function delete($key) {
    return $this->redis->del($key);
}

public function flush() {
    return $this->redis->flushAll();
}
}

// Пример использования для кеширования данных
function getCategoryProducts($categoryId) {
$cache = new Cache();
$cacheKey = "category_products_{$categoryId}";

$products = $cache->get($cacheKey);

if ($products === false) {
    // Данных в кеше нет, получаем из БД
    $db = getDatabaseConnection();
    $stmt = $db->prepare("SELECT * FROM products WHERE category_id = ?");
    $stmt->execute([$categoryId]);
    $products = $stmt->fetchAll(PDO::FETCH_ASSOC);
    
    // Сохраняем в кеш на 15 минут
    $cache->set($cacheKey, $products, 900);
}

return $products;
}

function renderNavigation() {
$cache = new Cache();
$cacheKey = "navigation_menu";

$html = $cache->get($cacheKey);

if ($html === false) {
    // Кеша нет, генерируем HTML навигации
    ob_start();
    // ... сложная логика генерации навигации ...
    $categories = getAllCategories();
    require 'templates/navigation.php';
    $html = ob_get_clean();
    
    // Сохраняем в кеш на 1 час
    $cache->set($cacheKey, $html, 3600);
}

return $html;
}

// Использование в шаблоне
echo renderNavigation();

function renderCachedPage($uniqueId, $ttl = 3600) {
$cache = new Cache();
$cacheKey = "page_{$uniqueId}";

$html = $cache->get($cacheKey);

if ($html === false) {
    // Начинаем буферизацию вывода
    ob_start();
    
    // Генерация страницы...
    require 'templates/header.php';
    require 'templates/content.php';
    require 'templates/footer.php';
    
    // Получаем сгенерированный HTML
    $html = ob_get_clean();
    
    // Сохраняем в кеш
    $cache->set($cacheKey, $html, $ttl);
}

return $html;
}

// Использование
$page = isset($_GET['page']) ? $_GET['page'] : 'home';
$userId = isset($_SESSION['user_id']) ? $_SESSION['user_id'] : 0;

// Если пользователь авторизован, страница уникальна для него
$uniqueId = $userId > 0 ? "{$page}_{$userId}" : $page;

// Вывод страницы с кешированием для гостей
if ($userId === 0) {
echo renderCachedPage($uniqueId);
} else {
// Для авторизованных пользователей не используем кеш
require 'templates/header.php';
require 'templates/content.php';
require 'templates/footer.php';
}

// Статические ресурсы с долгим сроком кеширования
function serveStaticFile($filename) {
$file = 'static/' . $filename;
$etag = md5_file($file);
$lastModified = filemtime($file);

// Отправка заголовков кеширования
header("Cache-Control: public, max-age=31536000"); // 1 год
header("Expires: " . gmdate("D, d M Y H:i:s", time() + 31536000) . " GMT");
header("Last-Modified: " . gmdate("D, d M Y H:i:s", $lastModified) . " GMT");
header("ETag: \"{$etag}\"");

// Проверка If-None-Match для условных запросов
if (isset($_SERVER['HTTP_IF_NONE_MATCH']) && $_SERVER['HTTP_IF_NONE_MATCH'] === "\"$etag\"") {
    header("HTTP/1.1 304 Not Modified");
    exit;
}

// Проверка If-Modified-Since
if (isset($_SERVER['HTTP_IF_MODIFIED_SINCE'])) {
    $ifModifiedSince = strtotime($_SERVER['HTTP_IF_MODIFIED_SINCE']);
    if ($lastModified <= $ifModifiedSince) {
        header("HTTP/1.1 304 Not Modified");
        exit;
    }
}

// Отправка файла
header("Content-Type: " . getMimeType($filename));
readfile($file);
exit;
}

// Для динамического контента с частым обновлением
function setDynamicPageHeaders() {
// Разрешаем кеширование, но требуем проверку свежести
header("Cache-Control: no-cache, must-revalidate");
header("Pragma: no-cache");
header("Expires: 0");
}

// Простой middleware для логирования производительности
function performanceMiddleware($callback) {
$startTime = microtime(true);
$startMemory = memory_get_usage();

// Выполнение основного запроса
$response = $callback();

// Расчет метрик
$endTime = microtime(true);
$endMemory = memory_get_usage();

$metrics = [
    'request_uri' => $_SERVER['REQUEST_URI'],
    'method' => $_SERVER['REQUEST_METHOD'],
    'execution_time' => round(($endTime - $startTime) * 1000, 2), // в мс
    'memory_usage' => round(($endMemory - $startMemory) / 1024, 2), // в КБ
    'timestamp' => date('Y-m-d H:i:s'),
    'php_version' => PHP_VERSION
];

// Логирование метрик
logMetrics($metrics);

return $response;
}

// Функция для сохранения метрик (пример для файлового лога)
function logMetrics($metrics) {
$logFile = '/var/log/app/performance.log';
$logLine = json_encode($metrics) . PHP_EOL;

file_put_contents($logFile, $logLine, FILE_APPEND);
}

// Использование в промышленном коде (1 из 100 запросов для снижения нагрузки)
if (rand(1, 100) === 1) {
register_shutdown_function(function() {
    $metrics = [
        'request_uri' => $_SERVER['REQUEST_URI'],
        'execution_time' => round((microtime(true) - $_SERVER['REQUEST_TIME_FLOAT']) * 1000, 2),
        'memory_peak' => round(memory_get_peak_usage() / 1024 / 1024, 2), // в МБ
        'timestamp' => date('Y-m-d H:i:s')
    ];
    logMetrics($metrics);
});
}

// Установка клиента Prometheus для PHP
composer require promphp/prometheus_client_php

// Создание файла exporter.php для сбора метрик
$adapter = new Prometheus\Storage\APC();
$registry = new Prometheus\CollectorRegistry($adapter);

// Счетчик запросов по URL
$counter = $registry->getOrRegisterCounter('app', 'requests_total', 'Total requests', ['route', 'method']);
$counter->incBy(1, [$_SERVER['REQUEST_URI'], $_SERVER['REQUEST_METHOD']]);

// Гистограмма времени ответа
$histogram = $registry->getOrRegisterHistogram(
'app',
'response_time_seconds',
'Response time in seconds',
['route'],
[0.01, 0.05, 0.1, 0.5, 1, 2]
);
$histogram->observe(microtime(true) - $_SERVER['REQUEST_TIME_FLOAT'], [$_SERVER['REQUEST_URI']]);

// Вывод метрик в формате Prometheus
header('Content-Type: text/plain; version=0.0.4');
echo $registry->render();

# Настройка Prometheus (prometheus.yml)
scrape_configs:
- job_name: 'php_app'
scrape_interval: 15s
static_configs:
  - targets: ['app.example.com:80']
metrics_path: '/metrics.php'

# Docker-compose для быстрого запуска мониторинга
version: '3'
services:
prometheus:
image: prom/prometheus
volumes:
  - ./prometheus.yml:/etc/prometheus/prometheus.yml
ports:
  - "9090:9090"

grafana:
image: grafana/grafana
depends_on:
  - prometheus
ports:
  - "3000:3000"

# Пример правила оповещения в Prometheus
groups:
- name: php_alerts
rules:
- alert: HighResponseTime
expr: avg(app_response_time_seconds) > 0.5
for: 5m
labels:
  severity: warning
annotations:
  summary: "High response time"
  description: "Average response time is above 500ms for 5 minutes"
  
- alert: HighErrorRate
expr: sum(rate(app_errors_total[5m])) / sum(rate(app_requests_total[5m])) > 0.05
for: 5m
labels:
  severity: critical
annotations:
  summary: "Error rate above 5%"
  description: "Application error rate is above 5% for 5 minutes"