fix v1.37 dbengine page alignment crashes (#14086)
page alignment is a property of metric collection, so it has been moved to metric collection only
Costa Tsaousis committed
Dec 3, 2022 at 20:12 UTC
67186785cef9c3bd00992e99665b55d5b9e293a1
10 files changed
+44
-69
database/engine/pagecache.c
-1
@@ -1204,7 +1204,6 @@ struct pg_cache_page_index *create_page_index(uuid_t *id, struct rrdengine_insta
1204
page_index->refcount = 0;
1205
page_index->writers = 0;
1206
page_index->ctx = ctx;
1207
- page_index->alignment = NULL;
1207
page_index->latest_update_every_s = default_rrd_update_every;
1208
1209
return page_index;
database/engine/pagecache.h
-1
@@ -112,7 +112,6 @@ struct pg_cache_page_index {
112
usec_t latest_time_ut;
113
114
struct rrdengine_instance *ctx;
115
- struct pg_alignment *alignment;
115
uint32_t latest_update_every_s;
116
117
struct pg_cache_page_index *prev;
database/engine/rrdengine.h
+1
@@ -41,6 +41,7 @@ struct rrdeng_collect_handle {
41
unsigned long page_correlation_id;
42
// set to 1 when this dimension is not page aligned with the other dimensions in the chart
43
uint8_t unaligned_page;
44
+ struct pg_alignment *alignment;
45
};
46
47
struct rrdeng_query_handle {
database/engine/rrdengineapi.c
+24
-48
@@ -63,16 +63,11 @@ STORAGE_METRICS_GROUP *rrdeng_metrics_group_get(STORAGE_INSTANCE *db_instance __
63
}
64
65
// charts call this
66
-void rrdeng_metrics_group_release(STORAGE_INSTANCE *db_instance, STORAGE_METRICS_GROUP *smg) {
66
+void rrdeng_metrics_group_release(STORAGE_INSTANCE *db_instance __maybe_unused, STORAGE_METRICS_GROUP *smg) {
67
if(unlikely(!smg)) return;
68
69
- struct rrdengine_instance *ctx = (struct rrdengine_instance *)db_instance;
69
struct pg_alignment *pa = (struct pg_alignment *)smg;
71
- struct page_cache *pg_cache = &ctx->pg_cache;
72
-
73
- uv_rwlock_rdlock(&pg_cache->metrics_index.lock);
70
rrdeng_page_alignment_release(pa);
75
- uv_rwlock_rdunlock(&pg_cache->metrics_index.lock);
71
}
72
73
// ----------------------------------------------------------------------------
@@ -112,10 +107,10 @@ void rrdeng_convert_legacy_uuid_to_multihost(char machine_guid[GUID_LEN + 1], uu
107
memcpy(ret_uuid, hash_value, sizeof(uuid_t));
108
}
109
115
-STORAGE_METRIC_HANDLE *rrdeng_metric_get_legacy(STORAGE_INSTANCE *db_instance, const char *rd_id, const char *st_id, STORAGE_METRICS_GROUP *smg) {
110
+STORAGE_METRIC_HANDLE *rrdeng_metric_get_legacy(STORAGE_INSTANCE *db_instance, const char *rd_id, const char *st_id) {
111
uuid_t legacy_uuid;
112
rrdeng_generate_legacy_uuid(rd_id, st_id, &legacy_uuid);
118
- return rrdeng_metric_get(db_instance, &legacy_uuid, smg);
113
+ return rrdeng_metric_get(db_instance, &legacy_uuid);
114
}
115
116
// ----------------------------------------------------------------------------
@@ -124,11 +119,7 @@ STORAGE_METRIC_HANDLE *rrdeng_metric_get_legacy(STORAGE_INSTANCE *db_instance, c
119
void rrdeng_metric_release(STORAGE_METRIC_HANDLE *db_metric_handle) {
120
struct pg_cache_page_index *page_index = (struct pg_cache_page_index *)db_metric_handle;
121
127
- unsigned short refcount = __atomic_sub_fetch(&page_index->refcount, 1, __ATOMIC_SEQ_CST);
128
- if(refcount == 0 && page_index->alignment) {
129
- __atomic_sub_fetch(&page_index->alignment->refcount, 1, __ATOMIC_SEQ_CST);
130
- page_index->alignment = NULL;
131
- }
122
+ __atomic_sub_fetch(&page_index->refcount, 1, __ATOMIC_SEQ_CST);
123
}
124
125
STORAGE_METRIC_HANDLE *rrdeng_metric_dup(STORAGE_METRIC_HANDLE *db_metric_handle) {
@@ -137,9 +128,8 @@ STORAGE_METRIC_HANDLE *rrdeng_metric_dup(STORAGE_METRIC_HANDLE *db_metric_handle
128
return db_metric_handle;
129
}
130
140
-STORAGE_METRIC_HANDLE *rrdeng_metric_get(STORAGE_INSTANCE *db_instance, uuid_t *uuid, STORAGE_METRICS_GROUP *smg) {
131
+STORAGE_METRIC_HANDLE *rrdeng_metric_get(STORAGE_INSTANCE *db_instance, uuid_t *uuid) {
132
struct rrdengine_instance *ctx = (struct rrdengine_instance *)db_instance;
142
- struct pg_alignment *pa = (struct pg_alignment *)smg;
133
struct page_cache *pg_cache = &ctx->pg_cache;
134
struct pg_cache_page_index *page_index = NULL;
135
@@ -149,28 +139,16 @@ STORAGE_METRIC_HANDLE *rrdeng_metric_get(STORAGE_INSTANCE *db_instance, uuid_t *
139
page_index = *PValue;
140
uv_rwlock_rdunlock(&pg_cache->metrics_index.lock);
141
152
- if (likely(page_index)) {
142
+ if (likely(page_index))
143
__atomic_add_fetch(&page_index->refcount, 1, __ATOMIC_SEQ_CST);
144
155
- if(pa) {
156
- if(page_index->alignment != pa) {
157
- if(!rrdeng_page_alignment_release(page_index->alignment)) // NULL is ok
158
- error("DBENGINE: metric switched alignment, but the previous is still used.");
159
-
160
- rrdeng_page_alignment_acquire(pa);
161
- page_index->alignment = pa;
162
- }
163
- }
164
- }
165
-
145
return (STORAGE_METRIC_HANDLE *)page_index;
146
}
147
169
-STORAGE_METRIC_HANDLE *rrdeng_metric_create(STORAGE_INSTANCE *db_instance, uuid_t *uuid, STORAGE_METRICS_GROUP *smg) {
148
+STORAGE_METRIC_HANDLE *rrdeng_metric_create(STORAGE_INSTANCE *db_instance, uuid_t *uuid) {
149
internal_fatal(!db_instance, "DBENGINE: db_instance is NULL");
150
151
struct rrdengine_instance *ctx = (struct rrdengine_instance *)db_instance;
173
- struct pg_alignment *pa = (struct pg_alignment *)smg;
152
struct pg_cache_page_index *page_index;
153
struct page_cache *pg_cache = &ctx->pg_cache;
154
@@ -180,27 +158,25 @@ STORAGE_METRIC_HANDLE *rrdeng_metric_create(STORAGE_INSTANCE *db_instance, uuid_
158
*PValue = page_index = create_page_index(uuid, ctx);
159
page_index->prev = pg_cache->metrics_index.last_page_index;
160
pg_cache->metrics_index.last_page_index = page_index;
183
- page_index->alignment = pa;
161
page_index->refcount = 1;
185
- rrdeng_page_alignment_acquire(pa);
162
uv_rwlock_wrunlock(&pg_cache->metrics_index.lock);
163
164
return (STORAGE_METRIC_HANDLE *)page_index;
165
}
166
191
-STORAGE_METRIC_HANDLE *rrdeng_metric_get_or_create(RRDDIM *rd, STORAGE_INSTANCE *db_instance, STORAGE_METRICS_GROUP *smg) {
167
+STORAGE_METRIC_HANDLE *rrdeng_metric_get_or_create(RRDDIM *rd, STORAGE_INSTANCE *db_instance) {
168
STORAGE_METRIC_HANDLE *db_metric_handle;
169
194
- db_metric_handle = rrdeng_metric_get(db_instance, &rd->metric_uuid, smg);
170
+ db_metric_handle = rrdeng_metric_get(db_instance, &rd->metric_uuid);
171
if(!db_metric_handle) {
196
- db_metric_handle = rrdeng_metric_get_legacy(db_instance, rrddim_id(rd), rrdset_id(rd->rrdset), smg);
172
+ db_metric_handle = rrdeng_metric_get_legacy(db_instance, rrddim_id(rd), rrdset_id(rd->rrdset));
173
if(db_metric_handle) {
174
struct pg_cache_page_index *page_index = (struct pg_cache_page_index *)db_metric_handle;
175
uuid_copy(rd->metric_uuid, page_index->id);
176
}
177
}
178
if(!db_metric_handle)
203
- db_metric_handle = rrdeng_metric_create(db_instance, &rd->metric_uuid, smg);
179
+ db_metric_handle = rrdeng_metric_create(db_instance, &rd->metric_uuid);
180
181
#ifdef NETDATA_INTERNAL_CHECKS
182
struct pg_cache_page_index *page_index = (struct pg_cache_page_index *)db_metric_handle;
@@ -229,19 +205,19 @@ STORAGE_METRIC_HANDLE *rrdeng_metric_get_or_create(RRDDIM *rd, STORAGE_INSTANCE
205
* Gets a handle for storing metrics to the database.
206
* The handle must be released with rrdeng_store_metric_final().
207
*/
232
-STORAGE_COLLECT_HANDLE *rrdeng_store_metric_init(STORAGE_METRIC_HANDLE *db_metric_handle, uint32_t update_every) {
208
+STORAGE_COLLECT_HANDLE *rrdeng_store_metric_init(STORAGE_METRIC_HANDLE *db_metric_handle, uint32_t update_every, STORAGE_METRICS_GROUP *smg) {
209
struct pg_cache_page_index *page_index = (struct pg_cache_page_index *)db_metric_handle;
210
struct rrdeng_collect_handle *handle;
211
236
- if(!page_index->alignment)
237
- fatal("DBENGINE: metric group is required for collect operations");
238
-
212
handle = callocz(1, sizeof(struct rrdeng_collect_handle));
213
handle->page_index = page_index;
214
handle->descr = NULL;
215
handle->unaligned_page = 0;
216
page_index->latest_update_every_s = update_every;
217
218
+ handle->alignment = (struct pg_alignment *)smg;
219
+ rrdeng_page_alignment_acquire(handle->alignment);
220
+
221
uv_rwlock_wrlock(&page_index->lock);
222
++page_index->writers;
223
uv_rwlock_wrunlock(&page_index->lock);
@@ -350,18 +326,18 @@ static void rrdeng_store_metric_next_internal(STORAGE_COLLECT_HANDLE *collection
326
}
327
#endif
328
353
- if (descr->page_length == page_index->alignment->page_length) {
329
+ if (descr->page_length == handle->alignment->page_length) {
330
/* this is the leading dimension that defines chart alignment */
331
perfect_page_alignment = 1;
332
}
333
/* is the metric far enough out of alignment with the others? */
358
- if (unlikely(descr->page_length + PAGE_POINT_SIZE_BYTES(descr) < page_index->alignment->page_length)) {
334
+ if (unlikely(descr->page_length + PAGE_POINT_SIZE_BYTES(descr) < handle->alignment->page_length)) {
335
handle->unaligned_page = 1;
336
print_page_cache_descr(descr, "Metric page is not aligned with chart", true);
337
}
338
if (unlikely(handle->unaligned_page &&
339
/* did the other metrics change page? */
364
- page_index->alignment->page_length <= PAGE_POINT_SIZE_BYTES(descr))) {
340
+ handle->alignment->page_length <= PAGE_POINT_SIZE_BYTES(descr))) {
341
print_page_cache_descr(descr, "must_flush_unaligned_page = 1", true);
342
must_flush_unaligned_page = 1;
343
handle->unaligned_page = 0;
@@ -384,7 +360,7 @@ static void rrdeng_store_metric_next_internal(STORAGE_COLLECT_HANDLE *collection
360
361
handle->page_correlation_id = rrd_atomic_fetch_add(&pg_cache->committed_page_index.latest_corr_id, 1);
362
387
- if (0 == page_index->alignment->page_length) {
363
+ if (0 == handle->alignment->page_length) {
364
/* this is the leading dimension that defines chart alignment */
365
perfect_page_alignment = 1;
366
}
@@ -422,7 +398,7 @@ static void rrdeng_store_metric_next_internal(STORAGE_COLLECT_HANDLE *collection
398
pg_cache_atomic_set_pg_info(descr, point_in_time_ut, descr->page_length + PAGE_POINT_SIZE_BYTES(descr));
399
400
if (perfect_page_alignment)
425
- page_index->alignment->page_length = descr->page_length;
401
+ handle->alignment->page_length = descr->page_length;
402
if (unlikely(INVALID_TIME == descr->start_time_ut)) {
403
unsigned long new_metric_API_producers, old_metric_API_max_producers, ret_metric_API_max_producers;
404
descr->start_time_ut = point_in_time_ut;
@@ -549,13 +525,13 @@ int rrdeng_store_metric_finalize(STORAGE_COLLECT_HANDLE *collection_handle) {
525
526
rrdeng_store_metric_flush_current_page(collection_handle);
527
uv_rwlock_wrlock(&page_index->lock);
552
- if (!--page_index->writers && !page_index->page_count) {
528
+
529
+ if (!--page_index->writers && !page_index->page_count)
530
can_delete_metric = 1;
531
555
- rrdeng_page_alignment_release(page_index->alignment);
556
- page_index->alignment = NULL;
557
- }
532
uv_rwlock_wrunlock(&page_index->lock);
533
+
534
+ rrdeng_page_alignment_release(handle->alignment);
535
freez(handle);
536
537
return can_delete_metric;
database/engine/rrdengineapi.h
+5
-5
@@ -42,14 +42,14 @@ void rrdeng_convert_legacy_uuid_to_multihost(char machine_guid[GUID_LEN + 1], uu
42
uuid_t *ret_uuid);
43
44
45
-STORAGE_METRIC_HANDLE *rrdeng_metric_get_or_create(RRDDIM *rd, STORAGE_INSTANCE *db_instance, STORAGE_METRICS_GROUP *smg);
46
-STORAGE_METRIC_HANDLE *rrdeng_metric_get(STORAGE_INSTANCE *db_instance, uuid_t *uuid, STORAGE_METRICS_GROUP *smg);
47
-STORAGE_METRIC_HANDLE *rrdeng_metric_create(STORAGE_INSTANCE *db_instance, uuid_t *uuid, STORAGE_METRICS_GROUP *smg);
48
-STORAGE_METRIC_HANDLE *rrdeng_metric_get_legacy(STORAGE_INSTANCE *db_instance, const char *rd_id, const char *st_id, STORAGE_METRICS_GROUP *smg);
45
+STORAGE_METRIC_HANDLE *rrdeng_metric_get_or_create(RRDDIM *rd, STORAGE_INSTANCE *db_instance);
46
+STORAGE_METRIC_HANDLE *rrdeng_metric_get(STORAGE_INSTANCE *db_instance, uuid_t *uuid);
47
+STORAGE_METRIC_HANDLE *rrdeng_metric_create(STORAGE_INSTANCE *db_instance, uuid_t *uuid);
48
+STORAGE_METRIC_HANDLE *rrdeng_metric_get_legacy(STORAGE_INSTANCE *db_instance, const char *rd_id, const char *st_id);
49
void rrdeng_metric_release(STORAGE_METRIC_HANDLE *db_metric_handle);
50
STORAGE_METRIC_HANDLE *rrdeng_metric_dup(STORAGE_METRIC_HANDLE *db_metric_handle);
51
52
-STORAGE_COLLECT_HANDLE *rrdeng_store_metric_init(STORAGE_METRIC_HANDLE *db_metric_handle, uint32_t update_every);
52
+STORAGE_COLLECT_HANDLE *rrdeng_store_metric_init(STORAGE_METRIC_HANDLE *db_metric_handle, uint32_t update_every, STORAGE_METRICS_GROUP *smg);
53
void rrdeng_store_metric_flush_current_page(STORAGE_COLLECT_HANDLE *collection_handle);
54
void rrdeng_store_metric_change_collection_frequency(STORAGE_COLLECT_HANDLE *collection_handle, int update_every);
55
void rrdeng_store_metric_next(STORAGE_COLLECT_HANDLE *collection_handle, usec_t point_in_time_ut, NETDATA_DOUBLE n,
database/ram/rrddim_mem.c
+4
-4
@@ -22,8 +22,8 @@ void rrddim_metrics_group_release(STORAGE_INSTANCE *db_instance __maybe_unused,
22
// RRDDIM legacy data collection functions
23
24
STORAGE_METRIC_HANDLE *
25
-rrddim_metric_get_or_create(RRDDIM *rd, STORAGE_INSTANCE *db_instance __maybe_unused, STORAGE_METRICS_GROUP *smg __maybe_unused) {
26
- STORAGE_METRIC_HANDLE *t = rrddim_metric_get(db_instance, &rd->metric_uuid, smg);
25
+rrddim_metric_get_or_create(RRDDIM *rd, STORAGE_INSTANCE *db_instance __maybe_unused) {
26
+ STORAGE_METRIC_HANDLE *t = rrddim_metric_get(db_instance, &rd->metric_uuid);
27
if(!t) {
28
netdata_rwlock_wrlock(&rrddim_JudyHS_rwlock);
29
Pvoid_t *PValue = JudyHSIns(&rrddim_JudyHS_array, &rd->metric_uuid, sizeof(uuid_t), PJE0);
@@ -40,7 +40,7 @@ rrddim_metric_get_or_create(RRDDIM *rd, STORAGE_INSTANCE *db_instance __maybe_un
40
}
41
42
STORAGE_METRIC_HANDLE *
43
-rrddim_metric_get(STORAGE_INSTANCE *db_instance __maybe_unused, uuid_t *uuid, STORAGE_METRICS_GROUP *smg __maybe_unused) {
43
+rrddim_metric_get(STORAGE_INSTANCE *db_instance __maybe_unused, uuid_t *uuid) {
44
RRDDIM *rd = NULL;
45
netdata_rwlock_rdlock(&rrddim_JudyHS_rwlock);
46
Pvoid_t *PValue = JudyHSGet(rrddim_JudyHS_array, uuid, sizeof(uuid_t));
@@ -67,7 +67,7 @@ void rrddim_store_metric_change_collection_frequency(STORAGE_COLLECT_HANDLE *col
67
rrddim_store_metric_flush(collection_handle);
68
}
69
70
-STORAGE_COLLECT_HANDLE *rrddim_collect_init(STORAGE_METRIC_HANDLE *db_metric_handle, uint32_t update_every __maybe_unused) {
70
+STORAGE_COLLECT_HANDLE *rrddim_collect_init(STORAGE_METRIC_HANDLE *db_metric_handle, uint32_t update_every __maybe_unused, STORAGE_METRICS_GROUP *smg __maybe_unused) {
71
RRDDIM *rd = (RRDDIM *)db_metric_handle;
72
rd->db[rd->rrdset->current_entry] = pack_storage_number(NAN, SN_FLAG_NONE);
73
struct mem_collect_handle *ch = callocz(1, sizeof(struct mem_collect_handle));
database/ram/rrddim_mem.h
+3
-3
@@ -20,15 +20,15 @@ struct mem_query_handle {
20
size_t last_slot;
21
};
22
23
-STORAGE_METRIC_HANDLE *rrddim_metric_get_or_create(RRDDIM *rd, STORAGE_INSTANCE *db_instance, STORAGE_METRICS_GROUP *smg);
24
-STORAGE_METRIC_HANDLE *rrddim_metric_get(STORAGE_INSTANCE *db_instance, uuid_t *uuid, STORAGE_METRICS_GROUP *smg);
23
+STORAGE_METRIC_HANDLE *rrddim_metric_get_or_create(RRDDIM *rd, STORAGE_INSTANCE *db_instance);
24
+STORAGE_METRIC_HANDLE *rrddim_metric_get(STORAGE_INSTANCE *db_instance, uuid_t *uuid);
25
STORAGE_METRIC_HANDLE *rrddim_metric_dup(STORAGE_METRIC_HANDLE *db_metric_handle);
26
void rrddim_metric_release(STORAGE_METRIC_HANDLE *db_metric_handle);
27
28
STORAGE_METRICS_GROUP *rrddim_metrics_group_get(STORAGE_INSTANCE *db_instance, uuid_t *uuid);
29
void rrddim_metrics_group_release(STORAGE_INSTANCE *db_instance, STORAGE_METRICS_GROUP *smg);
30
31
-STORAGE_COLLECT_HANDLE *rrddim_collect_init(STORAGE_METRIC_HANDLE *db_metric_handle, uint32_t update_every);
31
+STORAGE_COLLECT_HANDLE *rrddim_collect_init(STORAGE_METRIC_HANDLE *db_metric_handle, uint32_t update_every, STORAGE_METRICS_GROUP *smg);
32
void rrddim_store_metric_change_collection_frequency(STORAGE_COLLECT_HANDLE *collection_handle, int update_every);
33
void rrddim_collect_store_metric(STORAGE_COLLECT_HANDLE *collection_handle, usec_t point_in_time, NETDATA_DOUBLE number,
34
NETDATA_DOUBLE min_value,
database/rrd.h
+3
-3
@@ -409,7 +409,7 @@ typedef struct storage_query_handle STORAGE_QUERY_HANDLE;
409
// function pointers that handle data collection
410
struct storage_engine_collect_ops {
411
// an initialization function to run before starting collection
412
- STORAGE_COLLECT_HANDLE *(*init)(STORAGE_METRIC_HANDLE *db_metric_handle, uint32_t update_every);
412
+ STORAGE_COLLECT_HANDLE *(*init)(STORAGE_METRIC_HANDLE *db_metric_handle, uint32_t update_every, STORAGE_METRICS_GROUP *smg);
413
414
// run this to store each metric into the database
415
void (*store_metric)(STORAGE_COLLECT_HANDLE *collection_handle, usec_t point_in_time, NETDATA_DOUBLE number, NETDATA_DOUBLE min_value,
@@ -464,8 +464,8 @@ typedef struct storage_engine STORAGE_ENGINE;
464
// function pointers for all APIs provided by a storage engine
465
typedef struct storage_engine_api {
466
// metric management
467
- STORAGE_METRIC_HANDLE *(*metric_get)(STORAGE_INSTANCE *instance, uuid_t *uuid, STORAGE_METRICS_GROUP *smg);
468
- STORAGE_METRIC_HANDLE *(*metric_get_or_create)(RRDDIM *rd, STORAGE_INSTANCE *instance, STORAGE_METRICS_GROUP *smg);
467
+ STORAGE_METRIC_HANDLE *(*metric_get)(STORAGE_INSTANCE *instance, uuid_t *uuid);
468
+ STORAGE_METRIC_HANDLE *(*metric_get_or_create)(RRDDIM *rd, STORAGE_INSTANCE *instance);
469
void (*metric_release)(STORAGE_METRIC_HANDLE *);
470
STORAGE_METRIC_HANDLE *(*metric_dup)(STORAGE_METRIC_HANDLE *);
471
database/rrdcontext.c
+1
-1
@@ -2436,7 +2436,7 @@ static void query_target_add_metric(QUERY_TARGET_LOCALS *qtl, RRDMETRIC_ACQUIRED
2436
if(rm->rrddim && rm->rrddim->tiers[tier] && rm->rrddim->tiers[tier]->db_metric_handle)
2437
tier_retention[tier].db_metric_handle = eng->api.metric_dup(rm->rrddim->tiers[tier]->db_metric_handle);
2438
else
2439
- tier_retention[tier].db_metric_handle = eng->api.metric_get(qtl->host->db[tier].instance, &rm->uuid, NULL);
2439
+ tier_retention[tier].db_metric_handle = eng->api.metric_get(qtl->host->db[tier].instance, &rm->uuid);
2440
2441
if(tier_retention[tier].db_metric_handle) {
2442
tier_retention[tier].db_first_time_t = tier_retention[tier].eng->api.query_ops.oldest_time(tier_retention[tier].db_metric_handle);
database/rrddim.c
+3
-3
@@ -112,7 +112,7 @@ static void rrddim_insert_callback(const DICTIONARY_ITEM *item __maybe_unused, v
112
rd->tiers[tier]->tier_grouping = host->db[tier].tier_grouping;
113
rd->tiers[tier]->collect_ops = &eng->api.collect_ops;
114
rd->tiers[tier]->query_ops = &eng->api.query_ops;
115
- rd->tiers[tier]->db_metric_handle = eng->api.metric_get_or_create(rd, host->db[tier].instance, rd->rrdset->storage_metrics_groups[tier]);
115
+ rd->tiers[tier]->db_metric_handle = eng->api.metric_get_or_create(rd, host->db[tier].instance);
116
storage_point_unset(rd->tiers[tier]->virtual_point);
117
initialized++;
118
@@ -131,7 +131,7 @@ static void rrddim_insert_callback(const DICTIONARY_ITEM *item __maybe_unused, v
131
size_t initialized = 0;
132
for (size_t tier = 0; tier < storage_tiers; tier++) {
133
if (rd->tiers[tier]) {
134
- rd->tiers[tier]->db_collection_handle = rd->tiers[tier]->collect_ops->init(rd->tiers[tier]->db_metric_handle, st->rrdhost->db[tier].tier_grouping * st->update_every);
134
+ rd->tiers[tier]->db_collection_handle = rd->tiers[tier]->collect_ops->init(rd->tiers[tier]->db_metric_handle, st->rrdhost->db[tier].tier_grouping * st->update_every, rd->rrdset->storage_metrics_groups[tier]);
135
initialized++;
136
}
137
}
@@ -261,7 +261,7 @@ static bool rrddim_conflict_callback(const DICTIONARY_ITEM *item __maybe_unused,
261
for(size_t tier = 0; tier < storage_tiers ;tier++) {
262
if (rd->tiers[tier] && !rd->tiers[tier]->db_collection_handle)
263
rd->tiers[tier]->db_collection_handle =
264
- rd->tiers[tier]->collect_ops->init(rd->tiers[tier]->db_metric_handle, st->rrdhost->db[tier].tier_grouping * st->update_every);
264
+ rd->tiers[tier]->collect_ops->init(rd->tiers[tier]->db_metric_handle, st->rrdhost->db[tier].tier_grouping * st->update_every, rd->rrdset->storage_metrics_groups[tier]);
265
}
266
267
if(rrddim_flag_check(rd, RRDDIM_FLAG_ARCHIVED)) {