SysLoad

1
<?php
2
/**
3
 * Plugin Name: SysLoad
4
 * Description: Плагин для отображения нагрузки процессора, использования памяти и времени работы сервера.
5
 * Version: 1.20
6
 * Author: Aleksey Krivoshein
7
 */
8

9
// Отображение статистики сервера
10
function display_server_stats() {
11
    ob_start();
12
    ?>
13
    <div id="server-stats" class="server-stats">
14
        <div class="charts-container">
15
            <div class="chart">
16
                <h3>Нагрузка процессора:</h3>
17
                <canvas id="cpu-load-chart" width="400" height="200"></canvas>
18
            </div>
19
            <div class="chart">
20
                <h3>Использование памяти:</h3>
21
                <canvas id="memory-usage-chart" width="400" height="200"></canvas>
22
            </div>
23
        </div>
24

25
        <h3>Статистика сервера:</h3>
26
        <table>
27
            <tr>
28
                <th>Параметр</th>
29
                <th>Значение</th>
30
            </tr>
31
            <tr>
32
                <td>Время работы сервера:</td>
33
                <td id="uptime-stats">Загрузка...</td>
34
            </tr>
35
            <tr>
36
                <td>Общая память:</td>
37
                <td id="total-memory-stats">Загрузка...</td>
38
            </tr>
39
            <tr>
40
                <td>Использованная память:</td>
41
                <td id="used-memory-stats">Загрузка...</td>
42
            </tr>
43
            <tr>
44
                <td>Нагрузка процессора:</td>
45
                <td id="cpu-load-stats">Загрузка...</td>
46
            </tr>
47
        </table>
48
    </div>
49
    <style>
50
        .charts-container {
51
            display: flex;
52
            flex-wrap: wrap;
53
            justify-content: space-between;
54
        }
55
        .chart {
56
            flex: 1;
57
            min-width: 300px;
58
            margin: 10px;
59
        }
60
        table {
61
            width: 100%;
62
            border-collapse: collapse;
63
            margin-top: 20px;
64
        }
65
        th, td {
66
            border: 1px solid #ddd;
67
            padding: 8px;
68
            text-align: left;
69
        }
70
        th {
71
            background-color: #f2f2f2;
72
        }
73
        @media (max-width: 768px) {
74
            .charts-container {
75
                flex-direction: column;
76
            }
77
            table {
78
                display: flex;
79
                flex-direction: column;
80
                border: none;
81
            }
82
            tr {
83
                display: flex;
84
                justify-content: space-between;
85
                border-bottom: 1px solid #ddd;
86
                padding: 8px 0;
87
            }
88
            th, td {
89
                flex: 1;
90
                text-align: left;
91
            }
92
        }
93
    </style>
94
    <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
95
    <script>
96
        jQuery(document).ready(function($) {
97
            let cpuData = [];
98
            let memoryUsedData = [];
99
            let totalMemory = 0;
100
            const cpuChartCtx = document.getElementById('cpu-load-chart').getContext('2d');
101
            const memoryChartCtx = document.getElementById('memory-usage-chart').getContext('2d');
102

103
            const cpuChart = new Chart(cpuChartCtx, {
104
                type: 'line',
105
                data: {
106
                    labels: [],
107
                    datasets: [{
108
                        label: 'Загрузка процессора (%)',
109
                        data: cpuData,
110
                        borderColor: 'rgba(75, 192, 192, 1)',
111
                        fill: false,
112
                    }]
113
                },
114
                options: {
115
                    scales: {
116
                        y: {
117
                            beginAtZero: true,
118
                            max: 100,
119
                            title: {
120
                                display: true,
121
                                text: 'Процент'
122
                            }
123
                        },
124
                        x: {
125
                            title: {
126
                                display: true,
127
                                text: 'Время'
128
                            }
129
                        }
130
                    }
131
                }
132
            });
133

134
            const memoryChart = new Chart(memoryChartCtx, {
135
                type: 'line',
136
                data: {
137
                    labels: [],
138
                    datasets: [{
139
                        label: 'Использование памяти (MB)',
140
                        data: memoryUsedData,
141
                        borderColor: 'rgba(153, 102, 255, 1)',
142
                        fill: false,
143
                    }]
144
                },
145
                options: {
146
                    scales: {
147
                        y: {
148
                            beginAtZero: true,
149
                            title: {
150
                                display: true,
151
                                text: 'MB'
152
                            },
153
                            max: totalMemory, // Устанавливаем максимальное значение для графика памяти
154
                        },
155
                        x: {
156
                            title: {
157
                                display: true,
158
                                text: 'Время'
159
                            }
160
                        }
161
                    }
162
                }
163
            });
164

165
            function fetchServerStats() {
166
                $.ajax({
167
                    url: '<?php echo admin_url('admin-ajax.php'); ?>',
168
                    method: 'POST',
169
                    data: {
170
                        action: 'sysload_get_stats',
171
                    },
172
                    success: function(response) {
173
                        if (response.success) {
174
                            totalMemory = response.data.memory.total; // Обновляем общее количество памяти
175
                            memoryChart.options.scales.y.max = totalMemory; // Устанавливаем максимальное значение
176

177
                            cpuData.push(response.data.cpu_load);
178
                            memoryUsedData.push(response.data.memory.used);
179

180
                            const timestamp = new Date().toLocaleTimeString();
181
                            cpuChart.data.labels.push(timestamp);
182
                            memoryChart.data.labels.push(timestamp);
183

184
                            if (cpuData.length > 10) {
185
                                cpuData.shift();
186
                                memoryUsedData.shift();
187
                                cpuChart.data.labels.shift();
188
                                memoryChart.data.labels.shift();
189
                            }
190

191
                            cpuChart.update();
192
                            memoryChart.update();
193

194
                            $('#uptime-stats').html(response.data.uptime);
195
                            $('#total-memory-stats').html(response.data.memory.total + ' MB');
196
                            $('#used-memory-stats').html(response.data.memory.used + ' MB (' + response.data.memory.used_percent + '%)');
197
                            $('#cpu-load-stats').html(response.data.cpu_load + '%');
198
                        } else {
199
                            $('#uptime-stats').html('Ошибка при получении данных: ' + response.data.message);
200
                        }
201
                    },
202
                    error: function() {
203
                        $('#uptime-stats').html('Ошибка при получении данных.');
204
                    }
205
                });
206
            }
207

208
            fetchServerStats();
209
            setInterval(fetchServerStats, 10000);
210
        });
211
    </script>
212
    <?php
213
    return ob_get_clean();
214
}
215
add_shortcode('server_stats', 'display_server_stats');
216

