0b43c2392 · cryptotaxi247/netdata-1

@@ -253,14 +253,16 @@ static inline void facets_histogram_value_names(BUFFER *wb, FACETS *facets __may

253 if(first_key)

254 buffer_json_add_array_item_string(wb, first_key);

255

256 - FACET_VALUE *v;

257 - dfe_start_read(k->values, v) {

258 - if(unlikely(!v->histogram))

259 - continue;

256 + if(k && k->values) {

257 + FACET_VALUE *v;

258 + dfe_start_read(k->values, v){

259 + if (unlikely(!v->histogram))

260 + continue;

261

261 - buffer_json_add_array_item_string(wb, v->name);

262 + buffer_json_add_array_item_string(wb, v->name);

263 + }

264 + dfe_done(v);

265 }

263 - dfe_done(v);

266 }

267 buffer_json_array_close(wb); // key

268 }

@@ -268,14 +270,16 @@ static inline void facets_histogram_value_names(BUFFER *wb, FACETS *facets __may

270 static inline void facets_histogram_value_units(BUFFER *wb, FACETS *facets __maybe_unused, FACET_KEY *k, const char *key) {

271 buffer_json_member_add_array(wb, key);

272 {

271 - FACET_VALUE *v;

272 - dfe_start_read(k->values, v) {

273 - if(unlikely(!v->histogram))

274 - continue;

273 + if(k && k->values) {

274 + FACET_VALUE *v;

275 + dfe_start_read(k->values, v){

276 + if (unlikely(!v->histogram))

277 + continue;

278

276 - buffer_json_add_array_item_string(wb, "events");

279 + buffer_json_add_array_item_string(wb, "events");

280 + }

281 + dfe_done(v);

282 }

278 - dfe_done(v);

283 }

284 buffer_json_array_close(wb); // key

285 }

@@ -283,14 +287,16 @@ static inline void facets_histogram_value_units(BUFFER *wb, FACETS *facets __may

287 static inline void facets_histogram_value_min(BUFFER *wb, FACETS *facets __maybe_unused, FACET_KEY *k, const char *key) {

288 buffer_json_member_add_array(wb, key);

289 {

286 - FACET_VALUE *v;

287 - dfe_start_read(k->values, v) {

288 - if(unlikely(!v->histogram))

289 - continue;

290 + if(k && k->values) {

291 + FACET_VALUE *v;

292 + dfe_start_read(k->values, v){

293 + if (unlikely(!v->histogram))

294 + continue;

295

291 - buffer_json_add_array_item_uint64(wb, v->min);

296 + buffer_json_add_array_item_uint64(wb, v->min);

297 + }

298 + dfe_done(v);

299 }

293 - dfe_done(v);

300 }

301 buffer_json_array_close(wb); // key

302 }

@@ -298,14 +304,16 @@ static inline void facets_histogram_value_min(BUFFER *wb, FACETS *facets __maybe

304 static inline void facets_histogram_value_max(BUFFER *wb, FACETS *facets __maybe_unused, FACET_KEY *k, const char *key) {

305 buffer_json_member_add_array(wb, key);

306 {

301 - FACET_VALUE *v;

302 - dfe_start_read(k->values, v) {

303 - if(unlikely(!v->histogram))

304 - continue;

307 + if(k && k->values) {

308 + FACET_VALUE *v;

309 + dfe_start_read(k->values, v){

310 + if (unlikely(!v->histogram))

311 + continue;

312

306 - buffer_json_add_array_item_uint64(wb, v->max);

307 - }

308 - dfe_done(v);

313 + buffer_json_add_array_item_uint64(wb, v->max);

314 + }

315 + dfe_done(v);

316 + }

317 }

318 buffer_json_array_close(wb); // key

319 }

@@ -313,14 +321,16 @@ static inline void facets_histogram_value_max(BUFFER *wb, FACETS *facets __maybe

321 static inline void facets_histogram_value_avg(BUFFER *wb, FACETS *facets __maybe_unused, FACET_KEY *k, const char *key) {

322 buffer_json_member_add_array(wb, key);

323 {

316 - FACET_VALUE *v;

317 - dfe_start_read(k->values, v) {

318 - if(unlikely(!v->histogram))

319 - continue;

324 + if(k && k->values) {

325 + FACET_VALUE *v;

326 + dfe_start_read(k->values, v){

327 + if (unlikely(!v->histogram))

328 + continue;

329

321 - buffer_json_add_array_item_double(wb, (double)v->sum / (double)facets->histogram.slots);

330 + buffer_json_add_array_item_double(wb, (double) v->sum / (double) facets->histogram.slots);

331 + }

332 + dfe_done(v);

333 }

323 - dfe_done(v);

334 }

335 buffer_json_array_close(wb); // key

336 }

@@ -328,14 +338,16 @@ static inline void facets_histogram_value_avg(BUFFER *wb, FACETS *facets __maybe

338 static inline void facets_histogram_value_arp(BUFFER *wb, FACETS *facets __maybe_unused, FACET_KEY *k, const char *key) {

339 buffer_json_member_add_array(wb, key);

340 {

331 - FACET_VALUE *v;

332 - dfe_start_read(k->values, v) {

333 - if(unlikely(!v->histogram))

334 - continue;

341 + if(k && k->values) {

342 + FACET_VALUE *v;

343 + dfe_start_read(k->values, v){

344 + if (unlikely(!v->histogram))

345 + continue;

346

336 - buffer_json_add_array_item_uint64(wb, 0);

347 + buffer_json_add_array_item_uint64(wb, 0);

348 + }

349 + dfe_done(v);

350 }

338 - dfe_done(v);

351 }

352 buffer_json_array_close(wb); // key

353 }

@@ -343,14 +355,16 @@ static inline void facets_histogram_value_arp(BUFFER *wb, FACETS *facets __maybe

355 static inline void facets_histogram_value_con(BUFFER *wb, FACETS *facets __maybe_unused, FACET_KEY *k, const char *key, uint32_t sum) {

356 buffer_json_member_add_array(wb, key);

357 {

346 - FACET_VALUE *v;

347 - dfe_start_read(k->values, v) {

348 - if(unlikely(!v->histogram))

349 - continue;

358 + if(k && k->values) {

359 + FACET_VALUE *v;

360 + dfe_start_read(k->values, v){

361 + if (unlikely(!v->histogram))

362 + continue;

363

351 - buffer_json_add_array_item_double(wb, (double)v->sum * 100.0 / (double)sum);

364 + buffer_json_add_array_item_double(wb, (double) v->sum * 100.0 / (double) sum);

365 + }

366 + dfe_done(v);

367 }

353 - dfe_done(v);

368 }

369 buffer_json_array_close(wb); // key

370 }

@@ -359,7 +373,7 @@ static void facets_histogram_generate(FACETS *facets, FACET_KEY *k, BUFFER *wb)

373 size_t dimensions = 0;

374 uint32_t min = UINT32_MAX, max = 0, sum = 0, count = 0;

375

362 - {

376 + if(k && k->values) {

377 FACET_VALUE *v;

378 dfe_start_read(k->values, v){

379 if (unlikely(!v->histogram))

@@ -395,9 +409,6 @@ static void facets_histogram_generate(FACETS *facets, FACET_KEY *k, BUFFER *wb)

409 dfe_done(v);

410 }

411

398 - if(!dimensions)

399 - return;

400 -

412 buffer_json_member_add_object(wb, "summary");

413 {

414 buffer_json_member_add_array(wb, "nodes");

@@ -414,26 +425,33 @@ static void facets_histogram_generate(FACETS *facets, FACET_KEY *k, BUFFER *wb)

425 buffer_json_member_add_string(wb, "msg", "");

426 }

427 buffer_json_object_close(wb); // st

417 - buffer_json_member_add_object(wb, "is");

418 - {

419 - buffer_json_member_add_uint64(wb, "sl", 1);

420 - buffer_json_member_add_uint64(wb, "qr", 1);

421 - }

422 - buffer_json_object_close(wb); // is

423 - buffer_json_member_add_object(wb, "ds");

424 - {

425 - buffer_json_member_add_uint64(wb, "sl", dimensions);

426 - buffer_json_member_add_uint64(wb, "qr", dimensions);

428 +

429 + if(dimensions) {

430 + buffer_json_member_add_object(wb, "is");

431 + {

432 + buffer_json_member_add_uint64(wb, "sl", 1);

433 + buffer_json_member_add_uint64(wb, "qr", 1);

434 + }

435 + buffer_json_object_close(wb); // is

436 +

437 + buffer_json_member_add_object(wb, "ds");

438 + {

439 + buffer_json_member_add_uint64(wb, "sl", dimensions);

440 + buffer_json_member_add_uint64(wb, "qr", dimensions);

441 + }

442 + buffer_json_object_close(wb); // ds

443 }

428 - buffer_json_object_close(wb); // ds

429 - buffer_json_member_add_object(wb, "sts");

430 - {

431 - buffer_json_member_add_uint64(wb, "min", min);

432 - buffer_json_member_add_uint64(wb, "max", max);

433 - buffer_json_member_add_double(wb, "avg", (double)sum / (double)count);

434 - buffer_json_member_add_double(wb, "con", 100.0);

444 +

445 + if(count) {

446 + buffer_json_member_add_object(wb, "sts");

447 + {

448 + buffer_json_member_add_uint64(wb, "min", min);

449 + buffer_json_member_add_uint64(wb, "max", max);

450 + buffer_json_member_add_double(wb, "avg", (double) sum / (double) count);

451 + buffer_json_member_add_double(wb, "con", 100.0);

452 + }

453 + buffer_json_object_close(wb); // sts

454 }

436 - buffer_json_object_close(wb); // sts

455 }

456 buffer_json_object_close(wb); // node

457 }

@@ -444,26 +462,33 @@ static void facets_histogram_generate(FACETS *facets, FACET_KEY *k, BUFFER *wb)

462 buffer_json_add_array_item_object(wb); // context

463 {

464 buffer_json_member_add_string(wb, "id", "facets.histogram");

447 - buffer_json_member_add_object(wb, "is");

448 - {

449 - buffer_json_member_add_uint64(wb, "sl", 1);

450 - buffer_json_member_add_uint64(wb, "qr", 1);

451 - }

452 - buffer_json_object_close(wb); // is

453 - buffer_json_member_add_object(wb, "ds");

454 - {

455 - buffer_json_member_add_uint64(wb, "sl", dimensions);

456 - buffer_json_member_add_uint64(wb, "qr", dimensions);

465 +

466 + if(dimensions) {

467 + buffer_json_member_add_object(wb, "is");

468 + {

469 + buffer_json_member_add_uint64(wb, "sl", 1);

470 + buffer_json_member_add_uint64(wb, "qr", 1);

471 + }

472 + buffer_json_object_close(wb); // is

473 +

474 + buffer_json_member_add_object(wb, "ds");

475 + {

476 + buffer_json_member_add_uint64(wb, "sl", dimensions);

477 + buffer_json_member_add_uint64(wb, "qr", dimensions);

478 + }

479 + buffer_json_object_close(wb); // ds

480 }

458 - buffer_json_object_close(wb); // ds

459 - buffer_json_member_add_object(wb, "sts");

460 - {

461 - buffer_json_member_add_uint64(wb, "min", min);

462 - buffer_json_member_add_uint64(wb, "max", max);

463 - buffer_json_member_add_double(wb, "avg", (double)sum / (double)count);

464 - buffer_json_member_add_double(wb, "con", 100.0);

481 +

482 + if(count) {

483 + buffer_json_member_add_object(wb, "sts");

484 + {

485 + buffer_json_member_add_uint64(wb, "min", min);

486 + buffer_json_member_add_uint64(wb, "max", max);

487 + buffer_json_member_add_double(wb, "avg", (double) sum / (double) count);

488 + buffer_json_member_add_double(wb, "con", 100.0);

489 + }

490 + buffer_json_object_close(wb); // sts

491 }

466 - buffer_json_object_close(wb); // sts

492 }

493 buffer_json_object_close(wb); // context

494 }

@@ -475,27 +500,33 @@ static void facets_histogram_generate(FACETS *facets, FACET_KEY *k, BUFFER *wb)

500 {

501 buffer_json_member_add_string(wb, "id", "facets.histogram");

502 buffer_json_member_add_uint64(wb, "ni", 0);

478 - buffer_json_member_add_object(wb, "ds");

479 - {

480 - buffer_json_member_add_uint64(wb, "sl", dimensions);

481 - buffer_json_member_add_uint64(wb, "qr", dimensions);

503 +

504 + if(dimensions) {

505 + buffer_json_member_add_object(wb, "ds");

506 + {

507 + buffer_json_member_add_uint64(wb, "sl", dimensions);

508 + buffer_json_member_add_uint64(wb, "qr", dimensions);

509 + }

510 + buffer_json_object_close(wb); // ds

511 }

483 - buffer_json_object_close(wb); // ds

484 - buffer_json_member_add_object(wb, "sts");

485 - {

486 - buffer_json_member_add_uint64(wb, "min", min);

487 - buffer_json_member_add_uint64(wb, "max", max);

488 - buffer_json_member_add_double(wb, "avg", (double)sum / (double)count);

489 - buffer_json_member_add_double(wb, "con", 100.0);

512 +

513 + if(count) {

514 + buffer_json_member_add_object(wb, "sts");

515 + {

516 + buffer_json_member_add_uint64(wb, "min", min);

517 + buffer_json_member_add_uint64(wb, "max", max);

518 + buffer_json_member_add_double(wb, "avg", (double) sum / (double) count);

519 + buffer_json_member_add_double(wb, "con", 100.0);

520 + }

521 + buffer_json_object_close(wb); // sts

522 }

491 - buffer_json_object_close(wb); // sts

523 }

524 buffer_json_object_close(wb); // instance

525 }

526 buffer_json_array_close(wb); // instances

527

528 buffer_json_member_add_array(wb, "dimensions");

498 - {

529 + if(dimensions && k && k->values) {

530 size_t pri = 0;

531 FACET_VALUE *v;

532 dfe_start_read(k->values, v) {

@@ -543,24 +574,28 @@ static void facets_histogram_generate(FACETS *facets, FACET_KEY *k, BUFFER *wb)

574 buffer_json_member_add_uint64(wb, "qr", 1);

575 }

576 buffer_json_object_close(wb); // nodes

546 - buffer_json_member_add_object(wb, "contexts");

547 - {

548 - buffer_json_member_add_uint64(wb, "sl", 1);

549 - buffer_json_member_add_uint64(wb, "qr", 1);

550 - }

551 - buffer_json_object_close(wb); // contexts

552 - buffer_json_member_add_object(wb, "instances");

553 - {

554 - buffer_json_member_add_uint64(wb, "sl", 1);

555 - buffer_json_member_add_uint64(wb, "qr", 1);

556 - }

557 - buffer_json_object_close(wb); // instances

558 - buffer_json_member_add_object(wb, "dimensions");

559 - {

560 - buffer_json_member_add_uint64(wb, "sl", dimensions);

561 - buffer_json_member_add_uint64(wb, "qr", dimensions);

577 +

578 + if(dimensions) {

579 + buffer_json_member_add_object(wb, "contexts");

580 + {

581 + buffer_json_member_add_uint64(wb, "sl", 1);

582 + buffer_json_member_add_uint64(wb, "qr", 1);

583 + }

584 + buffer_json_object_close(wb); // contexts

585 + buffer_json_member_add_object(wb, "instances");

586 + {

587 + buffer_json_member_add_uint64(wb, "sl", 1);

588 + buffer_json_member_add_uint64(wb, "qr", 1);

589 + }

590 + buffer_json_object_close(wb); // instances

591 +

592 + buffer_json_member_add_object(wb, "dimensions");

593 + {

594 + buffer_json_member_add_uint64(wb, "sl", dimensions);

595 + buffer_json_member_add_uint64(wb, "qr", dimensions);

596 + }

597 + buffer_json_object_close(wb); // dimension

598 }

563 - buffer_json_object_close(wb); // dimension

599 }

600 buffer_json_object_close(wb); // totals

601

@@ -577,7 +612,7 @@ static void facets_histogram_generate(FACETS *facets, FACET_KEY *k, BUFFER *wb)

612 buffer_json_object_close(wb); // point

613

614 buffer_json_member_add_array(wb, "data");

580 - {

615 + if(k && k->values) {

616 usec_t t = facets->histogram.after_ut;

617 for(uint32_t i = 0; i < facets->histogram.slots ;i++) {

618 buffer_json_add_array_item_array(wb); // row

@@ -585,8 +620,8 @@ static void facets_histogram_generate(FACETS *facets, FACET_KEY *k, BUFFER *wb)

620 buffer_json_add_array_item_time_ms(wb, t / USEC_PER_SEC);

621

622 FACET_VALUE *v;

588 - dfe_start_read(k->values, v) {

589 - if(unlikely(!v->histogram))

623 + dfe_start_read(k->values, v){

624 + if (unlikely(!v->histogram))

625 continue;

626

627 buffer_json_add_array_item_array(wb); // point

@@ -1615,17 +1650,15 @@ void facets_report(FACETS *facets, BUFFER *wb) {

1650 k = dictionary_get(facets->keys, id);

1651 }

1652

1618 - if(k && k->values) {

1619 - buffer_json_member_add_object(wb, "histogram");

1620 - {

1621 - buffer_json_member_add_string(wb, "id", id);

1622 - buffer_json_member_add_string(wb, "name", k->name);

1623 - buffer_json_member_add_object(wb, "chart");

1624 - facets_histogram_generate(facets, k, wb);

1625 - buffer_json_object_close(wb);

1626 - }

1627 - buffer_json_object_close(wb); // histogram

1653 + buffer_json_member_add_object(wb, "histogram");

1654 + {

1655 + buffer_json_member_add_string(wb, "id", id);

1656 + buffer_json_member_add_string(wb, "name", k->name);

1657 + buffer_json_member_add_object(wb, "chart");

1658 + facets_histogram_generate(facets, k, wb);

1659 + buffer_json_object_close(wb);

1660 }

1661 + buffer_json_object_close(wb); // histogram

1662 }

1663 }

1664

facets histogram when empty (#15970)