1
-// SPDX-License-Identifier: GPL-3.0-or-later
2
-
3
-#include "common.h"
4
-
5
-#define GLOBAL_STATS_RESET_WEB_USEC_MAX 0x01
6
-
7
-#define WORKER_JOB_GLOBAL 0
8
-#define WORKER_JOB_GLOBAL_EXT 1
9
-#define WORKER_JOB_REGISTRY 2
10
-#define WORKER_JOB_WORKERS 3
11
-#define WORKER_JOB_DBENGINE 4
12
-#define WORKER_JOB_HEARTBEAT 5
13
-#define WORKER_JOB_STRINGS 6
14
-#define WORKER_JOB_DICTIONARIES 7
15
-#define WORKER_JOB_MALLOC_TRACE 8
16
-#define WORKER_JOB_SQLITE3 9
17
-
18
-#if WORKER_UTILIZATION_MAX_JOB_TYPES < 10
19
-#error WORKER_UTILIZATION_MAX_JOB_TYPES has to be at least 10
20
-#endif
21
-
22
-bool global_statistics_enabled = true;
23
-
24
-struct netdata_buffers_statistics netdata_buffers_statistics = {};
25
-
26
-static size_t dbengine_total_memory = 0;
27
-size_t rrddim_db_memory_size = 0;
28
-
29
-static struct global_statistics {
30
- uint16_t connected_clients;
31
-
32
- uint64_t web_requests;
33
- uint64_t web_usec;
34
- uint64_t web_usec_max;
35
- uint64_t bytes_received;
36
- uint64_t bytes_sent;
37
- uint64_t content_size;
38
- uint64_t compressed_content_size;
39
-
40
- uint64_t web_client_count;
41
-
42
- uint64_t api_data_queries_made;
43
- uint64_t api_data_db_points_read;
44
- uint64_t api_data_result_points_generated;
45
-
46
- uint64_t api_weights_queries_made;
47
- uint64_t api_weights_db_points_read;
48
- uint64_t api_weights_result_points_generated;
49
-
50
- uint64_t api_badges_queries_made;
51
- uint64_t api_badges_db_points_read;
52
- uint64_t api_badges_result_points_generated;
53
-
54
- uint64_t health_queries_made;
55
- uint64_t health_db_points_read;
56
- uint64_t health_result_points_generated;
57
-
58
- uint64_t ml_queries_made;
59
- uint64_t ml_db_points_read;
60
- uint64_t ml_result_points_generated;
61
- uint64_t ml_models_consulted;
62
-
63
- uint64_t exporters_queries_made;
64
- uint64_t exporters_db_points_read;
65
-
66
- uint64_t backfill_queries_made;
67
- uint64_t backfill_db_points_read;
68
-
69
- uint64_t tier0_hot_gorilla_buffers;
70
-
71
- uint64_t tier0_disk_compressed_bytes;
72
- uint64_t tier0_disk_uncompressed_bytes;
73
-
74
- uint64_t db_points_stored_per_tier[RRD_STORAGE_TIERS];
75
-
76
-} global_statistics = {
77
- .connected_clients = 0,
78
- .web_requests = 0,
79
- .web_usec = 0,
80
- .bytes_received = 0,
81
- .bytes_sent = 0,
82
- .content_size = 0,
83
- .compressed_content_size = 0,
84
- .web_client_count = 1,
85
-
86
- .api_data_queries_made = 0,
87
- .api_data_db_points_read = 0,
88
- .api_data_result_points_generated = 0,
89
-
90
- .tier0_hot_gorilla_buffers = 0,
91
- .tier0_disk_compressed_bytes = 0,
92
- .tier0_disk_uncompressed_bytes = 0,
93
-};
94
-
95
-void global_statistics_rrdset_done_chart_collection_completed(size_t *points_read_per_tier_array) {
96
- for(size_t tier = 0; tier < storage_tiers ;tier++) {
97
- __atomic_fetch_add(&global_statistics.db_points_stored_per_tier[tier], points_read_per_tier_array[tier], __ATOMIC_RELAXED);
98
- points_read_per_tier_array[tier] = 0;
99
- }
100
-}
101
-
102
-void global_statistics_ml_query_completed(size_t points_read) {
103
- __atomic_fetch_add(&global_statistics.ml_queries_made, 1, __ATOMIC_RELAXED);
104
- __atomic_fetch_add(&global_statistics.ml_db_points_read, points_read, __ATOMIC_RELAXED);
105
-}
106
-
107
-void global_statistics_ml_models_consulted(size_t models_consulted) {
108
- __atomic_fetch_add(&global_statistics.ml_models_consulted, models_consulted, __ATOMIC_RELAXED);
109
-}
110
-
111
-void global_statistics_exporters_query_completed(size_t points_read) {
112
- __atomic_fetch_add(&global_statistics.exporters_queries_made, 1, __ATOMIC_RELAXED);
113
- __atomic_fetch_add(&global_statistics.exporters_db_points_read, points_read, __ATOMIC_RELAXED);
114
-}
115
-
116
-void global_statistics_backfill_query_completed(size_t points_read) {
117
- __atomic_fetch_add(&global_statistics.backfill_queries_made, 1, __ATOMIC_RELAXED);
118
- __atomic_fetch_add(&global_statistics.backfill_db_points_read, points_read, __ATOMIC_RELAXED);
119
-}
120
-
121
-void global_statistics_gorilla_buffer_add_hot() {
122
- __atomic_fetch_add(&global_statistics.tier0_hot_gorilla_buffers, 1, __ATOMIC_RELAXED);
123
-}
124
-
125
-void global_statistics_tier0_disk_compressed_bytes(uint32_t size) {
126
- __atomic_fetch_add(&global_statistics.tier0_disk_compressed_bytes, size, __ATOMIC_RELAXED);
127
-}
128
-
129
-void global_statistics_tier0_disk_uncompressed_bytes(uint32_t size) {
130
- __atomic_fetch_add(&global_statistics.tier0_disk_uncompressed_bytes, size, __ATOMIC_RELAXED);
131
-}
132
-
133
-void global_statistics_rrdr_query_completed(size_t queries, uint64_t db_points_read, uint64_t result_points_generated, QUERY_SOURCE query_source) {
134
- switch(query_source) {
135
- case QUERY_SOURCE_API_DATA:
136
- __atomic_fetch_add(&global_statistics.api_data_queries_made, queries, __ATOMIC_RELAXED);
137
- __atomic_fetch_add(&global_statistics.api_data_db_points_read, db_points_read, __ATOMIC_RELAXED);
138
- __atomic_fetch_add(&global_statistics.api_data_result_points_generated, result_points_generated, __ATOMIC_RELAXED);
139
- break;
140
-
141
- case QUERY_SOURCE_ML:
142
- __atomic_fetch_add(&global_statistics.ml_queries_made, queries, __ATOMIC_RELAXED);
143
- __atomic_fetch_add(&global_statistics.ml_db_points_read, db_points_read, __ATOMIC_RELAXED);
144
- __atomic_fetch_add(&global_statistics.ml_result_points_generated, result_points_generated, __ATOMIC_RELAXED);
145
- break;
146
-
147
- case QUERY_SOURCE_API_WEIGHTS:
148
- __atomic_fetch_add(&global_statistics.api_weights_queries_made, queries, __ATOMIC_RELAXED);
149
- __atomic_fetch_add(&global_statistics.api_weights_db_points_read, db_points_read, __ATOMIC_RELAXED);
150
- __atomic_fetch_add(&global_statistics.api_weights_result_points_generated, result_points_generated, __ATOMIC_RELAXED);
151
- break;
152
-
153
- case QUERY_SOURCE_API_BADGE:
154
- __atomic_fetch_add(&global_statistics.api_badges_queries_made, queries, __ATOMIC_RELAXED);
155
- __atomic_fetch_add(&global_statistics.api_badges_db_points_read, db_points_read, __ATOMIC_RELAXED);
156
- __atomic_fetch_add(&global_statistics.api_badges_result_points_generated, result_points_generated, __ATOMIC_RELAXED);
157
- break;
158
-
159
- case QUERY_SOURCE_HEALTH:
160
- __atomic_fetch_add(&global_statistics.health_queries_made, queries, __ATOMIC_RELAXED);
161
- __atomic_fetch_add(&global_statistics.health_db_points_read, db_points_read, __ATOMIC_RELAXED);
162
- __atomic_fetch_add(&global_statistics.health_result_points_generated, result_points_generated, __ATOMIC_RELAXED);
163
- break;
164
-
165
- default:
166
- case QUERY_SOURCE_UNITTEST:
167
- case QUERY_SOURCE_UNKNOWN:
168
- break;
169
- }
170
-}
171
-
172
-void global_statistics_web_request_completed(uint64_t dt,
173
- uint64_t bytes_received,
174
- uint64_t bytes_sent,
175
- uint64_t content_size,
176
- uint64_t compressed_content_size) {
177
- uint64_t old_web_usec_max = global_statistics.web_usec_max;
178
- while(dt > old_web_usec_max)
179
- __atomic_compare_exchange(&global_statistics.web_usec_max, &old_web_usec_max, &dt, 1, __ATOMIC_RELAXED, __ATOMIC_RELAXED);
180
-
181
- __atomic_fetch_add(&global_statistics.web_requests, 1, __ATOMIC_RELAXED);
182
- __atomic_fetch_add(&global_statistics.web_usec, dt, __ATOMIC_RELAXED);
183
- __atomic_fetch_add(&global_statistics.bytes_received, bytes_received, __ATOMIC_RELAXED);
184
- __atomic_fetch_add(&global_statistics.bytes_sent, bytes_sent, __ATOMIC_RELAXED);
185
- __atomic_fetch_add(&global_statistics.content_size, content_size, __ATOMIC_RELAXED);
186
- __atomic_fetch_add(&global_statistics.compressed_content_size, compressed_content_size, __ATOMIC_RELAXED);
187
-}
188
-
189
-uint64_t global_statistics_web_client_connected(void) {
190
- __atomic_fetch_add(&global_statistics.connected_clients, 1, __ATOMIC_RELAXED);
191
- return __atomic_fetch_add(&global_statistics.web_client_count, 1, __ATOMIC_RELAXED);
192
-}
193
-
194
-void global_statistics_web_client_disconnected(void) {
195
- __atomic_fetch_sub(&global_statistics.connected_clients, 1, __ATOMIC_RELAXED);
196
-}
197
-
198
-static inline void global_statistics_copy(struct global_statistics *gs, uint8_t options) {
199
- gs->connected_clients = __atomic_load_n(&global_statistics.connected_clients, __ATOMIC_RELAXED);
200
- gs->web_requests = __atomic_load_n(&global_statistics.web_requests, __ATOMIC_RELAXED);
201
- gs->web_usec = __atomic_load_n(&global_statistics.web_usec, __ATOMIC_RELAXED);
202
- gs->web_usec_max = __atomic_load_n(&global_statistics.web_usec_max, __ATOMIC_RELAXED);
203
- gs->bytes_received = __atomic_load_n(&global_statistics.bytes_received, __ATOMIC_RELAXED);
204
- gs->bytes_sent = __atomic_load_n(&global_statistics.bytes_sent, __ATOMIC_RELAXED);
205
- gs->content_size = __atomic_load_n(&global_statistics.content_size, __ATOMIC_RELAXED);
206
- gs->compressed_content_size = __atomic_load_n(&global_statistics.compressed_content_size, __ATOMIC_RELAXED);
207
- gs->web_client_count = __atomic_load_n(&global_statistics.web_client_count, __ATOMIC_RELAXED);
208
-
209
- gs->api_data_queries_made = __atomic_load_n(&global_statistics.api_data_queries_made, __ATOMIC_RELAXED);
210
- gs->api_data_db_points_read = __atomic_load_n(&global_statistics.api_data_db_points_read, __ATOMIC_RELAXED);
211
- gs->api_data_result_points_generated = __atomic_load_n(&global_statistics.api_data_result_points_generated, __ATOMIC_RELAXED);
212
-
213
- gs->api_weights_queries_made = __atomic_load_n(&global_statistics.api_weights_queries_made, __ATOMIC_RELAXED);
214
- gs->api_weights_db_points_read = __atomic_load_n(&global_statistics.api_weights_db_points_read, __ATOMIC_RELAXED);
215
- gs->api_weights_result_points_generated = __atomic_load_n(&global_statistics.api_weights_result_points_generated, __ATOMIC_RELAXED);
216
-
217
- gs->api_badges_queries_made = __atomic_load_n(&global_statistics.api_badges_queries_made, __ATOMIC_RELAXED);
218
- gs->api_badges_db_points_read = __atomic_load_n(&global_statistics.api_badges_db_points_read, __ATOMIC_RELAXED);
219
- gs->api_badges_result_points_generated = __atomic_load_n(&global_statistics.api_badges_result_points_generated, __ATOMIC_RELAXED);
220
-
221
- gs->health_queries_made = __atomic_load_n(&global_statistics.health_queries_made, __ATOMIC_RELAXED);
222
- gs->health_db_points_read = __atomic_load_n(&global_statistics.health_db_points_read, __ATOMIC_RELAXED);
223
- gs->health_result_points_generated = __atomic_load_n(&global_statistics.health_result_points_generated, __ATOMIC_RELAXED);
224
-
225
- gs->ml_queries_made = __atomic_load_n(&global_statistics.ml_queries_made, __ATOMIC_RELAXED);
226
- gs->ml_db_points_read = __atomic_load_n(&global_statistics.ml_db_points_read, __ATOMIC_RELAXED);
227
- gs->ml_result_points_generated = __atomic_load_n(&global_statistics.ml_result_points_generated, __ATOMIC_RELAXED);
228
- gs->ml_models_consulted = __atomic_load_n(&global_statistics.ml_models_consulted, __ATOMIC_RELAXED);
229
-
230
- gs->exporters_queries_made = __atomic_load_n(&global_statistics.exporters_queries_made, __ATOMIC_RELAXED);
231
- gs->exporters_db_points_read = __atomic_load_n(&global_statistics.exporters_db_points_read, __ATOMIC_RELAXED);
232
- gs->backfill_queries_made = __atomic_load_n(&global_statistics.backfill_queries_made, __ATOMIC_RELAXED);
233
- gs->backfill_db_points_read = __atomic_load_n(&global_statistics.backfill_db_points_read, __ATOMIC_RELAXED);
234
-
235
- gs->tier0_hot_gorilla_buffers = __atomic_load_n(&global_statistics.tier0_hot_gorilla_buffers, __ATOMIC_RELAXED);
236
-
237
- gs->tier0_disk_compressed_bytes = __atomic_load_n(&global_statistics.tier0_disk_compressed_bytes, __ATOMIC_RELAXED);
238
- gs->tier0_disk_uncompressed_bytes = __atomic_load_n(&global_statistics.tier0_disk_uncompressed_bytes, __ATOMIC_RELAXED);
239
-
240
- for(size_t tier = 0; tier < storage_tiers ;tier++)
241
- gs->db_points_stored_per_tier[tier] = __atomic_load_n(&global_statistics.db_points_stored_per_tier[tier], __ATOMIC_RELAXED);
242
-
243
- if(options & GLOBAL_STATS_RESET_WEB_USEC_MAX) {
244
- uint64_t n = 0;
245
- __atomic_compare_exchange(&global_statistics.web_usec_max, (uint64_t *) &gs->web_usec_max, &n, 1, __ATOMIC_RELAXED, __ATOMIC_RELAXED);
246
- }
247
-}
248
-
249
-#define dictionary_stats_memory_total(stats) \
250
- ((stats).memory.dict + (stats).memory.values + (stats).memory.index)
251
-
252
-static void global_statistics_charts(void) {
253
- static unsigned long long old_web_requests = 0, old_web_usec = 0;
254
-
255
- static collected_number average_response_time = -1;
256
-
257
- static time_t netdata_boottime_time = 0;
258
- if (!netdata_boottime_time)
259
- netdata_boottime_time = now_boottime_sec();
260
- time_t netdata_uptime = now_boottime_sec() - netdata_boottime_time;
261
-
262
- struct global_statistics gs;
263
- struct rusage me;
264
-
265
- global_statistics_copy(&gs, GLOBAL_STATS_RESET_WEB_USEC_MAX);
266
- getrusage(RUSAGE_SELF, &me);
267
-
268
- // ----------------------------------------------------------------
269
-
270
- {
271
- static RRDSET *st_cpu = NULL;
272
- static RRDDIM *rd_cpu_user = NULL,
273
- *rd_cpu_system = NULL;
274
-
275
- if (unlikely(!st_cpu)) {
276
- st_cpu = rrdset_create_localhost(
277
- "netdata"
278
- , "server_cpu"
279
- , NULL
280
- , "netdata"
281
- , NULL
282
- , "Netdata CPU usage"
283
- , "milliseconds/s"
284
- , "netdata"
285
- , "stats"
286
- , 130000
287
- , localhost->rrd_update_every
288
- , RRDSET_TYPE_STACKED
289
- );
290
-
291
- rd_cpu_user = rrddim_add(st_cpu, "user", NULL, 1, 1000, RRD_ALGORITHM_INCREMENTAL);
292
- rd_cpu_system = rrddim_add(st_cpu, "system", NULL, 1, 1000, RRD_ALGORITHM_INCREMENTAL);
293
- }
294
-
295
- rrddim_set_by_pointer(st_cpu, rd_cpu_user, me.ru_utime.tv_sec * 1000000ULL + me.ru_utime.tv_usec);
296
- rrddim_set_by_pointer(st_cpu, rd_cpu_system, me.ru_stime.tv_sec * 1000000ULL + me.ru_stime.tv_usec);
297
- rrdset_done(st_cpu);
298
- }
299
-
300
- {
301
- static RRDSET *st_uptime = NULL;
302
- static RRDDIM *rd_uptime = NULL;
303
-
304
- if (unlikely(!st_uptime)) {
305
- st_uptime = rrdset_create_localhost(
306
- "netdata",
307
- "uptime",
308
- NULL,
309
- "netdata",
310
- NULL,
311
- "Netdata uptime",
312
- "seconds",
313
- "netdata",
314
- "stats",
315
- 130150,
316
- localhost->rrd_update_every,
317
- RRDSET_TYPE_LINE);
318
-
319
- rd_uptime = rrddim_add(st_uptime, "uptime", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
320
- }
321
-
322
- rrddim_set_by_pointer(st_uptime, rd_uptime, netdata_uptime);
323
- rrdset_done(st_uptime);
324
- }
325
-
326
- // ----------------------------------------------------------------
327
-
328
- {
329
- static RRDSET *st_clients = NULL;
330
- static RRDDIM *rd_clients = NULL;
331
-
332
- if (unlikely(!st_clients)) {
333
- st_clients = rrdset_create_localhost(
334
- "netdata"
335
- , "clients"
336
- , NULL
337
- , "api"
338
- , NULL
339
- , "Netdata Web Clients"
340
- , "connected clients"
341
- , "netdata"
342
- , "stats"
343
- , 130200
344
- , localhost->rrd_update_every
345
- , RRDSET_TYPE_LINE
346
- );
347
-
348
- rd_clients = rrddim_add(st_clients, "clients", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
349
- }
350
-
351
- rrddim_set_by_pointer(st_clients, rd_clients, gs.connected_clients);
352
- rrdset_done(st_clients);
353
- }
354
-
355
- // ----------------------------------------------------------------
356
-
357
- {
358
- static RRDSET *st_reqs = NULL;
359
- static RRDDIM *rd_requests = NULL;
360
-
361
- if (unlikely(!st_reqs)) {
362
- st_reqs = rrdset_create_localhost(
363
- "netdata"
364
- , "requests"
365
- , NULL
366
- , "api"
367
- , NULL
368
- , "Netdata Web Requests"
369
- , "requests/s"
370
- , "netdata"
371
- , "stats"
372
- , 130300
373
- , localhost->rrd_update_every
374
- , RRDSET_TYPE_LINE
375
- );
376
-
377
- rd_requests = rrddim_add(st_reqs, "requests", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
378
- }
379
-
380
- rrddim_set_by_pointer(st_reqs, rd_requests, (collected_number) gs.web_requests);
381
- rrdset_done(st_reqs);
382
- }
383
-
384
- // ----------------------------------------------------------------
385
-
386
- {
387
- static RRDSET *st_bytes = NULL;
388
- static RRDDIM *rd_in = NULL,
389
- *rd_out = NULL;
390
-
391
- if (unlikely(!st_bytes)) {
392
- st_bytes = rrdset_create_localhost(
393
- "netdata"
394
- , "net"
395
- , NULL
396
- , "api"
397
- , NULL
398
- , "Netdata Network Traffic"
399
- , "kilobits/s"
400
- , "netdata"
401
- , "stats"
402
- , 130400
403
- , localhost->rrd_update_every
404
- , RRDSET_TYPE_AREA
405
- );
406
-
407
- rd_in = rrddim_add(st_bytes, "in", NULL, 8, BITS_IN_A_KILOBIT, RRD_ALGORITHM_INCREMENTAL);
408
- rd_out = rrddim_add(st_bytes, "out", NULL, -8, BITS_IN_A_KILOBIT, RRD_ALGORITHM_INCREMENTAL);
409
- }
410
-
411
- rrddim_set_by_pointer(st_bytes, rd_in, (collected_number) gs.bytes_received);
412
- rrddim_set_by_pointer(st_bytes, rd_out, (collected_number) gs.bytes_sent);
413
- rrdset_done(st_bytes);
414
- }
415
-
416
- // ----------------------------------------------------------------
417
-
418
- {
419
- static RRDSET *st_duration = NULL;
420
- static RRDDIM *rd_average = NULL,
421
- *rd_max = NULL;
422
-
423
- if (unlikely(!st_duration)) {
424
- st_duration = rrdset_create_localhost(
425
- "netdata"
426
- , "response_time"
427
- , NULL
428
- , "api"
429
- , NULL
430
- , "Netdata API Response Time"
431
- , "milliseconds/request"
432
- , "netdata"
433
- , "stats"
434
- , 130500
435
- , localhost->rrd_update_every
436
- , RRDSET_TYPE_LINE
437
- );
438
-
439
- rd_average = rrddim_add(st_duration, "average", NULL, 1, 1000, RRD_ALGORITHM_ABSOLUTE);
440
- rd_max = rrddim_add(st_duration, "max", NULL, 1, 1000, RRD_ALGORITHM_ABSOLUTE);
441
- }
442
-
443
- uint64_t gweb_usec = gs.web_usec;
444
- uint64_t gweb_requests = gs.web_requests;
445
-
446
- uint64_t web_usec = (gweb_usec >= old_web_usec) ? gweb_usec - old_web_usec : 0;
447
- uint64_t web_requests = (gweb_requests >= old_web_requests) ? gweb_requests - old_web_requests : 0;
448
-
449
- old_web_usec = gweb_usec;
450
- old_web_requests = gweb_requests;
451
-
452
- if (web_requests)
453
- average_response_time = (collected_number) (web_usec / web_requests);
454
-
455
- if (unlikely(average_response_time != -1))
456
- rrddim_set_by_pointer(st_duration, rd_average, average_response_time);
457
- else
458
- rrddim_set_by_pointer(st_duration, rd_average, 0);
459
-
460
- rrddim_set_by_pointer(st_duration, rd_max, ((gs.web_usec_max)?(collected_number)gs.web_usec_max:average_response_time));
461
- rrdset_done(st_duration);
462
- }
463
-}
464
-
465
-static void global_statistics_extended_charts(void) {
466
- static unsigned long long old_content_size = 0, old_compressed_content_size = 0;
467
- static collected_number compression_ratio = -1;
468
-
469
- struct global_statistics gs;
470
- struct replication_query_statistics replication = replication_get_query_statistics();
471
- global_statistics_copy(&gs, GLOBAL_STATS_RESET_WEB_USEC_MAX);
472
-
473
- {
474
- static RRDSET *st_memory = NULL;
475
- static RRDDIM *rd_database = NULL;
476
- static RRDDIM *rd_collectors = NULL;
477
- static RRDDIM *rd_hosts = NULL;
478
- static RRDDIM *rd_rrd = NULL;
479
- static RRDDIM *rd_contexts = NULL;
480
- static RRDDIM *rd_health = NULL;
481
- static RRDDIM *rd_functions = NULL;
482
- static RRDDIM *rd_labels = NULL;
483
- static RRDDIM *rd_strings = NULL;
484
- static RRDDIM *rd_streaming = NULL;
485
- static RRDDIM *rd_replication = NULL;
486
- static RRDDIM *rd_buffers = NULL;
487
- static RRDDIM *rd_workers = NULL;
488
- static RRDDIM *rd_aral = NULL;
489
- static RRDDIM *rd_judy = NULL;
490
- static RRDDIM *rd_other = NULL;
491
-
492
- if (unlikely(!st_memory)) {
493
- st_memory = rrdset_create_localhost(
494
- "netdata",
495
- "memory",
496
- NULL,
497
- "netdata",
498
- NULL,
499
- "Netdata Memory",
500
- "bytes",
501
- "netdata",
502
- "stats",
503
- 130100,
504
- localhost->rrd_update_every,
505
- RRDSET_TYPE_STACKED);
506
-
507
- rd_database = rrddim_add(st_memory, "db", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
508
- rd_collectors = rrddim_add(st_memory, "collectors", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
509
- rd_hosts = rrddim_add(st_memory, "hosts", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
510
- rd_rrd = rrddim_add(st_memory, "rrdset rrddim", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
511
- rd_contexts = rrddim_add(st_memory, "contexts", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
512
- rd_health = rrddim_add(st_memory, "health", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
513
- rd_functions = rrddim_add(st_memory, "functions", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
514
- rd_labels = rrddim_add(st_memory, "labels", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
515
- rd_strings = rrddim_add(st_memory, "strings", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
516
- rd_streaming = rrddim_add(st_memory, "streaming", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
517
- rd_replication = rrddim_add(st_memory, "replication", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
518
- rd_buffers = rrddim_add(st_memory, "buffers", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
519
- rd_workers = rrddim_add(st_memory, "workers", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
520
- rd_aral = rrddim_add(st_memory, "aral", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
521
- rd_judy = rrddim_add(st_memory, "judy", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
522
- rd_other = rrddim_add(st_memory, "other", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
523
- }
524
-
525
- size_t buffers =
526
- netdata_buffers_statistics.query_targets_size +
527
- netdata_buffers_statistics.rrdset_done_rda_size +
528
- netdata_buffers_statistics.buffers_aclk +
529
- netdata_buffers_statistics.buffers_api +
530
- netdata_buffers_statistics.buffers_functions +
531
- netdata_buffers_statistics.buffers_sqlite +
532
- netdata_buffers_statistics.buffers_exporters +
533
- netdata_buffers_statistics.buffers_health +
534
- netdata_buffers_statistics.buffers_streaming +
535
- netdata_buffers_statistics.cbuffers_streaming +
536
- netdata_buffers_statistics.buffers_web +
537
- replication_allocated_buffers() +
538
- aral_by_size_overhead() +
539
- judy_aral_overhead();
540
-
541
- size_t strings = 0;
542
- string_statistics(NULL, NULL, NULL, NULL, NULL, &strings, NULL, NULL);
543
-
544
- rrddim_set_by_pointer(st_memory, rd_database, (collected_number)dbengine_total_memory + (collected_number)rrddim_db_memory_size);
545
- rrddim_set_by_pointer(st_memory, rd_collectors, (collected_number)dictionary_stats_memory_total(dictionary_stats_category_collectors));
546
- rrddim_set_by_pointer(st_memory, rd_hosts, (collected_number)dictionary_stats_memory_total(dictionary_stats_category_rrdhost) + (collected_number)netdata_buffers_statistics.rrdhost_allocations_size);
547
- rrddim_set_by_pointer(st_memory, rd_rrd, (collected_number)dictionary_stats_memory_total(dictionary_stats_category_rrdset_rrddim));
548
- rrddim_set_by_pointer(st_memory, rd_contexts, (collected_number)dictionary_stats_memory_total(dictionary_stats_category_rrdcontext));
549
- rrddim_set_by_pointer(st_memory, rd_health, (collected_number)dictionary_stats_memory_total(dictionary_stats_category_rrdhealth));
550
- rrddim_set_by_pointer(st_memory, rd_functions, (collected_number)dictionary_stats_memory_total(dictionary_stats_category_functions));
551
- rrddim_set_by_pointer(st_memory, rd_labels, (collected_number)dictionary_stats_memory_total(dictionary_stats_category_rrdlabels));
552
- rrddim_set_by_pointer(st_memory, rd_strings, (collected_number)strings);
553
- rrddim_set_by_pointer(st_memory, rd_streaming, (collected_number)netdata_buffers_statistics.rrdhost_senders + (collected_number)netdata_buffers_statistics.rrdhost_receivers);
554
- rrddim_set_by_pointer(st_memory, rd_replication, (collected_number)dictionary_stats_memory_total(dictionary_stats_category_replication) + (collected_number)replication_allocated_memory());
555
- rrddim_set_by_pointer(st_memory, rd_buffers, (collected_number)buffers);
556
- rrddim_set_by_pointer(st_memory, rd_workers, (collected_number) workers_allocated_memory());
557
- rrddim_set_by_pointer(st_memory, rd_aral, (collected_number) aral_by_size_structures());
558
- rrddim_set_by_pointer(st_memory, rd_judy, (collected_number) judy_aral_structures());
559
- rrddim_set_by_pointer(st_memory, rd_other, (collected_number)dictionary_stats_memory_total(dictionary_stats_category_other));
560
-
561
- rrdset_done(st_memory);
562
- }
563
-
564
- {
565
- static RRDSET *st_memory_buffers = NULL;
566
- static RRDDIM *rd_queries = NULL;
567
- static RRDDIM *rd_collectors = NULL;
568
- static RRDDIM *rd_buffers_aclk = NULL;
569
- static RRDDIM *rd_buffers_api = NULL;
570
- static RRDDIM *rd_buffers_functions = NULL;
571
- static RRDDIM *rd_buffers_sqlite = NULL;
572
- static RRDDIM *rd_buffers_exporters = NULL;
573
- static RRDDIM *rd_buffers_health = NULL;
574
- static RRDDIM *rd_buffers_streaming = NULL;
575
- static RRDDIM *rd_cbuffers_streaming = NULL;
576
- static RRDDIM *rd_buffers_replication = NULL;
577
- static RRDDIM *rd_buffers_web = NULL;
578
- static RRDDIM *rd_buffers_aral = NULL;
579
- static RRDDIM *rd_buffers_judy = NULL;
580
-
581
- if (unlikely(!st_memory_buffers)) {
582
- st_memory_buffers = rrdset_create_localhost(
583
- "netdata",
584
- "memory_buffers",
585
- NULL,
586
- "netdata",
587
- NULL,
588
- "Netdata Memory Buffers",
589
- "bytes",
590
- "netdata",
591
- "stats",
592
- 130101,
593
- localhost->rrd_update_every,
594
- RRDSET_TYPE_STACKED);
595
-
596
- rd_queries = rrddim_add(st_memory_buffers, "queries", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
597
- rd_collectors = rrddim_add(st_memory_buffers, "collection", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
598
- rd_buffers_aclk = rrddim_add(st_memory_buffers, "aclk", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
599
- rd_buffers_api = rrddim_add(st_memory_buffers, "api", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
600
- rd_buffers_functions = rrddim_add(st_memory_buffers, "functions", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
601
- rd_buffers_sqlite = rrddim_add(st_memory_buffers, "sqlite", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
602
- rd_buffers_exporters = rrddim_add(st_memory_buffers, "exporters", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
603
- rd_buffers_health = rrddim_add(st_memory_buffers, "health", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
604
- rd_buffers_streaming = rrddim_add(st_memory_buffers, "streaming", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
605
- rd_cbuffers_streaming = rrddim_add(st_memory_buffers, "streaming cbuf", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
606
- rd_buffers_replication = rrddim_add(st_memory_buffers, "replication", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
607
- rd_buffers_web = rrddim_add(st_memory_buffers, "web", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
608
- rd_buffers_aral = rrddim_add(st_memory_buffers, "aral", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
609
- rd_buffers_judy = rrddim_add(st_memory_buffers, "judy", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
610
- }
611
-
612
- rrddim_set_by_pointer(st_memory_buffers, rd_queries, (collected_number)netdata_buffers_statistics.query_targets_size + (collected_number) onewayalloc_allocated_memory());
613
- rrddim_set_by_pointer(st_memory_buffers, rd_collectors, (collected_number)netdata_buffers_statistics.rrdset_done_rda_size);
614
- rrddim_set_by_pointer(st_memory_buffers, rd_buffers_aclk, (collected_number)netdata_buffers_statistics.buffers_aclk);
615
- rrddim_set_by_pointer(st_memory_buffers, rd_buffers_api, (collected_number)netdata_buffers_statistics.buffers_api);
616
- rrddim_set_by_pointer(st_memory_buffers, rd_buffers_functions, (collected_number)netdata_buffers_statistics.buffers_functions);
617
- rrddim_set_by_pointer(st_memory_buffers, rd_buffers_sqlite, (collected_number)netdata_buffers_statistics.buffers_sqlite);
618
- rrddim_set_by_pointer(st_memory_buffers, rd_buffers_exporters, (collected_number)netdata_buffers_statistics.buffers_exporters);
619
- rrddim_set_by_pointer(st_memory_buffers, rd_buffers_health, (collected_number)netdata_buffers_statistics.buffers_health);
620
- rrddim_set_by_pointer(st_memory_buffers, rd_buffers_streaming, (collected_number)netdata_buffers_statistics.buffers_streaming);
621
- rrddim_set_by_pointer(st_memory_buffers, rd_cbuffers_streaming, (collected_number)netdata_buffers_statistics.cbuffers_streaming);
622
- rrddim_set_by_pointer(st_memory_buffers, rd_buffers_replication, (collected_number)replication_allocated_buffers());
623
- rrddim_set_by_pointer(st_memory_buffers, rd_buffers_web, (collected_number)netdata_buffers_statistics.buffers_web);
624
- rrddim_set_by_pointer(st_memory_buffers, rd_buffers_aral, (collected_number)aral_by_size_overhead());
625
- rrddim_set_by_pointer(st_memory_buffers, rd_buffers_judy, (collected_number)judy_aral_overhead());
626
-
627
- rrdset_done(st_memory_buffers);
628
- }
629
-
630
-
631
- {
632
- static RRDSET *st_compression = NULL;
633
- static RRDDIM *rd_savings = NULL;
634
-
635
- if (unlikely(!st_compression)) {
636
- st_compression = rrdset_create_localhost(
637
- "netdata"
638
- , "compression_ratio"
639
- , NULL
640
- , "api"
641
- , NULL
642
- , "Netdata API Responses Compression Savings Ratio"
643
- , "percentage"
644
- , "netdata"
645
- , "stats"
646
- , 130600
647
- , localhost->rrd_update_every
648
- , RRDSET_TYPE_LINE
649
- );
650
-
651
- rd_savings = rrddim_add(st_compression, "savings", NULL, 1, 1000, RRD_ALGORITHM_ABSOLUTE);
652
- }
653
-
654
- // since we don't lock here to read the global statistics
655
- // read the smaller value first
656
- unsigned long long gcompressed_content_size = gs.compressed_content_size;
657
- unsigned long long gcontent_size = gs.content_size;
658
-
659
- unsigned long long compressed_content_size = gcompressed_content_size - old_compressed_content_size;
660
- unsigned long long content_size = gcontent_size - old_content_size;
661
-
662
- old_compressed_content_size = gcompressed_content_size;
663
- old_content_size = gcontent_size;
664
-
665
- if (content_size && content_size >= compressed_content_size)
666
- compression_ratio = ((content_size - compressed_content_size) * 100 * 1000) / content_size;
667
-
668
- if (compression_ratio != -1)
669
- rrddim_set_by_pointer(st_compression, rd_savings, compression_ratio);
670
-
671
- rrdset_done(st_compression);
672
- }
673
-
674
- {
675
- static RRDSET *st_queries = NULL;
676
- static RRDDIM *rd_api_data_queries = NULL;
677
- static RRDDIM *rd_api_weights_queries = NULL;
678
- static RRDDIM *rd_api_badges_queries = NULL;
679
- static RRDDIM *rd_health_queries = NULL;
680
- static RRDDIM *rd_ml_queries = NULL;
681
- static RRDDIM *rd_exporters_queries = NULL;
682
- static RRDDIM *rd_backfill_queries = NULL;
683
- static RRDDIM *rd_replication_queries = NULL;
684
-
685
- if (unlikely(!st_queries)) {
686
- st_queries = rrdset_create_localhost(
687
- "netdata"
688
- , "queries"
689
- , NULL
690
- , "queries"
691
- , NULL
692
- , "Netdata DB Queries"
693
- , "queries/s"
694
- , "netdata"
695
- , "stats"
696
- , 131000
697
- , localhost->rrd_update_every
698
- , RRDSET_TYPE_STACKED
699
- );
700
-
701
- rd_api_data_queries = rrddim_add(st_queries, "/api/v1/data", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
702
- rd_api_weights_queries = rrddim_add(st_queries, "/api/v1/weights", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
703
- rd_api_badges_queries = rrddim_add(st_queries, "/api/v1/badge", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
704
- rd_health_queries = rrddim_add(st_queries, "health", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
705
- rd_ml_queries = rrddim_add(st_queries, "ml", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
706
- rd_exporters_queries = rrddim_add(st_queries, "exporters", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
707
- rd_backfill_queries = rrddim_add(st_queries, "backfill", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
708
- rd_replication_queries = rrddim_add(st_queries, "replication", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
709
- }
710
-
711
- rrddim_set_by_pointer(st_queries, rd_api_data_queries, (collected_number)gs.api_data_queries_made);
712
- rrddim_set_by_pointer(st_queries, rd_api_weights_queries, (collected_number)gs.api_weights_queries_made);
713
- rrddim_set_by_pointer(st_queries, rd_api_badges_queries, (collected_number)gs.api_badges_queries_made);
714
- rrddim_set_by_pointer(st_queries, rd_health_queries, (collected_number)gs.health_queries_made);
715
- rrddim_set_by_pointer(st_queries, rd_ml_queries, (collected_number)gs.ml_queries_made);
716
- rrddim_set_by_pointer(st_queries, rd_exporters_queries, (collected_number)gs.exporters_queries_made);
717
- rrddim_set_by_pointer(st_queries, rd_backfill_queries, (collected_number)gs.backfill_queries_made);
718
- rrddim_set_by_pointer(st_queries, rd_replication_queries, (collected_number)replication.queries_finished);
719
-
720
- rrdset_done(st_queries);
721
- }
722
-
723
- {
724
- static RRDSET *st_points_read = NULL;
725
- static RRDDIM *rd_api_data_points_read = NULL;
726
- static RRDDIM *rd_api_weights_points_read = NULL;
727
- static RRDDIM *rd_api_badges_points_read = NULL;
728
- static RRDDIM *rd_health_points_read = NULL;
729
- static RRDDIM *rd_ml_points_read = NULL;
730
- static RRDDIM *rd_exporters_points_read = NULL;
731
- static RRDDIM *rd_backfill_points_read = NULL;
732
- static RRDDIM *rd_replication_points_read = NULL;
733
-
734
- if (unlikely(!st_points_read)) {
735
- st_points_read = rrdset_create_localhost(
736
- "netdata"
737
- , "db_points_read"
738
- , NULL
739
- , "queries"
740
- , NULL
741
- , "Netdata DB Points Query Read"
742
- , "points/s"
743
- , "netdata"
744
- , "stats"
745
- , 131001
746
- , localhost->rrd_update_every
747
- , RRDSET_TYPE_STACKED
748
- );
749
-
750
- rd_api_data_points_read = rrddim_add(st_points_read, "/api/v1/data", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
751
- rd_api_weights_points_read = rrddim_add(st_points_read, "/api/v1/weights", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
752
- rd_api_badges_points_read = rrddim_add(st_points_read, "/api/v1/badge", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
753
- rd_health_points_read = rrddim_add(st_points_read, "health", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
754
- rd_ml_points_read = rrddim_add(st_points_read, "ml", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
755
- rd_exporters_points_read = rrddim_add(st_points_read, "exporters", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
756
- rd_backfill_points_read = rrddim_add(st_points_read, "backfill", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
757
- rd_replication_points_read = rrddim_add(st_points_read, "replication", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
758
- }
759
-
760
- rrddim_set_by_pointer(st_points_read, rd_api_data_points_read, (collected_number)gs.api_data_db_points_read);
761
- rrddim_set_by_pointer(st_points_read, rd_api_weights_points_read, (collected_number)gs.api_weights_db_points_read);
762
- rrddim_set_by_pointer(st_points_read, rd_api_badges_points_read, (collected_number)gs.api_badges_db_points_read);
763
- rrddim_set_by_pointer(st_points_read, rd_health_points_read, (collected_number)gs.health_db_points_read);
764
- rrddim_set_by_pointer(st_points_read, rd_ml_points_read, (collected_number)gs.ml_db_points_read);
765
- rrddim_set_by_pointer(st_points_read, rd_exporters_points_read, (collected_number)gs.exporters_db_points_read);
766
- rrddim_set_by_pointer(st_points_read, rd_backfill_points_read, (collected_number)gs.backfill_db_points_read);
767
- rrddim_set_by_pointer(st_points_read, rd_replication_points_read, (collected_number)replication.points_read);
768
-
769
- rrdset_done(st_points_read);
770
- }
771
-
772
- if(gs.api_data_result_points_generated || replication.points_generated) {
773
- static RRDSET *st_points_generated = NULL;
774
- static RRDDIM *rd_api_data_points_generated = NULL;
775
- static RRDDIM *rd_api_weights_points_generated = NULL;
776
- static RRDDIM *rd_api_badges_points_generated = NULL;
777
- static RRDDIM *rd_health_points_generated = NULL;
778
- static RRDDIM *rd_ml_points_generated = NULL;
779
- static RRDDIM *rd_replication_points_generated = NULL;
780
-
781
- if (unlikely(!st_points_generated)) {
782
- st_points_generated = rrdset_create_localhost(
783
- "netdata"
784
- , "db_points_results"
785
- , NULL
786
- , "queries"
787
- , NULL
788
- , "Netdata Points in Query Results"
789
- , "points/s"
790
- , "netdata"
791
- , "stats"
792
- , 131002
793
- , localhost->rrd_update_every
794
- , RRDSET_TYPE_STACKED
795
- );
796
-
797
- rd_api_data_points_generated = rrddim_add(st_points_generated, "/api/v1/data", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
798
- rd_api_weights_points_generated = rrddim_add(st_points_generated, "/api/v1/weights", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
799
- rd_api_badges_points_generated = rrddim_add(st_points_generated, "/api/v1/badge", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
800
- rd_health_points_generated = rrddim_add(st_points_generated, "health", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
801
- rd_ml_points_generated = rrddim_add(st_points_generated, "ml", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
802
- rd_replication_points_generated = rrddim_add(st_points_generated, "replication", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
803
- }
804
-
805
- rrddim_set_by_pointer(st_points_generated, rd_api_data_points_generated, (collected_number)gs.api_data_result_points_generated);
806
- rrddim_set_by_pointer(st_points_generated, rd_api_weights_points_generated, (collected_number)gs.api_weights_result_points_generated);
807
- rrddim_set_by_pointer(st_points_generated, rd_api_badges_points_generated, (collected_number)gs.api_badges_result_points_generated);
808
- rrddim_set_by_pointer(st_points_generated, rd_health_points_generated, (collected_number)gs.health_result_points_generated);
809
- rrddim_set_by_pointer(st_points_generated, rd_ml_points_generated, (collected_number)gs.ml_result_points_generated);
810
- rrddim_set_by_pointer(st_points_generated, rd_replication_points_generated, (collected_number)replication.points_generated);
811
-
812
- rrdset_done(st_points_generated);
813
- }
814
-
815
- ml_update_global_statistics_charts(gs.ml_models_consulted);
816
-
817
- {
818
- static RRDSET *st_points_stored = NULL;
819
- static RRDDIM *rds[RRD_STORAGE_TIERS] = {};
820
-
821
- if (unlikely(!st_points_stored)) {
822
- st_points_stored = rrdset_create_localhost(
823
- "netdata"
824
- , "db_points_stored"
825
- , NULL
826
- , "queries"
827
- , NULL
828
- , "Netdata DB Points Stored"
829
- , "points/s"
830
- , "netdata"
831
- , "stats"
832
- , 131003
833
- , localhost->rrd_update_every
834
- , RRDSET_TYPE_STACKED
835
- );
836
-
837
- for(size_t tier = 0; tier < storage_tiers ;tier++) {
838
- char buf[30 + 1];
839
- snprintfz(buf, sizeof(buf) - 1, "tier%zu", tier);
840
- rds[tier] = rrddim_add(st_points_stored, buf, NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
841
- }
842
- }
843
-
844
- for(size_t tier = 0; tier < storage_tiers ;tier++)
845
- rrddim_set_by_pointer(st_points_stored, rds[tier], (collected_number)gs.db_points_stored_per_tier[tier]);
846
-
847
- rrdset_done(st_points_stored);
848
- }
849
-
850
-#ifdef ENABLE_DBENGINE
851
- if (tier_page_type[0] == RRDENG_PAGE_TYPE_GORILLA_32BIT)
852
- {
853
- static RRDSET *st_tier0_gorilla_pages = NULL;
854
- static RRDDIM *rd_num_gorilla_pages = NULL;
855
-
856
- if (unlikely(!st_tier0_gorilla_pages)) {
857
- st_tier0_gorilla_pages = rrdset_create_localhost(
858
- "netdata"
859
- , "tier0_gorilla_pages"
860
- , NULL
861
- , "dbengine gorilla"
862
- , NULL
863
- , "Number of gorilla_pages"
864
- , "count"
865
- , "netdata"
866
- , "stats"
867
- , 131004
868
- , localhost->rrd_update_every
869
- , RRDSET_TYPE_LINE
870
- );
871
-
872
- rd_num_gorilla_pages = rrddim_add(st_tier0_gorilla_pages, "count", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
873
- }
874
-
875
- rrddim_set_by_pointer(st_tier0_gorilla_pages, rd_num_gorilla_pages, (collected_number)gs.tier0_hot_gorilla_buffers);
876
-
877
- rrdset_done(st_tier0_gorilla_pages);
878
- }
879
-
880
- if (tier_page_type[0] == RRDENG_PAGE_TYPE_GORILLA_32BIT)
881
- {
882
- static RRDSET *st_tier0_compression_info = NULL;
883
-
884
- static RRDDIM *rd_compressed_bytes = NULL;
885
- static RRDDIM *rd_uncompressed_bytes = NULL;
886
-
887
- if (unlikely(!st_tier0_compression_info)) {
888
- st_tier0_compression_info = rrdset_create_localhost(
889
- "netdata"
890
- , "tier0_compression_info"
891
- , NULL
892
- , "dbengine gorilla"
893
- , NULL
894
- , "Tier 0 compression info"
895
- , "bytes"
896
- , "netdata"
897
- , "stats"
898
- , 131005
899
- , localhost->rrd_update_every
900
- , RRDSET_TYPE_LINE
901
- );
902
-
903
- rd_compressed_bytes = rrddim_add(st_tier0_compression_info, "compressed", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
904
- rd_uncompressed_bytes = rrddim_add(st_tier0_compression_info, "uncompressed", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
905
- }
906
-
907
- rrddim_set_by_pointer(st_tier0_compression_info, rd_compressed_bytes, (collected_number)gs.tier0_disk_compressed_bytes);
908
- rrddim_set_by_pointer(st_tier0_compression_info, rd_uncompressed_bytes, (collected_number)gs.tier0_disk_uncompressed_bytes);
909
-
910
- rrdset_done(st_tier0_compression_info);
911
- }
912
-#endif
913
-}
914
-// ----------------------------------------------------------------------------
915
-// sqlite3 statistics
916
-
917
-struct sqlite3_statistics {
918
- uint64_t sqlite3_queries_made;
919
- uint64_t sqlite3_queries_ok;
920
- uint64_t sqlite3_queries_failed;
921
- uint64_t sqlite3_queries_failed_busy;
922
- uint64_t sqlite3_queries_failed_locked;
923
- uint64_t sqlite3_rows;
924
- uint64_t sqlite3_metadata_cache_hit;
925
- uint64_t sqlite3_context_cache_hit;
926
- uint64_t sqlite3_metadata_cache_miss;
927
- uint64_t sqlite3_context_cache_miss;
928
- uint64_t sqlite3_metadata_cache_spill;
929
- uint64_t sqlite3_context_cache_spill;
930
- uint64_t sqlite3_metadata_cache_write;
931
- uint64_t sqlite3_context_cache_write;
932
-
933
-} sqlite3_statistics = { };
934
-
935
-void global_statistics_sqlite3_query_completed(bool success, bool busy, bool locked) {
936
- __atomic_fetch_add(&sqlite3_statistics.sqlite3_queries_made, 1, __ATOMIC_RELAXED);
937
-
938
- if(success) {
939
- __atomic_fetch_add(&sqlite3_statistics.sqlite3_queries_ok, 1, __ATOMIC_RELAXED);
940
- }
941
- else {
942
- __atomic_fetch_add(&sqlite3_statistics.sqlite3_queries_failed, 1, __ATOMIC_RELAXED);
943
-
944
- if(busy)
945
- __atomic_fetch_add(&sqlite3_statistics.sqlite3_queries_failed_busy, 1, __ATOMIC_RELAXED);
946
-
947
- if(locked)
948
- __atomic_fetch_add(&sqlite3_statistics.sqlite3_queries_failed_locked, 1, __ATOMIC_RELAXED);
949
- }
950
-}
951
-
952
-void global_statistics_sqlite3_row_completed(void) {
953
- __atomic_fetch_add(&sqlite3_statistics.sqlite3_rows, 1, __ATOMIC_RELAXED);
954
-}
955
-
956
-static inline void sqlite3_statistics_copy(struct sqlite3_statistics *gs) {
957
- static usec_t last_run = 0;
958
-
959
- gs->sqlite3_queries_made = __atomic_load_n(&sqlite3_statistics.sqlite3_queries_made, __ATOMIC_RELAXED);
960
- gs->sqlite3_queries_ok = __atomic_load_n(&sqlite3_statistics.sqlite3_queries_ok, __ATOMIC_RELAXED);
961
- gs->sqlite3_queries_failed = __atomic_load_n(&sqlite3_statistics.sqlite3_queries_failed, __ATOMIC_RELAXED);
962
- gs->sqlite3_queries_failed_busy = __atomic_load_n(&sqlite3_statistics.sqlite3_queries_failed_busy, __ATOMIC_RELAXED);
963
- gs->sqlite3_queries_failed_locked = __atomic_load_n(&sqlite3_statistics.sqlite3_queries_failed_locked, __ATOMIC_RELAXED);
964
- gs->sqlite3_rows = __atomic_load_n(&sqlite3_statistics.sqlite3_rows, __ATOMIC_RELAXED);
965
-
966
- usec_t timeout = default_rrd_update_every * USEC_PER_SEC + default_rrd_update_every * USEC_PER_SEC / 3;
967
- usec_t now = now_monotonic_usec();
968
- if(!last_run)
969
- last_run = now;
970
- usec_t delta = now - last_run;
971
- bool query_sqlite3 = delta < timeout;
972
-
973
- if(query_sqlite3 && now_monotonic_usec() - last_run < timeout)
974
- gs->sqlite3_metadata_cache_hit = (uint64_t) sql_metadata_cache_stats(SQLITE_DBSTATUS_CACHE_HIT);
975
- else {
976
- gs->sqlite3_metadata_cache_hit = UINT64_MAX;
977
- query_sqlite3 = false;
978
- }
979
-
980
- if(query_sqlite3 && now_monotonic_usec() - last_run < timeout)
981
- gs->sqlite3_context_cache_hit = (uint64_t) sql_context_cache_stats(SQLITE_DBSTATUS_CACHE_HIT);
982
- else {
983
- gs->sqlite3_context_cache_hit = UINT64_MAX;
984
- query_sqlite3 = false;
985
- }
986
-
987
- if(query_sqlite3 && now_monotonic_usec() - last_run < timeout)
988
- gs->sqlite3_metadata_cache_miss = (uint64_t) sql_metadata_cache_stats(SQLITE_DBSTATUS_CACHE_MISS);
989
- else {
990
- gs->sqlite3_metadata_cache_miss = UINT64_MAX;
991
- query_sqlite3 = false;
992
- }
993
-
994
- if(query_sqlite3 && now_monotonic_usec() - last_run < timeout)
995
- gs->sqlite3_context_cache_miss = (uint64_t) sql_context_cache_stats(SQLITE_DBSTATUS_CACHE_MISS);
996
- else {
997
- gs->sqlite3_context_cache_miss = UINT64_MAX;
998
- query_sqlite3 = false;
999
- }
1000
-
1001
- if(query_sqlite3 && now_monotonic_usec() - last_run < timeout)
1002
- gs->sqlite3_metadata_cache_spill = (uint64_t) sql_metadata_cache_stats(SQLITE_DBSTATUS_CACHE_SPILL);
1003
- else {
1004
- gs->sqlite3_metadata_cache_spill = UINT64_MAX;
1005
- query_sqlite3 = false;
1006
- }
1007
-
1008
- if(query_sqlite3 && now_monotonic_usec() - last_run < timeout)
1009
- gs->sqlite3_context_cache_spill = (uint64_t) sql_context_cache_stats(SQLITE_DBSTATUS_CACHE_SPILL);
1010
- else {
1011
- gs->sqlite3_context_cache_spill = UINT64_MAX;
1012
- query_sqlite3 = false;
1013
- }
1014
-
1015
- if(query_sqlite3 && now_monotonic_usec() - last_run < timeout)
1016
- gs->sqlite3_metadata_cache_write = (uint64_t) sql_metadata_cache_stats(SQLITE_DBSTATUS_CACHE_WRITE);
1017
- else {
1018
- gs->sqlite3_metadata_cache_write = UINT64_MAX;
1019
- query_sqlite3 = false;
1020
- }
1021
-
1022
- if(query_sqlite3 && now_monotonic_usec() - last_run < timeout)
1023
- gs->sqlite3_context_cache_write = (uint64_t) sql_context_cache_stats(SQLITE_DBSTATUS_CACHE_WRITE);
1024
- else {
1025
- gs->sqlite3_context_cache_write = UINT64_MAX;
1026
- query_sqlite3 = false;
1027
- }
1028
-
1029
- last_run = now_monotonic_usec();
1030
-}
1031
-
1032
-static void sqlite3_statistics_charts(void) {
1033
- struct sqlite3_statistics gs;
1034
- sqlite3_statistics_copy(&gs);
1035
-
1036
- if(gs.sqlite3_queries_made) {
1037
- static RRDSET *st_sqlite3_queries = NULL;
1038
- static RRDDIM *rd_queries = NULL;
1039
-
1040
- if (unlikely(!st_sqlite3_queries)) {
1041
- st_sqlite3_queries = rrdset_create_localhost(
1042
- "netdata"
1043
- , "sqlite3_queries"
1044
- , NULL
1045
- , "sqlite3"
1046
- , NULL
1047
- , "Netdata SQLite3 Queries"
1048
- , "queries/s"
1049
- , "netdata"
1050
- , "stats"
1051
- , 131100
1052
- , localhost->rrd_update_every
1053
- , RRDSET_TYPE_LINE
1054
- );
1055
-
1056
- rd_queries = rrddim_add(st_sqlite3_queries, "queries", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1057
- }
1058
-
1059
- rrddim_set_by_pointer(st_sqlite3_queries, rd_queries, (collected_number)gs.sqlite3_queries_made);
1060
-
1061
- rrdset_done(st_sqlite3_queries);
1062
- }
1063
-
1064
- // ----------------------------------------------------------------
1065
-
1066
- if(gs.sqlite3_queries_ok || gs.sqlite3_queries_failed) {
1067
- static RRDSET *st_sqlite3_queries_by_status = NULL;
1068
- static RRDDIM *rd_ok = NULL, *rd_failed = NULL, *rd_busy = NULL, *rd_locked = NULL;
1069
-
1070
- if (unlikely(!st_sqlite3_queries_by_status)) {
1071
- st_sqlite3_queries_by_status = rrdset_create_localhost(
1072
- "netdata"
1073
- , "sqlite3_queries_by_status"
1074
- , NULL
1075
- , "sqlite3"
1076
- , NULL
1077
- , "Netdata SQLite3 Queries by status"
1078
- , "queries/s"
1079
- , "netdata"
1080
- , "stats"
1081
- , 131101
1082
- , localhost->rrd_update_every
1083
- , RRDSET_TYPE_LINE
1084
- );
1085
-
1086
- rd_ok = rrddim_add(st_sqlite3_queries_by_status, "ok", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1087
- rd_failed = rrddim_add(st_sqlite3_queries_by_status, "failed", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL);
1088
- rd_busy = rrddim_add(st_sqlite3_queries_by_status, "busy", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL);
1089
- rd_locked = rrddim_add(st_sqlite3_queries_by_status, "locked", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL);
1090
- }
1091
-
1092
- rrddim_set_by_pointer(st_sqlite3_queries_by_status, rd_ok, (collected_number)gs.sqlite3_queries_made);
1093
- rrddim_set_by_pointer(st_sqlite3_queries_by_status, rd_failed, (collected_number)gs.sqlite3_queries_failed);
1094
- rrddim_set_by_pointer(st_sqlite3_queries_by_status, rd_busy, (collected_number)gs.sqlite3_queries_failed_busy);
1095
- rrddim_set_by_pointer(st_sqlite3_queries_by_status, rd_locked, (collected_number)gs.sqlite3_queries_failed_locked);
1096
-
1097
- rrdset_done(st_sqlite3_queries_by_status);
1098
- }
1099
-
1100
- // ----------------------------------------------------------------
1101
-
1102
- if(gs.sqlite3_rows) {
1103
- static RRDSET *st_sqlite3_rows = NULL;
1104
- static RRDDIM *rd_rows = NULL;
1105
-
1106
- if (unlikely(!st_sqlite3_rows)) {
1107
- st_sqlite3_rows = rrdset_create_localhost(
1108
- "netdata"
1109
- , "sqlite3_rows"
1110
- , NULL
1111
- , "sqlite3"
1112
- , NULL
1113
- , "Netdata SQLite3 Rows"
1114
- , "rows/s"
1115
- , "netdata"
1116
- , "stats"
1117
- , 131102
1118
- , localhost->rrd_update_every
1119
- , RRDSET_TYPE_LINE
1120
- );
1121
-
1122
- rd_rows = rrddim_add(st_sqlite3_rows, "ok", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1123
- }
1124
-
1125
- rrddim_set_by_pointer(st_sqlite3_rows, rd_rows, (collected_number)gs.sqlite3_rows);
1126
-
1127
- rrdset_done(st_sqlite3_rows);
1128
- }
1129
-
1130
- if(gs.sqlite3_metadata_cache_hit) {
1131
- static RRDSET *st_sqlite3_cache = NULL;
1132
- static RRDDIM *rd_cache_hit = NULL;
1133
- static RRDDIM *rd_cache_miss= NULL;
1134
- static RRDDIM *rd_cache_spill= NULL;
1135
- static RRDDIM *rd_cache_write= NULL;
1136
-
1137
- if (unlikely(!st_sqlite3_cache)) {
1138
- st_sqlite3_cache = rrdset_create_localhost(
1139
- "netdata"
1140
- , "sqlite3_metatada_cache"
1141
- , NULL
1142
- , "sqlite3"
1143
- , NULL
1144
- , "Netdata SQLite3 metadata cache"
1145
- , "ops/s"
1146
- , "netdata"
1147
- , "stats"
1148
- , 131103
1149
- , localhost->rrd_update_every
1150
- , RRDSET_TYPE_LINE
1151
- );
1152
-
1153
- rd_cache_hit = rrddim_add(st_sqlite3_cache, "cache_hit", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1154
- rd_cache_miss = rrddim_add(st_sqlite3_cache, "cache_miss", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1155
- rd_cache_spill = rrddim_add(st_sqlite3_cache, "cache_spill", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1156
- rd_cache_write = rrddim_add(st_sqlite3_cache, "cache_write", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1157
- }
1158
-
1159
- if(gs.sqlite3_metadata_cache_hit != UINT64_MAX)
1160
- rrddim_set_by_pointer(st_sqlite3_cache, rd_cache_hit, (collected_number)gs.sqlite3_metadata_cache_hit);
1161
-
1162
- if(gs.sqlite3_metadata_cache_miss != UINT64_MAX)
1163
- rrddim_set_by_pointer(st_sqlite3_cache, rd_cache_miss, (collected_number)gs.sqlite3_metadata_cache_miss);
1164
-
1165
- if(gs.sqlite3_metadata_cache_spill != UINT64_MAX)
1166
- rrddim_set_by_pointer(st_sqlite3_cache, rd_cache_spill, (collected_number)gs.sqlite3_metadata_cache_spill);
1167
-
1168
- if(gs.sqlite3_metadata_cache_write != UINT64_MAX)
1169
- rrddim_set_by_pointer(st_sqlite3_cache, rd_cache_write, (collected_number)gs.sqlite3_metadata_cache_write);
1170
-
1171
- rrdset_done(st_sqlite3_cache);
1172
- }
1173
-
1174
- if(gs.sqlite3_context_cache_hit) {
1175
- static RRDSET *st_sqlite3_cache = NULL;
1176
- static RRDDIM *rd_cache_hit = NULL;
1177
- static RRDDIM *rd_cache_miss= NULL;
1178
- static RRDDIM *rd_cache_spill= NULL;
1179
- static RRDDIM *rd_cache_write= NULL;
1180
-
1181
- if (unlikely(!st_sqlite3_cache)) {
1182
- st_sqlite3_cache = rrdset_create_localhost(
1183
- "netdata"
1184
- , "sqlite3_context_cache"
1185
- , NULL
1186
- , "sqlite3"
1187
- , NULL
1188
- , "Netdata SQLite3 context cache"
1189
- , "ops/s"
1190
- , "netdata"
1191
- , "stats"
1192
- , 131104
1193
- , localhost->rrd_update_every
1194
- , RRDSET_TYPE_LINE
1195
- );
1196
-
1197
- rd_cache_hit = rrddim_add(st_sqlite3_cache, "cache_hit", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1198
- rd_cache_miss = rrddim_add(st_sqlite3_cache, "cache_miss", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1199
- rd_cache_spill = rrddim_add(st_sqlite3_cache, "cache_spill", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1200
- rd_cache_write = rrddim_add(st_sqlite3_cache, "cache_write", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1201
- }
1202
-
1203
- if(gs.sqlite3_context_cache_hit != UINT64_MAX)
1204
- rrddim_set_by_pointer(st_sqlite3_cache, rd_cache_hit, (collected_number)gs.sqlite3_context_cache_hit);
1205
-
1206
- if(gs.sqlite3_context_cache_miss != UINT64_MAX)
1207
- rrddim_set_by_pointer(st_sqlite3_cache, rd_cache_miss, (collected_number)gs.sqlite3_context_cache_miss);
1208
-
1209
- if(gs.sqlite3_context_cache_spill != UINT64_MAX)
1210
- rrddim_set_by_pointer(st_sqlite3_cache, rd_cache_spill, (collected_number)gs.sqlite3_context_cache_spill);
1211
-
1212
- if(gs.sqlite3_context_cache_write != UINT64_MAX)
1213
- rrddim_set_by_pointer(st_sqlite3_cache, rd_cache_write, (collected_number)gs.sqlite3_context_cache_write);
1214
-
1215
- rrdset_done(st_sqlite3_cache);
1216
- }
1217
-
1218
- // ----------------------------------------------------------------
1219
-}
1220
-
1221
-#ifdef ENABLE_DBENGINE
1222
-
1223
-struct dbengine2_cache_pointers {
1224
- RRDSET *st_cache_hit_ratio;
1225
- RRDDIM *rd_hit_ratio_closest;
1226
- RRDDIM *rd_hit_ratio_exact;
1227
-
1228
- RRDSET *st_operations;
1229
- RRDDIM *rd_searches_closest;
1230
- RRDDIM *rd_searches_exact;
1231
- RRDDIM *rd_add_hot;
1232
- RRDDIM *rd_add_clean;
1233
- RRDDIM *rd_evictions;
1234
- RRDDIM *rd_flushes;
1235
- RRDDIM *rd_acquires;
1236
- RRDDIM *rd_releases;
1237
- RRDDIM *rd_acquires_for_deletion;
1238
-
1239
- RRDSET *st_pgc_memory;
1240
- RRDDIM *rd_pgc_memory_free;
1241
- RRDDIM *rd_pgc_memory_clean;
1242
- RRDDIM *rd_pgc_memory_hot;
1243
- RRDDIM *rd_pgc_memory_dirty;
1244
- RRDDIM *rd_pgc_memory_index;
1245
- RRDDIM *rd_pgc_memory_evicting;
1246
- RRDDIM *rd_pgc_memory_flushing;
1247
-
1248
- RRDSET *st_pgc_tm;
1249
- RRDDIM *rd_pgc_tm_current;
1250
- RRDDIM *rd_pgc_tm_wanted;
1251
- RRDDIM *rd_pgc_tm_hot_max;
1252
- RRDDIM *rd_pgc_tm_dirty_max;
1253
- RRDDIM *rd_pgc_tm_hot;
1254
- RRDDIM *rd_pgc_tm_dirty;
1255
- RRDDIM *rd_pgc_tm_referenced;
1256
-
1257
- RRDSET *st_pgc_pages;
1258
- RRDDIM *rd_pgc_pages_clean;
1259
- RRDDIM *rd_pgc_pages_hot;
1260
- RRDDIM *rd_pgc_pages_dirty;
1261
- RRDDIM *rd_pgc_pages_referenced;
1262
-
1263
- RRDSET *st_pgc_memory_changes;
1264
- RRDDIM *rd_pgc_memory_new_hot;
1265
- RRDDIM *rd_pgc_memory_new_clean;
1266
- RRDDIM *rd_pgc_memory_clean_evictions;
1267
-
1268
- RRDSET *st_pgc_memory_migrations;
1269
- RRDDIM *rd_pgc_memory_hot_to_dirty;
1270
- RRDDIM *rd_pgc_memory_dirty_to_clean;
1271
-
1272
- RRDSET *st_pgc_workers;
1273
- RRDDIM *rd_pgc_workers_evictors;
1274
- RRDDIM *rd_pgc_workers_flushers;
1275
- RRDDIM *rd_pgc_workers_adders;
1276
- RRDDIM *rd_pgc_workers_searchers;
1277
- RRDDIM *rd_pgc_workers_jv2_flushers;
1278
- RRDDIM *rd_pgc_workers_hot2dirty;
1279
-
1280
- RRDSET *st_pgc_memory_events;
1281
- RRDDIM *rd_pgc_memory_evictions_critical;
1282
- RRDDIM *rd_pgc_memory_evictions_aggressive;
1283
- RRDDIM *rd_pgc_memory_flushes_critical;
1284
-
1285
- RRDSET *st_pgc_waste;
1286
- RRDDIM *rd_pgc_waste_evictions_skipped;
1287
- RRDDIM *rd_pgc_waste_flushes_cancelled;
1288
- RRDDIM *rd_pgc_waste_insert_spins;
1289
- RRDDIM *rd_pgc_waste_evict_spins;
1290
- RRDDIM *rd_pgc_waste_release_spins;
1291
- RRDDIM *rd_pgc_waste_acquire_spins;
1292
- RRDDIM *rd_pgc_waste_delete_spins;
1293
- RRDDIM *rd_pgc_waste_flush_spins;
1294
-
1295
-};
1296
-
1297
-static void dbengine2_cache_statistics_charts(struct dbengine2_cache_pointers *ptrs, struct pgc_statistics *pgc_stats, struct pgc_statistics *pgc_stats_old __maybe_unused, const char *name, int priority) {
1298
-
1299
- {
1300
- if (unlikely(!ptrs->st_cache_hit_ratio)) {
1301
- BUFFER *id = buffer_create(100, NULL);
1302
- buffer_sprintf(id, "dbengine_%s_cache_hit_ratio", name);
1303
-
1304
- BUFFER *family = buffer_create(100, NULL);
1305
- buffer_sprintf(family, "dbengine %s cache", name);
1306
-
1307
- BUFFER *title = buffer_create(100, NULL);
1308
- buffer_sprintf(title, "Netdata %s Cache Hit Ratio", name);
1309
-
1310
- ptrs->st_cache_hit_ratio = rrdset_create_localhost(
1311
- "netdata",
1312
- buffer_tostring(id),
1313
- NULL,
1314
- buffer_tostring(family),
1315
- NULL,
1316
- buffer_tostring(title),
1317
- "%",
1318
- "netdata",
1319
- "stats",
1320
- priority,
1321
- localhost->rrd_update_every,
1322
- RRDSET_TYPE_LINE);
1323
-
1324
- ptrs->rd_hit_ratio_closest = rrddim_add(ptrs->st_cache_hit_ratio, "closest", NULL, 1, 10000, RRD_ALGORITHM_ABSOLUTE);
1325
- ptrs->rd_hit_ratio_exact = rrddim_add(ptrs->st_cache_hit_ratio, "exact", NULL, 1, 10000, RRD_ALGORITHM_ABSOLUTE);
1326
-
1327
- buffer_free(id);
1328
- buffer_free(family);
1329
- buffer_free(title);
1330
- priority++;
1331
- }
1332
-
1333
- size_t closest_percent = 100 * 10000;
1334
- if(pgc_stats->searches_closest > pgc_stats_old->searches_closest)
1335
- closest_percent = (pgc_stats->searches_closest_hits - pgc_stats_old->searches_closest_hits) * 100 * 10000 / (pgc_stats->searches_closest - pgc_stats_old->searches_closest);
1336
-
1337
- size_t exact_percent = 100 * 10000;
1338
- if(pgc_stats->searches_exact > pgc_stats_old->searches_exact)
1339
- exact_percent = (pgc_stats->searches_exact_hits - pgc_stats_old->searches_exact_hits) * 100 * 10000 / (pgc_stats->searches_exact - pgc_stats_old->searches_exact);
1340
-
1341
- rrddim_set_by_pointer(ptrs->st_cache_hit_ratio, ptrs->rd_hit_ratio_closest, (collected_number)closest_percent);
1342
- rrddim_set_by_pointer(ptrs->st_cache_hit_ratio, ptrs->rd_hit_ratio_exact, (collected_number)exact_percent);
1343
-
1344
- rrdset_done(ptrs->st_cache_hit_ratio);
1345
- }
1346
-
1347
- {
1348
- if (unlikely(!ptrs->st_operations)) {
1349
- BUFFER *id = buffer_create(100, NULL);
1350
- buffer_sprintf(id, "dbengine_%s_cache_operations", name);
1351
-
1352
- BUFFER *family = buffer_create(100, NULL);
1353
- buffer_sprintf(family, "dbengine %s cache", name);
1354
-
1355
- BUFFER *title = buffer_create(100, NULL);
1356
- buffer_sprintf(title, "Netdata %s Cache Operations", name);
1357
-
1358
- ptrs->st_operations = rrdset_create_localhost(
1359
- "netdata",
1360
- buffer_tostring(id),
1361
- NULL,
1362
- buffer_tostring(family),
1363
- NULL,
1364
- buffer_tostring(title),
1365
- "ops/s",
1366
- "netdata",
1367
- "stats",
1368
- priority,
1369
- localhost->rrd_update_every,
1370
- RRDSET_TYPE_LINE);
1371
-
1372
- ptrs->rd_searches_closest = rrddim_add(ptrs->st_operations, "search closest", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1373
- ptrs->rd_searches_exact = rrddim_add(ptrs->st_operations, "search exact", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1374
- ptrs->rd_add_hot = rrddim_add(ptrs->st_operations, "add hot", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1375
- ptrs->rd_add_clean = rrddim_add(ptrs->st_operations, "add clean", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1376
- ptrs->rd_evictions = rrddim_add(ptrs->st_operations, "evictions", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1377
- ptrs->rd_flushes = rrddim_add(ptrs->st_operations, "flushes", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1378
- ptrs->rd_acquires = rrddim_add(ptrs->st_operations, "acquires", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1379
- ptrs->rd_releases = rrddim_add(ptrs->st_operations, "releases", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1380
- ptrs->rd_acquires_for_deletion = rrddim_add(ptrs->st_operations, "del acquires", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1381
-
1382
- buffer_free(id);
1383
- buffer_free(family);
1384
- buffer_free(title);
1385
- priority++;
1386
- }
1387
-
1388
- rrddim_set_by_pointer(ptrs->st_operations, ptrs->rd_searches_closest, (collected_number)pgc_stats->searches_closest);
1389
- rrddim_set_by_pointer(ptrs->st_operations, ptrs->rd_searches_exact, (collected_number)pgc_stats->searches_exact);
1390
- rrddim_set_by_pointer(ptrs->st_operations, ptrs->rd_add_hot, (collected_number)pgc_stats->queues.hot.added_entries);
1391
- rrddim_set_by_pointer(ptrs->st_operations, ptrs->rd_add_clean, (collected_number)(pgc_stats->added_entries - pgc_stats->queues.hot.added_entries));
1392
- rrddim_set_by_pointer(ptrs->st_operations, ptrs->rd_evictions, (collected_number)pgc_stats->queues.clean.removed_entries);
1393
- rrddim_set_by_pointer(ptrs->st_operations, ptrs->rd_flushes, (collected_number)pgc_stats->flushes_completed);
1394
- rrddim_set_by_pointer(ptrs->st_operations, ptrs->rd_acquires, (collected_number)pgc_stats->acquires);
1395
- rrddim_set_by_pointer(ptrs->st_operations, ptrs->rd_releases, (collected_number)pgc_stats->releases);
1396
- rrddim_set_by_pointer(ptrs->st_operations, ptrs->rd_acquires_for_deletion, (collected_number)pgc_stats->acquires_for_deletion);
1397
-
1398
- rrdset_done(ptrs->st_operations);
1399
- }
1400
-
1401
- {
1402
- if (unlikely(!ptrs->st_pgc_memory)) {
1403
- BUFFER *id = buffer_create(100, NULL);
1404
- buffer_sprintf(id, "dbengine_%s_cache_memory", name);
1405
-
1406
- BUFFER *family = buffer_create(100, NULL);
1407
- buffer_sprintf(family, "dbengine %s cache", name);
1408
-
1409
- BUFFER *title = buffer_create(100, NULL);
1410
- buffer_sprintf(title, "Netdata %s Cache Memory", name);
1411
-
1412
- ptrs->st_pgc_memory = rrdset_create_localhost(
1413
- "netdata",
1414
- buffer_tostring(id),
1415
- NULL,
1416
- buffer_tostring(family),
1417
- NULL,
1418
- buffer_tostring(title),
1419
- "bytes",
1420
- "netdata",
1421
- "stats",
1422
- priority,
1423
- localhost->rrd_update_every,
1424
- RRDSET_TYPE_STACKED);
1425
-
1426
- ptrs->rd_pgc_memory_free = rrddim_add(ptrs->st_pgc_memory, "free", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
1427
- ptrs->rd_pgc_memory_hot = rrddim_add(ptrs->st_pgc_memory, "hot", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
1428
- ptrs->rd_pgc_memory_dirty = rrddim_add(ptrs->st_pgc_memory, "dirty", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
1429
- ptrs->rd_pgc_memory_clean = rrddim_add(ptrs->st_pgc_memory, "clean", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
1430
- ptrs->rd_pgc_memory_index = rrddim_add(ptrs->st_pgc_memory, "index", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
1431
- ptrs->rd_pgc_memory_evicting = rrddim_add(ptrs->st_pgc_memory, "evicting", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
1432
- ptrs->rd_pgc_memory_flushing = rrddim_add(ptrs->st_pgc_memory, "flushing", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
1433
-
1434
- buffer_free(id);
1435
- buffer_free(family);
1436
- buffer_free(title);
1437
- priority++;
1438
- }
1439
-
1440
- collected_number free = (pgc_stats->current_cache_size > pgc_stats->wanted_cache_size) ? 0 :
1441
- (collected_number)(pgc_stats->wanted_cache_size - pgc_stats->current_cache_size);
1442
-
1443
- rrddim_set_by_pointer(ptrs->st_pgc_memory, ptrs->rd_pgc_memory_free, free);
1444
- rrddim_set_by_pointer(ptrs->st_pgc_memory, ptrs->rd_pgc_memory_hot, (collected_number)pgc_stats->queues.hot.size);
1445
- rrddim_set_by_pointer(ptrs->st_pgc_memory, ptrs->rd_pgc_memory_dirty, (collected_number)pgc_stats->queues.dirty.size);
1446
- rrddim_set_by_pointer(ptrs->st_pgc_memory, ptrs->rd_pgc_memory_clean, (collected_number)pgc_stats->queues.clean.size);
1447
- rrddim_set_by_pointer(ptrs->st_pgc_memory, ptrs->rd_pgc_memory_evicting, (collected_number)pgc_stats->evicting_size);
1448
- rrddim_set_by_pointer(ptrs->st_pgc_memory, ptrs->rd_pgc_memory_flushing, (collected_number)pgc_stats->flushing_size);
1449
- rrddim_set_by_pointer(ptrs->st_pgc_memory, ptrs->rd_pgc_memory_index,
1450
- (collected_number)(pgc_stats->size - pgc_stats->queues.clean.size - pgc_stats->queues.hot.size - pgc_stats->queues.dirty.size - pgc_stats->evicting_size - pgc_stats->flushing_size));
1451
-
1452
- rrdset_done(ptrs->st_pgc_memory);
1453
- }
1454
-
1455
- {
1456
- if (unlikely(!ptrs->st_pgc_tm)) {
1457
- BUFFER *id = buffer_create(100, NULL);
1458
- buffer_sprintf(id, "dbengine_%s_target_memory", name);
1459
-
1460
- BUFFER *family = buffer_create(100, NULL);
1461
- buffer_sprintf(family, "dbengine %s cache", name);
1462
-
1463
- BUFFER *title = buffer_create(100, NULL);
1464
- buffer_sprintf(title, "Netdata %s Target Cache Memory", name);
1465
-
1466
- ptrs->st_pgc_tm = rrdset_create_localhost(
1467
- "netdata",
1468
- buffer_tostring(id),
1469
- NULL,
1470
- buffer_tostring(family),
1471
- NULL,
1472
- buffer_tostring(title),
1473
- "bytes",
1474
- "netdata",
1475
- "stats",
1476
- priority,
1477
- localhost->rrd_update_every,
1478
- RRDSET_TYPE_LINE);
1479
-
1480
- ptrs->rd_pgc_tm_current = rrddim_add(ptrs->st_pgc_tm, "current", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
1481
- ptrs->rd_pgc_tm_wanted = rrddim_add(ptrs->st_pgc_tm, "wanted", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
1482
- ptrs->rd_pgc_tm_referenced = rrddim_add(ptrs->st_pgc_tm, "referenced", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
1483
- ptrs->rd_pgc_tm_hot_max = rrddim_add(ptrs->st_pgc_tm, "hot max", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
1484
- ptrs->rd_pgc_tm_dirty_max = rrddim_add(ptrs->st_pgc_tm, "dirty max", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
1485
- ptrs->rd_pgc_tm_hot = rrddim_add(ptrs->st_pgc_tm, "hot", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
1486
- ptrs->rd_pgc_tm_dirty = rrddim_add(ptrs->st_pgc_tm, "dirty", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
1487
-
1488
- buffer_free(id);
1489
- buffer_free(family);
1490
- buffer_free(title);
1491
- priority++;
1492
- }
1493
-
1494
- rrddim_set_by_pointer(ptrs->st_pgc_tm, ptrs->rd_pgc_tm_current, (collected_number)pgc_stats->current_cache_size);
1495
- rrddim_set_by_pointer(ptrs->st_pgc_tm, ptrs->rd_pgc_tm_wanted, (collected_number)pgc_stats->wanted_cache_size);
1496
- rrddim_set_by_pointer(ptrs->st_pgc_tm, ptrs->rd_pgc_tm_referenced, (collected_number)pgc_stats->referenced_size);
1497
- rrddim_set_by_pointer(ptrs->st_pgc_tm, ptrs->rd_pgc_tm_hot_max, (collected_number)pgc_stats->queues.hot.max_size);
1498
- rrddim_set_by_pointer(ptrs->st_pgc_tm, ptrs->rd_pgc_tm_dirty_max, (collected_number)pgc_stats->queues.dirty.max_size);
1499
- rrddim_set_by_pointer(ptrs->st_pgc_tm, ptrs->rd_pgc_tm_hot, (collected_number)pgc_stats->queues.hot.size);
1500
- rrddim_set_by_pointer(ptrs->st_pgc_tm, ptrs->rd_pgc_tm_dirty, (collected_number)pgc_stats->queues.dirty.size);
1501
-
1502
- rrdset_done(ptrs->st_pgc_tm);
1503
- }
1504
-
1505
- {
1506
- if (unlikely(!ptrs->st_pgc_pages)) {
1507
- BUFFER *id = buffer_create(100, NULL);
1508
- buffer_sprintf(id, "dbengine_%s_cache_pages", name);
1509
-
1510
- BUFFER *family = buffer_create(100, NULL);
1511
- buffer_sprintf(family, "dbengine %s cache", name);
1512
-
1513
- BUFFER *title = buffer_create(100, NULL);
1514
- buffer_sprintf(title, "Netdata %s Cache Pages", name);
1515
-
1516
- ptrs->st_pgc_pages = rrdset_create_localhost(
1517
- "netdata",
1518
- buffer_tostring(id),
1519
- NULL,
1520
- buffer_tostring(family),
1521
- NULL,
1522
- buffer_tostring(title),
1523
- "pages",
1524
- "netdata",
1525
- "stats",
1526
- priority,
1527
- localhost->rrd_update_every,
1528
- RRDSET_TYPE_LINE);
1529
-
1530
- ptrs->rd_pgc_pages_clean = rrddim_add(ptrs->st_pgc_pages, "clean", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
1531
- ptrs->rd_pgc_pages_hot = rrddim_add(ptrs->st_pgc_pages, "hot", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
1532
- ptrs->rd_pgc_pages_dirty = rrddim_add(ptrs->st_pgc_pages, "dirty", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
1533
- ptrs->rd_pgc_pages_referenced = rrddim_add(ptrs->st_pgc_pages, "referenced", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
1534
-
1535
- buffer_free(id);
1536
- buffer_free(family);
1537
- buffer_free(title);
1538
- priority++;
1539
- }
1540
-
1541
- rrddim_set_by_pointer(ptrs->st_pgc_pages, ptrs->rd_pgc_pages_clean, (collected_number)pgc_stats->queues.clean.entries);
1542
- rrddim_set_by_pointer(ptrs->st_pgc_pages, ptrs->rd_pgc_pages_hot, (collected_number)pgc_stats->queues.hot.entries);
1543
- rrddim_set_by_pointer(ptrs->st_pgc_pages, ptrs->rd_pgc_pages_dirty, (collected_number)pgc_stats->queues.dirty.entries);
1544
- rrddim_set_by_pointer(ptrs->st_pgc_pages, ptrs->rd_pgc_pages_referenced, (collected_number)pgc_stats->referenced_entries);
1545
-
1546
- rrdset_done(ptrs->st_pgc_pages);
1547
- }
1548
-
1549
- {
1550
- if (unlikely(!ptrs->st_pgc_memory_changes)) {
1551
- BUFFER *id = buffer_create(100, NULL);
1552
- buffer_sprintf(id, "dbengine_%s_cache_memory_changes", name);
1553
-
1554
- BUFFER *family = buffer_create(100, NULL);
1555
- buffer_sprintf(family, "dbengine %s cache", name);
1556
-
1557
- BUFFER *title = buffer_create(100, NULL);
1558
- buffer_sprintf(title, "Netdata %s Cache Memory Changes", name);
1559
-
1560
- ptrs->st_pgc_memory_changes = rrdset_create_localhost(
1561
- "netdata",
1562
- buffer_tostring(id),
1563
- NULL,
1564
- buffer_tostring(family),
1565
- NULL,
1566
- buffer_tostring(title),
1567
- "bytes/s",
1568
- "netdata",
1569
- "stats",
1570
- priority,
1571
- localhost->rrd_update_every,
1572
- RRDSET_TYPE_AREA);
1573
-
1574
- ptrs->rd_pgc_memory_new_clean = rrddim_add(ptrs->st_pgc_memory_changes, "new clean", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1575
- ptrs->rd_pgc_memory_clean_evictions = rrddim_add(ptrs->st_pgc_memory_changes, "evictions", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL);
1576
- ptrs->rd_pgc_memory_new_hot = rrddim_add(ptrs->st_pgc_memory_changes, "new hot", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1577
-
1578
- buffer_free(id);
1579
- buffer_free(family);
1580
- buffer_free(title);
1581
- priority++;
1582
- }
1583
-
1584
- rrddim_set_by_pointer(ptrs->st_pgc_memory_changes, ptrs->rd_pgc_memory_new_clean, (collected_number)(pgc_stats->added_size - pgc_stats->queues.hot.added_size));
1585
- rrddim_set_by_pointer(ptrs->st_pgc_memory_changes, ptrs->rd_pgc_memory_clean_evictions, (collected_number)pgc_stats->queues.clean.removed_size);
1586
- rrddim_set_by_pointer(ptrs->st_pgc_memory_changes, ptrs->rd_pgc_memory_new_hot, (collected_number)pgc_stats->queues.hot.added_size);
1587
-
1588
- rrdset_done(ptrs->st_pgc_memory_changes);
1589
- }
1590
-
1591
- {
1592
- if (unlikely(!ptrs->st_pgc_memory_migrations)) {
1593
- BUFFER *id = buffer_create(100, NULL);
1594
- buffer_sprintf(id, "dbengine_%s_cache_memory_migrations", name);
1595
-
1596
- BUFFER *family = buffer_create(100, NULL);
1597
- buffer_sprintf(family, "dbengine %s cache", name);
1598
-
1599
- BUFFER *title = buffer_create(100, NULL);
1600
- buffer_sprintf(title, "Netdata %s Cache Memory Migrations", name);
1601
-
1602
- ptrs->st_pgc_memory_migrations = rrdset_create_localhost(
1603
- "netdata",
1604
- buffer_tostring(id),
1605
- NULL,
1606
- buffer_tostring(family),
1607
- NULL,
1608
- buffer_tostring(title),
1609
- "bytes/s",
1610
- "netdata",
1611
- "stats",
1612
- priority,
1613
- localhost->rrd_update_every,
1614
- RRDSET_TYPE_AREA);
1615
-
1616
- ptrs->rd_pgc_memory_dirty_to_clean = rrddim_add(ptrs->st_pgc_memory_migrations, "dirty to clean", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1617
- ptrs->rd_pgc_memory_hot_to_dirty = rrddim_add(ptrs->st_pgc_memory_migrations, "hot to dirty", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL);
1618
-
1619
- buffer_free(id);
1620
- buffer_free(family);
1621
- buffer_free(title);
1622
- priority++;
1623
- }
1624
-
1625
- rrddim_set_by_pointer(ptrs->st_pgc_memory_migrations, ptrs->rd_pgc_memory_dirty_to_clean, (collected_number)pgc_stats->queues.dirty.removed_size);
1626
- rrddim_set_by_pointer(ptrs->st_pgc_memory_migrations, ptrs->rd_pgc_memory_hot_to_dirty, (collected_number)pgc_stats->queues.dirty.added_size);
1627
-
1628
- rrdset_done(ptrs->st_pgc_memory_migrations);
1629
- }
1630
-
1631
- {
1632
- if (unlikely(!ptrs->st_pgc_memory_events)) {
1633
- BUFFER *id = buffer_create(100, NULL);
1634
- buffer_sprintf(id, "dbengine_%s_cache_events", name);
1635
-
1636
- BUFFER *family = buffer_create(100, NULL);
1637
- buffer_sprintf(family, "dbengine %s cache", name);
1638
-
1639
- BUFFER *title = buffer_create(100, NULL);
1640
- buffer_sprintf(title, "Netdata %s Cache Events", name);
1641
-
1642
- ptrs->st_pgc_memory_events = rrdset_create_localhost(
1643
- "netdata",
1644
- buffer_tostring(id),
1645
- NULL,
1646
- buffer_tostring(family),
1647
- NULL,
1648
- buffer_tostring(title),
1649
- "events/s",
1650
- "netdata",
1651
- "stats",
1652
- priority,
1653
- localhost->rrd_update_every,
1654
- RRDSET_TYPE_AREA);
1655
-
1656
- ptrs->rd_pgc_memory_evictions_aggressive = rrddim_add(ptrs->st_pgc_memory_events, "evictions aggressive", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1657
- ptrs->rd_pgc_memory_evictions_critical = rrddim_add(ptrs->st_pgc_memory_events, "evictions critical", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1658
- ptrs->rd_pgc_memory_flushes_critical = rrddim_add(ptrs->st_pgc_memory_events, "flushes critical", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1659
-
1660
- buffer_free(id);
1661
- buffer_free(family);
1662
- buffer_free(title);
1663
- priority++;
1664
- }
1665
-
1666
- rrddim_set_by_pointer(ptrs->st_pgc_memory_events, ptrs->rd_pgc_memory_evictions_aggressive, (collected_number)pgc_stats->events_cache_needs_space_aggressively);
1667
- rrddim_set_by_pointer(ptrs->st_pgc_memory_events, ptrs->rd_pgc_memory_evictions_critical, (collected_number)pgc_stats->events_cache_under_severe_pressure);
1668
- rrddim_set_by_pointer(ptrs->st_pgc_memory_events, ptrs->rd_pgc_memory_flushes_critical, (collected_number)pgc_stats->events_flush_critical);
1669
-
1670
- rrdset_done(ptrs->st_pgc_memory_events);
1671
- }
1672
-
1673
- {
1674
- if (unlikely(!ptrs->st_pgc_waste)) {
1675
- BUFFER *id = buffer_create(100, NULL);
1676
- buffer_sprintf(id, "dbengine_%s_waste_events", name);
1677
-
1678
- BUFFER *family = buffer_create(100, NULL);
1679
- buffer_sprintf(family, "dbengine %s cache", name);
1680
-
1681
- BUFFER *title = buffer_create(100, NULL);
1682
- buffer_sprintf(title, "Netdata %s Waste Events", name);
1683
-
1684
- ptrs->st_pgc_waste = rrdset_create_localhost(
1685
- "netdata",
1686
- buffer_tostring(id),
1687
- NULL,
1688
- buffer_tostring(family),
1689
- NULL,
1690
- buffer_tostring(title),
1691
- "events/s",
1692
- "netdata",
1693
- "stats",
1694
- priority,
1695
- localhost->rrd_update_every,
1696
- RRDSET_TYPE_LINE);
1697
-
1698
- ptrs->rd_pgc_waste_evictions_skipped = rrddim_add(ptrs->st_pgc_waste, "evictions skipped", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1699
- ptrs->rd_pgc_waste_flushes_cancelled = rrddim_add(ptrs->st_pgc_waste, "flushes cancelled", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1700
- ptrs->rd_pgc_waste_acquire_spins = rrddim_add(ptrs->st_pgc_waste, "acquire spins", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1701
- ptrs->rd_pgc_waste_release_spins = rrddim_add(ptrs->st_pgc_waste, "release spins", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1702
- ptrs->rd_pgc_waste_insert_spins = rrddim_add(ptrs->st_pgc_waste, "insert spins", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1703
- ptrs->rd_pgc_waste_delete_spins = rrddim_add(ptrs->st_pgc_waste, "delete spins", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1704
- ptrs->rd_pgc_waste_evict_spins = rrddim_add(ptrs->st_pgc_waste, "evict spins", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1705
- ptrs->rd_pgc_waste_flush_spins = rrddim_add(ptrs->st_pgc_waste, "flush spins", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1706
-
1707
- buffer_free(id);
1708
- buffer_free(family);
1709
- buffer_free(title);
1710
- priority++;
1711
- }
1712
-
1713
- rrddim_set_by_pointer(ptrs->st_pgc_waste, ptrs->rd_pgc_waste_evictions_skipped, (collected_number)pgc_stats->evict_skipped);
1714
- rrddim_set_by_pointer(ptrs->st_pgc_waste, ptrs->rd_pgc_waste_flushes_cancelled, (collected_number)pgc_stats->flushes_cancelled);
1715
- rrddim_set_by_pointer(ptrs->st_pgc_waste, ptrs->rd_pgc_waste_acquire_spins, (collected_number)pgc_stats->acquire_spins);
1716
- rrddim_set_by_pointer(ptrs->st_pgc_waste, ptrs->rd_pgc_waste_release_spins, (collected_number)pgc_stats->release_spins);
1717
- rrddim_set_by_pointer(ptrs->st_pgc_waste, ptrs->rd_pgc_waste_insert_spins, (collected_number)pgc_stats->insert_spins);
1718
- rrddim_set_by_pointer(ptrs->st_pgc_waste, ptrs->rd_pgc_waste_delete_spins, (collected_number)pgc_stats->delete_spins);
1719
- rrddim_set_by_pointer(ptrs->st_pgc_waste, ptrs->rd_pgc_waste_evict_spins, (collected_number)pgc_stats->evict_spins);
1720
- rrddim_set_by_pointer(ptrs->st_pgc_waste, ptrs->rd_pgc_waste_flush_spins, (collected_number)pgc_stats->flush_spins);
1721
-
1722
- rrdset_done(ptrs->st_pgc_waste);
1723
- }
1724
-
1725
- {
1726
- if (unlikely(!ptrs->st_pgc_workers)) {
1727
- BUFFER *id = buffer_create(100, NULL);
1728
- buffer_sprintf(id, "dbengine_%s_cache_workers", name);
1729
-
1730
- BUFFER *family = buffer_create(100, NULL);
1731
- buffer_sprintf(family, "dbengine %s cache", name);
1732
-
1733
- BUFFER *title = buffer_create(100, NULL);
1734
- buffer_sprintf(title, "Netdata %s Cache Workers", name);
1735
-
1736
- ptrs->st_pgc_workers = rrdset_create_localhost(
1737
- "netdata",
1738
- buffer_tostring(id),
1739
- NULL,
1740
- buffer_tostring(family),
1741
- NULL,
1742
- buffer_tostring(title),
1743
- "workers",
1744
- "netdata",
1745
- "stats",
1746
- priority,
1747
- localhost->rrd_update_every,
1748
- RRDSET_TYPE_LINE);
1749
-
1750
- ptrs->rd_pgc_workers_searchers = rrddim_add(ptrs->st_pgc_workers, "searchers", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
1751
- ptrs->rd_pgc_workers_adders = rrddim_add(ptrs->st_pgc_workers, "adders", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
1752
- ptrs->rd_pgc_workers_evictors = rrddim_add(ptrs->st_pgc_workers, "evictors", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
1753
- ptrs->rd_pgc_workers_flushers = rrddim_add(ptrs->st_pgc_workers, "flushers", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
1754
- ptrs->rd_pgc_workers_hot2dirty = rrddim_add(ptrs->st_pgc_workers, "hot2dirty", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
1755
- ptrs->rd_pgc_workers_jv2_flushers = rrddim_add(ptrs->st_pgc_workers, "jv2 flushers", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
1756
-
1757
- buffer_free(id);
1758
- buffer_free(family);
1759
- buffer_free(title);
1760
- priority++;
1761
- }
1762
-
1763
- rrddim_set_by_pointer(ptrs->st_pgc_workers, ptrs->rd_pgc_workers_searchers, (collected_number)pgc_stats->workers_search);
1764
- rrddim_set_by_pointer(ptrs->st_pgc_workers, ptrs->rd_pgc_workers_adders, (collected_number)pgc_stats->workers_add);
1765
- rrddim_set_by_pointer(ptrs->st_pgc_workers, ptrs->rd_pgc_workers_evictors, (collected_number)pgc_stats->workers_evict);
1766
- rrddim_set_by_pointer(ptrs->st_pgc_workers, ptrs->rd_pgc_workers_flushers, (collected_number)pgc_stats->workers_flush);
1767
- rrddim_set_by_pointer(ptrs->st_pgc_workers, ptrs->rd_pgc_workers_hot2dirty, (collected_number)pgc_stats->workers_hot2dirty);
1768
- rrddim_set_by_pointer(ptrs->st_pgc_workers, ptrs->rd_pgc_workers_jv2_flushers, (collected_number)pgc_stats->workers_jv2_flush);
1769
-
1770
- rrdset_done(ptrs->st_pgc_workers);
1771
- }
1772
-}
1773
-
1774
-
1775
-static void dbengine2_statistics_charts(void) {
1776
- if(!main_cache || !main_mrg)
1777
- return;
1778
-
1779
- static struct dbengine2_cache_pointers main_cache_ptrs = {}, open_cache_ptrs = {}, extent_cache_ptrs = {};
1780
- static struct rrdeng_cache_efficiency_stats cache_efficiency_stats = {}, cache_efficiency_stats_old = {};
1781
- static struct pgc_statistics pgc_main_stats = {}, pgc_main_stats_old = {}; (void)pgc_main_stats_old;
1782
- static struct pgc_statistics pgc_open_stats = {}, pgc_open_stats_old = {}; (void)pgc_open_stats_old;
1783
- static struct pgc_statistics pgc_extent_stats = {}, pgc_extent_stats_old = {}; (void)pgc_extent_stats_old;
1784
- static struct mrg_statistics mrg_stats = {}, mrg_stats_old = {}; (void)mrg_stats_old;
1785
-
1786
- pgc_main_stats_old = pgc_main_stats;
1787
- pgc_main_stats = pgc_get_statistics(main_cache);
1788
- dbengine2_cache_statistics_charts(&main_cache_ptrs, &pgc_main_stats, &pgc_main_stats_old, "main", 135100);
1789
-
1790
- pgc_open_stats_old = pgc_open_stats;
1791
- pgc_open_stats = pgc_get_statistics(open_cache);
1792
- dbengine2_cache_statistics_charts(&open_cache_ptrs, &pgc_open_stats, &pgc_open_stats_old, "open", 135200);
1793
-
1794
- pgc_extent_stats_old = pgc_extent_stats;
1795
- pgc_extent_stats = pgc_get_statistics(extent_cache);
1796
- dbengine2_cache_statistics_charts(&extent_cache_ptrs, &pgc_extent_stats, &pgc_extent_stats_old, "extent", 135300);
1797
-
1798
- cache_efficiency_stats_old = cache_efficiency_stats;
1799
- cache_efficiency_stats = rrdeng_get_cache_efficiency_stats();
1800
-
1801
- mrg_stats_old = mrg_stats;
1802
- mrg_get_statistics(main_mrg, &mrg_stats);
1803
-
1804
- struct rrdeng_buffer_sizes buffers = rrdeng_get_buffer_sizes();
1805
- size_t buffers_total_size = buffers.handles + buffers.xt_buf + buffers.xt_io + buffers.pdc + buffers.descriptors +
1806
- buffers.opcodes + buffers.wal + buffers.workers + buffers.epdl + buffers.deol + buffers.pd + buffers.pgc + buffers.mrg;
1807
-
1808
-#ifdef PDC_USE_JULYL
1809
- buffers_total_size += buffers.julyl;
1810
-#endif
1811
-
1812
- dbengine_total_memory = pgc_main_stats.size + pgc_open_stats.size + pgc_extent_stats.size + mrg_stats.size + buffers_total_size;
1813
-
1814
- size_t priority = 135000;
1815
-
1816
- {
1817
- static RRDSET *st_pgc_memory = NULL;
1818
- static RRDDIM *rd_pgc_memory_main = NULL;
1819
- static RRDDIM *rd_pgc_memory_open = NULL; // open journal memory
1820
- static RRDDIM *rd_pgc_memory_extent = NULL; // extent compresses cache memory
1821
- static RRDDIM *rd_pgc_memory_metrics = NULL; // metric registry memory
1822
- static RRDDIM *rd_pgc_memory_buffers = NULL;
1823
-
1824
- if (unlikely(!st_pgc_memory)) {
1825
- st_pgc_memory = rrdset_create_localhost(
1826
- "netdata",
1827
- "dbengine_memory",
1828
- NULL,
1829
- "dbengine memory",
1830
- NULL,
1831
- "Netdata DB Memory",
1832
- "bytes",
1833
- "netdata",
1834
- "stats",
1835
- priority,
1836
- localhost->rrd_update_every,
1837
- RRDSET_TYPE_STACKED);
1838
-
1839
- rd_pgc_memory_main = rrddim_add(st_pgc_memory, "main cache", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
1840
- rd_pgc_memory_open = rrddim_add(st_pgc_memory, "open cache", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
1841
- rd_pgc_memory_extent = rrddim_add(st_pgc_memory, "extent cache", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
1842
- rd_pgc_memory_metrics = rrddim_add(st_pgc_memory, "metrics registry", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
1843
- rd_pgc_memory_buffers = rrddim_add(st_pgc_memory, "buffers", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
1844
- }
1845
- priority++;
1846
-
1847
-
1848
- rrddim_set_by_pointer(st_pgc_memory, rd_pgc_memory_main, (collected_number)pgc_main_stats.size);
1849
- rrddim_set_by_pointer(st_pgc_memory, rd_pgc_memory_open, (collected_number)pgc_open_stats.size);
1850
- rrddim_set_by_pointer(st_pgc_memory, rd_pgc_memory_extent, (collected_number)pgc_extent_stats.size);
1851
- rrddim_set_by_pointer(st_pgc_memory, rd_pgc_memory_metrics, (collected_number)mrg_stats.size);
1852
- rrddim_set_by_pointer(st_pgc_memory, rd_pgc_memory_buffers, (collected_number)buffers_total_size);
1853
-
1854
- rrdset_done(st_pgc_memory);
1855
- }
1856
-
1857
- {
1858
- static RRDSET *st_pgc_buffers = NULL;
1859
- static RRDDIM *rd_pgc_buffers_pgc = NULL;
1860
- static RRDDIM *rd_pgc_buffers_mrg = NULL;
1861
- static RRDDIM *rd_pgc_buffers_opcodes = NULL;
1862
- static RRDDIM *rd_pgc_buffers_handles = NULL;
1863
- static RRDDIM *rd_pgc_buffers_descriptors = NULL;
1864
- static RRDDIM *rd_pgc_buffers_wal = NULL;
1865
- static RRDDIM *rd_pgc_buffers_workers = NULL;
1866
- static RRDDIM *rd_pgc_buffers_pdc = NULL;
1867
- static RRDDIM *rd_pgc_buffers_xt_io = NULL;
1868
- static RRDDIM *rd_pgc_buffers_xt_buf = NULL;
1869
- static RRDDIM *rd_pgc_buffers_epdl = NULL;
1870
- static RRDDIM *rd_pgc_buffers_deol = NULL;
1871
- static RRDDIM *rd_pgc_buffers_pd = NULL;
1872
-#ifdef PDC_USE_JULYL
1873
- static RRDDIM *rd_pgc_buffers_julyl = NULL;
1874
-#endif
1875
-
1876
- if (unlikely(!st_pgc_buffers)) {
1877
- st_pgc_buffers = rrdset_create_localhost(
1878
- "netdata",
1879
- "dbengine_buffers",
1880
- NULL,
1881
- "dbengine memory",
1882
- NULL,
1883
- "Netdata DB Buffers",
1884
- "bytes",
1885
- "netdata",
1886
- "stats",
1887
- priority,
1888
- localhost->rrd_update_every,
1889
- RRDSET_TYPE_STACKED);
1890
-
1891
- rd_pgc_buffers_pgc = rrddim_add(st_pgc_buffers, "pgc", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
1892
- rd_pgc_buffers_mrg = rrddim_add(st_pgc_buffers, "mrg", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
1893
- rd_pgc_buffers_opcodes = rrddim_add(st_pgc_buffers, "opcodes", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
1894
- rd_pgc_buffers_handles = rrddim_add(st_pgc_buffers, "query handles", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
1895
- rd_pgc_buffers_descriptors = rrddim_add(st_pgc_buffers, "descriptors", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
1896
- rd_pgc_buffers_wal = rrddim_add(st_pgc_buffers, "wal", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
1897
- rd_pgc_buffers_workers = rrddim_add(st_pgc_buffers, "workers", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
1898
- rd_pgc_buffers_pdc = rrddim_add(st_pgc_buffers, "pdc", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
1899
- rd_pgc_buffers_pd = rrddim_add(st_pgc_buffers, "pd", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
1900
- rd_pgc_buffers_xt_io = rrddim_add(st_pgc_buffers, "extent io", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
1901
- rd_pgc_buffers_xt_buf = rrddim_add(st_pgc_buffers, "extent buffers", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
1902
- rd_pgc_buffers_epdl = rrddim_add(st_pgc_buffers, "epdl", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
1903
- rd_pgc_buffers_deol = rrddim_add(st_pgc_buffers, "deol", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
1904
-#ifdef PDC_USE_JULYL
1905
- rd_pgc_buffers_julyl = rrddim_add(st_pgc_buffers, "julyl", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
1906
-#endif
1907
- }
1908
- priority++;
1909
-
1910
- rrddim_set_by_pointer(st_pgc_buffers, rd_pgc_buffers_pgc, (collected_number)buffers.pgc);
1911
- rrddim_set_by_pointer(st_pgc_buffers, rd_pgc_buffers_mrg, (collected_number)buffers.mrg);
1912
- rrddim_set_by_pointer(st_pgc_buffers, rd_pgc_buffers_opcodes, (collected_number)buffers.opcodes);
1913
- rrddim_set_by_pointer(st_pgc_buffers, rd_pgc_buffers_handles, (collected_number)buffers.handles);
1914
- rrddim_set_by_pointer(st_pgc_buffers, rd_pgc_buffers_descriptors, (collected_number)buffers.descriptors);
1915
- rrddim_set_by_pointer(st_pgc_buffers, rd_pgc_buffers_wal, (collected_number)buffers.wal);
1916
- rrddim_set_by_pointer(st_pgc_buffers, rd_pgc_buffers_workers, (collected_number)buffers.workers);
1917
- rrddim_set_by_pointer(st_pgc_buffers, rd_pgc_buffers_pdc, (collected_number)buffers.pdc);
1918
- rrddim_set_by_pointer(st_pgc_buffers, rd_pgc_buffers_pd, (collected_number)buffers.pd);
1919
- rrddim_set_by_pointer(st_pgc_buffers, rd_pgc_buffers_xt_io, (collected_number)buffers.xt_io);
1920
- rrddim_set_by_pointer(st_pgc_buffers, rd_pgc_buffers_xt_buf, (collected_number)buffers.xt_buf);
1921
- rrddim_set_by_pointer(st_pgc_buffers, rd_pgc_buffers_epdl, (collected_number)buffers.epdl);
1922
- rrddim_set_by_pointer(st_pgc_buffers, rd_pgc_buffers_deol, (collected_number)buffers.deol);
1923
-#ifdef PDC_USE_JULYL
1924
- rrddim_set_by_pointer(st_pgc_buffers, rd_pgc_buffers_julyl, (collected_number)buffers.julyl);
1925
-#endif
1926
-
1927
- rrdset_done(st_pgc_buffers);
1928
- }
1929
-
1930
-#ifdef PDC_USE_JULYL
1931
- {
1932
- static RRDSET *st_julyl_moved = NULL;
1933
- static RRDDIM *rd_julyl_moved = NULL;
1934
-
1935
- if (unlikely(!st_julyl_moved)) {
1936
- st_julyl_moved = rrdset_create_localhost(
1937
- "netdata",
1938
- "dbengine_julyl_moved",
1939
- NULL,
1940
- "dbengine memory",
1941
- NULL,
1942
- "Netdata JulyL Memory Moved",
1943
- "bytes/s",
1944
- "netdata",
1945
- "stats",
1946
- priority,
1947
- localhost->rrd_update_every,
1948
- RRDSET_TYPE_AREA);
1949
-
1950
- rd_julyl_moved = rrddim_add(st_julyl_moved, "moved", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
1951
- }
1952
- priority++;
1953
-
1954
- rrddim_set_by_pointer(st_julyl_moved, rd_julyl_moved, (collected_number)julyl_bytes_moved());
1955
-
1956
- rrdset_done(st_julyl_moved);
1957
- }
1958
-#endif
1959
-
1960
- {
1961
- static RRDSET *st_mrg_metrics = NULL;
1962
- static RRDDIM *rd_mrg_metrics = NULL;
1963
- static RRDDIM *rd_mrg_acquired = NULL;
1964
- static RRDDIM *rd_mrg_collected = NULL;
1965
- static RRDDIM *rd_mrg_multiple_writers = NULL;
1966
-
1967
- if (unlikely(!st_mrg_metrics)) {
1968
- st_mrg_metrics = rrdset_create_localhost(
1969
- "netdata",
1970
- "dbengine_metrics",
1971
- NULL,
1972
- "dbengine metrics",
1973
- NULL,
1974
- "Netdata Metrics in Metrics Registry",
1975
- "metrics",
1976
- "netdata",
1977
- "stats",
1978
- priority,
1979
- localhost->rrd_update_every,
1980
- RRDSET_TYPE_LINE);
1981
-
1982
- rd_mrg_metrics = rrddim_add(st_mrg_metrics, "all", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
1983
- rd_mrg_acquired = rrddim_add(st_mrg_metrics, "acquired", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
1984
- rd_mrg_collected = rrddim_add(st_mrg_metrics, "collected", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
1985
- rd_mrg_multiple_writers = rrddim_add(st_mrg_metrics, "multi-collected", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
1986
- }
1987
- priority++;
1988
-
1989
- rrddim_set_by_pointer(st_mrg_metrics, rd_mrg_metrics, (collected_number)mrg_stats.entries);
1990
- rrddim_set_by_pointer(st_mrg_metrics, rd_mrg_acquired, (collected_number)mrg_stats.entries_referenced);
1991
- rrddim_set_by_pointer(st_mrg_metrics, rd_mrg_collected, (collected_number)mrg_stats.writers);
1992
- rrddim_set_by_pointer(st_mrg_metrics, rd_mrg_multiple_writers, (collected_number)mrg_stats.writers_conflicts);
1993
-
1994
- rrdset_done(st_mrg_metrics);
1995
- }
1996
-
1997
- {
1998
- static RRDSET *st_mrg_ops = NULL;
1999
- static RRDDIM *rd_mrg_add = NULL;
2000
- static RRDDIM *rd_mrg_del = NULL;
2001
- static RRDDIM *rd_mrg_search = NULL;
2002
-
2003
- if (unlikely(!st_mrg_ops)) {
2004
- st_mrg_ops = rrdset_create_localhost(
2005
- "netdata",
2006
- "dbengine_metrics_registry_operations",
2007
- NULL,
2008
- "dbengine metrics",
2009
- NULL,
2010
- "Netdata Metrics Registry Operations",
2011
- "metrics",
2012
- "netdata",
2013
- "stats",
2014
- priority,
2015
- localhost->rrd_update_every,
2016
- RRDSET_TYPE_LINE);
2017
-
2018
- rd_mrg_add = rrddim_add(st_mrg_ops, "add", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2019
- rd_mrg_del = rrddim_add(st_mrg_ops, "delete", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2020
- rd_mrg_search = rrddim_add(st_mrg_ops, "search", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2021
- }
2022
- priority++;
2023
-
2024
- rrddim_set_by_pointer(st_mrg_ops, rd_mrg_add, (collected_number)mrg_stats.additions);
2025
- rrddim_set_by_pointer(st_mrg_ops, rd_mrg_del, (collected_number)mrg_stats.deletions);
2026
- rrddim_set_by_pointer(st_mrg_ops, rd_mrg_search, (collected_number)mrg_stats.search_hits + (collected_number)mrg_stats.search_misses);
2027
-
2028
- rrdset_done(st_mrg_ops);
2029
- }
2030
-
2031
- {
2032
- static RRDSET *st_mrg_references = NULL;
2033
- static RRDDIM *rd_mrg_references = NULL;
2034
-
2035
- if (unlikely(!st_mrg_references)) {
2036
- st_mrg_references = rrdset_create_localhost(
2037
- "netdata",
2038
- "dbengine_metrics_registry_references",
2039
- NULL,
2040
- "dbengine metrics",
2041
- NULL,
2042
- "Netdata Metrics Registry References",
2043
- "references",
2044
- "netdata",
2045
- "stats",
2046
- priority,
2047
- localhost->rrd_update_every,
2048
- RRDSET_TYPE_LINE);
2049
-
2050
- rd_mrg_references = rrddim_add(st_mrg_references, "references", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
2051
- }
2052
- priority++;
2053
-
2054
- rrddim_set_by_pointer(st_mrg_references, rd_mrg_references, (collected_number)mrg_stats.current_references);
2055
-
2056
- rrdset_done(st_mrg_references);
2057
- }
2058
-
2059
- {
2060
- static RRDSET *st_cache_hit_ratio = NULL;
2061
- static RRDDIM *rd_hit_ratio = NULL;
2062
- static RRDDIM *rd_main_cache_hit_ratio = NULL;
2063
- static RRDDIM *rd_extent_cache_hit_ratio = NULL;
2064
- static RRDDIM *rd_extent_merge_hit_ratio = NULL;
2065
-
2066
- if (unlikely(!st_cache_hit_ratio)) {
2067
- st_cache_hit_ratio = rrdset_create_localhost(
2068
- "netdata",
2069
- "dbengine_cache_hit_ratio",
2070
- NULL,
2071
- "dbengine query router",
2072
- NULL,
2073
- "Netdata Queries Cache Hit Ratio",
2074
- "%",
2075
- "netdata",
2076
- "stats",
2077
- priority,
2078
- localhost->rrd_update_every,
2079
- RRDSET_TYPE_LINE);
2080
-
2081
- rd_hit_ratio = rrddim_add(st_cache_hit_ratio, "overall", NULL, 1, 10000, RRD_ALGORITHM_ABSOLUTE);
2082
- rd_main_cache_hit_ratio = rrddim_add(st_cache_hit_ratio, "main cache", NULL, 1, 10000, RRD_ALGORITHM_ABSOLUTE);
2083
- rd_extent_cache_hit_ratio = rrddim_add(st_cache_hit_ratio, "extent cache", NULL, 1, 10000, RRD_ALGORITHM_ABSOLUTE);
2084
- rd_extent_merge_hit_ratio = rrddim_add(st_cache_hit_ratio, "extent merge", NULL, 1, 10000, RRD_ALGORITHM_ABSOLUTE);
2085
- }
2086
- priority++;
2087
-
2088
- size_t delta_pages_total = cache_efficiency_stats.pages_total - cache_efficiency_stats_old.pages_total;
2089
- size_t delta_pages_to_load_from_disk = cache_efficiency_stats.pages_to_load_from_disk - cache_efficiency_stats_old.pages_to_load_from_disk;
2090
- size_t delta_extents_loaded_from_disk = cache_efficiency_stats.extents_loaded_from_disk - cache_efficiency_stats_old.extents_loaded_from_disk;
2091
-
2092
- size_t delta_pages_data_source_main_cache = cache_efficiency_stats.pages_data_source_main_cache - cache_efficiency_stats_old.pages_data_source_main_cache;
2093
- size_t delta_pages_pending_found_in_cache_at_pass4 = cache_efficiency_stats.pages_data_source_main_cache_at_pass4 - cache_efficiency_stats_old.pages_data_source_main_cache_at_pass4;
2094
-
2095
- size_t delta_pages_data_source_extent_cache = cache_efficiency_stats.pages_data_source_extent_cache - cache_efficiency_stats_old.pages_data_source_extent_cache;
2096
- size_t delta_pages_load_extent_merged = cache_efficiency_stats.pages_load_extent_merged - cache_efficiency_stats_old.pages_load_extent_merged;
2097
-
2098
- size_t pages_total_hit = delta_pages_total - delta_extents_loaded_from_disk;
2099
-
2100
- static size_t overall_hit_ratio = 100;
2101
- size_t main_cache_hit_ratio = 0, extent_cache_hit_ratio = 0, extent_merge_hit_ratio = 0;
2102
- if(delta_pages_total) {
2103
- if(pages_total_hit > delta_pages_total)
2104
- pages_total_hit = delta_pages_total;
2105
-
2106
- overall_hit_ratio = pages_total_hit * 100 * 10000 / delta_pages_total;
2107
-
2108
- size_t delta_pages_main_cache = delta_pages_data_source_main_cache + delta_pages_pending_found_in_cache_at_pass4;
2109
- if(delta_pages_main_cache > delta_pages_total)
2110
- delta_pages_main_cache = delta_pages_total;
2111
-
2112
- main_cache_hit_ratio = delta_pages_main_cache * 100 * 10000 / delta_pages_total;
2113
- }
2114
-
2115
- if(delta_pages_to_load_from_disk) {
2116
- if(delta_pages_data_source_extent_cache > delta_pages_to_load_from_disk)
2117
- delta_pages_data_source_extent_cache = delta_pages_to_load_from_disk;
2118
-
2119
- extent_cache_hit_ratio = delta_pages_data_source_extent_cache * 100 * 10000 / delta_pages_to_load_from_disk;
2120
-
2121
- if(delta_pages_load_extent_merged > delta_pages_to_load_from_disk)
2122
- delta_pages_load_extent_merged = delta_pages_to_load_from_disk;
2123
-
2124
- extent_merge_hit_ratio = delta_pages_load_extent_merged * 100 * 10000 / delta_pages_to_load_from_disk;
2125
- }
2126
-
2127
- rrddim_set_by_pointer(st_cache_hit_ratio, rd_hit_ratio, (collected_number)overall_hit_ratio);
2128
- rrddim_set_by_pointer(st_cache_hit_ratio, rd_main_cache_hit_ratio, (collected_number)main_cache_hit_ratio);
2129
- rrddim_set_by_pointer(st_cache_hit_ratio, rd_extent_cache_hit_ratio, (collected_number)extent_cache_hit_ratio);
2130
- rrddim_set_by_pointer(st_cache_hit_ratio, rd_extent_merge_hit_ratio, (collected_number)extent_merge_hit_ratio);
2131
-
2132
- rrdset_done(st_cache_hit_ratio);
2133
- }
2134
-
2135
- {
2136
- static RRDSET *st_queries = NULL;
2137
- static RRDDIM *rd_total = NULL;
2138
- static RRDDIM *rd_open = NULL;
2139
- static RRDDIM *rd_jv2 = NULL;
2140
- static RRDDIM *rd_planned_with_gaps = NULL;
2141
- static RRDDIM *rd_executed_with_gaps = NULL;
2142
-
2143
- if (unlikely(!st_queries)) {
2144
- st_queries = rrdset_create_localhost(
2145
- "netdata",
2146
- "dbengine_queries",
2147
- NULL,
2148
- "dbengine query router",
2149
- NULL,
2150
- "Netdata Queries",
2151
- "queries/s",
2152
- "netdata",
2153
- "stats",
2154
- priority,
2155
- localhost->rrd_update_every,
2156
- RRDSET_TYPE_LINE);
2157
-
2158
- rd_total = rrddim_add(st_queries, "total", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2159
- rd_open = rrddim_add(st_queries, "open cache", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2160
- rd_jv2 = rrddim_add(st_queries, "journal v2", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2161
- rd_planned_with_gaps = rrddim_add(st_queries, "planned with gaps", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2162
- rd_executed_with_gaps = rrddim_add(st_queries, "executed with gaps", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2163
- }
2164
- priority++;
2165
-
2166
- rrddim_set_by_pointer(st_queries, rd_total, (collected_number)cache_efficiency_stats.queries);
2167
- rrddim_set_by_pointer(st_queries, rd_open, (collected_number)cache_efficiency_stats.queries_open);
2168
- rrddim_set_by_pointer(st_queries, rd_jv2, (collected_number)cache_efficiency_stats.queries_journal_v2);
2169
- rrddim_set_by_pointer(st_queries, rd_planned_with_gaps, (collected_number)cache_efficiency_stats.queries_planned_with_gaps);
2170
- rrddim_set_by_pointer(st_queries, rd_executed_with_gaps, (collected_number)cache_efficiency_stats.queries_executed_with_gaps);
2171
-
2172
- rrdset_done(st_queries);
2173
- }
2174
-
2175
- {
2176
- static RRDSET *st_queries_running = NULL;
2177
- static RRDDIM *rd_queries = NULL;
2178
-
2179
- if (unlikely(!st_queries_running)) {
2180
- st_queries_running = rrdset_create_localhost(
2181
- "netdata",
2182
- "dbengine_queries_running",
2183
- NULL,
2184
- "dbengine query router",
2185
- NULL,
2186
- "Netdata Queries Running",
2187
- "queries",
2188
- "netdata",
2189
- "stats",
2190
- priority,
2191
- localhost->rrd_update_every,
2192
- RRDSET_TYPE_LINE);
2193
-
2194
- rd_queries = rrddim_add(st_queries_running, "queries", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
2195
- }
2196
- priority++;
2197
-
2198
- rrddim_set_by_pointer(st_queries_running, rd_queries, (collected_number)cache_efficiency_stats.currently_running_queries);
2199
-
2200
- rrdset_done(st_queries_running);
2201
- }
2202
-
2203
- {
2204
- static RRDSET *st_query_pages_metadata_source = NULL;
2205
- static RRDDIM *rd_cache = NULL;
2206
- static RRDDIM *rd_open = NULL;
2207
- static RRDDIM *rd_jv2 = NULL;
2208
-
2209
- if (unlikely(!st_query_pages_metadata_source)) {
2210
- st_query_pages_metadata_source = rrdset_create_localhost(
2211
- "netdata",
2212
- "dbengine_query_pages_metadata_source",
2213
- NULL,
2214
- "dbengine query router",
2215
- NULL,
2216
- "Netdata Query Pages Metadata Source",
2217
- "pages/s",
2218
- "netdata",
2219
- "stats",
2220
- priority,
2221
- localhost->rrd_update_every,
2222
- RRDSET_TYPE_STACKED);
2223
-
2224
- rd_cache = rrddim_add(st_query_pages_metadata_source, "cache hit", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2225
- rd_jv2 = rrddim_add(st_query_pages_metadata_source, "journal v2 scan", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2226
- rd_open = rrddim_add(st_query_pages_metadata_source, "open journal", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2227
- }
2228
- priority++;
2229
-
2230
- rrddim_set_by_pointer(st_query_pages_metadata_source, rd_cache, (collected_number)cache_efficiency_stats.pages_meta_source_main_cache);
2231
- rrddim_set_by_pointer(st_query_pages_metadata_source, rd_jv2, (collected_number)cache_efficiency_stats.pages_meta_source_journal_v2);
2232
- rrddim_set_by_pointer(st_query_pages_metadata_source, rd_open, (collected_number)cache_efficiency_stats.pages_meta_source_open_cache);
2233
-
2234
- rrdset_done(st_query_pages_metadata_source);
2235
- }
2236
-
2237
- {
2238
- static RRDSET *st_query_pages_data_source = NULL;
2239
- static RRDDIM *rd_pages_main_cache = NULL;
2240
- static RRDDIM *rd_pages_disk = NULL;
2241
- static RRDDIM *rd_pages_extent_cache = NULL;
2242
-
2243
- if (unlikely(!st_query_pages_data_source)) {
2244
- st_query_pages_data_source = rrdset_create_localhost(
2245
- "netdata",
2246
- "dbengine_query_pages_data_source",
2247
- NULL,
2248
- "dbengine query router",
2249
- NULL,
2250
- "Netdata Query Pages to Data Source",
2251
- "pages/s",
2252
- "netdata",
2253
- "stats",
2254
- priority,
2255
- localhost->rrd_update_every,
2256
- RRDSET_TYPE_STACKED);
2257
-
2258
- rd_pages_main_cache = rrddim_add(st_query_pages_data_source, "main cache", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2259
- rd_pages_disk = rrddim_add(st_query_pages_data_source, "disk", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2260
- rd_pages_extent_cache = rrddim_add(st_query_pages_data_source, "extent cache", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2261
- }
2262
- priority++;
2263
-
2264
- rrddim_set_by_pointer(st_query_pages_data_source, rd_pages_main_cache, (collected_number)cache_efficiency_stats.pages_data_source_main_cache + (collected_number)cache_efficiency_stats.pages_data_source_main_cache_at_pass4);
2265
- rrddim_set_by_pointer(st_query_pages_data_source, rd_pages_disk, (collected_number)cache_efficiency_stats.pages_to_load_from_disk);
2266
- rrddim_set_by_pointer(st_query_pages_data_source, rd_pages_extent_cache, (collected_number)cache_efficiency_stats.pages_data_source_extent_cache);
2267
-
2268
- rrdset_done(st_query_pages_data_source);
2269
- }
2270
-
2271
- {
2272
- static RRDSET *st_query_next_page = NULL;
2273
- static RRDDIM *rd_pass4 = NULL;
2274
- static RRDDIM *rd_nowait_failed = NULL;
2275
- static RRDDIM *rd_wait_failed = NULL;
2276
- static RRDDIM *rd_wait_loaded = NULL;
2277
- static RRDDIM *rd_nowait_loaded = NULL;
2278
-
2279
- if (unlikely(!st_query_next_page)) {
2280
- st_query_next_page = rrdset_create_localhost(
2281
- "netdata",
2282
- "dbengine_query_next_page",
2283
- NULL,
2284
- "dbengine query router",
2285
- NULL,
2286
- "Netdata Query Next Page",
2287
- "pages/s",
2288
- "netdata",
2289
- "stats",
2290
- priority,
2291
- localhost->rrd_update_every,
2292
- RRDSET_TYPE_STACKED);
2293
-
2294
- rd_pass4 = rrddim_add(st_query_next_page, "pass4", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2295
- rd_wait_failed = rrddim_add(st_query_next_page, "failed slow", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2296
- rd_nowait_failed = rrddim_add(st_query_next_page, "failed fast", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2297
- rd_wait_loaded = rrddim_add(st_query_next_page, "loaded slow", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2298
- rd_nowait_loaded = rrddim_add(st_query_next_page, "loaded fast", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2299
- }
2300
- priority++;
2301
-
2302
- rrddim_set_by_pointer(st_query_next_page, rd_pass4, (collected_number)cache_efficiency_stats.pages_data_source_main_cache_at_pass4);
2303
- rrddim_set_by_pointer(st_query_next_page, rd_wait_failed, (collected_number)cache_efficiency_stats.page_next_wait_failed);
2304
- rrddim_set_by_pointer(st_query_next_page, rd_nowait_failed, (collected_number)cache_efficiency_stats.page_next_nowait_failed);
2305
- rrddim_set_by_pointer(st_query_next_page, rd_wait_loaded, (collected_number)cache_efficiency_stats.page_next_wait_loaded);
2306
- rrddim_set_by_pointer(st_query_next_page, rd_nowait_loaded, (collected_number)cache_efficiency_stats.page_next_nowait_loaded);
2307
-
2308
- rrdset_done(st_query_next_page);
2309
- }
2310
-
2311
- {
2312
- static RRDSET *st_query_page_issues = NULL;
2313
- static RRDDIM *rd_pages_zero_time = NULL;
2314
- static RRDDIM *rd_pages_past_time = NULL;
2315
- static RRDDIM *rd_pages_invalid_size = NULL;
2316
- static RRDDIM *rd_pages_fixed_update_every = NULL;
2317
- static RRDDIM *rd_pages_fixed_entries = NULL;
2318
- static RRDDIM *rd_pages_overlapping = NULL;
2319
-
2320
- if (unlikely(!st_query_page_issues)) {
2321
- st_query_page_issues = rrdset_create_localhost(
2322
- "netdata",
2323
- "dbengine_query_next_page_issues",
2324
- NULL,
2325
- "dbengine query router",
2326
- NULL,
2327
- "Netdata Query Next Page Issues",
2328
- "pages/s",
2329
- "netdata",
2330
- "stats",
2331
- priority,
2332
- localhost->rrd_update_every,
2333
- RRDSET_TYPE_STACKED);
2334
-
2335
- rd_pages_zero_time = rrddim_add(st_query_page_issues, "zero timestamp", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2336
- rd_pages_invalid_size = rrddim_add(st_query_page_issues, "invalid size", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2337
- rd_pages_past_time = rrddim_add(st_query_page_issues, "past time", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2338
- rd_pages_overlapping = rrddim_add(st_query_page_issues, "overlapping", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2339
- rd_pages_fixed_update_every = rrddim_add(st_query_page_issues, "update every fixed", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2340
- rd_pages_fixed_entries = rrddim_add(st_query_page_issues, "entries fixed", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2341
- }
2342
- priority++;
2343
-
2344
- rrddim_set_by_pointer(st_query_page_issues, rd_pages_zero_time, (collected_number)cache_efficiency_stats.pages_zero_time_skipped);
2345
- rrddim_set_by_pointer(st_query_page_issues, rd_pages_invalid_size, (collected_number)cache_efficiency_stats.pages_invalid_size_skipped);
2346
- rrddim_set_by_pointer(st_query_page_issues, rd_pages_past_time, (collected_number)cache_efficiency_stats.pages_past_time_skipped);
2347
- rrddim_set_by_pointer(st_query_page_issues, rd_pages_overlapping, (collected_number)cache_efficiency_stats.pages_overlapping_skipped);
2348
- rrddim_set_by_pointer(st_query_page_issues, rd_pages_fixed_update_every, (collected_number)cache_efficiency_stats.pages_invalid_update_every_fixed);
2349
- rrddim_set_by_pointer(st_query_page_issues, rd_pages_fixed_entries, (collected_number)cache_efficiency_stats.pages_invalid_entries_fixed);
2350
-
2351
- rrdset_done(st_query_page_issues);
2352
- }
2353
-
2354
- {
2355
- static RRDSET *st_query_pages_from_disk = NULL;
2356
- static RRDDIM *rd_compressed = NULL;
2357
- static RRDDIM *rd_invalid = NULL;
2358
- static RRDDIM *rd_uncompressed = NULL;
2359
- static RRDDIM *rd_mmap_failed = NULL;
2360
- static RRDDIM *rd_unavailable = NULL;
2361
- static RRDDIM *rd_unroutable = NULL;
2362
- static RRDDIM *rd_not_found = NULL;
2363
- static RRDDIM *rd_cancelled = NULL;
2364
- static RRDDIM *rd_invalid_extent = NULL;
2365
- static RRDDIM *rd_extent_merged = NULL;
2366
-
2367
- if (unlikely(!st_query_pages_from_disk)) {
2368
- st_query_pages_from_disk = rrdset_create_localhost(
2369
- "netdata",
2370
- "dbengine_query_pages_disk_load",
2371
- NULL,
2372
- "dbengine query router",
2373
- NULL,
2374
- "Netdata Query Pages Loaded from Disk",
2375
- "pages/s",
2376
- "netdata",
2377
- "stats",
2378
- priority,
2379
- localhost->rrd_update_every,
2380
- RRDSET_TYPE_LINE);
2381
-
2382
- rd_compressed = rrddim_add(st_query_pages_from_disk, "ok compressed", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2383
- rd_invalid = rrddim_add(st_query_pages_from_disk, "fail invalid page", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL);
2384
- rd_uncompressed = rrddim_add(st_query_pages_from_disk, "ok uncompressed", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2385
- rd_mmap_failed = rrddim_add(st_query_pages_from_disk, "fail cant mmap", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL);
2386
- rd_unavailable = rrddim_add(st_query_pages_from_disk, "fail unavailable", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL);
2387
- rd_unroutable = rrddim_add(st_query_pages_from_disk, "fail unroutable", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL);
2388
- rd_not_found = rrddim_add(st_query_pages_from_disk, "fail not found", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL);
2389
- rd_invalid_extent = rrddim_add(st_query_pages_from_disk, "fail invalid extent", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL);
2390
- rd_extent_merged = rrddim_add(st_query_pages_from_disk, "extent merged", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2391
- rd_cancelled = rrddim_add(st_query_pages_from_disk, "cancelled", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL);
2392
- }
2393
- priority++;
2394
-
2395
- rrddim_set_by_pointer(st_query_pages_from_disk, rd_compressed, (collected_number)cache_efficiency_stats.pages_load_ok_compressed);
2396
- rrddim_set_by_pointer(st_query_pages_from_disk, rd_invalid, (collected_number)cache_efficiency_stats.pages_load_fail_invalid_page_in_extent);
2397
- rrddim_set_by_pointer(st_query_pages_from_disk, rd_uncompressed, (collected_number)cache_efficiency_stats.pages_load_ok_uncompressed);
2398
- rrddim_set_by_pointer(st_query_pages_from_disk, rd_mmap_failed, (collected_number)cache_efficiency_stats.pages_load_fail_cant_mmap_extent);
2399
- rrddim_set_by_pointer(st_query_pages_from_disk, rd_unavailable, (collected_number)cache_efficiency_stats.pages_load_fail_datafile_not_available);
2400
- rrddim_set_by_pointer(st_query_pages_from_disk, rd_unroutable, (collected_number)cache_efficiency_stats.pages_load_fail_unroutable);
2401
- rrddim_set_by_pointer(st_query_pages_from_disk, rd_not_found, (collected_number)cache_efficiency_stats.pages_load_fail_not_found);
2402
- rrddim_set_by_pointer(st_query_pages_from_disk, rd_cancelled, (collected_number)cache_efficiency_stats.pages_load_fail_cancelled);
2403
- rrddim_set_by_pointer(st_query_pages_from_disk, rd_invalid_extent, (collected_number)cache_efficiency_stats.pages_load_fail_invalid_extent);
2404
- rrddim_set_by_pointer(st_query_pages_from_disk, rd_extent_merged, (collected_number)cache_efficiency_stats.pages_load_extent_merged);
2405
-
2406
- rrdset_done(st_query_pages_from_disk);
2407
- }
2408
-
2409
- {
2410
- static RRDSET *st_events = NULL;
2411
- static RRDDIM *rd_journal_v2_mapped = NULL;
2412
- static RRDDIM *rd_journal_v2_unmapped = NULL;
2413
- static RRDDIM *rd_datafile_creation = NULL;
2414
- static RRDDIM *rd_datafile_deletion = NULL;
2415
- static RRDDIM *rd_datafile_deletion_spin = NULL;
2416
- static RRDDIM *rd_jv2_indexing = NULL;
2417
- static RRDDIM *rd_retention = NULL;
2418
-
2419
- if (unlikely(!st_events)) {
2420
- st_events = rrdset_create_localhost(
2421
- "netdata",
2422
- "dbengine_events",
2423
- NULL,
2424
- "dbengine query router",
2425
- NULL,
2426
- "Netdata Database Events",
2427
- "events/s",
2428
- "netdata",
2429
- "stats",
2430
- priority,
2431
- localhost->rrd_update_every,
2432
- RRDSET_TYPE_LINE);
2433
-
2434
- rd_journal_v2_mapped = rrddim_add(st_events, "journal v2 mapped", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2435
- rd_journal_v2_unmapped = rrddim_add(st_events, "journal v2 unmapped", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2436
- rd_datafile_creation = rrddim_add(st_events, "datafile creation", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2437
- rd_datafile_deletion = rrddim_add(st_events, "datafile deletion", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2438
- rd_datafile_deletion_spin = rrddim_add(st_events, "datafile deletion spin", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2439
- rd_jv2_indexing = rrddim_add(st_events, "journal v2 indexing", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2440
- rd_retention = rrddim_add(st_events, "retention", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2441
- }
2442
- priority++;
2443
-
2444
- rrddim_set_by_pointer(st_events, rd_journal_v2_mapped, (collected_number)cache_efficiency_stats.journal_v2_mapped);
2445
- rrddim_set_by_pointer(st_events, rd_journal_v2_unmapped, (collected_number)cache_efficiency_stats.journal_v2_unmapped);
2446
- rrddim_set_by_pointer(st_events, rd_datafile_creation, (collected_number)cache_efficiency_stats.datafile_creation_started);
2447
- rrddim_set_by_pointer(st_events, rd_datafile_deletion, (collected_number)cache_efficiency_stats.datafile_deletion_started);
2448
- rrddim_set_by_pointer(st_events, rd_datafile_deletion_spin, (collected_number)cache_efficiency_stats.datafile_deletion_spin);
2449
- rrddim_set_by_pointer(st_events, rd_jv2_indexing, (collected_number)cache_efficiency_stats.journal_v2_indexing_started);
2450
- rrddim_set_by_pointer(st_events, rd_retention, (collected_number)cache_efficiency_stats.metrics_retention_started);
2451
-
2452
- rrdset_done(st_events);
2453
- }
2454
-
2455
- {
2456
- static RRDSET *st_prep_timings = NULL;
2457
- static RRDDIM *rd_routing = NULL;
2458
- static RRDDIM *rd_main_cache = NULL;
2459
- static RRDDIM *rd_open_cache = NULL;
2460
- static RRDDIM *rd_journal_v2 = NULL;
2461
- static RRDDIM *rd_pass4 = NULL;
2462
-
2463
- if (unlikely(!st_prep_timings)) {
2464
- st_prep_timings = rrdset_create_localhost(
2465
- "netdata",
2466
- "dbengine_prep_timings",
2467
- NULL,
2468
- "dbengine query router",
2469
- NULL,
2470
- "Netdata Query Preparation Timings",
2471
- "usec/s",
2472
- "netdata",
2473
- "stats",
2474
- priority,
2475
- localhost->rrd_update_every,
2476
- RRDSET_TYPE_STACKED);
2477
-
2478
- rd_routing = rrddim_add(st_prep_timings, "routing", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2479
- rd_main_cache = rrddim_add(st_prep_timings, "main cache", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2480
- rd_open_cache = rrddim_add(st_prep_timings, "open cache", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2481
- rd_journal_v2 = rrddim_add(st_prep_timings, "journal v2", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2482
- rd_pass4 = rrddim_add(st_prep_timings, "pass4", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2483
- }
2484
- priority++;
2485
-
2486
- rrddim_set_by_pointer(st_prep_timings, rd_routing, (collected_number)cache_efficiency_stats.prep_time_to_route);
2487
- rrddim_set_by_pointer(st_prep_timings, rd_main_cache, (collected_number)cache_efficiency_stats.prep_time_in_main_cache_lookup);
2488
- rrddim_set_by_pointer(st_prep_timings, rd_open_cache, (collected_number)cache_efficiency_stats.prep_time_in_open_cache_lookup);
2489
- rrddim_set_by_pointer(st_prep_timings, rd_journal_v2, (collected_number)cache_efficiency_stats.prep_time_in_journal_v2_lookup);
2490
- rrddim_set_by_pointer(st_prep_timings, rd_pass4, (collected_number)cache_efficiency_stats.prep_time_in_pass4_lookup);
2491
-
2492
- rrdset_done(st_prep_timings);
2493
- }
2494
-
2495
- {
2496
- static RRDSET *st_query_timings = NULL;
2497
- static RRDDIM *rd_init = NULL;
2498
- static RRDDIM *rd_prep_wait = NULL;
2499
- static RRDDIM *rd_next_page_disk_fast = NULL;
2500
- static RRDDIM *rd_next_page_disk_slow = NULL;
2501
- static RRDDIM *rd_next_page_preload_fast = NULL;
2502
- static RRDDIM *rd_next_page_preload_slow = NULL;
2503
-
2504
- if (unlikely(!st_query_timings)) {
2505
- st_query_timings = rrdset_create_localhost(
2506
- "netdata",
2507
- "dbengine_query_timings",
2508
- NULL,
2509
- "dbengine query router",
2510
- NULL,
2511
- "Netdata Query Timings",
2512
- "usec/s",
2513
- "netdata",
2514
- "stats",
2515
- priority,
2516
- localhost->rrd_update_every,
2517
- RRDSET_TYPE_STACKED);
2518
-
2519
- rd_init = rrddim_add(st_query_timings, "init", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2520
- rd_prep_wait = rrddim_add(st_query_timings, "prep wait", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2521
- rd_next_page_disk_fast = rrddim_add(st_query_timings, "next page disk fast", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2522
- rd_next_page_disk_slow = rrddim_add(st_query_timings, "next page disk slow", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2523
- rd_next_page_preload_fast = rrddim_add(st_query_timings, "next page preload fast", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2524
- rd_next_page_preload_slow = rrddim_add(st_query_timings, "next page preload slow", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2525
- }
2526
- priority++;
2527
-
2528
- rrddim_set_by_pointer(st_query_timings, rd_init, (collected_number)cache_efficiency_stats.query_time_init);
2529
- rrddim_set_by_pointer(st_query_timings, rd_prep_wait, (collected_number)cache_efficiency_stats.query_time_wait_for_prep);
2530
- rrddim_set_by_pointer(st_query_timings, rd_next_page_disk_fast, (collected_number)cache_efficiency_stats.query_time_to_fast_disk_next_page);
2531
- rrddim_set_by_pointer(st_query_timings, rd_next_page_disk_slow, (collected_number)cache_efficiency_stats.query_time_to_slow_disk_next_page);
2532
- rrddim_set_by_pointer(st_query_timings, rd_next_page_preload_fast, (collected_number)cache_efficiency_stats.query_time_to_fast_preload_next_page);
2533
- rrddim_set_by_pointer(st_query_timings, rd_next_page_preload_slow, (collected_number)cache_efficiency_stats.query_time_to_slow_preload_next_page);
2534
-
2535
- rrdset_done(st_query_timings);
2536
- }
2537
-
2538
- if(netdata_rwlock_tryrdlock(&rrd_rwlock) == 0) {
2539
- priority = 135400;
2540
-
2541
- RRDHOST *host;
2542
- unsigned long long stats_array[RRDENG_NR_STATS] = {0};
2543
- unsigned long long local_stats_array[RRDENG_NR_STATS];
2544
- unsigned dbengine_contexts = 0, counted_multihost_db[RRD_STORAGE_TIERS] = { 0 }, i;
2545
-
2546
- rrdhost_foreach_read(host) {
2547
- if (!rrdhost_flag_check(host, RRDHOST_FLAG_ARCHIVED)) {
2548
-
2549
- /* get localhost's DB engine's statistics for each tier */
2550
- for(size_t tier = 0; tier < storage_tiers ;tier++) {
2551
- if(host->db[tier].mode != RRD_MEMORY_MODE_DBENGINE) continue;
2552
- if(!host->db[tier].si) continue;
2553
-
2554
- if(counted_multihost_db[tier])
2555
- continue;
2556
- else
2557
- counted_multihost_db[tier] = 1;
2558
-
2559
- ++dbengine_contexts;
2560
- rrdeng_get_37_statistics((struct rrdengine_instance *)host->db[tier].si, local_stats_array);
2561
- for (i = 0; i < RRDENG_NR_STATS; ++i) {
2562
- /* aggregate statistics across hosts */
2563
- stats_array[i] += local_stats_array[i];
2564
- }
2565
- }
2566
- }
2567
- }
2568
- rrd_rdunlock();
2569
-
2570
- if (dbengine_contexts) {
2571
- /* deduplicate global statistics by getting the ones from the last context */
2572
- stats_array[30] = local_stats_array[30];
2573
- stats_array[31] = local_stats_array[31];
2574
- stats_array[32] = local_stats_array[32];
2575
- stats_array[34] = local_stats_array[34];
2576
- stats_array[36] = local_stats_array[36];
2577
-
2578
- // ----------------------------------------------------------------
2579
-
2580
- {
2581
- static RRDSET *st_compression = NULL;
2582
- static RRDDIM *rd_savings = NULL;
2583
-
2584
- if (unlikely(!st_compression)) {
2585
- st_compression = rrdset_create_localhost(
2586
- "netdata",
2587
- "dbengine_compression_ratio",
2588
- NULL,
2589
- "dbengine io",
2590
- NULL,
2591
- "Netdata DB engine data extents' compression savings ratio",
2592
- "percentage",
2593
- "netdata",
2594
- "stats",
2595
- priority,
2596
- localhost->rrd_update_every,
2597
- RRDSET_TYPE_LINE);
2598
-
2599
- rd_savings = rrddim_add(st_compression, "savings", NULL, 1, 1000, RRD_ALGORITHM_ABSOLUTE);
2600
- }
2601
- priority++;
2602
-
2603
- unsigned long long ratio;
2604
- unsigned long long compressed_content_size = stats_array[12];
2605
- unsigned long long content_size = stats_array[11];
2606
-
2607
- if (content_size) {
2608
- // allow negative savings
2609
- ratio = ((content_size - compressed_content_size) * 100 * 1000) / content_size;
2610
- } else {
2611
- ratio = 0;
2612
- }
2613
- rrddim_set_by_pointer(st_compression, rd_savings, ratio);
2614
-
2615
- rrdset_done(st_compression);
2616
- }
2617
-
2618
- // ----------------------------------------------------------------
2619
-
2620
- {
2621
- static RRDSET *st_io_stats = NULL;
2622
- static RRDDIM *rd_reads = NULL;
2623
- static RRDDIM *rd_writes = NULL;
2624
-
2625
- if (unlikely(!st_io_stats)) {
2626
- st_io_stats = rrdset_create_localhost(
2627
- "netdata",
2628
- "dbengine_io_throughput",
2629
- NULL,
2630
- "dbengine io",
2631
- NULL,
2632
- "Netdata DB engine I/O throughput",
2633
- "MiB/s",
2634
- "netdata",
2635
- "stats",
2636
- priority,
2637
- localhost->rrd_update_every,
2638
- RRDSET_TYPE_LINE);
2639
-
2640
- rd_reads = rrddim_add(st_io_stats, "reads", NULL, 1, 1024 * 1024, RRD_ALGORITHM_INCREMENTAL);
2641
- rd_writes = rrddim_add(st_io_stats, "writes", NULL, -1, 1024 * 1024, RRD_ALGORITHM_INCREMENTAL);
2642
- }
2643
- priority++;
2644
-
2645
- rrddim_set_by_pointer(st_io_stats, rd_reads, (collected_number)stats_array[17]);
2646
- rrddim_set_by_pointer(st_io_stats, rd_writes, (collected_number)stats_array[15]);
2647
- rrdset_done(st_io_stats);
2648
- }
2649
-
2650
- // ----------------------------------------------------------------
2651
-
2652
- {
2653
- static RRDSET *st_io_stats = NULL;
2654
- static RRDDIM *rd_reads = NULL;
2655
- static RRDDIM *rd_writes = NULL;
2656
-
2657
- if (unlikely(!st_io_stats)) {
2658
- st_io_stats = rrdset_create_localhost(
2659
- "netdata",
2660
- "dbengine_io_operations",
2661
- NULL,
2662
- "dbengine io",
2663
- NULL,
2664
- "Netdata DB engine I/O operations",
2665
- "operations/s",
2666
- "netdata",
2667
- "stats",
2668
- priority,
2669
- localhost->rrd_update_every,
2670
- RRDSET_TYPE_LINE);
2671
-
2672
- rd_reads = rrddim_add(st_io_stats, "reads", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2673
- rd_writes = rrddim_add(st_io_stats, "writes", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL);
2674
- }
2675
- priority++;
2676
-
2677
- rrddim_set_by_pointer(st_io_stats, rd_reads, (collected_number)stats_array[18]);
2678
- rrddim_set_by_pointer(st_io_stats, rd_writes, (collected_number)stats_array[16]);
2679
- rrdset_done(st_io_stats);
2680
- }
2681
-
2682
- // ----------------------------------------------------------------
2683
-
2684
- {
2685
- static RRDSET *st_errors = NULL;
2686
- static RRDDIM *rd_fs_errors = NULL;
2687
- static RRDDIM *rd_io_errors = NULL;
2688
- static RRDDIM *pg_cache_over_half_dirty_events = NULL;
2689
-
2690
- if (unlikely(!st_errors)) {
2691
- st_errors = rrdset_create_localhost(
2692
- "netdata",
2693
- "dbengine_global_errors",
2694
- NULL,
2695
- "dbengine io",
2696
- NULL,
2697
- "Netdata DB engine errors",
2698
- "errors/s",
2699
- "netdata",
2700
- "stats",
2701
- priority,
2702
- localhost->rrd_update_every,
2703
- RRDSET_TYPE_LINE);
2704
-
2705
- rd_io_errors = rrddim_add(st_errors, "io_errors", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2706
- rd_fs_errors = rrddim_add(st_errors, "fs_errors", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2707
- pg_cache_over_half_dirty_events =
2708
- rrddim_add(st_errors, "pg_cache_over_half_dirty_events", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2709
- }
2710
- priority++;
2711
-
2712
- rrddim_set_by_pointer(st_errors, rd_io_errors, (collected_number)stats_array[30]);
2713
- rrddim_set_by_pointer(st_errors, rd_fs_errors, (collected_number)stats_array[31]);
2714
- rrddim_set_by_pointer(st_errors, pg_cache_over_half_dirty_events, (collected_number)stats_array[34]);
2715
- rrdset_done(st_errors);
2716
- }
2717
-
2718
- // ----------------------------------------------------------------
2719
-
2720
- {
2721
- static RRDSET *st_fd = NULL;
2722
- static RRDDIM *rd_fd_current = NULL;
2723
- static RRDDIM *rd_fd_max = NULL;
2724
-
2725
- if (unlikely(!st_fd)) {
2726
- st_fd = rrdset_create_localhost(
2727
- "netdata",
2728
- "dbengine_global_file_descriptors",
2729
- NULL,
2730
- "dbengine io",
2731
- NULL,
2732
- "Netdata DB engine File Descriptors",
2733
- "descriptors",
2734
- "netdata",
2735
- "stats",
2736
- priority,
2737
- localhost->rrd_update_every,
2738
- RRDSET_TYPE_LINE);
2739
-
2740
- rd_fd_current = rrddim_add(st_fd, "current", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
2741
- rd_fd_max = rrddim_add(st_fd, "max", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
2742
- }
2743
- priority++;
2744
-
2745
- rrddim_set_by_pointer(st_fd, rd_fd_current, (collected_number)stats_array[32]);
2746
- /* Careful here, modify this accordingly if the File-Descriptor budget ever changes */
2747
- rrddim_set_by_pointer(st_fd, rd_fd_max, (collected_number)rlimit_nofile.rlim_cur / 4);
2748
- rrdset_done(st_fd);
2749
- }
2750
- }
2751
- }
2752
-}
2753
-#endif // ENABLE_DBENGINE
2754
-
2755
-static void update_strings_charts() {
2756
- static RRDSET *st_ops = NULL, *st_entries = NULL, *st_mem = NULL;
2757
- static RRDDIM *rd_ops_inserts = NULL, *rd_ops_deletes = NULL;
2758
- static RRDDIM *rd_entries_entries = NULL;
2759
- static RRDDIM *rd_mem = NULL;
2760
-#ifdef NETDATA_INTERNAL_CHECKS
2761
- static RRDDIM *rd_entries_refs = NULL, *rd_ops_releases = NULL, *rd_ops_duplications = NULL, *rd_ops_searches = NULL;
2762
-#endif
2763
-
2764
- size_t inserts, deletes, searches, entries, references, memory, duplications, releases;
2765
-
2766
- string_statistics(&inserts, &deletes, &searches, &entries, &references, &memory, &duplications, &releases);
2767
-
2768
- if (unlikely(!st_ops)) {
2769
- st_ops = rrdset_create_localhost(
2770
- "netdata"
2771
- , "strings_ops"
2772
- , NULL
2773
- , "strings"
2774
- , NULL
2775
- , "Strings operations"
2776
- , "ops/s"
2777
- , "netdata"
2778
- , "stats"
2779
- , 910000
2780
- , localhost->rrd_update_every
2781
- , RRDSET_TYPE_LINE);
2782
-
2783
- rd_ops_inserts = rrddim_add(st_ops, "inserts", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2784
- rd_ops_deletes = rrddim_add(st_ops, "deletes", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL);
2785
-#ifdef NETDATA_INTERNAL_CHECKS
2786
- rd_ops_searches = rrddim_add(st_ops, "searches", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2787
- rd_ops_duplications = rrddim_add(st_ops, "duplications", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
2788
- rd_ops_releases = rrddim_add(st_ops, "releases", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL);
2789
-#endif
2790
- }
2791
-
2792
- rrddim_set_by_pointer(st_ops, rd_ops_inserts, (collected_number)inserts);
2793
- rrddim_set_by_pointer(st_ops, rd_ops_deletes, (collected_number)deletes);
2794
-#ifdef NETDATA_INTERNAL_CHECKS
2795
- rrddim_set_by_pointer(st_ops, rd_ops_searches, (collected_number)searches);
2796
- rrddim_set_by_pointer(st_ops, rd_ops_duplications, (collected_number)duplications);
2797
- rrddim_set_by_pointer(st_ops, rd_ops_releases, (collected_number)releases);
2798
-#endif
2799
- rrdset_done(st_ops);
2800
-
2801
- if (unlikely(!st_entries)) {
2802
- st_entries = rrdset_create_localhost(
2803
- "netdata"
2804
- , "strings_entries"
2805
- , NULL
2806
- , "strings"
2807
- , NULL
2808
- , "Strings entries"
2809
- , "entries"
2810
- , "netdata"
2811
- , "stats"
2812
- , 910001
2813
- , localhost->rrd_update_every
2814
- , RRDSET_TYPE_AREA);
2815
-
2816
- rd_entries_entries = rrddim_add(st_entries, "entries", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
2817
-#ifdef NETDATA_INTERNAL_CHECKS
2818
- rd_entries_refs = rrddim_add(st_entries, "references", NULL, 1, -1, RRD_ALGORITHM_ABSOLUTE);
2819
-#endif
2820
- }
2821
-
2822
- rrddim_set_by_pointer(st_entries, rd_entries_entries, (collected_number)entries);
2823
-#ifdef NETDATA_INTERNAL_CHECKS
2824
- rrddim_set_by_pointer(st_entries, rd_entries_refs, (collected_number)references);
2825
-#endif
2826
- rrdset_done(st_entries);
2827
-
2828
- if (unlikely(!st_mem)) {
2829
- st_mem = rrdset_create_localhost(
2830
- "netdata"
2831
- , "strings_memory"
2832
- , NULL
2833
- , "strings"
2834
- , NULL
2835
- , "Strings memory"
2836
- , "bytes"
2837
- , "netdata"
2838
- , "stats"
2839
- , 910001
2840
- , localhost->rrd_update_every
2841
- , RRDSET_TYPE_AREA);
2842
-
2843
- rd_mem = rrddim_add(st_mem, "memory", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
2844
- }
2845
-
2846
- rrddim_set_by_pointer(st_mem, rd_mem, (collected_number)memory);
2847
- rrdset_done(st_mem);
2848
-}
2849
-
2850
-static void update_heartbeat_charts() {
2851
- static RRDSET *st_heartbeat = NULL;
2852
- static RRDDIM *rd_heartbeat_min = NULL;
2853
- static RRDDIM *rd_heartbeat_max = NULL;
2854
- static RRDDIM *rd_heartbeat_avg = NULL;
2855
-
2856
- if (unlikely(!st_heartbeat)) {
2857
- st_heartbeat = rrdset_create_localhost(
2858
- "netdata"
2859
- , "heartbeat"
2860
- , NULL
2861
- , "heartbeat"
2862
- , NULL
2863
- , "System clock jitter"
2864
- , "microseconds"
2865
- , "netdata"
2866
- , "stats"
2867
- , 900000
2868
- , localhost->rrd_update_every
2869
- , RRDSET_TYPE_AREA);
2870
-
2871
- rd_heartbeat_min = rrddim_add(st_heartbeat, "min", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
2872
- rd_heartbeat_max = rrddim_add(st_heartbeat, "max", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
2873
- rd_heartbeat_avg = rrddim_add(st_heartbeat, "average", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
2874
- }
2875
-
2876
- usec_t min, max, average;
2877
- size_t count;
2878
-
2879
- heartbeat_statistics(&min, &max, &average, &count);
2880
-
2881
- rrddim_set_by_pointer(st_heartbeat, rd_heartbeat_min, (collected_number)min);
2882
- rrddim_set_by_pointer(st_heartbeat, rd_heartbeat_max, (collected_number)max);
2883
- rrddim_set_by_pointer(st_heartbeat, rd_heartbeat_avg, (collected_number)average);
2884
-
2885
- rrdset_done(st_heartbeat);
2886
-}
2887
-
2888
-// ---------------------------------------------------------------------------------------------------------------------
2889
-// dictionary statistics
2890
-
2891
-struct dictionary_stats dictionary_stats_category_collectors = { .name = "collectors" };
2892
-struct dictionary_stats dictionary_stats_category_rrdhost = { .name = "rrdhost" };
2893
-struct dictionary_stats dictionary_stats_category_rrdset_rrddim = { .name = "rrdset_rrddim" };
2894
-struct dictionary_stats dictionary_stats_category_rrdcontext = { .name = "context" };
2895
-struct dictionary_stats dictionary_stats_category_rrdlabels = { .name = "labels" };
2896
-struct dictionary_stats dictionary_stats_category_rrdhealth = { .name = "health" };
2897
-struct dictionary_stats dictionary_stats_category_functions = { .name = "functions" };
2898
-struct dictionary_stats dictionary_stats_category_replication = { .name = "replication" };
2899
-
2900
-#ifdef DICT_WITH_STATS
2901
-struct dictionary_categories {
2902
- struct dictionary_stats *stats;
2903
- const char *family;
2904
- const char *context_prefix;
2905
- int priority;
2906
-
2907
- RRDSET *st_dicts;
2908
- RRDDIM *rd_dicts_active;
2909
- RRDDIM *rd_dicts_deleted;
2910
-
2911
- RRDSET *st_items;
2912
- RRDDIM *rd_items_entries;
2913
- RRDDIM *rd_items_referenced;
2914
- RRDDIM *rd_items_pending_deletion;
2915
-
2916
- RRDSET *st_ops;
2917
- RRDDIM *rd_ops_creations;
2918
- RRDDIM *rd_ops_destructions;
2919
- RRDDIM *rd_ops_flushes;
2920
- RRDDIM *rd_ops_traversals;
2921
- RRDDIM *rd_ops_walkthroughs;
2922
- RRDDIM *rd_ops_garbage_collections;
2923
- RRDDIM *rd_ops_searches;
2924
- RRDDIM *rd_ops_inserts;
2925
- RRDDIM *rd_ops_resets;
2926
- RRDDIM *rd_ops_deletes;
2927
-
2928
- RRDSET *st_callbacks;
2929
- RRDDIM *rd_callbacks_inserts;
2930
- RRDDIM *rd_callbacks_conflicts;
2931
- RRDDIM *rd_callbacks_reacts;
2932
- RRDDIM *rd_callbacks_deletes;
2933
-
2934
- RRDSET *st_memory;
2935
- RRDDIM *rd_memory_indexed;
2936
- RRDDIM *rd_memory_values;
2937
- RRDDIM *rd_memory_dict;
2938
-
2939
- RRDSET *st_spins;
2940
- RRDDIM *rd_spins_use;
2941
- RRDDIM *rd_spins_search;
2942
- RRDDIM *rd_spins_insert;
2943
- RRDDIM *rd_spins_delete;
2944
-
2945
-} dictionary_categories[] = {
2946
- { .stats = &dictionary_stats_category_collectors, "dictionaries collectors", "dictionaries", 900000 },
2947
- { .stats = &dictionary_stats_category_rrdhost, "dictionaries hosts", "dictionaries", 900000 },
2948
- { .stats = &dictionary_stats_category_rrdset_rrddim, "dictionaries rrd", "dictionaries", 900000 },
2949
- { .stats = &dictionary_stats_category_rrdcontext, "dictionaries contexts", "dictionaries", 900000 },
2950
- { .stats = &dictionary_stats_category_rrdlabels, "dictionaries labels", "dictionaries", 900000 },
2951
- { .stats = &dictionary_stats_category_rrdhealth, "dictionaries health", "dictionaries", 900000 },
2952
- { .stats = &dictionary_stats_category_functions, "dictionaries functions", "dictionaries", 900000 },
2953
- { .stats = &dictionary_stats_category_replication, "dictionaries replication", "dictionaries", 900000 },
2954
- { .stats = &dictionary_stats_category_other, "dictionaries other", "dictionaries", 900000 },
2955
-
2956
- // terminator
2957
- { .stats = NULL, NULL, NULL, 0 },
2958
-};
2959
-
2960
-#define load_dictionary_stats_entry(x) total += (size_t)(stats.x = __atomic_load_n(&c->stats->x, __ATOMIC_RELAXED))
2961
-
2962
-static void update_dictionary_category_charts(struct dictionary_categories *c) {
2963
- struct dictionary_stats stats;
2964
- stats.name = c->stats->name;
2965
-
2966
- // ------------------------------------------------------------------------
2967
-
2968
- size_t total = 0;
2969
- load_dictionary_stats_entry(dictionaries.active);
2970
- load_dictionary_stats_entry(dictionaries.deleted);
2971
-
2972
- if(c->st_dicts || total != 0) {
2973
- if (unlikely(!c->st_dicts)) {
2974
- char id[RRD_ID_LENGTH_MAX + 1];
2975
- snprintfz(id, RRD_ID_LENGTH_MAX, "%s.%s.dictionaries", c->context_prefix, stats.name);
2976
-
2977
- char context[RRD_ID_LENGTH_MAX + 1];
2978
- snprintfz(context, RRD_ID_LENGTH_MAX, "netdata.%s.category.dictionaries", c->context_prefix);
2979
-
2980
- c->st_dicts = rrdset_create_localhost(
2981
- "netdata"
2982
- , id
2983
- , NULL
2984
- , c->family
2985
- , context
2986
- , "Dictionaries"
2987
- , "dictionaries"
2988
- , "netdata"
2989
- , "stats"
2990
- , c->priority + 0
2991
- , localhost->rrd_update_every
2992
- , RRDSET_TYPE_LINE
2993
- );
2994
-
2995
- c->rd_dicts_active = rrddim_add(c->st_dicts, "active", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
2996
- c->rd_dicts_deleted = rrddim_add(c->st_dicts, "deleted", NULL, -1, 1, RRD_ALGORITHM_ABSOLUTE);
2997
-
2998
- rrdlabels_add(c->st_dicts->rrdlabels, "category", stats.name, RRDLABEL_SRC_AUTO);
2999
- }
3000
-
3001
- rrddim_set_by_pointer(c->st_dicts, c->rd_dicts_active, (collected_number)stats.dictionaries.active);
3002
- rrddim_set_by_pointer(c->st_dicts, c->rd_dicts_deleted, (collected_number)stats.dictionaries.deleted);
3003
- rrdset_done(c->st_dicts);
3004
- }
3005
-
3006
- // ------------------------------------------------------------------------
3007
-
3008
- total = 0;
3009
- load_dictionary_stats_entry(items.entries);
3010
- load_dictionary_stats_entry(items.referenced);
3011
- load_dictionary_stats_entry(items.pending_deletion);
3012
-
3013
- if(c->st_items || total != 0) {
3014
- if (unlikely(!c->st_items)) {
3015
- char id[RRD_ID_LENGTH_MAX + 1];
3016
- snprintfz(id, RRD_ID_LENGTH_MAX, "%s.%s.items", c->context_prefix, stats.name);
3017
-
3018
- char context[RRD_ID_LENGTH_MAX + 1];
3019
- snprintfz(context, RRD_ID_LENGTH_MAX, "netdata.%s.category.items", c->context_prefix);
3020
-
3021
- c->st_items = rrdset_create_localhost(
3022
- "netdata"
3023
- , id
3024
- , NULL
3025
- , c->family
3026
- , context
3027
- , "Dictionary Items"
3028
- , "items"
3029
- , "netdata"
3030
- , "stats"
3031
- , c->priority + 1
3032
- , localhost->rrd_update_every
3033
- , RRDSET_TYPE_LINE
3034
- );
3035
-
3036
- c->rd_items_entries = rrddim_add(c->st_items, "active", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
3037
- c->rd_items_pending_deletion = rrddim_add(c->st_items, "deleted", NULL, -1, 1, RRD_ALGORITHM_ABSOLUTE);
3038
- c->rd_items_referenced = rrddim_add(c->st_items, "referenced", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
3039
-
3040
- rrdlabels_add(c->st_items->rrdlabels, "category", stats.name, RRDLABEL_SRC_AUTO);
3041
- }
3042
-
3043
- rrddim_set_by_pointer(c->st_items, c->rd_items_entries, stats.items.entries);
3044
- rrddim_set_by_pointer(c->st_items, c->rd_items_pending_deletion, stats.items.pending_deletion);
3045
- rrddim_set_by_pointer(c->st_items, c->rd_items_referenced, stats.items.referenced);
3046
- rrdset_done(c->st_items);
3047
- }
3048
-
3049
- // ------------------------------------------------------------------------
3050
-
3051
- total = 0;
3052
- load_dictionary_stats_entry(ops.creations);
3053
- load_dictionary_stats_entry(ops.destructions);
3054
- load_dictionary_stats_entry(ops.flushes);
3055
- load_dictionary_stats_entry(ops.traversals);
3056
- load_dictionary_stats_entry(ops.walkthroughs);
3057
- load_dictionary_stats_entry(ops.garbage_collections);
3058
- load_dictionary_stats_entry(ops.searches);
3059
- load_dictionary_stats_entry(ops.inserts);
3060
- load_dictionary_stats_entry(ops.resets);
3061
- load_dictionary_stats_entry(ops.deletes);
3062
-
3063
- if(c->st_ops || total != 0) {
3064
- if (unlikely(!c->st_ops)) {
3065
- char id[RRD_ID_LENGTH_MAX + 1];
3066
- snprintfz(id, RRD_ID_LENGTH_MAX, "%s.%s.ops", c->context_prefix, stats.name);
3067
-
3068
- char context[RRD_ID_LENGTH_MAX + 1];
3069
- snprintfz(context, RRD_ID_LENGTH_MAX, "netdata.%s.category.ops", c->context_prefix);
3070
-
3071
- c->st_ops = rrdset_create_localhost(
3072
- "netdata"
3073
- , id
3074
- , NULL
3075
- , c->family
3076
- , context
3077
- , "Dictionary Operations"
3078
- , "ops/s"
3079
- , "netdata"
3080
- , "stats"
3081
- , c->priority + 2
3082
- , localhost->rrd_update_every
3083
- , RRDSET_TYPE_LINE
3084
- );
3085
-
3086
- c->rd_ops_creations = rrddim_add(c->st_ops, "creations", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
3087
- c->rd_ops_destructions = rrddim_add(c->st_ops, "destructions", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
3088
- c->rd_ops_flushes = rrddim_add(c->st_ops, "flushes", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
3089
- c->rd_ops_traversals = rrddim_add(c->st_ops, "traversals", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
3090
- c->rd_ops_walkthroughs = rrddim_add(c->st_ops, "walkthroughs", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
3091
- c->rd_ops_garbage_collections = rrddim_add(c->st_ops, "garbage_collections", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
3092
- c->rd_ops_searches = rrddim_add(c->st_ops, "searches", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
3093
- c->rd_ops_inserts = rrddim_add(c->st_ops, "inserts", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
3094
- c->rd_ops_resets = rrddim_add(c->st_ops, "resets", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
3095
- c->rd_ops_deletes = rrddim_add(c->st_ops, "deletes", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
3096
-
3097
- rrdlabels_add(c->st_ops->rrdlabels, "category", stats.name, RRDLABEL_SRC_AUTO);
3098
- }
3099
-
3100
- rrddim_set_by_pointer(c->st_ops, c->rd_ops_creations, (collected_number)stats.ops.creations);
3101
- rrddim_set_by_pointer(c->st_ops, c->rd_ops_destructions, (collected_number)stats.ops.destructions);
3102
- rrddim_set_by_pointer(c->st_ops, c->rd_ops_flushes, (collected_number)stats.ops.flushes);
3103
- rrddim_set_by_pointer(c->st_ops, c->rd_ops_traversals, (collected_number)stats.ops.traversals);
3104
- rrddim_set_by_pointer(c->st_ops, c->rd_ops_walkthroughs, (collected_number)stats.ops.walkthroughs);
3105
- rrddim_set_by_pointer(c->st_ops, c->rd_ops_garbage_collections, (collected_number)stats.ops.garbage_collections);
3106
- rrddim_set_by_pointer(c->st_ops, c->rd_ops_searches, (collected_number)stats.ops.searches);
3107
- rrddim_set_by_pointer(c->st_ops, c->rd_ops_inserts, (collected_number)stats.ops.inserts);
3108
- rrddim_set_by_pointer(c->st_ops, c->rd_ops_resets, (collected_number)stats.ops.resets);
3109
- rrddim_set_by_pointer(c->st_ops, c->rd_ops_deletes, (collected_number)stats.ops.deletes);
3110
-
3111
- rrdset_done(c->st_ops);
3112
- }
3113
-
3114
- // ------------------------------------------------------------------------
3115
-
3116
- total = 0;
3117
- load_dictionary_stats_entry(callbacks.inserts);
3118
- load_dictionary_stats_entry(callbacks.conflicts);
3119
- load_dictionary_stats_entry(callbacks.reacts);
3120
- load_dictionary_stats_entry(callbacks.deletes);
3121
-
3122
- if(c->st_callbacks || total != 0) {
3123
- if (unlikely(!c->st_callbacks)) {
3124
- char id[RRD_ID_LENGTH_MAX + 1];
3125
- snprintfz(id, RRD_ID_LENGTH_MAX, "%s.%s.callbacks", c->context_prefix, stats.name);
3126
-
3127
- char context[RRD_ID_LENGTH_MAX + 1];
3128
- snprintfz(context, RRD_ID_LENGTH_MAX, "netdata.%s.category.callbacks", c->context_prefix);
3129
-
3130
- c->st_callbacks = rrdset_create_localhost(
3131
- "netdata"
3132
- , id
3133
- , NULL
3134
- , c->family
3135
- , context
3136
- , "Dictionary Callbacks"
3137
- , "callbacks/s"
3138
- , "netdata"
3139
- , "stats"
3140
- , c->priority + 3
3141
- , localhost->rrd_update_every
3142
- , RRDSET_TYPE_LINE
3143
- );
3144
-
3145
- c->rd_callbacks_inserts = rrddim_add(c->st_callbacks, "inserts", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
3146
- c->rd_callbacks_deletes = rrddim_add(c->st_callbacks, "deletes", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
3147
- c->rd_callbacks_conflicts = rrddim_add(c->st_callbacks, "conflicts", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
3148
- c->rd_callbacks_reacts = rrddim_add(c->st_callbacks, "reacts", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
3149
-
3150
- rrdlabels_add(c->st_callbacks->rrdlabels, "category", stats.name, RRDLABEL_SRC_AUTO);
3151
- }
3152
-
3153
- rrddim_set_by_pointer(c->st_callbacks, c->rd_callbacks_inserts, (collected_number)stats.callbacks.inserts);
3154
- rrddim_set_by_pointer(c->st_callbacks, c->rd_callbacks_conflicts, (collected_number)stats.callbacks.conflicts);
3155
- rrddim_set_by_pointer(c->st_callbacks, c->rd_callbacks_reacts, (collected_number)stats.callbacks.reacts);
3156
- rrddim_set_by_pointer(c->st_callbacks, c->rd_callbacks_deletes, (collected_number)stats.callbacks.deletes);
3157
-
3158
- rrdset_done(c->st_callbacks);
3159
- }
3160
-
3161
- // ------------------------------------------------------------------------
3162
-
3163
- total = 0;
3164
- load_dictionary_stats_entry(memory.index);
3165
- load_dictionary_stats_entry(memory.values);
3166
- load_dictionary_stats_entry(memory.dict);
3167
-
3168
- if(c->st_memory || total != 0) {
3169
- if (unlikely(!c->st_memory)) {
3170
- char id[RRD_ID_LENGTH_MAX + 1];
3171
- snprintfz(id, RRD_ID_LENGTH_MAX, "%s.%s.memory", c->context_prefix, stats.name);
3172
-
3173
- char context[RRD_ID_LENGTH_MAX + 1];
3174
- snprintfz(context, RRD_ID_LENGTH_MAX, "netdata.%s.category.memory", c->context_prefix);
3175
-
3176
- c->st_memory = rrdset_create_localhost(
3177
- "netdata"
3178
- , id
3179
- , NULL
3180
- , c->family
3181
- , context
3182
- , "Dictionary Memory"
3183
- , "bytes"
3184
- , "netdata"
3185
- , "stats"
3186
- , c->priority + 4
3187
- , localhost->rrd_update_every
3188
- , RRDSET_TYPE_STACKED
3189
- );
3190
-
3191
- c->rd_memory_indexed = rrddim_add(c->st_memory, "index", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
3192
- c->rd_memory_values = rrddim_add(c->st_memory, "data", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
3193
- c->rd_memory_dict = rrddim_add(c->st_memory, "structures", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
3194
-
3195
- rrdlabels_add(c->st_memory->rrdlabels, "category", stats.name, RRDLABEL_SRC_AUTO);
3196
- }
3197
-
3198
- rrddim_set_by_pointer(c->st_memory, c->rd_memory_indexed, (collected_number)stats.memory.index);
3199
- rrddim_set_by_pointer(c->st_memory, c->rd_memory_values, (collected_number)stats.memory.values);
3200
- rrddim_set_by_pointer(c->st_memory, c->rd_memory_dict, (collected_number)stats.memory.dict);
3201
-
3202
- rrdset_done(c->st_memory);
3203
- }
3204
-
3205
- // ------------------------------------------------------------------------
3206
-
3207
- total = 0;
3208
- load_dictionary_stats_entry(spin_locks.use_spins);
3209
- load_dictionary_stats_entry(spin_locks.search_spins);
3210
- load_dictionary_stats_entry(spin_locks.insert_spins);
3211
- load_dictionary_stats_entry(spin_locks.delete_spins);
3212
-
3213
- if(c->st_spins || total != 0) {
3214
- if (unlikely(!c->st_spins)) {
3215
- char id[RRD_ID_LENGTH_MAX + 1];
3216
- snprintfz(id, RRD_ID_LENGTH_MAX, "%s.%s.spins", c->context_prefix, stats.name);
3217
-
3218
- char context[RRD_ID_LENGTH_MAX + 1];
3219
- snprintfz(context, RRD_ID_LENGTH_MAX, "netdata.%s.category.spins", c->context_prefix);
3220
-
3221
- c->st_spins = rrdset_create_localhost(
3222
- "netdata"
3223
- , id
3224
- , NULL
3225
- , c->family
3226
- , context
3227
- , "Dictionary Spins"
3228
- , "count"
3229
- , "netdata"
3230
- , "stats"
3231
- , c->priority + 5
3232
- , localhost->rrd_update_every
3233
- , RRDSET_TYPE_LINE
3234
- );
3235
-
3236
- c->rd_spins_use = rrddim_add(c->st_spins, "use", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
3237
- c->rd_spins_search = rrddim_add(c->st_spins, "search", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
3238
- c->rd_spins_insert = rrddim_add(c->st_spins, "insert", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
3239
- c->rd_spins_delete = rrddim_add(c->st_spins, "delete", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
3240
-
3241
- rrdlabels_add(c->st_spins->rrdlabels, "category", stats.name, RRDLABEL_SRC_AUTO);
3242
- }
3243
-
3244
- rrddim_set_by_pointer(c->st_spins, c->rd_spins_use, (collected_number)stats.spin_locks.use_spins);
3245
- rrddim_set_by_pointer(c->st_spins, c->rd_spins_search, (collected_number)stats.spin_locks.search_spins);
3246
- rrddim_set_by_pointer(c->st_spins, c->rd_spins_insert, (collected_number)stats.spin_locks.insert_spins);
3247
- rrddim_set_by_pointer(c->st_spins, c->rd_spins_delete, (collected_number)stats.spin_locks.delete_spins);
3248
-
3249
- rrdset_done(c->st_spins);
3250
- }
3251
-}
3252
-
3253
-static void dictionary_statistics(void) {
3254
- for(int i = 0; dictionary_categories[i].stats ;i++) {
3255
- update_dictionary_category_charts(&dictionary_categories[i]);
3256
- }
3257
-}
3258
-#endif // DICT_WITH_STATS
3259
-
3260
-#ifdef NETDATA_TRACE_ALLOCATIONS
3261
-
3262
-struct memory_trace_data {
3263
- RRDSET *st_memory;
3264
- RRDSET *st_allocations;
3265
- RRDSET *st_avg_alloc;
3266
- RRDSET *st_ops;
3267
-};
3268
-
3269
-static int do_memory_trace_item(void *item, void *data) {
3270
- struct memory_trace_data *tmp = data;
3271
- struct malloc_trace *p = item;
3272
-
3273
- // ------------------------------------------------------------------------
3274
-
3275
- if(!p->rd_bytes)
3276
- p->rd_bytes = rrddim_add(tmp->st_memory, p->function, NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
3277
-
3278
- collected_number bytes = (collected_number)__atomic_load_n(&p->bytes, __ATOMIC_RELAXED);
3279
- rrddim_set_by_pointer(tmp->st_memory, p->rd_bytes, bytes);
3280
-
3281
- // ------------------------------------------------------------------------
3282
-
3283
- if(!p->rd_allocations)
3284
- p->rd_allocations = rrddim_add(tmp->st_allocations, p->function, NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
3285
-
3286
- collected_number allocs = (collected_number)__atomic_load_n(&p->allocations, __ATOMIC_RELAXED);
3287
- rrddim_set_by_pointer(tmp->st_allocations, p->rd_allocations, allocs);
3288
-
3289
- // ------------------------------------------------------------------------
3290
-
3291
- if(!p->rd_avg_alloc)
3292
- p->rd_avg_alloc = rrddim_add(tmp->st_avg_alloc, p->function, NULL, 1, 100, RRD_ALGORITHM_ABSOLUTE);
3293
-
3294
- collected_number avg_alloc = (allocs)?(bytes * 100 / allocs):0;
3295
- rrddim_set_by_pointer(tmp->st_avg_alloc, p->rd_avg_alloc, avg_alloc);
3296
-
3297
- // ------------------------------------------------------------------------
3298
-
3299
- if(!p->rd_ops)
3300
- p->rd_ops = rrddim_add(tmp->st_ops, p->function, NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
3301
-
3302
- collected_number ops = 0;
3303
- ops += (collected_number)__atomic_load_n(&p->malloc_calls, __ATOMIC_RELAXED);
3304
- ops += (collected_number)__atomic_load_n(&p->calloc_calls, __ATOMIC_RELAXED);
3305
- ops += (collected_number)__atomic_load_n(&p->realloc_calls, __ATOMIC_RELAXED);
3306
- ops += (collected_number)__atomic_load_n(&p->strdup_calls, __ATOMIC_RELAXED);
3307
- ops += (collected_number)__atomic_load_n(&p->free_calls, __ATOMIC_RELAXED);
3308
- rrddim_set_by_pointer(tmp->st_ops, p->rd_ops, ops);
3309
-
3310
- // ------------------------------------------------------------------------
3311
-
3312
- return 1;
3313
-}
3314
-static void malloc_trace_statistics(void) {
3315
- static struct memory_trace_data tmp = {
3316
- .st_memory = NULL,
3317
- .st_allocations = NULL,
3318
- .st_avg_alloc = NULL,
3319
- .st_ops = NULL,
3320
- };
3321
-
3322
- if(!tmp.st_memory) {
3323
- tmp.st_memory = rrdset_create_localhost(
3324
- "netdata"
3325
- , "memory_size"
3326
- , NULL
3327
- , "memory"
3328
- , "netdata.memory.size"
3329
- , "Netdata Memory Used by Function"
3330
- , "bytes"
3331
- , "netdata"
3332
- , "stats"
3333
- , 900000
3334
- , localhost->rrd_update_every
3335
- , RRDSET_TYPE_STACKED
3336
- );
3337
- }
3338
-
3339
- if(!tmp.st_ops) {
3340
- tmp.st_ops = rrdset_create_localhost(
3341
- "netdata"
3342
- , "memory_operations"
3343
- , NULL
3344
- , "memory"
3345
- , "netdata.memory.operations"
3346
- , "Netdata Memory Operations by Function"
3347
- , "ops/s"
3348
- , "netdata"
3349
- , "stats"
3350
- , 900001
3351
- , localhost->rrd_update_every
3352
- , RRDSET_TYPE_LINE
3353
- );
3354
- }
3355
-
3356
- if(!tmp.st_allocations) {
3357
- tmp.st_allocations = rrdset_create_localhost(
3358
- "netdata"
3359
- , "memory_allocations"
3360
- , NULL
3361
- , "memory"
3362
- , "netdata.memory.allocations"
3363
- , "Netdata Memory Allocations by Function"
3364
- , "allocations"
3365
- , "netdata"
3366
- , "stats"
3367
- , 900002
3368
- , localhost->rrd_update_every
3369
- , RRDSET_TYPE_STACKED
3370
- );
3371
- }
3372
-
3373
- if(!tmp.st_avg_alloc) {
3374
- tmp.st_avg_alloc = rrdset_create_localhost(
3375
- "netdata"
3376
- , "memory_avg_alloc"
3377
- , NULL
3378
- , "memory"
3379
- , "netdata.memory.avg_alloc"
3380
- , "Netdata Average Allocation Size by Function"
3381
- , "bytes"
3382
- , "netdata"
3383
- , "stats"
3384
- , 900003
3385
- , localhost->rrd_update_every
3386
- , RRDSET_TYPE_LINE
3387
- );
3388
- }
3389
-
3390
- malloc_trace_walkthrough(do_memory_trace_item, &tmp);
3391
-
3392
- rrdset_done(tmp.st_memory);
3393
- rrdset_done(tmp.st_ops);
3394
- rrdset_done(tmp.st_allocations);
3395
- rrdset_done(tmp.st_avg_alloc);
3396
-}
3397
-#endif
3398
-
3399
-// ---------------------------------------------------------------------------------------------------------------------
3400
-// worker utilization
3401
-
3402
-#define WORKERS_MIN_PERCENT_DEFAULT 10000.0
3403
-
3404
-struct worker_job_type_gs {
3405
- STRING *name;
3406
- STRING *units;
3407
-
3408
- size_t jobs_started;
3409
- usec_t busy_time;
3410
-
3411
- RRDDIM *rd_jobs_started;
3412
- RRDDIM *rd_busy_time;
3413
-
3414
- WORKER_METRIC_TYPE type;
3415
- NETDATA_DOUBLE min_value;
3416
- NETDATA_DOUBLE max_value;
3417
- NETDATA_DOUBLE sum_value;
3418
- size_t count_value;
3419
-
3420
- RRDSET *st;
3421
- RRDDIM *rd_min;
3422
- RRDDIM *rd_max;
3423
- RRDDIM *rd_avg;
3424
-};
3425
-
3426
-struct worker_thread {
3427
- pid_t pid;
3428
- bool enabled;
3429
-
3430
- bool cpu_enabled;
3431
- double cpu;
3432
-
3433
- kernel_uint_t utime;
3434
- kernel_uint_t stime;
3435
-
3436
- kernel_uint_t utime_old;
3437
- kernel_uint_t stime_old;
3438
-
3439
- usec_t collected_time;
3440
- usec_t collected_time_old;
3441
-
3442
- size_t jobs_started;
3443
- usec_t busy_time;
3444
-
3445
- struct worker_thread *next;
3446
- struct worker_thread *prev;
3447
-};
3448
-
3449
-struct worker_utilization {
3450
- const char *name;
3451
- const char *family;
3452
- size_t priority;
3453
- uint32_t flags;
3454
-
3455
- char *name_lowercase;
3456
-
3457
- struct worker_job_type_gs per_job_type[WORKER_UTILIZATION_MAX_JOB_TYPES];
3458
-
3459
- size_t workers_max_job_id;
3460
- size_t workers_registered;
3461
- size_t workers_busy;
3462
- usec_t workers_total_busy_time;
3463
- usec_t workers_total_duration;
3464
- size_t workers_total_jobs_started;
3465
- double workers_min_busy_time;
3466
- double workers_max_busy_time;
3467
-
3468
- size_t workers_cpu_registered;
3469
- double workers_cpu_min;
3470
- double workers_cpu_max;
3471
- double workers_cpu_total;
3472
-
3473
- struct worker_thread *threads;
3474
-
3475
- RRDSET *st_workers_time;
3476
- RRDDIM *rd_workers_time_avg;
3477
- RRDDIM *rd_workers_time_min;
3478
- RRDDIM *rd_workers_time_max;
3479
-
3480
- RRDSET *st_workers_cpu;
3481
- RRDDIM *rd_workers_cpu_avg;
3482
- RRDDIM *rd_workers_cpu_min;
3483
- RRDDIM *rd_workers_cpu_max;
3484
-
3485
- RRDSET *st_workers_threads;
3486
- RRDDIM *rd_workers_threads_free;
3487
- RRDDIM *rd_workers_threads_busy;
3488
-
3489
- RRDSET *st_workers_jobs_per_job_type;
3490
- RRDSET *st_workers_busy_per_job_type;
3491
-
3492
- RRDDIM *rd_total_cpu_utilizaton;
3493
-};
3494
-
3495
-static struct worker_utilization all_workers_utilization[] = {
3496
- { .name = "STATS", .family = "workers global statistics", .priority = 1000000 },
3497
- { .name = "HEALTH", .family = "workers health alarms", .priority = 1000000 },
3498
- { .name = "MLTRAIN", .family = "workers ML training", .priority = 1000000 },
3499
- { .name = "MLDETECT", .family = "workers ML detection", .priority = 1000000 },
3500
- { .name = "STREAMRCV", .family = "workers streaming receive", .priority = 1000000 },
3501
- { .name = "STREAMSND", .family = "workers streaming send", .priority = 1000000 },
3502
- { .name = "DBENGINE", .family = "workers dbengine instances", .priority = 1000000 },
3503
- { .name = "LIBUV", .family = "workers libuv threadpool", .priority = 1000000 },
3504
- { .name = "WEB", .family = "workers web server", .priority = 1000000 },
3505
- { .name = "ACLKSYNC", .family = "workers aclk sync", .priority = 1000000 },
3506
- { .name = "METASYNC", .family = "workers metadata sync", .priority = 1000000 },
3507
- { .name = "PLUGINSD", .family = "workers plugins.d", .priority = 1000000 },
3508
- { .name = "STATSD", .family = "workers plugin statsd", .priority = 1000000 },
3509
- { .name = "STATSDFLUSH", .family = "workers plugin statsd flush", .priority = 1000000 },
3510
- { .name = "PROC", .family = "workers plugin proc", .priority = 1000000 },
3511
- { .name = "WIN", .family = "workers plugin windows", .priority = 1000000 },
3512
- { .name = "NETDEV", .family = "workers plugin proc netdev", .priority = 1000000 },
3513
- { .name = "FREEBSD", .family = "workers plugin freebsd", .priority = 1000000 },
3514
- { .name = "MACOS", .family = "workers plugin macos", .priority = 1000000 },
3515
- { .name = "CGROUPS", .family = "workers plugin cgroups", .priority = 1000000 },
3516
- { .name = "CGROUPSDISC", .family = "workers plugin cgroups find", .priority = 1000000 },
3517
- { .name = "DISKSPACE", .family = "workers plugin diskspace", .priority = 1000000 },
3518
- { .name = "TC", .family = "workers plugin tc", .priority = 1000000 },
3519
- { .name = "TIMEX", .family = "workers plugin timex", .priority = 1000000 },
3520
- { .name = "IDLEJITTER", .family = "workers plugin idlejitter", .priority = 1000000 },
3521
- { .name = "LOGSMANAGPLG",.family = "workers plugin logs management", .priority = 1000000 },
3522
- { .name = "RRDCONTEXT", .family = "workers contexts", .priority = 1000000 },
3523
- { .name = "REPLICATION", .family = "workers replication sender", .priority = 1000000 },
3524
- { .name = "SERVICE", .family = "workers service", .priority = 1000000 },
3525
- { .name = "PROFILER", .family = "workers profile", .priority = 1000000 },
3526
-
3527
- // has to be terminated with a NULL
3528
- { .name = NULL, .family = NULL }
3529
-};
3530
-
3531
-static void workers_total_cpu_utilization_chart(void) {
3532
- size_t i, cpu_enabled = 0;
3533
- for(i = 0; all_workers_utilization[i].name ;i++)
3534
- if(all_workers_utilization[i].workers_cpu_registered) cpu_enabled++;
3535
-
3536
- if(!cpu_enabled) return;
3537
-
3538
- static RRDSET *st = NULL;
3539
-
3540
- if(!st) {
3541
- st = rrdset_create_localhost(
3542
- "netdata",
3543
- "workers_cpu",
3544
- NULL,
3545
- "workers",
3546
- "netdata.workers.cpu_total",
3547
- "Netdata Workers CPU Utilization (100% = 1 core)",
3548
- "%",
3549
- "netdata",
3550
- "stats",
3551
- 999000,
3552
- localhost->rrd_update_every,
3553
- RRDSET_TYPE_STACKED);
3554
- }
3555
-
3556
- for(i = 0; all_workers_utilization[i].name ;i++) {
3557
- struct worker_utilization *wu = &all_workers_utilization[i];
3558
- if(!wu->workers_cpu_registered) continue;
3559
-
3560
- if(!wu->rd_total_cpu_utilizaton)
3561
- wu->rd_total_cpu_utilizaton = rrddim_add(st, wu->name_lowercase, NULL, 1, 100, RRD_ALGORITHM_ABSOLUTE);
3562
-
3563
- rrddim_set_by_pointer(st, wu->rd_total_cpu_utilizaton, (collected_number)((double)wu->workers_cpu_total * 100.0));
3564
- }
3565
-
3566
- rrdset_done(st);
3567
-}
3568
-
3569
-#define WORKER_CHART_DECIMAL_PRECISION 100
3570
-
3571
-static void workers_utilization_update_chart(struct worker_utilization *wu) {
3572
- if(!wu->workers_registered) return;
3573
-
3574
- //fprintf(stderr, "%-12s WORKER UTILIZATION: %-3.2f%%, %zu jobs done, %zu running, on %zu workers, min %-3.02f%%, max %-3.02f%%.\n",
3575
- // wu->name,
3576
- // (double)wu->workers_total_busy_time * 100.0 / (double)wu->workers_total_duration,
3577
- // wu->workers_total_jobs_started, wu->workers_busy, wu->workers_registered,
3578
- // wu->workers_min_busy_time, wu->workers_max_busy_time);
3579
-
3580
- // ----------------------------------------------------------------------
3581
-
3582
- if(unlikely(!wu->st_workers_time)) {
3583
- char name[RRD_ID_LENGTH_MAX + 1];
3584
- snprintfz(name, RRD_ID_LENGTH_MAX, "workers_time_%s", wu->name_lowercase);
3585
-
3586
- char context[RRD_ID_LENGTH_MAX + 1];
3587
- snprintf(context, RRD_ID_LENGTH_MAX, "netdata.workers.%s.time", wu->name_lowercase);
3588
-
3589
- wu->st_workers_time = rrdset_create_localhost(
3590
- "netdata"
3591
- , name
3592
- , NULL
3593
- , wu->family
3594
- , context
3595
- , "Netdata Workers Busy Time (100% = all workers busy)"
3596
- , "%"
3597
- , "netdata"
3598
- , "stats"
3599
- , wu->priority
3600
- , localhost->rrd_update_every
3601
- , RRDSET_TYPE_AREA
3602
- );
3603
- }
3604
-
3605
- // we add the min and max dimensions only when we have multiple workers
3606
-
3607
- if(unlikely(!wu->rd_workers_time_min && wu->workers_registered > 1))
3608
- wu->rd_workers_time_min = rrddim_add(wu->st_workers_time, "min", NULL, 1, WORKER_CHART_DECIMAL_PRECISION, RRD_ALGORITHM_ABSOLUTE);
3609
-
3610
- if(unlikely(!wu->rd_workers_time_max && wu->workers_registered > 1))
3611
- wu->rd_workers_time_max = rrddim_add(wu->st_workers_time, "max", NULL, 1, WORKER_CHART_DECIMAL_PRECISION, RRD_ALGORITHM_ABSOLUTE);
3612
-
3613
- if(unlikely(!wu->rd_workers_time_avg))
3614
- wu->rd_workers_time_avg = rrddim_add(wu->st_workers_time, "average", NULL, 1, WORKER_CHART_DECIMAL_PRECISION, RRD_ALGORITHM_ABSOLUTE);
3615
-
3616
- if(unlikely(wu->workers_min_busy_time == WORKERS_MIN_PERCENT_DEFAULT)) wu->workers_min_busy_time = 0.0;
3617
-
3618
- if(wu->rd_workers_time_min)
3619
- rrddim_set_by_pointer(wu->st_workers_time, wu->rd_workers_time_min, (collected_number)((double)wu->workers_min_busy_time * WORKER_CHART_DECIMAL_PRECISION));
3620
-
3621
- if(wu->rd_workers_time_max)
3622
- rrddim_set_by_pointer(wu->st_workers_time, wu->rd_workers_time_max, (collected_number)((double)wu->workers_max_busy_time * WORKER_CHART_DECIMAL_PRECISION));
3623
-
3624
- if(wu->workers_total_duration == 0)
3625
- rrddim_set_by_pointer(wu->st_workers_time, wu->rd_workers_time_avg, 0);
3626
- else
3627
- rrddim_set_by_pointer(wu->st_workers_time, wu->rd_workers_time_avg, (collected_number)((double)wu->workers_total_busy_time * 100.0 * WORKER_CHART_DECIMAL_PRECISION / (double)wu->workers_total_duration));
3628
-
3629
- rrdset_done(wu->st_workers_time);
3630
-
3631
- // ----------------------------------------------------------------------
3632
-
3633
-#ifdef __linux__
3634
- if(wu->workers_cpu_registered || wu->st_workers_cpu) {
3635
- if(unlikely(!wu->st_workers_cpu)) {
3636
- char name[RRD_ID_LENGTH_MAX + 1];
3637
- snprintfz(name, RRD_ID_LENGTH_MAX, "workers_cpu_%s", wu->name_lowercase);
3638
-
3639
- char context[RRD_ID_LENGTH_MAX + 1];
3640
- snprintf(context, RRD_ID_LENGTH_MAX, "netdata.workers.%s.cpu", wu->name_lowercase);
3641
-
3642
- wu->st_workers_cpu = rrdset_create_localhost(
3643
- "netdata"
3644
- , name
3645
- , NULL
3646
- , wu->family
3647
- , context
3648
- , "Netdata Workers CPU Utilization (100% = all workers busy)"
3649
- , "%"
3650
- , "netdata"
3651
- , "stats"
3652
- , wu->priority + 1
3653
- , localhost->rrd_update_every
3654
- , RRDSET_TYPE_AREA
3655
- );
3656
- }
3657
-
3658
- if (unlikely(!wu->rd_workers_cpu_min && wu->workers_registered > 1))
3659
- wu->rd_workers_cpu_min = rrddim_add(wu->st_workers_cpu, "min", NULL, 1, WORKER_CHART_DECIMAL_PRECISION, RRD_ALGORITHM_ABSOLUTE);
3660
-
3661
- if (unlikely(!wu->rd_workers_cpu_max && wu->workers_registered > 1))
3662
- wu->rd_workers_cpu_max = rrddim_add(wu->st_workers_cpu, "max", NULL, 1, WORKER_CHART_DECIMAL_PRECISION, RRD_ALGORITHM_ABSOLUTE);
3663
-
3664
- if(unlikely(!wu->rd_workers_cpu_avg))
3665
- wu->rd_workers_cpu_avg = rrddim_add(wu->st_workers_cpu, "average", NULL, 1, WORKER_CHART_DECIMAL_PRECISION, RRD_ALGORITHM_ABSOLUTE);
3666
-
3667
- if(unlikely(wu->workers_cpu_min == WORKERS_MIN_PERCENT_DEFAULT)) wu->workers_cpu_min = 0.0;
3668
-
3669
- if(wu->rd_workers_cpu_min)
3670
- rrddim_set_by_pointer(wu->st_workers_cpu, wu->rd_workers_cpu_min, (collected_number)(wu->workers_cpu_min * WORKER_CHART_DECIMAL_PRECISION));
3671
-
3672
- if(wu->rd_workers_cpu_max)
3673
- rrddim_set_by_pointer(wu->st_workers_cpu, wu->rd_workers_cpu_max, (collected_number)(wu->workers_cpu_max * WORKER_CHART_DECIMAL_PRECISION));
3674
-
3675
- if(wu->workers_cpu_registered == 0)
3676
- rrddim_set_by_pointer(wu->st_workers_cpu, wu->rd_workers_cpu_avg, 0);
3677
- else
3678
- rrddim_set_by_pointer(wu->st_workers_cpu, wu->rd_workers_cpu_avg, (collected_number)( wu->workers_cpu_total * WORKER_CHART_DECIMAL_PRECISION / (NETDATA_DOUBLE)wu->workers_cpu_registered ));
3679
-
3680
- rrdset_done(wu->st_workers_cpu);
3681
- }
3682
-#endif
3683
-
3684
- // ----------------------------------------------------------------------
3685
-
3686
- if(unlikely(!wu->st_workers_jobs_per_job_type)) {
3687
- char name[RRD_ID_LENGTH_MAX + 1];
3688
- snprintfz(name, RRD_ID_LENGTH_MAX, "workers_jobs_by_type_%s", wu->name_lowercase);
3689
-
3690
- char context[RRD_ID_LENGTH_MAX + 1];
3691
- snprintf(context, RRD_ID_LENGTH_MAX, "netdata.workers.%s.jobs_started_by_type", wu->name_lowercase);
3692
-
3693
- wu->st_workers_jobs_per_job_type = rrdset_create_localhost(
3694
- "netdata"
3695
- , name
3696
- , NULL
3697
- , wu->family
3698
- , context
3699
- , "Netdata Workers Jobs Started by Type"
3700
- , "jobs"
3701
- , "netdata"
3702
- , "stats"
3703
- , wu->priority + 2
3704
- , localhost->rrd_update_every
3705
- , RRDSET_TYPE_STACKED
3706
- );
3707
- }
3708
-
3709
- {
3710
- size_t i;
3711
- for(i = 0; i <= wu->workers_max_job_id ;i++) {
3712
- if(unlikely(wu->per_job_type[i].type != WORKER_METRIC_IDLE_BUSY))
3713
- continue;
3714
-
3715
- if (wu->per_job_type[i].name) {
3716
-
3717
- if(unlikely(!wu->per_job_type[i].rd_jobs_started))
3718
- wu->per_job_type[i].rd_jobs_started = rrddim_add(wu->st_workers_jobs_per_job_type, string2str(wu->per_job_type[i].name), NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
3719
-
3720
- rrddim_set_by_pointer(wu->st_workers_jobs_per_job_type, wu->per_job_type[i].rd_jobs_started, (collected_number)(wu->per_job_type[i].jobs_started));
3721
- }
3722
- }
3723
- }
3724
-
3725
- rrdset_done(wu->st_workers_jobs_per_job_type);
3726
-
3727
- // ----------------------------------------------------------------------
3728
-
3729
- if(unlikely(!wu->st_workers_busy_per_job_type)) {
3730
- char name[RRD_ID_LENGTH_MAX + 1];
3731
- snprintfz(name, RRD_ID_LENGTH_MAX, "workers_busy_time_by_type_%s", wu->name_lowercase);
3732
-
3733
- char context[RRD_ID_LENGTH_MAX + 1];
3734
- snprintf(context, RRD_ID_LENGTH_MAX, "netdata.workers.%s.time_by_type", wu->name_lowercase);
3735
-
3736
- wu->st_workers_busy_per_job_type = rrdset_create_localhost(
3737
- "netdata"
3738
- , name
3739
- , NULL
3740
- , wu->family
3741
- , context
3742
- , "Netdata Workers Busy Time by Type"
3743
- , "ms"
3744
- , "netdata"
3745
- , "stats"
3746
- , wu->priority + 3
3747
- , localhost->rrd_update_every
3748
- , RRDSET_TYPE_STACKED
3749
- );
3750
- }
3751
-
3752
- {
3753
- size_t i;
3754
- for(i = 0; i <= wu->workers_max_job_id ;i++) {
3755
- if(unlikely(wu->per_job_type[i].type != WORKER_METRIC_IDLE_BUSY))
3756
- continue;
3757
-
3758
- if (wu->per_job_type[i].name) {
3759
-
3760
- if(unlikely(!wu->per_job_type[i].rd_busy_time))
3761
- wu->per_job_type[i].rd_busy_time = rrddim_add(wu->st_workers_busy_per_job_type, string2str(wu->per_job_type[i].name), NULL, 1, USEC_PER_MS, RRD_ALGORITHM_ABSOLUTE);
3762
-
3763
- rrddim_set_by_pointer(wu->st_workers_busy_per_job_type, wu->per_job_type[i].rd_busy_time, (collected_number)(wu->per_job_type[i].busy_time));
3764
- }
3765
- }
3766
- }
3767
-
3768
- rrdset_done(wu->st_workers_busy_per_job_type);
3769
-
3770
- // ----------------------------------------------------------------------
3771
-
3772
- if(wu->st_workers_threads || wu->workers_registered > 1) {
3773
- if(unlikely(!wu->st_workers_threads)) {
3774
- char name[RRD_ID_LENGTH_MAX + 1];
3775
- snprintfz(name, RRD_ID_LENGTH_MAX, "workers_threads_%s", wu->name_lowercase);
3776
-
3777
- char context[RRD_ID_LENGTH_MAX + 1];
3778
- snprintf(context, RRD_ID_LENGTH_MAX, "netdata.workers.%s.threads", wu->name_lowercase);
3779
-
3780
- wu->st_workers_threads = rrdset_create_localhost(
3781
- "netdata"
3782
- , name
3783
- , NULL
3784
- , wu->family
3785
- , context
3786
- , "Netdata Workers Threads"
3787
- , "threads"
3788
- , "netdata"
3789
- , "stats"
3790
- , wu->priority + 4
3791
- , localhost->rrd_update_every
3792
- , RRDSET_TYPE_STACKED
3793
- );
3794
-
3795
- wu->rd_workers_threads_free = rrddim_add(wu->st_workers_threads, "free", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
3796
- wu->rd_workers_threads_busy = rrddim_add(wu->st_workers_threads, "busy", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
3797
- }
3798
-
3799
- rrddim_set_by_pointer(wu->st_workers_threads, wu->rd_workers_threads_free, (collected_number)(wu->workers_registered - wu->workers_busy));
3800
- rrddim_set_by_pointer(wu->st_workers_threads, wu->rd_workers_threads_busy, (collected_number)(wu->workers_busy));
3801
- rrdset_done(wu->st_workers_threads);
3802
- }
3803
-
3804
- // ----------------------------------------------------------------------
3805
- // custom metric types WORKER_METRIC_ABSOLUTE
3806
-
3807
- {
3808
- size_t i;
3809
- for (i = 0; i <= wu->workers_max_job_id; i++) {
3810
- if(wu->per_job_type[i].type != WORKER_METRIC_ABSOLUTE)
3811
- continue;
3812
-
3813
- if(!wu->per_job_type[i].count_value)
3814
- continue;
3815
-
3816
- if(!wu->per_job_type[i].st) {
3817
- size_t job_name_len = string_strlen(wu->per_job_type[i].name);
3818
- if(job_name_len > RRD_ID_LENGTH_MAX) job_name_len = RRD_ID_LENGTH_MAX;
3819
-
3820
- char job_name_sanitized[job_name_len + 1];
3821
- rrdset_strncpyz_name(job_name_sanitized, string2str(wu->per_job_type[i].name), job_name_len);
3822
-
3823
- char name[RRD_ID_LENGTH_MAX + 1];
3824
- snprintfz(name, RRD_ID_LENGTH_MAX, "workers_%s_value_%s", wu->name_lowercase, job_name_sanitized);
3825
-
3826
- char context[RRD_ID_LENGTH_MAX + 1];
3827
- snprintf(context, RRD_ID_LENGTH_MAX, "netdata.workers.%s.value.%s", wu->name_lowercase, job_name_sanitized);
3828
-
3829
- char title[1000 + 1];
3830
- snprintf(title, 1000, "Netdata Workers %s value of %s", wu->name_lowercase, string2str(wu->per_job_type[i].name));
3831
-
3832
- wu->per_job_type[i].st = rrdset_create_localhost(
3833
- "netdata"
3834
- , name
3835
- , NULL
3836
- , wu->family
3837
- , context
3838
- , title
3839
- , (wu->per_job_type[i].units)?string2str(wu->per_job_type[i].units):"value"
3840
- , "netdata"
3841
- , "stats"
3842
- , wu->priority + 5 + i
3843
- , localhost->rrd_update_every
3844
- , RRDSET_TYPE_LINE
3845
- );
3846
-
3847
- wu->per_job_type[i].rd_min = rrddim_add(wu->per_job_type[i].st, "min", NULL, 1, WORKER_CHART_DECIMAL_PRECISION, RRD_ALGORITHM_ABSOLUTE);
3848
- wu->per_job_type[i].rd_max = rrddim_add(wu->per_job_type[i].st, "max", NULL, 1, WORKER_CHART_DECIMAL_PRECISION, RRD_ALGORITHM_ABSOLUTE);
3849
- wu->per_job_type[i].rd_avg = rrddim_add(wu->per_job_type[i].st, "average", NULL, 1, WORKER_CHART_DECIMAL_PRECISION, RRD_ALGORITHM_ABSOLUTE);
3850
- }
3851
-
3852
- rrddim_set_by_pointer(wu->per_job_type[i].st, wu->per_job_type[i].rd_min, (collected_number)(wu->per_job_type[i].min_value * WORKER_CHART_DECIMAL_PRECISION));
3853
- rrddim_set_by_pointer(wu->per_job_type[i].st, wu->per_job_type[i].rd_max, (collected_number)(wu->per_job_type[i].max_value * WORKER_CHART_DECIMAL_PRECISION));
3854
- rrddim_set_by_pointer(wu->per_job_type[i].st, wu->per_job_type[i].rd_avg, (collected_number)(wu->per_job_type[i].sum_value / wu->per_job_type[i].count_value * WORKER_CHART_DECIMAL_PRECISION));
3855
-
3856
- rrdset_done(wu->per_job_type[i].st);
3857
- }
3858
- }
3859
-
3860
- // ----------------------------------------------------------------------
3861
- // custom metric types WORKER_METRIC_INCREMENTAL
3862
-
3863
- {
3864
- size_t i;
3865
- for (i = 0; i <= wu->workers_max_job_id ; i++) {
3866
- if(wu->per_job_type[i].type != WORKER_METRIC_INCREMENT && wu->per_job_type[i].type != WORKER_METRIC_INCREMENTAL_TOTAL)
3867
- continue;
3868
-
3869
- if(!wu->per_job_type[i].count_value)
3870
- continue;
3871
-
3872
- if(!wu->per_job_type[i].st) {
3873
- size_t job_name_len = string_strlen(wu->per_job_type[i].name);
3874
- if(job_name_len > RRD_ID_LENGTH_MAX) job_name_len = RRD_ID_LENGTH_MAX;
3875
-
3876
- char job_name_sanitized[job_name_len + 1];
3877
- rrdset_strncpyz_name(job_name_sanitized, string2str(wu->per_job_type[i].name), job_name_len);
3878
-
3879
- char name[RRD_ID_LENGTH_MAX + 1];
3880
- snprintfz(name, RRD_ID_LENGTH_MAX, "workers_%s_rate_%s", wu->name_lowercase, job_name_sanitized);
3881
-
3882
- char context[RRD_ID_LENGTH_MAX + 1];
3883
- snprintf(context, RRD_ID_LENGTH_MAX, "netdata.workers.%s.rate.%s", wu->name_lowercase, job_name_sanitized);
3884
-
3885
- char title[1000 + 1];
3886
- snprintf(title, 1000, "Netdata Workers %s rate of %s", wu->name_lowercase, string2str(wu->per_job_type[i].name));
3887
-
3888
- wu->per_job_type[i].st = rrdset_create_localhost(
3889
- "netdata"
3890
- , name
3891
- , NULL
3892
- , wu->family
3893
- , context
3894
- , title
3895
- , (wu->per_job_type[i].units)?string2str(wu->per_job_type[i].units):"rate"
3896
- , "netdata"
3897
- , "stats"
3898
- , wu->priority + 5 + i
3899
- , localhost->rrd_update_every
3900
- , RRDSET_TYPE_LINE
3901
- );
3902
-
3903
- wu->per_job_type[i].rd_min = rrddim_add(wu->per_job_type[i].st, "min", NULL, 1, WORKER_CHART_DECIMAL_PRECISION, RRD_ALGORITHM_ABSOLUTE);
3904
- wu->per_job_type[i].rd_max = rrddim_add(wu->per_job_type[i].st, "max", NULL, 1, WORKER_CHART_DECIMAL_PRECISION, RRD_ALGORITHM_ABSOLUTE);
3905
- wu->per_job_type[i].rd_avg = rrddim_add(wu->per_job_type[i].st, "average", NULL, 1, WORKER_CHART_DECIMAL_PRECISION, RRD_ALGORITHM_ABSOLUTE);
3906
- }
3907
-
3908
- rrddim_set_by_pointer(wu->per_job_type[i].st, wu->per_job_type[i].rd_min, (collected_number)(wu->per_job_type[i].min_value * WORKER_CHART_DECIMAL_PRECISION));
3909
- rrddim_set_by_pointer(wu->per_job_type[i].st, wu->per_job_type[i].rd_max, (collected_number)(wu->per_job_type[i].max_value * WORKER_CHART_DECIMAL_PRECISION));
3910
- rrddim_set_by_pointer(wu->per_job_type[i].st, wu->per_job_type[i].rd_avg, (collected_number)(wu->per_job_type[i].sum_value / wu->per_job_type[i].count_value * WORKER_CHART_DECIMAL_PRECISION));
3911
-
3912
- rrdset_done(wu->per_job_type[i].st);
3913
- }
3914
- }
3915
-}
3916
-
3917
-static void workers_utilization_reset_statistics(struct worker_utilization *wu) {
3918
- wu->workers_registered = 0;
3919
- wu->workers_busy = 0;
3920
- wu->workers_total_busy_time = 0;
3921
- wu->workers_total_duration = 0;
3922
- wu->workers_total_jobs_started = 0;
3923
- wu->workers_min_busy_time = WORKERS_MIN_PERCENT_DEFAULT;
3924
- wu->workers_max_busy_time = 0;
3925
-
3926
- wu->workers_cpu_registered = 0;
3927
- wu->workers_cpu_min = WORKERS_MIN_PERCENT_DEFAULT;
3928
- wu->workers_cpu_max = 0;
3929
- wu->workers_cpu_total = 0;
3930
-
3931
- size_t i;
3932
- for(i = 0; i < WORKER_UTILIZATION_MAX_JOB_TYPES ;i++) {
3933
- if(unlikely(!wu->name_lowercase)) {
3934
- wu->name_lowercase = strdupz(wu->name);
3935
- char *s = wu->name_lowercase;
3936
- for( ; *s ; s++) *s = tolower(*s);
3937
- }
3938
-
3939
- wu->per_job_type[i].jobs_started = 0;
3940
- wu->per_job_type[i].busy_time = 0;
3941
-
3942
- wu->per_job_type[i].min_value = NAN;
3943
- wu->per_job_type[i].max_value = NAN;
3944
- wu->per_job_type[i].sum_value = NAN;
3945
- wu->per_job_type[i].count_value = 0;
3946
- }
3947
-
3948
- struct worker_thread *wt;
3949
- for(wt = wu->threads; wt ; wt = wt->next) {
3950
- wt->enabled = false;
3951
- wt->cpu_enabled = false;
3952
- }
3953
-}
3954
-
3955
-#define TASK_STAT_PREFIX "/proc/self/task/"
3956
-#define TASK_STAT_SUFFIX "/stat"
3957
-
3958
-static int read_thread_cpu_time_from_proc_stat(pid_t pid __maybe_unused, kernel_uint_t *utime __maybe_unused, kernel_uint_t *stime __maybe_unused) {
3959
-#ifdef __linux__
3960
- static char filename[sizeof(TASK_STAT_PREFIX) + sizeof(TASK_STAT_SUFFIX) + 20] = TASK_STAT_PREFIX;
3961
- static size_t start_pos = sizeof(TASK_STAT_PREFIX) - 1;
3962
- static procfile *ff = NULL;
3963
-
3964
- // construct the filename
3965
- size_t end_pos = snprintfz(&filename[start_pos], 20, "%d", pid);
3966
- strcpy(&filename[start_pos + end_pos], TASK_STAT_SUFFIX);
3967
-
3968
- // (re)open the procfile to the new filename
3969
- bool set_quotes = (ff == NULL) ? true : false;
3970
- ff = procfile_reopen(ff, filename, NULL, PROCFILE_FLAG_ERROR_ON_ERROR_LOG);
3971
- if(unlikely(!ff)) return -1;
3972
-
3973
- if(set_quotes)
3974
- procfile_set_open_close(ff, "(", ")");
3975
-
3976
- // read the entire file and split it to lines and words
3977
- ff = procfile_readall(ff);
3978
- if(unlikely(!ff)) return -1;
3979
-
3980
- // parse the numbers we are interested
3981
- *utime = str2kernel_uint_t(procfile_lineword(ff, 0, 13));
3982
- *stime = str2kernel_uint_t(procfile_lineword(ff, 0, 14));
3983
-
3984
- // leave the file open for the next iteration
3985
-
3986
- return 0;
3987
-#else
3988
- // TODO: add here cpu time detection per thread, for FreeBSD and MacOS
3989
- *utime = 0;
3990
- *stime = 0;
3991
- return 1;
3992
-#endif
3993
-}
3994
-
3995
-static Pvoid_t workers_by_pid_JudyL_array = NULL;
3996
-
3997
-static void workers_threads_cleanup(struct worker_utilization *wu) {
3998
- struct worker_thread *t = wu->threads;
3999
- while(t) {
4000
- struct worker_thread *next = t->next;
4001
-
4002
- if(!t->enabled) {
4003
- JudyLDel(&workers_by_pid_JudyL_array, t->pid, PJE0);
4004
- DOUBLE_LINKED_LIST_REMOVE_ITEM_UNSAFE(wu->threads, t, prev, next);
4005
- freez(t);
4006
- }
4007
- t = next;
4008
- }
4009
- }
4010
-
4011
-static struct worker_thread *worker_thread_find(struct worker_utilization *wu __maybe_unused, pid_t pid) {
4012
- struct worker_thread *wt = NULL;
4013
-
4014
- Pvoid_t *PValue = JudyLGet(workers_by_pid_JudyL_array, pid, PJE0);
4015
- if(PValue)
4016
- wt = *PValue;
4017
-
4018
- return wt;
4019
-}
4020
-
4021
-static struct worker_thread *worker_thread_create(struct worker_utilization *wu, pid_t pid) {
4022
- struct worker_thread *wt;
4023
-
4024
- wt = (struct worker_thread *)callocz(1, sizeof(struct worker_thread));
4025
- wt->pid = pid;
4026
-
4027
- Pvoid_t *PValue = JudyLIns(&workers_by_pid_JudyL_array, pid, PJE0);
4028
- *PValue = wt;
4029
-
4030
- // link it
4031
- DOUBLE_LINKED_LIST_APPEND_ITEM_UNSAFE(wu->threads, wt, prev, next);
4032
-
4033
- return wt;
4034
-}
4035
-
4036
-static struct worker_thread *worker_thread_find_or_create(struct worker_utilization *wu, pid_t pid) {
4037
- struct worker_thread *wt;
4038
- wt = worker_thread_find(wu, pid);
4039
- if(!wt) wt = worker_thread_create(wu, pid);
4040
-
4041
- return wt;
4042
-}
4043
-
4044
-static void worker_utilization_charts_callback(void *ptr
4045
- , pid_t pid __maybe_unused
4046
- , const char *thread_tag __maybe_unused
4047
- , size_t max_job_id __maybe_unused
4048
- , size_t utilization_usec __maybe_unused
4049
- , size_t duration_usec __maybe_unused
4050
- , size_t jobs_started __maybe_unused
4051
- , size_t is_running __maybe_unused
4052
- , STRING **job_types_names __maybe_unused
4053
- , STRING **job_types_units __maybe_unused
4054
- , WORKER_METRIC_TYPE *job_types_metric_types __maybe_unused
4055
- , size_t *job_types_jobs_started __maybe_unused
4056
- , usec_t *job_types_busy_time __maybe_unused
4057
- , NETDATA_DOUBLE *job_types_custom_metrics __maybe_unused
4058
- ) {
4059
- struct worker_utilization *wu = (struct worker_utilization *)ptr;
4060
-
4061
- // find the worker_thread in the list
4062
- struct worker_thread *wt = worker_thread_find_or_create(wu, pid);
4063
-
4064
- if(utilization_usec > duration_usec)
4065
- utilization_usec = duration_usec;
4066
-
4067
- wt->enabled = true;
4068
- wt->busy_time = utilization_usec;
4069
- wt->jobs_started = jobs_started;
4070
-
4071
- wt->utime_old = wt->utime;
4072
- wt->stime_old = wt->stime;
4073
- wt->collected_time_old = wt->collected_time;
4074
-
4075
- if(max_job_id > wu->workers_max_job_id)
4076
- wu->workers_max_job_id = max_job_id;
4077
-
4078
- wu->workers_total_busy_time += utilization_usec;
4079
- wu->workers_total_duration += duration_usec;
4080
- wu->workers_total_jobs_started += jobs_started;
4081
- wu->workers_busy += is_running;
4082
- wu->workers_registered++;
4083
-
4084
- double util = (double)utilization_usec * 100.0 / (double)duration_usec;
4085
- if(util > wu->workers_max_busy_time)
4086
- wu->workers_max_busy_time = util;
4087
-
4088
- if(util < wu->workers_min_busy_time)
4089
- wu->workers_min_busy_time = util;
4090
-
4091
- // accumulate per job type statistics
4092
- size_t i;
4093
- for(i = 0; i <= max_job_id ;i++) {
4094
- if(!wu->per_job_type[i].name && job_types_names[i])
4095
- wu->per_job_type[i].name = string_dup(job_types_names[i]);
4096
-
4097
- if(!wu->per_job_type[i].units && job_types_units[i])
4098
- wu->per_job_type[i].units = string_dup(job_types_units[i]);
4099
-
4100
- wu->per_job_type[i].type = job_types_metric_types[i];
4101
-
4102
- wu->per_job_type[i].jobs_started += job_types_jobs_started[i];
4103
- wu->per_job_type[i].busy_time += job_types_busy_time[i];
4104
-
4105
- NETDATA_DOUBLE value = job_types_custom_metrics[i];
4106
- if(netdata_double_isnumber(value)) {
4107
- if(!wu->per_job_type[i].count_value) {
4108
- wu->per_job_type[i].count_value = 1;
4109
- wu->per_job_type[i].min_value = value;
4110
- wu->per_job_type[i].max_value = value;
4111
- wu->per_job_type[i].sum_value = value;
4112
- }
4113
- else {
4114
- wu->per_job_type[i].count_value++;
4115
- wu->per_job_type[i].sum_value += value;
4116
- if(value < wu->per_job_type[i].min_value) wu->per_job_type[i].min_value = value;
4117
- if(value > wu->per_job_type[i].max_value) wu->per_job_type[i].max_value = value;
4118
- }
4119
- }
4120
- }
4121
-
4122
- // find its CPU utilization
4123
- if((!read_thread_cpu_time_from_proc_stat(pid, &wt->utime, &wt->stime))) {
4124
- wt->collected_time = now_realtime_usec();
4125
- usec_t delta = wt->collected_time - wt->collected_time_old;
4126
-
4127
- double utime = (double)(wt->utime - wt->utime_old) / (double)system_hz * 100.0 * (double)USEC_PER_SEC / (double)delta;
4128
- double stime = (double)(wt->stime - wt->stime_old) / (double)system_hz * 100.0 * (double)USEC_PER_SEC / (double)delta;
4129
- double cpu = utime + stime;
4130
- wt->cpu = cpu;
4131
- wt->cpu_enabled = true;
4132
-
4133
- wu->workers_cpu_total += cpu;
4134
- if(cpu < wu->workers_cpu_min) wu->workers_cpu_min = cpu;
4135
- if(cpu > wu->workers_cpu_max) wu->workers_cpu_max = cpu;
4136
- }
4137
- wu->workers_cpu_registered += (wt->cpu_enabled) ? 1 : 0;
4138
-}
4139
-
4140
-static void worker_utilization_charts(void) {
4141
- static size_t iterations = 0;
4142
- iterations++;
4143
-
4144
- for(int i = 0; all_workers_utilization[i].name ;i++) {
4145
- workers_utilization_reset_statistics(&all_workers_utilization[i]);
4146
-
4147
- workers_foreach(all_workers_utilization[i].name, worker_utilization_charts_callback, &all_workers_utilization[i]);
4148
-
4149
- // skip the first iteration, so that we don't accumulate startup utilization to our charts
4150
- if(likely(iterations > 1))
4151
- workers_utilization_update_chart(&all_workers_utilization[i]);
4152
-
4153
- workers_threads_cleanup(&all_workers_utilization[i]);
4154
- }
4155
-
4156
- workers_total_cpu_utilization_chart();
4157
-}
4158
-
4159
-static void worker_utilization_finish(void) {
4160
- int i, j;
4161
- for(i = 0; all_workers_utilization[i].name ;i++) {
4162
- struct worker_utilization *wu = &all_workers_utilization[i];
4163
-
4164
- if(wu->name_lowercase) {
4165
- freez(wu->name_lowercase);
4166
- wu->name_lowercase = NULL;
4167
- }
4168
-
4169
- for(j = 0; j < WORKER_UTILIZATION_MAX_JOB_TYPES ;j++) {
4170
- string_freez(wu->per_job_type[j].name);
4171
- wu->per_job_type[j].name = NULL;
4172
-
4173
- string_freez(wu->per_job_type[j].units);
4174
- wu->per_job_type[j].units = NULL;
4175
- }
4176
-
4177
- // mark all threads as not enabled
4178
- struct worker_thread *t;
4179
- for(t = wu->threads; t ; t = t->next)
4180
- t->enabled = false;
4181
-
4182
- // let the cleanup job free them
4183
- workers_threads_cleanup(wu);
4184
- }
4185
-}
4186
-
4187
-// ---------------------------------------------------------------------------------------------------------------------
4188
-// global statistics thread
4189
-
4190
-
4191
-static void global_statistics_register_workers(void) {
4192
- worker_register("STATS");
4193
- worker_register_job_name(WORKER_JOB_GLOBAL, "global");
4194
- worker_register_job_name(WORKER_JOB_GLOBAL_EXT, "global_ext");
4195
- worker_register_job_name(WORKER_JOB_REGISTRY, "registry");
4196
- worker_register_job_name(WORKER_JOB_DBENGINE, "dbengine");
4197
- worker_register_job_name(WORKER_JOB_STRINGS, "strings");
4198
- worker_register_job_name(WORKER_JOB_DICTIONARIES, "dictionaries");
4199
- worker_register_job_name(WORKER_JOB_MALLOC_TRACE, "malloc_trace");
4200
- worker_register_job_name(WORKER_JOB_WORKERS, "workers");
4201
- worker_register_job_name(WORKER_JOB_SQLITE3, "sqlite3");
4202
-}
4203
-
4204
-static void global_statistics_cleanup(void *pptr)
4205
-{
4206
- struct netdata_static_thread *static_thread = CLEANUP_FUNCTION_GET_PTR(pptr);
4207
- if(!static_thread) return;
4208
-
4209
- static_thread->enabled = NETDATA_MAIN_THREAD_EXITING;
4210
-
4211
- worker_unregister();
4212
- netdata_log_info("cleaning up...");
4213
-
4214
- static_thread->enabled = NETDATA_MAIN_THREAD_EXITED;
4215
-}
4216
-
4217
-void *global_statistics_main(void *ptr)
4218
-{
4219
- CLEANUP_FUNCTION_REGISTER(global_statistics_cleanup) cleanup_ptr = ptr;
4220
-
4221
- global_statistics_register_workers();
4222
-
4223
- int update_every =
4224
- (int)config_get_duration_seconds(CONFIG_SECTION_GLOBAL_STATISTICS, "update every", localhost->rrd_update_every);
4225
- if (update_every < localhost->rrd_update_every) {
4226
- update_every = localhost->rrd_update_every;
4227
- config_set_duration_seconds(CONFIG_SECTION_GLOBAL_STATISTICS, "update every", update_every);
4228
- }
4229
-
4230
- usec_t step = update_every * USEC_PER_SEC;
4231
- heartbeat_t hb;
4232
- heartbeat_init(&hb, USEC_PER_SEC);
4233
- usec_t real_step = USEC_PER_SEC;
4234
-
4235
- // keep the randomness at zero
4236
- // to make sure we are not close to any other thread
4237
- hb.randomness = 0;
4238
-
4239
- while (service_running(SERVICE_COLLECTORS)) {
4240
- worker_is_idle();
4241
- heartbeat_next(&hb);
4242
- if (real_step < step) {
4243
- real_step += USEC_PER_SEC;
4244
- continue;
4245
- }
4246
- real_step = USEC_PER_SEC;
4247
-
4248
- worker_is_busy(WORKER_JOB_GLOBAL);
4249
- global_statistics_charts();
4250
- }
4251
-
4252
- return NULL;
4253
-}
4254
-
4255
-
4256
-// ---------------------------------------------------------------------------------------------------------------------
4257
-// global statistics extended thread
4258
-
4259
-static void global_statistics_extended_cleanup(void *pptr)
4260
-{
4261
- struct netdata_static_thread *static_thread = CLEANUP_FUNCTION_GET_PTR(pptr);
4262
- if (!static_thread)
4263
- return;
4264
-
4265
- static_thread->enabled = NETDATA_MAIN_THREAD_EXITING;
4266
-
4267
- netdata_log_info("cleaning up...");
4268
-
4269
- worker_unregister();
4270
- worker_utilization_finish();
4271
-
4272
- static_thread->enabled = NETDATA_MAIN_THREAD_EXITED;
4273
-}
4274
-
4275
-void *global_statistics_extended_main(void *ptr)
4276
-{
4277
- CLEANUP_FUNCTION_REGISTER(global_statistics_extended_cleanup) cleanup_ptr = ptr;
4278
-
4279
- global_statistics_register_workers();
4280
-
4281
- int update_every =
4282
- (int)config_get_duration_seconds(CONFIG_SECTION_GLOBAL_STATISTICS, "update every", localhost->rrd_update_every);
4283
- if (update_every < localhost->rrd_update_every) {
4284
- update_every = localhost->rrd_update_every;
4285
- config_set_duration_seconds(CONFIG_SECTION_GLOBAL_STATISTICS, "update every", update_every);
4286
- }
4287
-
4288
- usec_t step = update_every * USEC_PER_SEC;
4289
- heartbeat_t hb;
4290
- heartbeat_init(&hb, USEC_PER_SEC);
4291
- usec_t real_step = USEC_PER_SEC;
4292
-
4293
- while (service_running(SERVICE_COLLECTORS)) {
4294
- worker_is_idle();
4295
- heartbeat_next(&hb);
4296
- if (real_step < step) {
4297
- real_step += USEC_PER_SEC;
4298
- continue;
4299
- }
4300
- real_step = USEC_PER_SEC;
4301
-
4302
- worker_is_busy(WORKER_JOB_HEARTBEAT);
4303
- update_heartbeat_charts();
4304
-
4305
- worker_is_busy(WORKER_JOB_GLOBAL_EXT);
4306
- global_statistics_extended_charts();
4307
-
4308
-#ifdef ENABLE_DBENGINE
4309
- if(dbengine_enabled) {
4310
- worker_is_busy(WORKER_JOB_DBENGINE);
4311
- dbengine2_statistics_charts();
4312
- }
4313
-#endif
4314
-
4315
- worker_is_busy(WORKER_JOB_REGISTRY);
4316
- registry_statistics();
4317
-
4318
- worker_is_busy(WORKER_JOB_STRINGS);
4319
- update_strings_charts();
4320
-
4321
-#ifdef DICT_WITH_STATS
4322
- worker_is_busy(WORKER_JOB_DICTIONARIES);
4323
- dictionary_statistics();
4324
-#endif
4325
-
4326
-#ifdef NETDATA_TRACE_ALLOCATIONS
4327
- worker_is_busy(WORKER_JOB_MALLOC_TRACE);
4328
- malloc_trace_statistics();
4329
-#endif
4330
-
4331
- worker_is_busy(WORKER_JOB_WORKERS);
4332
- worker_utilization_charts();
4333
-
4334
- worker_is_busy(WORKER_JOB_SQLITE3);
4335
- sqlite3_statistics_charts();
4336
- }
4337
-
4338
- return NULL;
4339
-}