217
// AJAX обработчик
218
function sysload_get_stats() {
219
    $cpu_load = sys_getloadavg();
220
    if (!$cpu_load) {
221
        wp_send_json_error(['message' => 'Не удалось получить нагрузку процессора.']);
222
        return;
223
    }
224

225
    $cpu_percent = round($cpu_load[0] / (count($cpu_load) * 1.0) * 100, 2);
226
    $memory = shell_exec('free -m');
227
    if (!$memory) {
228
        wp_send_json_error(['message' => 'Не удалось получить данные о памяти.']);
229
        return;
230
    }
231

232
    $memory = explode("\n", $memory);
233
    $memory_info = preg_split('/\s+/', $memory[1]);
234
    $uptime = shell_exec('uptime -p');
235
    if (!$uptime) {
236
        wp_send_json_error(['message' => 'Не удалось получить время работы.']);
237
        return;
238
    }
239

240
    $response = array(
241
        'cpu_load' => $cpu_percent,
242
        'memory' => array(
243
            'total' => (int)$memory_info[1],
244
            'used' => (int)$memory_info[2],
245
            'used_percent' => round(($memory_info[2] / $memory_info[1]) * 100, 2),
246
        ),
247
        'uptime' => trim($uptime),
248
    );
249

250
    wp_send_json_success($response);
251
}
252
add_action('wp_ajax_sysload_get_stats', 'sysload_get_stats');
253
add_action('wp_ajax_nopriv_sysload_get_stats', 'sysload_get_stats');
254

255
// Добавляем виджет на главную страницу админки
256
function sysload_add_dashboard_widget() {
257
    wp_add_dashboard_widget(
258
        'sysload_dashboard_widget',
259
        'Статистика сервера',
260
        'sysload_dashboard_widget_display'
261
    );
262
}
263
add_action('wp_dashboard_setup', 'sysload_add_dashboard_widget');
264

