@cryptotaxi247 / netdata-1 / commits / 37bee1d19

Store uuid_t metric_uuid in the dimension state structure instead of uuid_t * (#11212)

Stelios Fragkakis committed Jun 1, 2021 at 14:26 UTC 37bee1d197229a4de1d6eac9942fc626f1da8ee3

9 files changed +36 -75

database/engine/rrdengineapi.c

+7 -14

@@ -49,7 +49,7 @@ void rrdeng_convert_legacy_uuid_to_multihost(char machine_guid[GUID_LEN + 1], uu

49 memcpy(ret_uuid, hash_value, sizeof(uuid_t));

50 }

52 -void rrdeng_metric_init(RRDDIM *rd, uuid_t *dim_uuid)

52 +void rrdeng_metric_init(RRDDIM *rd)

53 {

54 struct page_cache *pg_cache;

55 struct rrdengine_instance *ctx;

@@ -68,7 +68,6 @@ void rrdeng_metric_init(RRDDIM *rd, uuid_t *dim_uuid)

68 pg_cache = &ctx->pg_cache;

70 rrdeng_generate_legacy_uuid(rd->id, rd->rrdset->id, &legacy_uuid);

71 - rd->state->metric_uuid = dim_uuid;

71 if (host != localhost && host->rrdeng_ctx == &multidb_ctx)

72 is_multihost_child = 1;

@@ -82,20 +81,17 @@ void rrdeng_metric_init(RRDDIM *rd, uuid_t *dim_uuid)

81 /* First time we see the legacy UUID or metric belongs to child host in multi-host DB.

82 * Drop legacy support, normal path */

85 - if (unlikely(!rd->state->metric_uuid))

86 - rd->state->metric_uuid = create_dimension_uuid(rd->rrdset, rd);

87 -

84 uv_rwlock_rdlock(&pg_cache->metrics_index.lock);

89 - PValue = JudyHSGet(pg_cache->metrics_index.JudyHS_array, rd->state->metric_uuid, sizeof(uuid_t));

85 + PValue = JudyHSGet(pg_cache->metrics_index.JudyHS_array, &rd->state->metric_uuid, sizeof(uuid_t));

86 if (likely(NULL != PValue)) {

87 page_index = *PValue;

88 }

89 uv_rwlock_rdunlock(&pg_cache->metrics_index.lock);

90 if (NULL == PValue) {

91 uv_rwlock_wrlock(&pg_cache->metrics_index.lock);

96 - PValue = JudyHSIns(&pg_cache->metrics_index.JudyHS_array, rd->state->metric_uuid, sizeof(uuid_t), PJE0);

92 + PValue = JudyHSIns(&pg_cache->metrics_index.JudyHS_array, &rd->state->metric_uuid, sizeof(uuid_t), PJE0);

93 fatal_assert(NULL == *PValue); /* TODO: figure out concurrency model */

98 - *PValue = page_index = create_page_index(rd->state->metric_uuid);

94 + *PValue = page_index = create_page_index(&rd->state->metric_uuid);

95 page_index->prev = pg_cache->metrics_index.last_page_index;

96 pg_cache->metrics_index.last_page_index = page_index;

97 uv_rwlock_wrunlock(&pg_cache->metrics_index.lock);

@@ -106,15 +102,12 @@ void rrdeng_metric_init(RRDDIM *rd, uuid_t *dim_uuid)

102 rrdeng_convert_legacy_uuid_to_multihost(rd->rrdset->rrdhost->machine_guid, &legacy_uuid,

103 &multihost_legacy_uuid);

104

109 - if (unlikely(!rd->state->metric_uuid))

110 - rd->state->metric_uuid = mallocz(sizeof(uuid_t));

111 -

112 - int need_to_store = (dim_uuid == NULL || uuid_compare(*rd->state->metric_uuid, multihost_legacy_uuid));

105 + int need_to_store = uuid_compare(rd->state->metric_uuid, multihost_legacy_uuid);

106

114 - uuid_copy(*rd->state->metric_uuid, multihost_legacy_uuid);

107 + uuid_copy(rd->state->metric_uuid, multihost_legacy_uuid);

108

109 if (unlikely(need_to_store))

117 - (void)sql_store_dimension(rd->state->metric_uuid, rd->rrdset->chart_uuid, rd->id, rd->name, rd->multiplier, rd->divisor,

110 + (void)sql_store_dimension(&rd->state->metric_uuid, rd->rrdset->chart_uuid, rd->id, rd->name, rd->multiplier, rd->divisor,

111 rd->algorithm);

112

113 }

database/engine/rrdengineapi.h

+1 -1

@@ -36,7 +36,7 @@ extern void rrdeng_convert_legacy_uuid_to_multihost(char machine_guid[GUID_LEN +

36 uuid_t *ret_uuid);

39 -extern void rrdeng_metric_init(RRDDIM *rd, uuid_t *dim_uuid);

39 +extern void rrdeng_metric_init(RRDDIM *rd);

40 extern void rrdeng_store_metric_init(RRDDIM *rd);

41 extern void rrdeng_store_metric_flush_current_page(RRDDIM *rd);

42 extern void rrdeng_store_metric_next(RRDDIM *rd, usec_t point_in_time, storage_number number);

database/rrd.h

+1 -1

@@ -384,7 +384,7 @@ struct rrddim_volatile {

384 uuid_t *rrdeng_uuid; // database engine metric UUID

385 struct pg_cache_page_index *page_index;

386 #endif

387 - uuid_t *metric_uuid; // global UUID for this metric (unique_across hosts)

387 + uuid_t metric_uuid; // global UUID for this metric (unique_across hosts)

388 union rrddim_collect_handle handle;

389 // ------------------------------------------------------------------------

390 // function pointers that handle data collection

database/rrddim.c

+6 -10

@@ -232,7 +232,7 @@ RRDDIM *rrddim_add_custom(RRDSET *st, const char *id, const char *name, collecte

232 rc += rrddim_set_multiplier(st, rd, multiplier);

233 rc += rrddim_set_divisor(st, rd, divisor);

234 if (rrddim_flag_check(rd, RRDDIM_FLAG_ARCHIVED)) {

235 - store_active_dimension(rd->state->metric_uuid);

235 + store_active_dimension(&rd->state->metric_uuid);

236 rd->state->collect_ops.init(rd);

237 rrddim_flag_clear(rd, RRDDIM_FLAG_ARCHIVED);

238 rrddimvar_create(rd, RRDVAR_TYPE_CALCULATED, NULL, NULL, &rd->last_stored_value, RRDVAR_OPTION_DEFAULT);

@@ -242,7 +242,7 @@ RRDDIM *rrddim_add_custom(RRDSET *st, const char *id, const char *name, collecte

242 }

243 if (unlikely(rc)) {

244 debug(D_METADATALOG, "DIMENSION [%s] metadata updated", rd->id);

245 - (void)sql_store_dimension(rd->state->metric_uuid, rd->rrdset->chart_uuid, rd->id, rd->name, rd->multiplier, rd->divisor,

245 + (void)sql_store_dimension(&rd->state->metric_uuid, rd->rrdset->chart_uuid, rd->id, rd->name, rd->multiplier, rd->divisor,

246 rd->algorithm);

247 }

248 rrdset_unlock(st);

@@ -387,10 +387,10 @@ RRDDIM *rrddim_add_custom(RRDSET *st, const char *id, const char *name, collecte

387 rd->last_collected_time.tv_usec = 0;

388 rd->rrdset = st;

389 rd->state = mallocz(sizeof(*rd->state));

390 + (void) find_dimension_uuid(st, rd, &(rd->state->metric_uuid));

391 if(memory_mode == RRD_MEMORY_MODE_DBENGINE) {

392 #ifdef ENABLE_DBENGINE

392 - uuid_t *dim_uuid = find_dimension_uuid(st, rd);

393 - rrdeng_metric_init(rd, dim_uuid);

393 + rrdeng_metric_init(rd);

394 rd->state->collect_ops.init = rrdeng_store_metric_init;

395 rd->state->collect_ops.store_metric = rrdeng_store_metric_next;

396 rd->state->collect_ops.finalize = rrdeng_store_metric_finalize;

@@ -402,9 +402,6 @@ RRDDIM *rrddim_add_custom(RRDSET *st, const char *id, const char *name, collecte

402 rd->state->query_ops.oldest_time = rrdeng_metric_oldest_time;

403 #endif

404 } else {

405 - rd->state->metric_uuid = find_dimension_uuid(st, rd);

406 - if (unlikely(!rd->state->metric_uuid))

407 - rd->state->metric_uuid = create_dimension_uuid(rd->rrdset, rd);

405 rd->state->collect_ops.init = rrddim_collect_init;

406 rd->state->collect_ops.store_metric = rrddim_collect_store_metric;

407 rd->state->collect_ops.finalize = rrddim_collect_finalize;

@@ -415,7 +412,7 @@ RRDDIM *rrddim_add_custom(RRDSET *st, const char *id, const char *name, collecte

412 rd->state->query_ops.latest_time = rrddim_query_latest_time;

413 rd->state->query_ops.oldest_time = rrddim_query_oldest_time;

414 }

418 - store_active_dimension(rd->state->metric_uuid);

415 + store_active_dimension(&rd->state->metric_uuid);

416 rd->state->collect_ops.init(rd);

417 // append this dimension

418 if(!st->dimensions)

@@ -475,7 +472,7 @@ void rrddim_free_custom(RRDSET *st, RRDDIM *rd, int db_rotated)

472 uint8_t can_delete_metric = rd->state->collect_ops.finalize(rd);

473 if (can_delete_metric && rd->rrd_memory_mode == RRD_MEMORY_MODE_DBENGINE) {

474 /* This metric has no data and no references */

478 - delete_dimension_uuid(rd->state->metric_uuid);

475 + delete_dimension_uuid(&rd->state->metric_uuid);

476 }

477 }

478

@@ -499,7 +496,6 @@ void rrddim_free_custom(RRDSET *st, RRDDIM *rd, int db_rotated)

496 error("RRDDIM: INTERNAL ERROR: attempt to remove from index dimension '%s' on chart '%s', removed a different dimension.", rd->id, st->id);

497

498 // free(rd->annotations);

502 - freez(rd->state->metric_uuid);

499

500 RRD_MEMORY_MODE rrd_memory_mode = rd->rrd_memory_mode;

501 switch(rrd_memory_mode) {

database/rrdhost.c

+1 -1

@@ -1417,7 +1417,7 @@ restart_after_removal:

1417 uint8_t can_delete_metric = rd->state->collect_ops.finalize(rd);

1418 if (can_delete_metric) {

1419 /* This metric has no data and no references */

1420 - delete_dimension_uuid(rd->state->metric_uuid);

1420 + delete_dimension_uuid(&rd->state->metric_uuid);

1421 rrddim_free(st, rd);

1422 if (unlikely(!last)) {

1423 rd = st->dimensions;

database/rrdset.c

+1 -1

@@ -1886,7 +1886,7 @@ after_second_database_work:

1886 uint8_t can_delete_metric = rd->state->collect_ops.finalize(rd);

1887 if (can_delete_metric) {

1888 /* This metric has no data and no references */

1889 - delete_dimension_uuid(rd->state->metric_uuid);

1889 + delete_dimension_uuid(&rd->state->metric_uuid);

1890 } else {

1891 /* Do not delete this dimension */

1892 last = rd;

database/sqlite/sqlite_functions.c

+15 -40

@@ -246,20 +246,20 @@ bind_fail:

246 return 0;

247 }

248

249 -uuid_t *find_dimension_uuid(RRDSET *st, RRDDIM *rd)

249 +int find_dimension_uuid(RRDSET *st, RRDDIM *rd, uuid_t *store_uuid)

250 {

251 static __thread sqlite3_stmt *res = NULL;

252 - uuid_t *uuid = NULL;

252 int rc;

253 + int status = 1;

254

255 if (unlikely(!db_meta) && default_rrd_memory_mode != RRD_MEMORY_MODE_DBENGINE)

256 - return NULL;

256 + return 1;

257

258 if (unlikely(!res)) {

259 rc = prepare_statement(db_meta, SQL_FIND_DIMENSION_UUID, &res);

260 if (rc != SQLITE_OK) {

261 error_report("Failed to bind prepare statement to lookup dimension UUID in the database");

262 - return NULL;

262 + return 1;

263 }

264 }

265

@@ -277,49 +277,24 @@ uuid_t *find_dimension_uuid(RRDSET *st, RRDDIM *rd)

277

278 rc = sqlite3_step(res);

279 if (likely(rc == SQLITE_ROW)) {

280 - uuid = mallocz(sizeof(uuid_t));

281 - uuid_copy(*uuid, sqlite3_column_blob(res, 0));

280 + uuid_copy(*store_uuid, *((uuid_t *) sqlite3_column_blob(res, 0)));

281 + status = 0;

282 + }

283 + else {

284 + uuid_generate(*store_uuid);

285 + status = sql_store_dimension(store_uuid, st->chart_uuid, rd->id, rd->name, rd->multiplier, rd->divisor, rd->algorithm);

286 + if (unlikely(status))

287 + error_report("Failed to store dimension metadata in the database");

288 }

289

290 rc = sqlite3_reset(res);

291 if (unlikely(rc != SQLITE_OK))

292 error_report("Failed to reset statement find dimension uuid, rc = %d", rc);

287 -

288 -#ifdef NETDATA_INTERNAL_CHECKS

289 - char uuid_str[GUID_LEN + 1];

290 - if (likely(uuid)) {

291 - uuid_unparse_lower(*uuid, uuid_str);

292 - debug(D_METADATALOG, "Found UUID %s for dimension %s", uuid_str, rd->name);

293 - }

294 - else

295 - debug(D_METADATALOG, "UUID not found for dimension %s", rd->name);

296 -#endif

297 - return uuid;

293 + return status;

294

295 bind_fail:

296 error_report("Failed to bind input parameter to perform dimension UUID database lookup, rc = %d", rc);

301 - return NULL;

302 -}

303 -

304 -uuid_t *create_dimension_uuid(RRDSET *st, RRDDIM *rd)

305 -{

306 - uuid_t *uuid = NULL;

307 - int rc;

308 -

309 - uuid = mallocz(sizeof(uuid_t));

310 - uuid_generate(*uuid);

311 -

312 -#ifdef NETDATA_INTERNAL_CHECKS

313 - char uuid_str[GUID_LEN + 1];

314 - uuid_unparse_lower(*uuid, uuid_str);

315 - debug(D_METADATALOG,"Generating uuid [%s] for dimension %s under chart %s", uuid_str, rd->name, st->id);

316 -#endif

317 -

318 - rc = sql_store_dimension(uuid, st->chart_uuid, rd->id, rd->name, rd->multiplier, rd->divisor, rd->algorithm);

319 - if (unlikely(rc))

320 - error_report("Failed to store dimension metadata in the database");

321 -

322 - return uuid;

297 + return 1;

298 }

299

300 #define DELETE_DIMENSION_UUID "delete from dimension where dim_id = @uuid;"

@@ -1206,7 +1181,7 @@ static RRDDIM *create_rrdim_entry(RRDSET *st, char *id, char *name, uuid_t *metr

1181 rd->state->query_ops.oldest_time = rrdeng_metric_oldest_time;

1182 rd->state->rrdeng_uuid = mallocz(sizeof(uuid_t));

1183 uuid_copy(*rd->state->rrdeng_uuid, *metric_uuid);

1209 - rd->state->metric_uuid = rd->state->rrdeng_uuid;

1184 + uuid_copy(rd->state->metric_uuid, *metric_uuid);

1185 rd->id = strdupz(id);

1186 rd->name = strdupz(name);

1187 return rd;

database/sqlite/sqlite_functions.h

+4 -4

@@ -34,9 +34,10 @@ struct node_instance_list {

34 #define SQL_STORE_DIMENSION \

35 "INSERT OR REPLACE into dimension (dim_id, chart_id, id, name, multiplier, divisor , algorithm) values (?0001,?0002,?0003,?0004,?0005,?0006,?0007);"

37 -#define SQL_FIND_DIMENSION_UUID "select dim_id from dimension where chart_id=@chart and id=@id and name=@name;"

37 +#define SQL_FIND_DIMENSION_UUID \

38 + "select dim_id from dimension where chart_id=@chart and id=@id and name=@name and length(dim_id)=16;"

39 -#define SQL_STORE_ACTIVE_DIMENSION \

40 +#define SQL_STORE_ACTIVE_DIMENSION \

41 "insert or replace into dimension_active (dim_id, date_created) values (@id, strftime('%s'));"

42 extern int sql_init_database(void);

43 extern void sql_close_database(void);

@@ -49,8 +50,7 @@ extern int sql_store_chart(

50 extern int sql_store_dimension(uuid_t *dim_uuid, uuid_t *chart_uuid, const char *id, const char *name, collected_number multiplier,

51 collected_number divisor, int algorithm);

52 -extern uuid_t *find_dimension_uuid(RRDSET *st, RRDDIM *rd);

53 -extern uuid_t *create_dimension_uuid(RRDSET *st, RRDDIM *rd);

53 +extern int find_dimension_uuid(RRDSET *st, RRDDIM *rd, uuid_t *store_uuid);

54 extern void store_active_dimension(uuid_t *dimension_uuid);

56 extern uuid_t *find_chart_uuid(RRDHOST *host, const char *type, const char *id, const char *name);

web/api/formatters/rrd2json.c

-3

@@ -18,7 +18,6 @@ static inline void free_single_rrdrim(RRDDIM *temp_rd, int archive_mode)

18 freez(temp_rd->rrdset);

19 }

20 }

21 - freez(temp_rd->state->metric_uuid);

21 freez(temp_rd->state);

22 freez(temp_rd);

23 }

@@ -95,8 +94,6 @@ void build_context_param_list(struct context_param **param_list, RRDSET *st)

94 memcpy(rd->state, rd1->state, sizeof(*rd->state));

95 memcpy(&rd->state->collect_ops, &rd1->state->collect_ops, sizeof(struct rrddim_collect_ops));

96 memcpy(&rd->state->query_ops, &rd1->state->query_ops, sizeof(struct rrddim_query_ops));

98 - rd->state->metric_uuid = mallocz(sizeof(uuid_t));

99 - uuid_copy(*rd->state->metric_uuid, *rd1->state->metric_uuid);

97 rd->next = (*param_list)->rd;

98 (*param_list)->rd = rd;

99 }