265
// Функция для отображения содержимого виджета
266
function sysload_dashboard_widget_display() {
267
    ?>
268
    <div id="sysload-dashboard-stats">
269
        <h3>Статистика сервера</h3>
270
        <p>Загрузка процессора: <span id="dashboard-cpu-load">Загрузка...</span></p>
271
        <p>Использованная память: <span id="dashboard-used-memory">Загрузка...</span></p>
272
        <p>Общая память: <span id="dashboard-total-memory">Загрузка...</span></p>
273
        <p>Время работы сервера: <span id="dashboard-uptime">Загрузка...</span></p>
274

275
        <div>
276
            <canvas id="dashboard-cpu-load-chart" width="400" height="200"></canvas>
277
            <canvas id="dashboard-memory-usage-chart" width="400" height="200"></canvas>
278
        </div>
279
    </div>
280

281
    <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
282
    <script>
283
        jQuery(document).ready(function($) {
284
            let cpuData = [];
285
            let memoryUsedData = [];
286
            let totalMemory = 0;
287
            const cpuChartCtx = document.getElementById('dashboard-cpu-load-chart').getContext('2d');
288
            const memoryChartCtx = document.getElementById('dashboard-memory-usage-chart').getContext('2d');
289

290
            const cpuChart = new Chart(cpuChartCtx, {
291
                type: 'line',
292
                data: {
293
                    labels: [],
294
                    datasets: [{
295
                        label: 'Загрузка процессора (%)',
296
                        data: cpuData,
297
                        borderColor: 'rgba(75, 192, 192, 1)',
298
                        fill: false,
299
                    }]
300
                },
301
                options: {
302
                    scales: {
303
                        y: {
304
                            beginAtZero: true,
305
                            max: 100,
306
                            title: {
307
                                display: true,
308
                                text: 'Процент'
309
                            }
310
                        },
311
                        x: {
312
                            title: {
313
                                display: true,
314
                                text: 'Время'
315
                            }
316
                        }
317
                    }
318
                }
319
            });
320

321
            const memoryChart = new Chart(memoryChartCtx, {
322
                type: 'line',
323
                data: {
324
                    labels: [],
325
                    datasets: [{
326
                        label: 'Использование памяти (MB)',
327
                        data: memoryUsedData,
328
                        borderColor: 'rgba(153, 102, 255, 1)',
329
                        fill: false,
330
                    }]
331
                },
332
                options: {
333
                    scales: {
334
                        y: {
335
                            beginAtZero: true,
336
                            title: {
337
                                display: true,
338
                                text: 'MB'
339
                            },
340
                            max: totalMemory, // Устанавливаем максимальное значение для графика памяти
341
                        },
342
                        x: {
343
                            title: {
344
                                display: true,
345
                                text: 'Время'
346
                            }
347
                        }
348
                    }
349
                }
350
            });
351

352
            function fetchDashboardStats() {
353
                $.ajax({
354
                    url: '<?php echo admin_url('admin-ajax.php'); ?>',
355
                    method: 'POST',
356
                    data: {
357
                        action: 'sysload_get_stats',
358
                    },
359
                    success: function(response) {
360
                        if (response.success) {
361
                            totalMemory = response.data.memory.total; // Обновляем общее количество памяти
362
                            memoryChart.options.scales.y.max = totalMemory; // Устанавливаем максимальное значение
363

364
                            cpuData.push(response.data.cpu_load);
365
                            memoryUsedData.push(response.data.memory.used);
366

367
                            const timestamp = new Date().toLocaleTimeString();
368
                            cpuChart.data.labels.push(timestamp);
369
                            memoryChart.data.labels.push(timestamp);
370

371
                            if (cpuData.length > 10) {
372
                                cpuData.shift();
373
                                memoryUsedData.shift();
374
                                cpuChart.data.labels.shift();
375
                                memoryChart.data.labels.shift();
376
                            }
377

378
                            cpuChart.update();
379
                            memoryChart.update();
380

381
                            $('#dashboard-uptime').html(response.data.uptime);
382
                            $('#dashboard-total-memory').html(response.data.memory.total + ' MB');
383
                            $('#dashboard-used-memory').html(response.data.memory.used + ' MB (' + response.data.memory.used_percent + '%)');
384
                            $('#dashboard-cpu-load').html(response.data.cpu_load + '%');
385
                        } else {
386
                            $('#dashboard-uptime').html('Ошибка при получении данных: ' + response.data.message);
387
                        }
388
                    },
389
                    error: function() {
390
                        $('#dashboard-uptime').html('Ошибка при получении данных.');
391
                    }
392
                });
393
            }
394

395
            fetchDashboardStats();
396
            setInterval(fetchDashboardStats, 10000);
397
        });
398
    </script>
399
    <?php
400
}
401

402
// Добавьте следующий код, чтобы создать новый виджет на главной странице админки
403
add_action('wp_dashboard_setup', 'sysload_add_dashboard_widget');
404

405
?>
406