From 373a832b2c4a410a529805292eabca2b61ad75f2 Mon Sep 17 00:00:00 2001 From: Bartek Plotka Date: Wed, 18 Nov 2026 05:13:02 +0000 Subject: [PATCH 1/3] relabel: add str-slice and iterator dictionary helpers for arena interners Adds resolve_conflicting_exposed_keys_iter, eval_key_keep_mask_iter, SingleLabelKeepCache::keep_str, SingleLabelTransformCache::transform_str, SingleLabelTransformCache::eval_single_str, and retained_memory_bytes helpers so arena-backed interners like ArrowDecoder's StringInterner can run Stage 2 relabeling without building temporary key/value slices. Signed-off-by: Bartek Plotka --- crates/relabel/src/lib.rs | 88 ++++++++++++++++++++++++++++++--- crates/relabel/tests/relabel.rs | 41 +++++++++++++-- 2 files changed, 117 insertions(+), 12 deletions(-) diff --git a/crates/relabel/src/lib.rs b/crates/relabel/src/lib.rs index 13600ab..95aea62 100644 --- a/crates/relabel/src/lib.rs +++ b/crates/relabel/src/lib.rs @@ -1310,8 +1310,27 @@ pub fn resolve_conflicting_exposed_keys>( honor_labels: bool, renamed_keys: &mut Vec>, ) -> bool { + resolve_conflicting_exposed_keys_iter( + metric_keys.iter().map(AsRef::as_ref), + target_labels, + honor_labels, + renamed_keys, + ) +} + +/// Iterator variant of [`resolve_conflicting_exposed_keys`] that operates directly over borrowed +/// `&str` entries (such as a contiguous arena string interner) without building a temporary slice. +pub fn resolve_conflicting_exposed_keys_iter<'a, I>( + metric_keys: I, + target_labels: &LabelSet, + honor_labels: bool, + renamed_keys: &mut Vec>, +) -> bool +where + I: ExactSizeIterator + Clone, +{ renamed_keys.clear(); - if honor_labels || metric_keys.is_empty() || target_labels.is_empty() { + if honor_labels || metric_keys.len() == 0 || target_labels.is_empty() { return false; } @@ -1320,7 +1339,7 @@ pub fn resolve_conflicting_exposed_keys>( && target_labels.get(key).is_some_and(|v| !v.is_empty()) }; - if !metric_keys.iter().any(|k| is_public_target_key(k.as_ref())) { + if !metric_keys.clone().any(is_public_target_key) { return false; } @@ -1332,8 +1351,7 @@ pub fn resolve_conflicting_exposed_keys>( .collect(); let mut conflicting: Vec<(usize, &str)> = Vec::new(); - for (idx, key) in metric_keys.iter().enumerate() { - let key_str = key.as_ref(); + for (idx, key_str) in metric_keys.enumerate() { if is_public_target_key(key_str) { conflicting.push((idx, key_str)); } else { @@ -1368,6 +1386,19 @@ pub fn eval_key_keep_mask>( cfg: &Config, keep_mask: &mut Vec, ) -> Option { + eval_key_keep_mask_iter(metric_keys.iter().map(AsRef::as_ref), cfg, keep_mask) +} + +/// Iterator variant of [`eval_key_keep_mask`] that operates directly over borrowed `&str` entries +/// without building a temporary slice. +pub fn eval_key_keep_mask_iter<'a, I>( + metric_keys: I, + cfg: &Config, + keep_mask: &mut Vec, +) -> Option +where + I: ExactSizeIterator, +{ if !matches!(cfg.action, Action::LabelDrop | Action::LabelKeep) { return None; } @@ -1376,8 +1407,8 @@ pub fn eval_key_keep_mask>( let mut dropped = 0usize; for key in metric_keys { let keep = match cfg.action { - Action::LabelDrop => !cfg.regex.is_match(key.as_ref()), - Action::LabelKeep => cfg.regex.is_match(key.as_ref()), + Action::LabelDrop => !cfg.regex.is_match(key), + Action::LabelKeep => cfg.regex.is_match(key), _ => unreachable!(), }; if !keep { @@ -1477,6 +1508,12 @@ impl SingleLabelKeepCache { self.keep_when_absent } + /// Returns the heap buffer capacity in bytes retained by this cache. + #[must_use] + pub fn retained_memory_bytes(&self) -> usize { + self.states.capacity() + } + /// Evaluates or returns the memoized keep decision for `metric_values[val_id]`. pub fn keep_value>( &mut self, @@ -1484,11 +1521,16 @@ impl SingleLabelKeepCache { metric_values: &[V], cfg: &Config, ) -> bool { + self.keep_str(val_id, metric_values[val_id].as_ref(), cfg) + } + + /// Evaluates or returns the memoized keep decision for dictionary index `val_id` with string + /// value `val_str`, avoiding an intermediate slice when values live in an arena interner. + pub fn keep_str(&mut self, val_id: usize, val_str: &str, cfg: &Config) -> bool { let cached = self.states[val_id]; if cached != 0 { return cached == 2; } - let val_str = metric_values[val_id].as_ref(); let keep = match cfg.action { Action::Keep => cfg.regex.is_match(val_str), Action::Drop => !cfg.regex.is_match(val_str), @@ -1659,15 +1701,31 @@ impl SingleLabelTransformCache { .expect("SingleLabelTransformCache::prepare must succeed before calling when_absent") } + /// Returns the heap buffer capacity in bytes retained by this cache. + #[must_use] + pub fn retained_memory_bytes(&self) -> usize { + self.entries.capacity() * size_of::>() + } + /// Evaluates or returns the memoized transformation for `metric_values[val_id]`. pub fn transform_value>( &mut self, val_id: usize, metric_values: &[V], cfg: &Config, + ) -> &DictionaryValueTransform { + self.transform_str(val_id, metric_values[val_id].as_ref(), cfg) + } + + /// Evaluates or returns the memoized transformation for dictionary index `val_id` with string + /// value `val_str`, avoiding an intermediate slice when values live in an arena interner. + pub fn transform_str( + &mut self, + val_id: usize, + val_str: &str, + cfg: &Config, ) -> &DictionaryValueTransform { if self.entries[val_id].is_none() { - let val_str = metric_values[val_id].as_ref(); let xform = eval_value_transform_one( val_str, true, @@ -1681,6 +1739,20 @@ impl SingleLabelTransformCache { } self.entries[val_id].as_ref().unwrap() } + + /// Evaluates `cfg` once for a single target-provided value `val_str` (outside the batch value + /// dictionary) using this cache's prepared `CaptureLocations`. + pub fn eval_single_str(&mut self, val_str: &str, cfg: &Config) -> DictionaryValueTransform { + eval_value_transform_one( + val_str, + !val_str.is_empty(), + cfg, + self.in_place, + self.target_valid, + self.single_capture_group, + &mut self.locs, + ) + } } #[allow(clippy::too_many_arguments)] diff --git a/crates/relabel/tests/relabel.rs b/crates/relabel/tests/relabel.rs index fdeb4d3..d325a36 100644 --- a/crates/relabel/tests/relabel.rs +++ b/crates/relabel/tests/relabel.rs @@ -19,10 +19,11 @@ use std::collections::BTreeMap; use prometheus_relabel::{ Action, Config, DEFAULT_REPLACEMENT, DictionaryValueTransform, LabelSet, METRIC_NAME_LABEL, Regexp, SingleLabelFilterSummary, SingleLabelKeepCache, SingleLabelTransformCache, - TargetPopulateConfig, ValidationScheme, eval_key_keep_mask, eval_single_label_keep_mask, - eval_single_label_value_transform, is_valid_legacy_target_label, keep_metric_name, - merge_target_and_metric_labels, populate_discovered_labels, populate_labels, process, - resolve_conflicting_exposed_keys, split_metric_name_pushdown, + TargetPopulateConfig, ValidationScheme, eval_key_keep_mask, eval_key_keep_mask_iter, + eval_single_label_keep_mask, eval_single_label_value_transform, is_valid_legacy_target_label, + keep_metric_name, merge_target_and_metric_labels, populate_discovered_labels, populate_labels, + process, resolve_conflicting_exposed_keys, resolve_conflicting_exposed_keys_iter, + split_metric_name_pushdown, }; fn label_set(pairs: &[(&str, &str)]) -> LabelSet { @@ -1397,6 +1398,38 @@ fn stage2_dictionary_vectorized_honor_labels_and_attribute_transforms() { .target_value(shared_vals[2]), Some("api") ); + assert!(keep_cache.keep_str(0, "prod", &keep_env)); + assert!(!keep_cache.keep_str(1, "dev", &keep_env)); + assert!(keep_cache.retained_memory_bytes() >= shared_vals.len()); + assert_eq!( + xform_cache + .transform_str(2, "api-7f8b", &replace_cfg) + .target_value("api-7f8b"), + Some("api") + ); + assert_eq!( + xform_cache + .eval_single_str("worker-12ab", &replace_cfg) + .target_value("worker-12ab"), + Some("worker") + ); + assert!(xform_cache.retained_memory_bytes() > 0); + + let mut iter_renamed = Vec::new(); + assert!(resolve_conflicting_exposed_keys_iter( + colliding_keys.iter().copied(), + &target_labels, + false, + &mut iter_renamed, + )); + assert_eq!(iter_renamed, renamed); + + let mut iter_mask = Vec::new(); + assert_eq!( + eval_key_keep_mask_iter(dict_keys.iter().copied(), &drop_cfg, &mut iter_mask), + Some(2) + ); + assert_eq!(iter_mask, vec![true, true, false, false, true]); // 7. End-to-end equivalence: Stage 1 `__name__` pushdown + Stage 2 dictionary primitives vs per-sample `process`. let pipeline_cfgs = [ From 8a19730ba46ae52b104832e0452b0308995e7448 Mon Sep 17 00:00:00 2001 From: Bartek Plotka Date: Wed, 18 Nov 2026 05:20:40 +0000 Subject: [PATCH 2/3] arrow: wire honor_labels and two-stage metric_relabel_configs into ArrowDecoder Adds MetricRelabelPlan, DecodeOptions::honor_labels (default false), and DecodeOptions::metric_relabel_plan / with_metric_relabel_configs to ArrowDecoder. - Stage 1 pushes leading __name__-only keep/drop/keepequal/dropequal rules into ArrowDecoder::ingest_entries, caching per contiguous wire series name so dropped series runs skip label unescaping, string interning, and family assembly while preserving cooperative budget accounting. - Stage 2 resolves honor_labels = false collisions once across key_interner (leaving exemplar attributes untouched), executes labeldrop/labelkeep and single-label keep/drop/replace/lowercase/uppercase/hashmod rules on dictionary interners, and falls back to exact prometheus_relabel::process_in_place for general multi-label, labelmap, keepequal/dropequal, dynamic target_label, and __name__-mutating rules. - Compacts dropped data points, child exemplars, and unused metric families in place, skips empty chunks in decode_stream, and updates ResourceAttrs only when Stage 2 mutates or drops target labels. Towards #35. Signed-off-by: Bartek Plotka --- Cargo.lock | 1 + crates/expfmt/Cargo.toml | 3 +- crates/expfmt/src/arrow.rs | 187 ++-- crates/expfmt/src/arrow/columns.rs | 496 +++++++++++ crates/expfmt/src/arrow/options.rs | 102 ++- crates/expfmt/src/arrow/relabel.rs | 1268 ++++++++++++++++++++++++++++ crates/expfmt/src/lib.rs | 2 + 7 files changed, 1987 insertions(+), 72 deletions(-) create mode 100644 crates/expfmt/src/arrow/relabel.rs diff --git a/Cargo.lock b/Cargo.lock index 5ce678b..28ddd7c 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1074,6 +1074,7 @@ dependencies = [ "arrow-buffer", "arrow-schema", "benchfmt", + "prometheus-relabel", "prost", "prost-build", "prost-types", diff --git a/crates/expfmt/Cargo.toml b/crates/expfmt/Cargo.toml index cec1acc..8b6b6e0 100644 --- a/crates/expfmt/Cargo.toml +++ b/crates/expfmt/Cargo.toml @@ -16,13 +16,14 @@ exclude = [ [features] default = ["arrow", "dto"] -arrow = ["dep:arrow-array", "dep:arrow-buffer", "dep:arrow-schema"] +arrow = ["dep:arrow-array", "dep:arrow-buffer", "dep:arrow-schema", "dep:prometheus-relabel"] dto = ["dep:prost", "dep:prost-types"] [dependencies] arrow-array = { workspace = true, optional = true } arrow-buffer = { workspace = true, optional = true } arrow-schema = { workspace = true, optional = true } +prometheus-relabel = { workspace = true, optional = true } prost = { workspace = true, optional = true } prost-types = { workspace = true, optional = true } thiserror = { workspace = true } diff --git a/crates/expfmt/src/arrow.rs b/crates/expfmt/src/arrow.rs index 25b8630..0047269 100644 --- a/crates/expfmt/src/arrow.rs +++ b/crates/expfmt/src/arrow.rs @@ -24,6 +24,7 @@ mod family; mod intern; mod options; mod records; +mod relabel; mod schema; #[cfg(test)] mod tests; @@ -53,6 +54,8 @@ pub use self::options::{ UnitSuffixPolicy, UntypedPolicy, }; pub use self::records::{MetricPayloadType, OtapMetricRecords}; +pub use self::relabel::MetricRelabelPlan; +use self::relabel::{Stage2Scratch, apply_stage2_relabeling}; pub use self::schema::{PROMETHEUS_TYPE_METADATA_KEY, SERVICE_INSTANCE_ID_ATTR, SERVICE_NAME_ATTR}; /// Maximum distinct `UnivariateMetrics` rows representable in a single OTAP batch (`u16` IDs). @@ -313,6 +316,10 @@ pub struct ArrowDecoder { hist_dp: HistogramDpTable, temp_attrs: Vec<(u32, u32)>, scratch: ScratchBuffers, + stage1_last_raw_name: Vec, + stage1_last_kept: bool, + stage1_cache_valid: bool, + stage2_scratch: Stage2Scratch, } impl Default for ArrowDecoder { @@ -357,6 +364,10 @@ impl ArrowDecoder { hist_dp: HistogramDpTable::default(), temp_attrs: Vec::new(), scratch: ScratchBuffers::with_capacity(metrics, data_points, attrs), + stage1_last_raw_name: Vec::new(), + stage1_last_kept: true, + stage1_cache_valid: false, + stage2_scratch: Stage2Scratch::default(), } } @@ -378,6 +389,8 @@ impl ArrowDecoder { + self.hist_dp.retained_memory_bytes() + self.temp_attrs.capacity() * size_of::<(u32, u32)>() + self.scratch.retained_memory_bytes() + + self.stage1_last_raw_name.capacity() + + self.stage2_scratch.retained_memory_bytes() } /// Decodes a single exposition scrape buffer of `format` into OTAP metric @@ -730,6 +743,9 @@ impl ArrowDecoder { self.scrape_id = next_scrape_id(); self.current_family.clear(); self.assembly.clear(); + self.stage1_last_raw_name.clear(); + self.stage1_last_kept = true; + self.stage1_cache_valid = false; self.reset_batch(); } @@ -848,6 +864,9 @@ impl ArrowDecoder { if CHUNKED { self.reset_batch(); } + if batch.is_empty() { + return Ok(DecodeStep::Done); + } return Ok(DecodeStep::Batch(batch)); } } @@ -869,68 +888,88 @@ impl ArrowDecoder { offset: name_offset, }); } - let role = if self.current_family.active - && self.current_family.raw_name.as_slice() == raw_name - && !matches!( - self.current_family.metric_type, - MetricType::Histogram | MetricType::GaugeHistogram - ) { - if self.current_family.metric_type == MetricType::Summary { - SeriesRole::SummaryQuantile - } else { - SeriesRole::Scalar + let mut stage1_kept = true; + if let Some(plan) = opts.metric_relabel_plan.as_deref() { + let stage1 = plan.stage1_configs(); + if !stage1.is_empty() { + stage1_kept = + self.check_stage1_metric_name(raw_name, name_offset, stage1)?; } - } else { - let unescaped = unescape_bytes_into(raw_name, true, &mut self.unescape_buf); - if let Some(r) = self.current_family.classify_series(unescaped) { - r + } + if stage1_kept { + let role = if self.current_family.active + && self.current_family.raw_name.as_slice() == raw_name + && !matches!( + self.current_family.metric_type, + MetricType::Histogram | MetricType::GaugeHistogram + ) { + if self.current_family.metric_type == MetricType::Summary { + SeriesRole::SummaryQuantile + } else { + SeriesRole::Scalar + } } else { - self.series_name_buf.clear(); - self.series_name_buf.extend_from_slice(unescaped); - self.flush_pending_family(opts, default_ts_ns)?; - if CHUNKED && self.total_data_points() >= max_data_points { + let unescaped = + unescape_bytes_into(raw_name, true, &mut self.unescape_buf); + if let Some(r) = self.current_family.classify_series(unescaped) { + r + } else { + self.series_name_buf.clear(); + self.series_name_buf.extend_from_slice(unescaped); + self.flush_pending_family(opts, default_ts_ns)?; + if CHUNKED && self.total_data_points() >= max_data_points { + self.current_family + .start_new(raw_name, &self.series_name_buf); + *pending_series = true; + let batch = + self.finish_batches(opts, default_ts_ns.is_some())?; + self.reset_batch(); + if !batch.is_empty() { + return Ok(DecodeStep::Batch(batch)); + } + continue; + } self.current_family .start_new(raw_name, &self.series_name_buf); + SeriesRole::Scalar + } + }; + + if CHUNKED { + let split_assembled = !self.assembly.is_empty() + && self.batch_data_points() >= max_data_points + && !self.series_matches_staged_group(parser, role); + let split_scalar = self.assembly.is_empty() + && (self.total_data_points() >= max_data_points + || (self.current_family.batch_id.is_none() + && self.metrics.len() >= MAX_METRICS_PER_BATCH)); + if split_assembled || split_scalar { + if split_assembled { + self.flush_pending_family(opts, default_ts_ns)?; + } *pending_series = true; let batch = self.finish_batches(opts, default_ts_ns.is_some())?; self.reset_batch(); - return Ok(DecodeStep::Batch(batch)); + if !batch.is_empty() { + return Ok(DecodeStep::Batch(batch)); + } + continue; } - self.current_family - .start_new(raw_name, &self.series_name_buf); - SeriesRole::Scalar } - }; - if CHUNKED { - let split_assembled = !self.assembly.is_empty() - && self.batch_data_points() >= max_data_points - && !self.series_matches_staged_group(parser, role); - let split_scalar = self.assembly.is_empty() - && (self.total_data_points() >= max_data_points - || (self.current_family.batch_id.is_none() - && self.metrics.len() >= MAX_METRICS_PER_BATCH)); - if split_assembled || split_scalar { - if split_assembled { - self.flush_pending_family(opts, default_ts_ns)?; - } - *pending_series = true; + self.ingest_series_entry(parser, role, opts, default_ts_ns)?; + + if CHUNKED + && self.assembly.is_empty() + && self.total_data_points() >= max_data_points + { let batch = self.finish_batches(opts, default_ts_ns.is_some())?; self.reset_batch(); - return Ok(DecodeStep::Batch(batch)); + if !batch.is_empty() { + return Ok(DecodeStep::Batch(batch)); + } } } - - self.ingest_series_entry(parser, role, opts, default_ts_ns)?; - - if CHUNKED - && self.assembly.is_empty() - && self.total_data_points() >= max_data_points - { - let batch = self.finish_batches(opts, default_ts_ns.is_some())?; - self.reset_batch(); - return Ok(DecodeStep::Batch(batch)); - } } } @@ -1549,6 +1588,28 @@ impl ArrowDecoder { Ok(()) } + #[inline] + fn check_stage1_metric_name( + &mut self, + raw_name: &[u8], + name_offset: usize, + stage1: &[prometheus_relabel::Config], + ) -> Result { + if self.stage1_cache_valid && self.stage1_last_raw_name.as_slice() == raw_name { + return Ok(self.stage1_last_kept); + } + let unescaped = unescape_bytes_into(raw_name, true, &mut self.unescape_buf); + let name_str = std::str::from_utf8(unescaped).map_err(|_| DecodeError::InvalidUtf8 { + offset: name_offset, + })?; + let kept = prometheus_relabel::keep_metric_name(name_str, stage1); + self.stage1_last_raw_name.clear(); + self.stage1_last_raw_name.extend_from_slice(raw_name); + self.stage1_last_kept = kept; + self.stage1_cache_valid = true; + Ok(kept) + } + fn finish_batches( &mut self, opts: &DecodeOptions, @@ -1558,9 +1619,33 @@ impl ArrowDecoder { return Ok(OtapMetricRecords::default()); } - let resource_attrs = match opts.target_attributes.as_deref() { - Some(target) => target.resource_attrs_batch()?, - None => None, + let target_attrs = opts.target_attributes.as_deref(); + let has_target_labels = target_attrs.is_some_and(|t| !t.target_labels().is_empty()); + let has_stage2 = opts + .metric_relabel_plan + .as_deref() + .is_some_and(|p| !p.stage2_configs().is_empty()); + + let resource_attrs = if (!opts.honor_labels && has_target_labels) || has_stage2 { + let res = apply_stage2_relabeling( + opts, + &mut self.metrics, + &mut self.key_interner, + &mut self.val_interner, + &mut self.num_dp, + &mut self.sum_dp, + &mut self.hist_dp, + &mut self.stage2_scratch, + )?; + if self.metrics.is_empty() { + return Ok(OtapMetricRecords::default()); + } + res + } else { + match target_attrs { + Some(target) => target.resource_attrs_batch()?, + None => None, + } }; let univariate_metrics = Some(self.metrics.build_univariate_metrics(&mut self.scratch)?); let number_data_points = self.num_dp.build_batch(has_default_ts, &mut self.scratch)?; diff --git a/crates/expfmt/src/arrow/columns.rs b/crates/expfmt/src/arrow/columns.rs index 360e490..ac3ecbe 100644 --- a/crates/expfmt/src/arrow/columns.rs +++ b/crates/expfmt/src/arrow/columns.rs @@ -270,6 +270,67 @@ impl OptionalStringCol { .then(|| NullBuffer::new(BooleanBuffer::from_iter(self.valid.iter().copied()))); Arc::new(string_array_from_slices(&self.offsets, &self.bytes, nulls)) } + + pub(super) fn get(&self, idx: usize) -> Option<&[u8]> { + if !self.any { + return None; + } + if !self.all && !self.valid[idx] { + return None; + } + let start = self.offsets[idx] as usize; + let end = self.offsets[idx + 1] as usize; + Some(&self.bytes[start..end]) + } + + pub(super) fn compact(&mut self, keep: &[bool]) { + if !self.any { + return; + } + let mut write_row = 0usize; + let mut write_byte = 0usize; + let mut any_present = false; + let mut all_present = true; + let was_all = self.all; + + for (i, &k) in keep.iter().enumerate() { + if !k { + continue; + } + let is_valid = was_all || self.valid[i]; + if is_valid { + let start = self.offsets[i] as usize; + let end = self.offsets[i + 1] as usize; + let len = end - start; + if start != write_byte && len > 0 { + self.bytes.copy_within(start..end, write_byte); + } + write_byte += len; + any_present = true; + } else { + all_present = false; + } + if !was_all { + self.valid[write_row] = is_valid; + } + write_row += 1; + self.offsets[write_row] = write_byte as i32; + } + + if !any_present { + self.clear(); + return; + } + self.bytes.truncate(write_byte); + self.offsets.truncate(write_row + 1); + self.any = true; + self.all = all_present; + if all_present { + self.valid.clear(); + } else { + self.valid.truncate(write_row); + } + } } /// Staging buffers for `UnivariateMetrics` and `MetricAttrs`. @@ -341,6 +402,120 @@ impl MetricTable { self.metric_types.is_empty() } + #[inline] + pub(super) fn name(&self, id: u16) -> &str { + let idx = usize::from(id); + let start = self.name_offsets[idx] as usize; + let end = self.name_offsets[idx + 1] as usize; + std::str::from_utf8(&self.name_bytes[start..end]).unwrap_or_default() + } + + /// Clones metric descriptor `src_id` under `new_name`, returning the newly allocated metric + /// ID. Used when a Stage 2 `metric_relabel_configs` rule rewrites `__name__`. + pub(super) fn clone_with_name( + &mut self, + src_id: u16, + new_name: &str, + ) -> Result { + let m_idx = self.metric_types.len(); + let id = u16::try_from(m_idx).map_err(|_| DecodeError::CapacityOverflow { + table: "UnivariateMetrics", + count: m_idx + 1, + })?; + let next_name_len = self.name_bytes.len().saturating_add(new_name.len()); + let name_end_off = + i32::try_from(next_name_len).map_err(|_| DecodeError::CapacityOverflow { + table: "UnivariateMetrics.name", + count: next_name_len, + })?; + + let src = usize::from(src_id); + let desc_copy = self.desc.get(src).map(<[u8]>::to_vec); + let unit_copy = self.unit.get(src).map(<[u8]>::to_vec); + let next_desc = self.desc.check_next_offset( + desc_copy.is_some(), + desc_copy.as_deref().unwrap_or(&[]), + "UnivariateMetrics.description", + )?; + let next_unit = self.unit.check_next_offset( + unit_copy.is_some(), + unit_copy.as_deref().unwrap_or(&[]), + "UnivariateMetrics.unit", + )?; + + let otap_type = self.metric_types[src]; + let is_monotonic = self.is_monotonic[src]; + let attr_type_key = self.attr_type_keys[src]; + let has_temporality = + otap_type == OTAP_METRIC_TYPE_SUM || otap_type == OTAP_METRIC_TYPE_HISTOGRAM; + let has_sum = otap_type == OTAP_METRIC_TYPE_SUM; + + self.name_bytes.extend_from_slice(new_name.as_bytes()); + self.name_offsets.push(name_end_off); + self.metric_types.push(otap_type); + self.is_monotonic.push(is_monotonic); + self.attr_type_keys.push(attr_type_key); + self.any_temporality |= has_temporality; + self.all_temporality &= has_temporality; + self.any_sum |= has_sum; + self.all_sum &= has_sum; + self.desc + .append_checked(m_idx, next_desc, desc_copy.as_deref().unwrap_or(&[])); + self.unit + .append_checked(m_idx, next_unit, unit_copy.as_deref().unwrap_or(&[])); + Ok(id) + } + + /// Compacts the metric table to retain only rows where `keep[id]` is `true`, writing old-to-new + /// IDs into `remap`. + pub(super) fn compact(&mut self, keep: &[bool], remap: &mut Vec) { + remap.clear(); + remap.resize(keep.len(), u16::MAX); + let mut write_row = 0usize; + let mut write_byte = 0usize; + self.any_temporality = false; + self.all_temporality = true; + self.any_sum = false; + self.all_sum = true; + + for (i, &k) in keep.iter().enumerate() { + if !k { + continue; + } + remap[i] = write_row as u16; + let otap_type = self.metric_types[i]; + self.metric_types[write_row] = otap_type; + self.is_monotonic[write_row] = self.is_monotonic[i]; + self.attr_type_keys[write_row] = self.attr_type_keys[i]; + + let has_temporality = + otap_type == OTAP_METRIC_TYPE_SUM || otap_type == OTAP_METRIC_TYPE_HISTOGRAM; + let has_sum = otap_type == OTAP_METRIC_TYPE_SUM; + self.any_temporality |= has_temporality; + self.all_temporality &= has_temporality; + self.any_sum |= has_sum; + self.all_sum &= has_sum; + + let start = self.name_offsets[i] as usize; + let end = self.name_offsets[i + 1] as usize; + let len = end - start; + if start != write_byte && len > 0 { + self.name_bytes.copy_within(start..end, write_byte); + } + write_byte += len; + write_row += 1; + self.name_offsets[write_row] = write_byte as i32; + } + + self.metric_types.truncate(write_row); + self.is_monotonic.truncate(write_row); + self.attr_type_keys.truncate(write_row); + self.name_bytes.truncate(write_byte); + self.name_offsets.truncate(write_row + 1); + self.desc.compact(keep); + self.unit.compact(keep); + } + pub(super) fn build_univariate_metrics( &self, scratch: &mut ScratchBuffers, @@ -519,6 +694,47 @@ impl SparseTimestampCol { .with_timezone(UTC_TIME_ZONE); Arc::new(arr) } + + pub(super) fn compact(&mut self, keep: &[bool]) { + if self.values.is_empty() { + return; + } + let mut write = 0usize; + if self.valid.is_empty() { + for (i, &k) in keep.iter().enumerate() { + if k { + self.values[write] = self.values[i]; + write += 1; + } + } + self.values.truncate(write); + return; + } + + let mut any_present = false; + let mut all_present = true; + for (i, &k) in keep.iter().enumerate() { + if !k { + continue; + } + let ok = self.valid[i]; + self.values[write] = self.values[i]; + self.valid[write] = ok; + any_present |= ok; + all_present &= ok; + write += 1; + } + if !any_present { + self.clear(); + return; + } + self.values.truncate(write); + if all_present { + self.valid.clear(); + } else { + self.valid.truncate(write); + } + } } /// Shared leading columns (`id`, `parent_id`, `start_time_unix_nano`, `time_unix_nano`) across @@ -611,6 +827,19 @@ impl DpBaseCols { cols.push(self.time.to_array(time_nullable)); } } + + pub(super) fn compact(&mut self, keep: &[bool]) { + let mut write = 0usize; + for (i, &k) in keep.iter().enumerate() { + if k { + self.parent_ids[write] = self.parent_ids[i]; + write += 1; + } + } + self.parent_ids.truncate(write); + self.start_time.compact(keep); + self.time.compact(keep); + } } /// Staging buffer for a dense column (`count` or `sum` on summaries and histograms) whose validity @@ -660,6 +889,37 @@ impl OptionalValueCol { (!self.valid.is_empty()) .then(|| NullBuffer::new(BooleanBuffer::from_iter(self.valid.iter().copied()))) } + + pub(super) fn compact(&mut self, keep: &[bool]) { + let mut write = 0usize; + if self.valid.is_empty() { + for (i, &k) in keep.iter().enumerate() { + if k { + self.values[write] = self.values[i]; + write += 1; + } + } + self.values.truncate(write); + return; + } + let mut all_present = true; + for (i, &k) in keep.iter().enumerate() { + if !k { + continue; + } + let ok = self.valid[i]; + self.values[write] = self.values[i]; + self.valid[write] = ok; + all_present &= ok; + write += 1; + } + self.values.truncate(write); + if all_present { + self.valid.clear(); + } else { + self.valid.truncate(write); + } + } } impl OptionalValueCol { @@ -731,6 +991,50 @@ impl AttrTable { self.pairs.extend_from_slice(attrs); } + /// Retains only attribute rows whose `parent_id` survives in `parent_keep`, rewriting + /// `parent_id` via `parent_remap`. + pub(super) fn compact_by_parent(&mut self, parent_keep: &[bool], parent_remap: &[u32]) { + if self.pairs.is_empty() { + return; + } + let mut write = 0usize; + for i in 0..self.pairs.len() { + let old_parent = self.parent_ids[i] as usize; + if parent_keep[old_parent] { + self.parent_ids[write] = parent_remap[old_parent]; + self.pairs[write] = self.pairs[i]; + write += 1; + } + } + self.parent_ids.truncate(write); + self.pairs.truncate(write); + } + + /// Retains only attribute rows whose key passes `key_keep_mask`. + pub(super) fn filter_by_key_mask(&mut self, key_keep_mask: &[bool]) { + if self.pairs.is_empty() { + return; + } + let mut write = 0usize; + for i in 0..self.pairs.len() { + let pair = self.pairs[i]; + if key_keep_mask[pair.0 as usize] { + self.parent_ids[write] = self.parent_ids[i]; + self.pairs[write] = pair; + write += 1; + } + } + self.parent_ids.truncate(write); + self.pairs.truncate(write); + } + + /// Remaps every attribute key ID through `remapped_key_ids`. + pub(super) fn remap_keys(&mut self, remapped_key_ids: &[u32]) { + for pair in &mut self.pairs { + pair.0 = remapped_key_ids[pair.0 as usize]; + } + } + pub(super) fn build_batch( &self, enc: &AttrEncoding<'_>, @@ -861,6 +1165,49 @@ impl SparseFixedBinaryCol { )?; Ok(Arc::new(arr)) } + + pub(super) fn compact(&mut self, keep: &[bool]) { + if !self.any_present { + return; + } + let mut write = 0usize; + if self.valid.is_empty() { + for (i, &k) in keep.iter().enumerate() { + if k { + self.values[write] = self.values[i]; + write += 1; + } + } + self.values.truncate(write); + if write == 0 { + self.any_present = false; + } + return; + } + let mut any = false; + let mut all = true; + for (i, &k) in keep.iter().enumerate() { + if !k { + continue; + } + let ok = self.valid[i]; + self.values[write] = self.values[i]; + self.valid[write] = ok; + any |= ok; + all &= ok; + write += 1; + } + if !any { + self.clear(); + return; + } + self.values.truncate(write); + if all { + self.valid.clear(); + } else { + self.valid.truncate(write); + } + } } /// Staging buffers for an OTAP exemplar table (`NumberDpExemplars` or `HistogramDpExemplars`) and @@ -972,6 +1319,43 @@ impl ExemplarTable { Ok(Some(RecordBatch::try_new(schema, cols)?)) } + + pub(super) fn compact_by_parent( + &mut self, + dp_keep: &[bool], + dp_remap: &[u32], + ex_keep: &mut Vec, + ex_remap: &mut Vec, + ) { + if self.parent_ids.is_empty() { + return; + } + let n = self.parent_ids.len(); + ex_keep.clear(); + ex_keep.reserve(n); + ex_remap.clear(); + ex_remap.resize(n, u32::MAX); + + let mut write = 0usize; + for (i, remap_slot) in ex_remap.iter_mut().enumerate().take(n) { + let old_dp = self.parent_ids[i] as usize; + let keep = dp_keep[old_dp]; + ex_keep.push(keep); + if keep { + *remap_slot = write as u32; + self.parent_ids[write] = dp_remap[old_dp]; + self.timestamps[write] = self.timestamps[i]; + self.values[write] = self.values[i]; + write += 1; + } + } + self.parent_ids.truncate(write); + self.timestamps.truncate(write); + self.values.truncate(write); + self.span_ids.compact(ex_keep); + self.trace_ids.compact(ex_keep); + self.attrs.compact_by_parent(ex_keep, ex_remap); + } } /// Staging buffers for `NumberDataPoints`, `NumberDpAttrs`, `NumberDpExemplars`, and @@ -1036,6 +1420,30 @@ impl NumberDpTable { Ok(Some(RecordBatch::try_new(schema, cols)?)) } + + pub(super) fn compact( + &mut self, + keep: &[bool], + dp_remap: &mut Vec, + ex_keep: &mut Vec, + ex_remap: &mut Vec, + ) { + dp_remap.clear(); + dp_remap.resize(keep.len(), u32::MAX); + let mut write = 0usize; + for (i, &k) in keep.iter().enumerate() { + if k { + dp_remap[i] = write as u32; + self.values[write] = self.values[i]; + write += 1; + } + } + self.values.truncate(write); + self.base.compact(keep); + self.attrs.compact_by_parent(keep, dp_remap); + self.exemplars + .compact_by_parent(keep, dp_remap, ex_keep, ex_remap); + } } /// Staging buffers for `SummaryDataPoints` and `SummaryDpAttrs`. @@ -1124,6 +1532,40 @@ impl SummaryDpTable { Ok(Some(RecordBatch::try_new(schema, cols)?)) } + + pub(super) fn compact(&mut self, keep: &[bool], dp_remap: &mut Vec) { + dp_remap.clear(); + dp_remap.resize(keep.len(), u32::MAX); + let mut write_row = 0usize; + let mut write_q = 0usize; + for (i, &k) in keep.iter().enumerate() { + if !k { + continue; + } + dp_remap[i] = write_row as u32; + let start = self.quantile_offsets[i] as usize; + let end = self.quantile_offsets[i + 1] as usize; + let len = end - start; + if start != write_q && len > 0 { + self.quantile_bounds.copy_within(start..end, write_q); + self.quantile_vals.copy_within(start..end, write_q); + } + write_q += len; + write_row += 1; + self.quantile_offsets[write_row] = write_q as i32; + } + if write_row == 0 { + self.clear(); + return; + } + self.quantile_offsets.truncate(write_row + 1); + self.quantile_bounds.truncate(write_q); + self.quantile_vals.truncate(write_q); + self.base.compact(keep); + self.counts.compact(keep); + self.sums.compact(keep); + self.attrs.compact_by_parent(keep, dp_remap); + } } /// Staging buffers for `HistogramDataPoints`, `HistogramDpAttrs`, `HistogramDpExemplars`, and @@ -1219,6 +1661,60 @@ impl HistogramDpTable { Ok(Some(RecordBatch::try_new(schema, cols)?)) } + + pub(super) fn compact( + &mut self, + keep: &[bool], + dp_remap: &mut Vec, + ex_keep: &mut Vec, + ex_remap: &mut Vec, + ) { + dp_remap.clear(); + dp_remap.resize(keep.len(), u32::MAX); + let mut write_row = 0usize; + let mut write_bucket = 0usize; + let mut write_bound = 0usize; + for (i, &k) in keep.iter().enumerate() { + if !k { + continue; + } + dp_remap[i] = write_row as u32; + + let b_start = self.bucket_offsets[i] as usize; + let b_end = self.bucket_offsets[i + 1] as usize; + let b_len = b_end - b_start; + if b_start != write_bucket && b_len > 0 { + self.bucket_counts.copy_within(b_start..b_end, write_bucket); + } + write_bucket += b_len; + + let e_start = self.bounds_offsets[i] as usize; + let e_end = self.bounds_offsets[i + 1] as usize; + let e_len = e_end - e_start; + if e_start != write_bound && e_len > 0 { + self.bounds_vals.copy_within(e_start..e_end, write_bound); + } + write_bound += e_len; + + write_row += 1; + self.bucket_offsets[write_row] = write_bucket as i32; + self.bounds_offsets[write_row] = write_bound as i32; + } + if write_row == 0 { + self.clear(); + return; + } + self.bucket_offsets.truncate(write_row + 1); + self.bucket_counts.truncate(write_bucket); + self.bounds_offsets.truncate(write_row + 1); + self.bounds_vals.truncate(write_bound); + self.base.compact(keep); + self.counts.compact(keep); + self.sums.compact(keep); + self.attrs.compact_by_parent(keep, dp_remap); + self.exemplars + .compact_by_parent(keep, dp_remap, ex_keep, ex_remap); + } } #[inline] diff --git a/crates/expfmt/src/arrow/options.rs b/crates/expfmt/src/arrow/options.rs index 2ff2692..55eccd2 100644 --- a/crates/expfmt/src/arrow/options.rs +++ b/crates/expfmt/src/arrow/options.rs @@ -24,6 +24,7 @@ use arrow_schema::ArrowError; use crate::parse::ParseError; use super::columns::build_resource_attrs_batch; +use super::relabel::MetricRelabelPlan; use super::schema::{SERVICE_INSTANCE_ID_ATTR, SERVICE_NAME_ATTR}; /// Default upper bound on data points emitted per [`super::OtapMetricRecords`] chunk in @@ -312,6 +313,10 @@ impl TargetAttributes { &self.resolved_resource_attrs } + pub(super) fn explicit_resource_attributes(&self) -> &BTreeMap { + &self.explicit_resource_attrs + } + /// Returns `true` when neither Prometheus target labels nor explicit resource attributes are /// configured. #[must_use] @@ -340,29 +345,44 @@ impl TargetAttributes { } fn rebuild_resolved(&mut self) { - self.resolved_resource_attrs.clear(); - for (k, v) in &self.target_labels { - if k != JOB_LABEL && k != INSTANCE_LABEL { - self.resolved_resource_attrs.insert(k.clone(), v.clone()); - } - } - if let Some(job) = self.target_labels.get(JOB_LABEL) { - self.resolved_resource_attrs - .entry(SERVICE_NAME_ATTR.to_owned()) - .or_insert_with(|| job.clone()); - } - if let Some(instance) = self.target_labels.get(INSTANCE_LABEL) { - self.resolved_resource_attrs - .entry(SERVICE_INSTANCE_ID_ATTR.to_owned()) - .or_insert_with(|| instance.clone()); - } - for (k, v) in &self.explicit_resource_attrs { - self.resolved_resource_attrs.insert(k.clone(), v.clone()); - } + self.resolved_resource_attrs = + resolve_resource_attributes(&self.target_labels, &self.explicit_resource_attrs); self.cached_batch = OnceLock::new(); } } +/// Maps public Prometheus `target_labels` (`job` -> `service.name`, `instance` -> +/// `service.instance.id`, plus extra labels) and overlays `explicit_resource_attrs`. +pub(super) fn resolve_resource_attributes( + target_labels: &BTreeMap, + explicit_resource_attrs: &BTreeMap, +) -> BTreeMap { + let mut resolved = BTreeMap::new(); + for (k, v) in target_labels { + if k != JOB_LABEL + && k != INSTANCE_LABEL + && !k.starts_with(RESERVED_LABEL_PREFIX) + && !v.is_empty() + { + resolved.insert(k.clone(), v.clone()); + } + } + if let Some(job) = target_labels.get(JOB_LABEL).filter(|v| !v.is_empty()) { + resolved + .entry(SERVICE_NAME_ATTR.to_owned()) + .or_insert_with(|| job.clone()); + } + if let Some(instance) = target_labels.get(INSTANCE_LABEL).filter(|v| !v.is_empty()) { + resolved + .entry(SERVICE_INSTANCE_ID_ATTR.to_owned()) + .or_insert_with(|| instance.clone()); + } + for (k, v) in explicit_resource_attrs { + resolved.insert(k.clone(), v.clone()); + } + resolved +} + /// Options controlling [`super::ArrowDecoder::decode`] and [`super::ArrowDecoder::decode_stream`]. #[derive(Clone, Debug, PartialEq, Eq)] pub struct DecodeOptions { @@ -382,6 +402,16 @@ pub struct DecodeOptions { /// Optional target labels and OpenTelemetry resource attributes attached to every non-empty /// decoded batch as `ResourceAttrs` (`ArrowPayloadType = 1`). pub target_attributes: Option>, + /// Controls how exposed sample labels colliding with public target labels in + /// [`Self::target_attributes`] are resolved, matching Prometheus `scrape_config.honor_labels`. + /// + /// When `false` (the default), colliding exposed sample label keys are prefixed with + /// `"exported_"` in the batch key dictionary. When `true`, exposed sample labels take + /// precedence without renaming. + pub honor_labels: bool, + /// Optional compiled `metric_relabel_configs` plan executed as Stage 1 wire-series `__name__` + /// pushdown during parsing and Stage 2 dictionary-vectorized relabeling at batch finalization. + pub metric_relabel_plan: Option>, } impl Default for DecodeOptions { @@ -393,7 +423,7 @@ impl Default for DecodeOptions { impl DecodeOptions { /// Creates default [`DecodeOptions`] with no fallback timestamp, /// [`DEFAULT_MAX_DATA_POINTS_PER_BATCH`] data points per streamed batch, default translation - /// policies, and no target resource attributes. + /// policies, `honor_labels = false`, and no target resource attributes or relabel rules. #[must_use] pub const fn new() -> Self { Self { @@ -403,6 +433,8 @@ impl DecodeOptions { unit_suffix_policy: UnitSuffixPolicy::Keep, untyped_policy: UntypedPolicy::Gauge, target_attributes: None, + honor_labels: false, + metric_relabel_plan: None, } } @@ -448,6 +480,31 @@ impl DecodeOptions { self.target_attributes = Some(target_attributes); self } + + /// Sets [`Self::honor_labels`] (`false` by default, matching Go Prometheus). + #[must_use] + pub fn with_honor_labels(mut self, honor_labels: bool) -> Self { + self.honor_labels = honor_labels; + self + } + + /// Sets a pre-compiled [`MetricRelabelPlan`] shared across scrapes and chunks. + #[must_use] + pub fn with_metric_relabel_plan(mut self, plan: Arc) -> Self { + self.metric_relabel_plan = if plan.is_empty() { None } else { Some(plan) }; + self + } + + /// Compiles and attaches Prometheus `metric_relabel_configs` rules. + #[must_use] + pub fn with_metric_relabel_configs(mut self, configs: Vec) -> Self { + self.metric_relabel_plan = if configs.is_empty() { + None + } else { + Some(Arc::new(MetricRelabelPlan::new(configs))) + }; + self + } } /// Errors returned by [`super::ArrowDecoder::decode`]. @@ -502,6 +559,11 @@ pub enum DecodeError { offset: usize, }, + /// A `metric_relabel_configs` rule stripped `__name__` while leaving other labels on a series, + /// matching Prometheus `errNameLabelMandatory`. + #[error("missing metric name (__name__ label) after relabeling")] + MissingMetricName, + /// OpenMetrics payload did not end with `# EOF`. #[error("data does not end with # EOF")] MissingEof, diff --git a/crates/expfmt/src/arrow/relabel.rs b/crates/expfmt/src/arrow/relabel.rs new file mode 100644 index 0000000..1a9e947 --- /dev/null +++ b/crates/expfmt/src/arrow/relabel.rs @@ -0,0 +1,1268 @@ +// Copyright 2026 The Prometheus Authors +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +//! Stage 1 (`__name__` pushdown) and Stage 2 (dictionary-vectorized `honor_labels` and +//! `metric_relabel_configs`) execution for [`super::ArrowDecoder`]. + +use std::collections::{BTreeMap, HashMap}; + +use arrow_array::RecordBatch; +use prometheus_relabel::{ + Action, Config, DictionaryValueTransform, LabelSet, METRIC_NAME_LABEL, RelabelError, + SingleLabelKeepCache, SingleLabelTransformCache, ValidationScheme, eval_key_keep_mask_iter, + resolve_conflicting_exposed_keys_iter, split_metric_name_pushdown, +}; + +use super::columns::{ + AttrTable, HistogramDpTable, MetricTable, NumberDpTable, SummaryDpTable, + build_resource_attrs_batch, +}; +use super::intern::StringInterner; +use super::options::{DecodeError, DecodeOptions, TargetAttributes, resolve_resource_attributes}; + +/// Pre-compiled Prometheus `metric_relabel_configs` plan shared across scrapes and streaming +/// chunks via `Arc`. +/// +/// Splits rules once via [`prometheus_relabel::split_metric_name_pushdown`] into: +/// - **Stage 1** (`stage1_configs`): leading `__name__`-only `keep`, `drop`, `keepequal`, and +/// `dropequal` filters evaluated once per contiguous wire series-name transition before label +/// unescaping, string interning, or family assembly. +/// - **Stage 2** (`stage2_configs`): remaining rules executed after family assembly and string +/// interning, using dictionary-vectorized fast paths for `labeldrop`, `labelkeep`, and +/// single-label `keep`/`drop`/`replace`/`lowercase`/`uppercase`/`hashmod` rules and falling back +/// to exact per-data-point [`prometheus_relabel::process_in_place`] for general rules. +#[derive(Clone, Debug, Default, PartialEq, Eq)] +pub struct MetricRelabelPlan { + configs: Vec, + stage1_len: usize, +} + +impl MetricRelabelPlan { + /// Compiles `configs` into a two-stage [`MetricRelabelPlan`]. + #[must_use] + pub fn new(configs: Vec) -> Self { + let stage1_len = split_metric_name_pushdown(&configs).0.len(); + Self { + configs, + stage1_len, + } + } + + /// Validates every rule in `configs` against `default_scheme` and compiles a + /// [`MetricRelabelPlan`]. + /// + /// # Errors + /// + /// Returns [`RelabelError`] if any rule fails [`Config::validate`]. + pub fn try_new( + mut configs: Vec, + default_scheme: ValidationScheme, + ) -> Result { + for cfg in &mut configs { + cfg.validate(default_scheme)?; + } + Ok(Self::new(configs)) + } + + /// Returns all configured `metric_relabel_configs` rules in evaluation order. + #[must_use] + pub fn configs(&self) -> &[Config] { + &self.configs + } + + /// Returns the leading Stage 1 `__name__`-only filter prefix pushed down into ingestion. + #[must_use] + pub fn stage1_configs(&self) -> &[Config] { + &self.configs[..self.stage1_len] + } + + /// Returns the remaining Stage 2 rules evaluated at batch finalization. + #[must_use] + pub fn stage2_configs(&self) -> &[Config] { + &self.configs[self.stage1_len..] + } + + /// Returns `true` when no relabeling rules are configured. + #[must_use] + pub fn is_empty(&self) -> bool { + self.configs.is_empty() + } +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +enum CachedValAction { + Uncomputed, + KeepExisting, + Delete, + Set(u32), +} + +/// Reusable scratch buffers for Stage 2 dictionary-vectorized relabeling and general fallback, +/// keeping steady-state scrapes free of repeat heap allocations. +#[derive(Default)] +pub(super) struct Stage2Scratch { + renamed_keys: Vec>, + remapped_key_ids: Vec, + key_keep_mask: Vec, + keep_cache: SingleLabelKeepCache, + xform_cache: SingleLabelTransformCache, + mapped_val_actions: Vec, + dp_keep: Vec, + dp_remap: Vec, + ex_keep: Vec, + ex_remap: Vec, + metric_used: Vec, + metric_remap: Vec, + tmp_parent_ids: Vec, + tmp_pairs: Vec<(u32, u32)>, + tmp_str: String, + effective_target_labels: BTreeMap, + scalar_work: LabelSet, +} + +impl Stage2Scratch { + pub(super) fn retained_memory_bytes(&self) -> usize { + self.renamed_keys.capacity() * size_of::>() + + self.remapped_key_ids.capacity() * size_of::() + + self.key_keep_mask.capacity() * size_of::() + + self.keep_cache.retained_memory_bytes() + + self.xform_cache.retained_memory_bytes() + + self.mapped_val_actions.capacity() * size_of::() + + self.dp_keep.capacity() * size_of::() + + self.dp_remap.capacity() * size_of::() + + self.ex_keep.capacity() * size_of::() + + self.ex_remap.capacity() * size_of::() + + self.metric_used.capacity() * size_of::() + + self.metric_remap.capacity() * size_of::() + + self.tmp_parent_ids.capacity() * size_of::() + + self.tmp_pairs.capacity() * size_of::<(u32, u32)>() + + self.tmp_str.capacity() + } +} + +/// Runs Stage 2 `honor_labels` collision resolution and `metric_relabel_configs` over the staged +/// columnar tables before Arrow `RecordBatch` materialization. +/// +/// Returns the final `ResourceAttrs` batch to attach (reusing the cached batch on +/// [`TargetAttributes`] whenever target labels were not modified by `metric_relabel_configs`). +#[allow(clippy::too_many_arguments)] +pub(super) fn apply_stage2_relabeling( + opts: &DecodeOptions, + metrics: &mut MetricTable, + key_interner: &mut StringInterner, + val_interner: &mut StringInterner, + num_dp: &mut NumberDpTable, + sum_dp: &mut SummaryDpTable, + hist_dp: &mut HistogramDpTable, + scratch: &mut Stage2Scratch, +) -> Result, DecodeError> { + let target_attrs = opts.target_attributes.as_deref(); + let stage2_cfgs = opts + .metric_relabel_plan + .as_deref() + .map_or(&[][..], MetricRelabelPlan::stage2_configs); + + // Step 1: Resolve `honor_labels = false` collisions once across `key_interner` in + // O(unique_keys). Exemplar attributes are intentionally left untouched to match Prometheus. + if let Some(target) = target_attrs + && !opts.honor_labels + && !target.target_labels().is_empty() + { + let key_count = key_interner.len(); + let has_collision = resolve_conflicting_exposed_keys_iter( + (0..key_count).map(|i| key_interner.get(i as u32)), + target.target_labels(), + false, + &mut scratch.renamed_keys, + ); + if has_collision { + scratch.remapped_key_ids.clear(); + scratch.remapped_key_ids.reserve(key_count); + for kid in 0..key_count { + if let Some(exported) = scratch.renamed_keys[kid].as_deref() { + let new_kid = intern_key(key_interner, exported)?; + scratch.remapped_key_ids.push(new_kid); + } else { + scratch.remapped_key_ids.push(kid as u32); + } + } + num_dp.attrs.remap_keys(&scratch.remapped_key_ids); + sum_dp.attrs.remap_keys(&scratch.remapped_key_ids); + hist_dp.attrs.remap_keys(&scratch.remapped_key_ids); + } + } + + if stage2_cfgs.is_empty() { + return match target_attrs { + Some(target) => target.resource_attrs_batch(), + None => Ok(None), + }; + } + + // Step 2: Execute Stage 2 `metric_relabel_configs`. + scratch.effective_target_labels.clear(); + if let Some(target) = target_attrs { + scratch + .effective_target_labels + .clone_from(target.target_labels()); + } + let mut target_labels_dirty = false; + let mut any_dp_or_metric_mutated = false; + + let mut rule_idx = 0usize; + while rule_idx < stage2_cfgs.len() { + if all_dps_empty(num_dp, sum_dp, hist_dp) { + metrics.clear(); + return Ok(None); + } + + let cfg = &stage2_cfgs[rule_idx]; + match classify_stage2_rule(cfg) { + Stage2RuleKind::KeyFilter => { + apply_key_filter_rule( + cfg, + key_interner, + num_dp, + sum_dp, + hist_dp, + scratch, + &mut target_labels_dirty, + ); + rule_idx += 1; + } + Stage2RuleKind::SingleLabelFilter => { + let dropped_any = apply_single_label_filter_rule( + cfg, + key_interner, + val_interner, + num_dp, + sum_dp, + hist_dp, + scratch, + ); + any_dp_or_metric_mutated |= dropped_any; + rule_idx += 1; + } + Stage2RuleKind::SingleLabelTransform => { + apply_single_label_transform_rule( + cfg, + key_interner, + val_interner, + num_dp, + sum_dp, + hist_dp, + scratch, + &mut target_labels_dirty, + )?; + rule_idx += 1; + } + Stage2RuleKind::General => { + // Batch contiguous general rules into a single pass over surviving data points. + let start = rule_idx; + rule_idx += 1; + while rule_idx < stage2_cfgs.len() + && classify_stage2_rule(&stage2_cfgs[rule_idx]) == Stage2RuleKind::General + { + rule_idx += 1; + } + let mutated = apply_general_rules( + &stage2_cfgs[start..rule_idx], + metrics, + key_interner, + val_interner, + num_dp, + sum_dp, + hist_dp, + scratch, + &mut target_labels_dirty, + )?; + any_dp_or_metric_mutated |= mutated; + } + } + } + + if all_dps_empty(num_dp, sum_dp, hist_dp) { + metrics.clear(); + return Ok(None); + } + + // Step 3: Prune metric families whose data points were all dropped or renamed away. + if any_dp_or_metric_mutated { + prune_unused_metrics(metrics, num_dp, sum_dp, hist_dp, scratch); + if metrics.is_empty() { + return Ok(None); + } + } + + // Step 4: Reuse cached `ResourceAttrs` unless Stage 2 mutated or dropped a target label. + if !target_labels_dirty { + return match target_attrs { + Some(target) => target.resource_attrs_batch(), + None => Ok(None), + }; + } + + let empty_explicit = BTreeMap::new(); + let explicit = target_attrs.map_or( + &empty_explicit, + TargetAttributes::explicit_resource_attributes, + ); + let resolved = resolve_resource_attributes(&scratch.effective_target_labels, explicit); + build_resource_attrs_batch(&resolved) +} + +#[derive(Clone, Copy, PartialEq, Eq)] +enum Stage2RuleKind { + KeyFilter, + SingleLabelFilter, + SingleLabelTransform, + General, +} + +fn classify_stage2_rule(cfg: &Config) -> Stage2RuleKind { + match cfg.action { + Action::LabelDrop => { + if cfg.regex.is_match(METRIC_NAME_LABEL) { + Stage2RuleKind::General + } else { + Stage2RuleKind::KeyFilter + } + } + Action::LabelKeep => { + if cfg.regex.is_match(METRIC_NAME_LABEL) { + Stage2RuleKind::KeyFilter + } else { + Stage2RuleKind::General + } + } + Action::Keep | Action::Drop + if cfg.source_labels.len() == 1 && cfg.source_labels[0] != METRIC_NAME_LABEL => + { + Stage2RuleKind::SingleLabelFilter + } + Action::Replace | Action::Lowercase | Action::Uppercase | Action::HashMod + if cfg.source_labels.len() == 1 + && cfg.source_labels[0] != METRIC_NAME_LABEL + && cfg.target_label != METRIC_NAME_LABEL + && !cfg.target_label.contains('$') => + { + Stage2RuleKind::SingleLabelTransform + } + _ => Stage2RuleKind::General, + } +} + +#[inline] +fn all_dps_empty( + num_dp: &NumberDpTable, + sum_dp: &SummaryDpTable, + hist_dp: &HistogramDpTable, +) -> bool { + num_dp.base.is_empty() && sum_dp.base.is_empty() && hist_dp.base.is_empty() +} + +#[inline] +fn intern_key(key_interner: &mut StringInterner, key: &str) -> Result { + key_interner + .intern(key.as_bytes()) + .ok_or_else(|| DecodeError::CapacityOverflow { + table: "DpAttrs.key", + count: key_interner.len(), + }) +} + +#[inline] +fn intern_val(val_interner: &mut StringInterner, val: &str) -> Result { + val_interner + .intern(val.as_bytes()) + .ok_or_else(|| DecodeError::CapacityOverflow { + table: "DpAttrs.str", + count: val_interner.len(), + }) +} + +fn apply_key_filter_rule( + cfg: &Config, + key_interner: &StringInterner, + num_dp: &mut NumberDpTable, + sum_dp: &mut SummaryDpTable, + hist_dp: &mut HistogramDpTable, + scratch: &mut Stage2Scratch, + target_labels_dirty: &mut bool, +) { + let key_count = key_interner.len(); + if let Some(dropped) = eval_key_keep_mask_iter( + (0..key_count).map(|i| key_interner.get(i as u32)), + cfg, + &mut scratch.key_keep_mask, + ) && dropped > 0 + { + num_dp.attrs.filter_by_key_mask(&scratch.key_keep_mask); + sum_dp.attrs.filter_by_key_mask(&scratch.key_keep_mask); + hist_dp.attrs.filter_by_key_mask(&scratch.key_keep_mask); + } + + if !scratch.effective_target_labels.is_empty() { + let before = scratch.effective_target_labels.len(); + match cfg.action { + Action::LabelDrop => { + scratch + .effective_target_labels + .retain(|k, _| !cfg.regex.is_match(k)); + } + Action::LabelKeep => { + scratch + .effective_target_labels + .retain(|k, _| cfg.regex.is_match(k)); + } + _ => unreachable!(), + } + if scratch.effective_target_labels.len() != before { + *target_labels_dirty = true; + } + } +} + +fn apply_single_label_filter_rule( + cfg: &Config, + key_interner: &StringInterner, + val_interner: &StringInterner, + num_dp: &mut NumberDpTable, + sum_dp: &mut SummaryDpTable, + hist_dp: &mut HistogramDpTable, + scratch: &mut Stage2Scratch, +) -> bool { + let src_key = &cfg.source_labels[0]; + let ok = scratch.keep_cache.prepare(val_interner.len(), cfg); + debug_assert!(ok); + + let absent_keep = match scratch.effective_target_labels.get(src_key.as_str()) { + Some(tv) => match cfg.action { + Action::Keep => cfg.regex.is_match(tv), + Action::Drop => !cfg.regex.is_match(tv), + _ => unreachable!(), + }, + None => scratch.keep_cache.keep_when_absent(), + }; + + let Some(src_kid) = key_interner.lookup(src_key.as_bytes()) else { + if absent_keep { + return false; + } + num_dp.clear(); + sum_dp.clear(); + hist_dp.clear(); + return true; + }; + + let mut dropped_any = false; + + if !num_dp.base.is_empty() { + let any_dropped = eval_dp_keep_mask( + num_dp.base.len(), + &num_dp.attrs, + src_kid, + absent_keep, + val_interner, + cfg, + &mut scratch.keep_cache, + &mut scratch.dp_keep, + ); + if any_dropped { + num_dp.compact( + &scratch.dp_keep, + &mut scratch.dp_remap, + &mut scratch.ex_keep, + &mut scratch.ex_remap, + ); + dropped_any = true; + } + } + + if !sum_dp.base.is_empty() { + let any_dropped = eval_dp_keep_mask( + sum_dp.base.len(), + &sum_dp.attrs, + src_kid, + absent_keep, + val_interner, + cfg, + &mut scratch.keep_cache, + &mut scratch.dp_keep, + ); + if any_dropped { + sum_dp.compact(&scratch.dp_keep, &mut scratch.dp_remap); + dropped_any = true; + } + } + + if !hist_dp.base.is_empty() { + let any_dropped = eval_dp_keep_mask( + hist_dp.base.len(), + &hist_dp.attrs, + src_kid, + absent_keep, + val_interner, + cfg, + &mut scratch.keep_cache, + &mut scratch.dp_keep, + ); + if any_dropped { + hist_dp.compact( + &scratch.dp_keep, + &mut scratch.dp_remap, + &mut scratch.ex_keep, + &mut scratch.ex_remap, + ); + dropped_any = true; + } + } + + dropped_any +} + +#[allow(clippy::too_many_arguments)] +fn eval_dp_keep_mask( + num_dps: usize, + attrs: &AttrTable, + src_kid: u32, + absent_keep: bool, + val_interner: &StringInterner, + cfg: &Config, + keep_cache: &mut SingleLabelKeepCache, + dp_keep: &mut Vec, +) -> bool { + dp_keep.clear(); + dp_keep.reserve(num_dps); + let mut attr_pos = 0usize; + let total_attrs = attrs.pairs.len(); + let mut dropped_any = false; + + for dp_idx in 0..num_dps { + let dp_id = dp_idx as u32; + let mut found_vid: Option = None; + while attr_pos < total_attrs && attrs.parent_ids[attr_pos] == dp_id { + let (k, v) = attrs.pairs[attr_pos]; + if k == src_kid { + found_vid = Some(v); + } + attr_pos += 1; + } + let kept = match found_vid { + Some(vid) => keep_cache.keep_str(vid as usize, val_interner.get(vid), cfg), + None => absent_keep, + }; + if !kept { + dropped_any = true; + } + dp_keep.push(kept); + } + + dropped_any +} + +#[allow(clippy::too_many_arguments)] +fn apply_single_label_transform_rule( + cfg: &Config, + key_interner: &mut StringInterner, + val_interner: &mut StringInterner, + num_dp: &mut NumberDpTable, + sum_dp: &mut SummaryDpTable, + hist_dp: &mut HistogramDpTable, + scratch: &mut Stage2Scratch, + target_labels_dirty: &mut bool, +) -> Result<(), DecodeError> { + let src_key = &cfg.source_labels[0]; + let dst_key = &cfg.target_label; + let ok = scratch.xform_cache.prepare(val_interner.len(), cfg); + debug_assert!(ok); + + let src_kid = key_interner.lookup(src_key.as_bytes()); + let target_src_val = scratch + .effective_target_labels + .get(src_key.as_str()) + .cloned(); + + // Uniform source fast path: no series overrides `src_key` in `DpAttrs`, so every surviving + // series sees the same source value (either `effective_target_labels[src_key]` or `""`). + let Some(src_kid) = src_kid else { + let src_str = target_src_val.as_deref().unwrap_or(""); + let xform = if target_src_val.is_some() { + scratch.xform_cache.eval_single_str(src_str, cfg) + } else { + scratch.xform_cache.when_absent().clone() + }; + match xform { + DictionaryValueTransform::KeepExisting => {} + DictionaryValueTransform::DeleteTarget => { + if scratch + .effective_target_labels + .remove(dst_key.as_str()) + .is_some() + { + *target_labels_dirty = true; + } + if let Some(dst_kid) = key_interner.lookup(dst_key.as_bytes()) { + delete_key_from_all_dps(dst_kid, num_dp, sum_dp, hist_dp); + } + } + DictionaryValueTransform::SetTargetSlice { .. } + | DictionaryValueTransform::SetTarget(_) => { + let new_val = xform + .target_value(src_str) + .expect("SetTarget* always yields Some"); + if scratch + .effective_target_labels + .contains_key(dst_key.as_str()) + { + if scratch + .effective_target_labels + .get(dst_key.as_str()) + .map(String::as_str) + != Some(new_val) + { + scratch + .effective_target_labels + .insert(dst_key.clone(), new_val.to_owned()); + *target_labels_dirty = true; + } + if let Some(dst_kid) = key_interner.lookup(dst_key.as_bytes()) { + delete_key_from_all_dps(dst_kid, num_dp, sum_dp, hist_dp); + } + } else { + let dst_kid = intern_key(key_interner, dst_key)?; + let new_vid = intern_val(val_interner, new_val)?; + upsert_uniform_attr_on_all_dps( + dst_kid, new_vid, num_dp, sum_dp, hist_dp, scratch, + ); + } + } + } + return Ok(()); + }; + + // If a per-series varying transform targets a public target label, demote that target label + // out of `effective_target_labels` onto data points that did not already override it so + // per-series deletes or mutations cannot leak the old `ResourceAttrs` value. + if let Some(target_dst_val) = scratch.effective_target_labels.remove(dst_key.as_str()) { + *target_labels_dirty = true; + let dst_kid = intern_key(key_interner, dst_key)?; + let dst_vid = intern_val(val_interner, &target_dst_val)?; + insert_missing_attr_on_all_dps(dst_kid, dst_vid, num_dp, sum_dp, hist_dp, scratch); + } + + let absent_action = { + let src_str = target_src_val.as_deref().unwrap_or(""); + let xform = if target_src_val.is_some() { + scratch.xform_cache.eval_single_str(src_str, cfg) + } else { + scratch.xform_cache.when_absent().clone() + }; + materialize_transform_action(&xform, src_str, val_interner, &mut scratch.tmp_str)? + }; + + scratch.mapped_val_actions.clear(); + scratch + .mapped_val_actions + .resize(val_interner.len(), CachedValAction::Uncomputed); + + let mut dst_kid = key_interner.lookup(dst_key.as_bytes()); + if !num_dp.base.is_empty() { + apply_single_label_transform_table( + num_dp.base.len(), + &mut num_dp.attrs, + src_kid, + dst_key, + &mut dst_kid, + absent_action, + key_interner, + val_interner, + cfg, + scratch, + )?; + } + if !sum_dp.base.is_empty() { + apply_single_label_transform_table( + sum_dp.base.len(), + &mut sum_dp.attrs, + src_kid, + dst_key, + &mut dst_kid, + absent_action, + key_interner, + val_interner, + cfg, + scratch, + )?; + } + if !hist_dp.base.is_empty() { + apply_single_label_transform_table( + hist_dp.base.len(), + &mut hist_dp.attrs, + src_kid, + dst_key, + &mut dst_kid, + absent_action, + key_interner, + val_interner, + cfg, + scratch, + )?; + } + + Ok(()) +} + +fn materialize_transform_action( + xform: &DictionaryValueTransform, + src_str: &str, + val_interner: &mut StringInterner, + tmp_str: &mut String, +) -> Result { + match xform { + DictionaryValueTransform::KeepExisting => Ok(CachedValAction::KeepExisting), + DictionaryValueTransform::DeleteTarget => Ok(CachedValAction::Delete), + DictionaryValueTransform::SetTargetSlice { start, end } => { + tmp_str.clear(); + tmp_str.push_str(&src_str[*start..*end]); + let vid = intern_val(val_interner, tmp_str)?; + Ok(CachedValAction::Set(vid)) + } + DictionaryValueTransform::SetTarget(s) => { + let vid = intern_val(val_interner, s)?; + Ok(CachedValAction::Set(vid)) + } + } +} + +#[allow(clippy::too_many_arguments)] +fn apply_single_label_transform_table( + num_dps: usize, + attrs: &mut AttrTable, + src_kid: u32, + dst_key: &str, + dst_kid: &mut Option, + absent_action: CachedValAction, + key_interner: &mut StringInterner, + val_interner: &mut StringInterner, + cfg: &Config, + scratch: &mut Stage2Scratch, +) -> Result<(), DecodeError> { + scratch.tmp_parent_ids.clear(); + scratch.tmp_pairs.clear(); + scratch.tmp_parent_ids.reserve(attrs.parent_ids.len()); + scratch.tmp_pairs.reserve(attrs.pairs.len()); + + let mut attr_pos = 0usize; + let total_attrs = attrs.pairs.len(); + + for dp_idx in 0..num_dps { + let dp_id = dp_idx as u32; + let start = attr_pos; + let mut found_src_vid: Option = None; + while attr_pos < total_attrs && attrs.parent_ids[attr_pos] == dp_id { + let (k, v) = attrs.pairs[attr_pos]; + if k == src_kid { + found_src_vid = Some(v); + } + attr_pos += 1; + } + let end = attr_pos; + + let action = match found_src_vid { + Some(svid) => { + let idx = svid as usize; + let cached = scratch.mapped_val_actions[idx]; + if cached == CachedValAction::Uncomputed { + let computed = { + let src_str = val_interner.get(svid); + let xform = scratch.xform_cache.transform_str(idx, src_str, cfg); + match xform { + DictionaryValueTransform::KeepExisting => CachedValAction::KeepExisting, + DictionaryValueTransform::DeleteTarget => CachedValAction::Delete, + DictionaryValueTransform::SetTargetSlice { start, end } => { + scratch.tmp_str.clear(); + scratch.tmp_str.push_str(&src_str[*start..*end]); + CachedValAction::Set(u32::MAX) + } + DictionaryValueTransform::SetTarget(s) => { + scratch.tmp_str.clear(); + scratch.tmp_str.push_str(s); + CachedValAction::Set(u32::MAX) + } + } + }; + let finalized = if computed == CachedValAction::Set(u32::MAX) { + CachedValAction::Set(intern_val(val_interner, &scratch.tmp_str)?) + } else { + computed + }; + scratch.mapped_val_actions[idx] = finalized; + finalized + } else { + cached + } + } + None => absent_action, + }; + + match action { + CachedValAction::Uncomputed => unreachable!(), + CachedValAction::KeepExisting => { + scratch + .tmp_parent_ids + .extend_from_slice(&attrs.parent_ids[start..end]); + scratch + .tmp_pairs + .extend_from_slice(&attrs.pairs[start..end]); + } + CachedValAction::Delete => { + if let Some(dk) = *dst_kid { + for &pair in &attrs.pairs[start..end] { + if pair.0 != dk { + scratch.tmp_parent_ids.push(dp_id); + scratch.tmp_pairs.push(pair); + } + } + } else { + scratch + .tmp_parent_ids + .extend_from_slice(&attrs.parent_ids[start..end]); + scratch + .tmp_pairs + .extend_from_slice(&attrs.pairs[start..end]); + } + } + CachedValAction::Set(new_vid) => { + let dk = match *dst_kid { + Some(k) => k, + None => { + let k = intern_key(key_interner, dst_key)?; + *dst_kid = Some(k); + k + } + }; + let mut replaced = false; + for &pair in &attrs.pairs[start..end] { + if pair.0 == dk { + scratch.tmp_parent_ids.push(dp_id); + scratch.tmp_pairs.push((dk, new_vid)); + replaced = true; + } else { + scratch.tmp_parent_ids.push(dp_id); + scratch.tmp_pairs.push(pair); + } + } + if !replaced { + scratch.tmp_parent_ids.push(dp_id); + scratch.tmp_pairs.push((dk, new_vid)); + } + } + } + } + + std::mem::swap(&mut attrs.parent_ids, &mut scratch.tmp_parent_ids); + std::mem::swap(&mut attrs.pairs, &mut scratch.tmp_pairs); + Ok(()) +} + +fn delete_key_from_all_dps( + dst_kid: u32, + num_dp: &mut NumberDpTable, + sum_dp: &mut SummaryDpTable, + hist_dp: &mut HistogramDpTable, +) { + for attrs in [&mut num_dp.attrs, &mut sum_dp.attrs, &mut hist_dp.attrs] { + if attrs.pairs.is_empty() { + continue; + } + let mut write = 0usize; + for i in 0..attrs.pairs.len() { + let pair = attrs.pairs[i]; + if pair.0 != dst_kid { + attrs.parent_ids[write] = attrs.parent_ids[i]; + attrs.pairs[write] = pair; + write += 1; + } + } + attrs.parent_ids.truncate(write); + attrs.pairs.truncate(write); + } +} + +fn upsert_uniform_attr_on_all_dps( + dst_kid: u32, + new_vid: u32, + num_dp: &mut NumberDpTable, + sum_dp: &mut SummaryDpTable, + hist_dp: &mut HistogramDpTable, + scratch: &mut Stage2Scratch, +) { + for (num_dps, attrs) in [ + (num_dp.base.len(), &mut num_dp.attrs), + (sum_dp.base.len(), &mut sum_dp.attrs), + (hist_dp.base.len(), &mut hist_dp.attrs), + ] { + if num_dps == 0 { + continue; + } + rewrite_attr_table_with_key(num_dps, attrs, dst_kid, new_vid, true, scratch); + } +} + +fn insert_missing_attr_on_all_dps( + dst_kid: u32, + default_vid: u32, + num_dp: &mut NumberDpTable, + sum_dp: &mut SummaryDpTable, + hist_dp: &mut HistogramDpTable, + scratch: &mut Stage2Scratch, +) { + for (num_dps, attrs) in [ + (num_dp.base.len(), &mut num_dp.attrs), + (sum_dp.base.len(), &mut sum_dp.attrs), + (hist_dp.base.len(), &mut hist_dp.attrs), + ] { + if num_dps == 0 { + continue; + } + rewrite_attr_table_with_key(num_dps, attrs, dst_kid, default_vid, false, scratch); + } +} + +fn rewrite_attr_table_with_key( + num_dps: usize, + attrs: &mut AttrTable, + target_kid: u32, + val_id: u32, + overwrite_existing: bool, + scratch: &mut Stage2Scratch, +) { + scratch.tmp_parent_ids.clear(); + scratch.tmp_pairs.clear(); + scratch + .tmp_parent_ids + .reserve(attrs.parent_ids.len() + num_dps); + scratch.tmp_pairs.reserve(attrs.pairs.len() + num_dps); + + let mut attr_pos = 0usize; + let total_attrs = attrs.pairs.len(); + + for dp_idx in 0..num_dps { + let dp_id = dp_idx as u32; + let mut saw_key = false; + while attr_pos < total_attrs && attrs.parent_ids[attr_pos] == dp_id { + let pair = attrs.pairs[attr_pos]; + attr_pos += 1; + if pair.0 == target_kid { + saw_key = true; + scratch.tmp_parent_ids.push(dp_id); + scratch.tmp_pairs.push(if overwrite_existing { + (target_kid, val_id) + } else { + pair + }); + } else { + scratch.tmp_parent_ids.push(dp_id); + scratch.tmp_pairs.push(pair); + } + } + if !saw_key { + scratch.tmp_parent_ids.push(dp_id); + scratch.tmp_pairs.push((target_kid, val_id)); + } + } + + std::mem::swap(&mut attrs.parent_ids, &mut scratch.tmp_parent_ids); + std::mem::swap(&mut attrs.pairs, &mut scratch.tmp_pairs); +} + +enum TargetUniformity { + Unseen, + Uniform(String), + Diverged, +} + +/// Exact Prometheus scalar fallback for general Stage 2 rules (multi-label `source_labels`, +/// `labelmap`, `keepequal`, `dropequal`, dynamic `$1` `target_label`, or `__name__` reads/writes). +#[allow(clippy::too_many_arguments)] +fn apply_general_rules( + cfgs: &[Config], + metrics: &mut MetricTable, + key_interner: &mut StringInterner, + val_interner: &mut StringInterner, + num_dp: &mut NumberDpTable, + sum_dp: &mut SummaryDpTable, + hist_dp: &mut HistogramDpTable, + scratch: &mut Stage2Scratch, + target_labels_dirty: &mut bool, +) -> Result { + let orig_targets: Vec<(String, String)> = scratch + .effective_target_labels + .iter() + .map(|(k, v)| (k.clone(), v.clone())) + .collect(); + let mut target_states: Vec = (0..orig_targets.len()) + .map(|_| TargetUniformity::Unseen) + .collect(); + let mut renamed_metrics: HashMap<(u16, String), u16> = HashMap::new(); + let mut any_mutated = false; + + if !num_dp.base.is_empty() { + let (dropped, renamed) = apply_general_rules_table( + cfgs, + &orig_targets, + &mut target_states, + &mut renamed_metrics, + metrics, + key_interner, + val_interner, + &mut num_dp.base.parent_ids, + &mut num_dp.attrs, + scratch, + )?; + if dropped { + num_dp.compact( + &scratch.dp_keep, + &mut scratch.dp_remap, + &mut scratch.ex_keep, + &mut scratch.ex_remap, + ); + any_mutated = true; + } + any_mutated |= renamed; + } + + if !sum_dp.base.is_empty() { + let (dropped, renamed) = apply_general_rules_table( + cfgs, + &orig_targets, + &mut target_states, + &mut renamed_metrics, + metrics, + key_interner, + val_interner, + &mut sum_dp.base.parent_ids, + &mut sum_dp.attrs, + scratch, + )?; + if dropped { + sum_dp.compact(&scratch.dp_keep, &mut scratch.dp_remap); + any_mutated = true; + } + any_mutated |= renamed; + } + + if !hist_dp.base.is_empty() { + let (dropped, renamed) = apply_general_rules_table( + cfgs, + &orig_targets, + &mut target_states, + &mut renamed_metrics, + metrics, + key_interner, + val_interner, + &mut hist_dp.base.parent_ids, + &mut hist_dp.attrs, + scratch, + )?; + if dropped { + hist_dp.compact( + &scratch.dp_keep, + &mut scratch.dp_remap, + &mut scratch.ex_keep, + &mut scratch.ex_remap, + ); + any_mutated = true; + } + any_mutated |= renamed; + } + + // Re-hoist uniform surviving target labels back into `ResourceAttrs` and strip them from + // `DpAttrs` so unchanged target labels are not duplicated onto every data-point row. + if !orig_targets.is_empty() { + scratch.key_keep_mask.clear(); + scratch.key_keep_mask.resize(key_interner.len(), true); + let mut strip_any_key = false; + + for ((tk, orig_val), state) in orig_targets.iter().zip(target_states) { + match state { + TargetUniformity::Uniform(uniform_val) => { + if &uniform_val != orig_val { + scratch + .effective_target_labels + .insert(tk.clone(), uniform_val); + *target_labels_dirty = true; + } + if let Some(kid) = key_interner.lookup(tk.as_bytes()) { + scratch.key_keep_mask[kid as usize] = false; + strip_any_key = true; + } + } + TargetUniformity::Unseen | TargetUniformity::Diverged => { + if scratch + .effective_target_labels + .remove(tk.as_str()) + .is_some() + { + *target_labels_dirty = true; + } + } + } + } + + if strip_any_key { + num_dp.attrs.filter_by_key_mask(&scratch.key_keep_mask); + sum_dp.attrs.filter_by_key_mask(&scratch.key_keep_mask); + hist_dp.attrs.filter_by_key_mask(&scratch.key_keep_mask); + } + } + + Ok(any_mutated) +} + +#[allow(clippy::too_many_arguments)] +fn apply_general_rules_table( + cfgs: &[Config], + orig_targets: &[(String, String)], + target_states: &mut [TargetUniformity], + renamed_metrics: &mut HashMap<(u16, String), u16>, + metrics: &mut MetricTable, + key_interner: &mut StringInterner, + val_interner: &mut StringInterner, + dp_metric_ids: &mut [u16], + attrs: &mut AttrTable, + scratch: &mut Stage2Scratch, +) -> Result<(bool, bool), DecodeError> { + let num_dps = dp_metric_ids.len(); + scratch.dp_keep.clear(); + scratch.dp_keep.reserve(num_dps); + scratch.tmp_parent_ids.clear(); + scratch.tmp_pairs.clear(); + scratch.tmp_parent_ids.reserve(attrs.parent_ids.len()); + scratch.tmp_pairs.reserve(attrs.pairs.len()); + + let mut attr_pos = 0usize; + let total_attrs = attrs.pairs.len(); + let mut dropped_any = false; + let mut renamed_any = false; + + for (dp_idx, metric_id_slot) in dp_metric_ids.iter_mut().enumerate() { + let dp_id = dp_idx as u32; + let orig_metric_id = *metric_id_slot; + let orig_name = metrics.name(orig_metric_id); + + scratch.scalar_work.clear(); + scratch + .scalar_work + .insert(METRIC_NAME_LABEL.to_owned(), orig_name.to_owned()); + for (tk, tv) in orig_targets { + scratch.scalar_work.insert(tk.clone(), tv.clone()); + } + while attr_pos < total_attrs && attrs.parent_ids[attr_pos] == dp_id { + let (kid, vid) = attrs.pairs[attr_pos]; + attr_pos += 1; + scratch.scalar_work.insert( + key_interner.get(kid).to_owned(), + val_interner.get(vid).to_owned(), + ); + } + + let kept = prometheus_relabel::process_in_place(&mut scratch.scalar_work, cfgs); + if !kept || scratch.scalar_work.is_empty() { + scratch.dp_keep.push(false); + dropped_any = true; + continue; + } + + let Some(new_name) = scratch.scalar_work.remove(METRIC_NAME_LABEL) else { + return Err(DecodeError::MissingMetricName); + }; + if new_name.is_empty() { + return Err(DecodeError::MissingMetricName); + } + + if new_name != orig_name { + let new_metric_id = if let Some(&cached_id) = + renamed_metrics.get(&(orig_metric_id, new_name.clone())) + { + cached_id + } else { + let id = metrics.clone_with_name(orig_metric_id, &new_name)?; + renamed_metrics.insert((orig_metric_id, new_name), id); + id + }; + *metric_id_slot = new_metric_id; + renamed_any = true; + } + + for ((tk, _), state) in orig_targets.iter().zip(target_states.iter_mut()) { + match scratch.scalar_work.get(tk.as_str()) { + Some(v) => match state { + TargetUniformity::Unseen => *state = TargetUniformity::Uniform(v.clone()), + TargetUniformity::Uniform(prev) if prev == v => {} + TargetUniformity::Uniform(_) | TargetUniformity::Diverged => { + *state = TargetUniformity::Diverged; + } + }, + None => *state = TargetUniformity::Diverged, + } + } + + for (k, v) in &scratch.scalar_work { + let kid = intern_key(key_interner, k)?; + let vid = intern_val(val_interner, v)?; + scratch.tmp_parent_ids.push(dp_id); + scratch.tmp_pairs.push((kid, vid)); + } + scratch.dp_keep.push(true); + } + + std::mem::swap(&mut attrs.parent_ids, &mut scratch.tmp_parent_ids); + std::mem::swap(&mut attrs.pairs, &mut scratch.tmp_pairs); + Ok((dropped_any, renamed_any)) +} + +fn prune_unused_metrics( + metrics: &mut MetricTable, + num_dp: &mut NumberDpTable, + sum_dp: &mut SummaryDpTable, + hist_dp: &mut HistogramDpTable, + scratch: &mut Stage2Scratch, +) { + let num_metrics = metrics.len(); + scratch.metric_used.clear(); + scratch.metric_used.resize(num_metrics, false); + for &id in &num_dp.base.parent_ids { + scratch.metric_used[usize::from(id)] = true; + } + for &id in &sum_dp.base.parent_ids { + scratch.metric_used[usize::from(id)] = true; + } + for &id in &hist_dp.base.parent_ids { + scratch.metric_used[usize::from(id)] = true; + } + if scratch.metric_used.iter().all(|&u| u) { + return; + } + metrics.compact(&scratch.metric_used, &mut scratch.metric_remap); + for id in &mut num_dp.base.parent_ids { + *id = scratch.metric_remap[usize::from(*id)]; + } + for id in &mut sum_dp.base.parent_ids { + *id = scratch.metric_remap[usize::from(*id)]; + } + for id in &mut hist_dp.base.parent_ids { + *id = scratch.metric_remap[usize::from(*id)]; + } +} diff --git a/crates/expfmt/src/lib.rs b/crates/expfmt/src/lib.rs index b878c03..c57dbe0 100644 --- a/crates/expfmt/src/lib.rs +++ b/crates/expfmt/src/lib.rs @@ -18,6 +18,8 @@ pub mod arrow; #[cfg(feature = "dto")] pub mod dto; pub mod format; +#[cfg(feature = "arrow")] +pub use prometheus_relabel as relabel; // Layer 0 parsers remain crate-internal; `arrow` and `dto` expose the public decoding APIs. #[allow(dead_code, unused_imports)] pub(crate) mod parse; From 87efe0ad0826c0dc62c7539211ed06cbc7385201 Mon Sep 17 00:00:00 2001 From: Bartek Plotka Date: Wed, 18 Nov 2026 05:25:34 +0000 Subject: [PATCH 3/3] tests, benches, docs: verify ArrowDecoder honor_labels and two-stage relabeling Add unit tests covering honor_labels collision handling and exemplar preservation, Stage 1 __name__ pushdown (including histograms and cooperative budgets), Stage 2 dictionary-vectorized rules, general scalar fallback with a prometheus-relabel oracle, and empty-chunk dropping. Add OTAP/OTLP round-trip coverage and enable MetricRelabelPlan in the dhat bounded-memory test, add a Stage 1 + Stage 2 decode benchmark case, and update specs/SPEC.md. Signed-off-by: Bartek Plotka --- crates/expfmt/benches/decode.rs | 61 ++- crates/expfmt/src/arrow/tests.rs | 562 ++++++++++++++++++++ specs/SPEC.md | 12 +- tests/otap-compat/tests/arrow_otap.rs | 119 +++++ tests/otap-compat/tests/dhat_bounded_mem.rs | 17 +- 5 files changed, 763 insertions(+), 8 deletions(-) diff --git a/crates/expfmt/benches/decode.rs b/crates/expfmt/benches/decode.rs index 1c8e4f5..a7d026e 100644 --- a/crates/expfmt/benches/decode.rs +++ b/crates/expfmt/benches/decode.rs @@ -24,11 +24,15 @@ use std::future::Future; use std::hint::black_box; use std::path::Path; use std::pin::{Pin, pin}; +use std::sync::Arc; use std::task::{Context, Poll, Waker}; use benchfmt::{CountingAlloc, Suite}; -use prometheus_expfmt::arrow::{ArrowDecoder, DecodeBudget, DecodeOptions, DecodeStep}; +use prometheus_expfmt::arrow::{ + ArrowDecoder, DecodeBudget, DecodeOptions, DecodeStep, MetricRelabelPlan, TargetAttributes, +}; use prometheus_expfmt::format::Format; +use prometheus_expfmt::relabel::{Action, Config, METRIC_NAME_LABEL, Regexp}; #[global_allocator] static ALLOC: CountingAlloc = CountingAlloc::new(); @@ -232,5 +236,60 @@ fn main() { ); } + let relabel_target = Arc::new(TargetAttributes::from_target_labels([ + ("job", "prometheus"), + ("instance", "127.0.0.1:9090"), + ("env", "prod"), + ("handler", "target-handler"), + ])); + let relabel_plan = Arc::new(MetricRelabelPlan::new(vec![ + Config { + source_labels: vec![METRIC_NAME_LABEL.to_owned()], + regex: Regexp::must_new("(prometheus|go)_.*"), + action: Action::Keep, + ..Config::default() + }, + Config { + regex: Regexp::must_new("le_unused_.*"), + action: Action::LabelDrop, + ..Config::default() + }, + Config { + source_labels: vec!["handler".to_owned()], + regex: Regexp::must_new("/.*"), + target_label: "route_group".to_owned(), + replacement: "http".to_owned(), + action: Action::Replace, + ..Config::default() + }, + ])); + let relabel_opts = DecodeOptions::new() + .with_timestamp_ms(0) + .with_target_attributes(relabel_target) + .with_honor_labels(false) + .with_metric_relabel_plan(relabel_plan); + let full_bytes_len = full_bytes.len() as u64; + + suite = suite.bench( + "Decode/case=alltypes.237mfs/mode=relabel_stage1_stage2", + move |b| { + let mut decoder = ArrowDecoder::new(); + black_box( + decoder + .decode(full_bytes, &Format::TEXT, &relabel_opts) + .unwrap(), + ); + + b.set_bytes(full_bytes_len); + b.report_allocs(); + while b.keep_running() { + let records = decoder + .decode(black_box(full_bytes), &Format::TEXT, &relabel_opts) + .unwrap(); + black_box(records); + } + }, + ); + suite.run(); } diff --git a/crates/expfmt/src/arrow/tests.rs b/crates/expfmt/src/arrow/tests.rs index a8a6b5c..9be2fef 100644 --- a/crates/expfmt/src/arrow/tests.rs +++ b/crates/expfmt/src/arrow/tests.rs @@ -1395,3 +1395,565 @@ fn target_attributes_emit_resource_attrs_and_map_job_and_instance() { &DataType::Dictionary(Box::new(DataType::UInt16), Box::new(DataType::Utf8)) ); } + +fn extract_attrs_by_parent_u32( + batch: Option<&arrow_array::RecordBatch>, +) -> std::collections::BTreeMap> { + use std::collections::BTreeMap; + + use arrow_array::UInt32Array; + + let mut out: BTreeMap> = BTreeMap::new(); + let Some(batch) = batch else { + return out; + }; + let parents = batch + .column_by_name("parent_id") + .unwrap() + .as_any() + .downcast_ref::() + .unwrap(); + let key_col = batch.column_by_name("key").unwrap(); + let val_col = batch.column_by_name("str").unwrap(); + + let read_str = |col: &arrow_array::ArrayRef, row: usize| -> String { + if let Some(d) = col.as_any().downcast_ref::>() { + let vals = d.values().as_any().downcast_ref::().unwrap(); + vals.value(usize::from(d.keys().value(row))).to_owned() + } else if let Some(d) = col.as_any().downcast_ref::>() { + let vals = d.values().as_any().downcast_ref::().unwrap(); + vals.value(usize::from(d.keys().value(row))).to_owned() + } else { + col.as_any() + .downcast_ref::() + .unwrap() + .value(row) + .to_owned() + } + }; + + for row in 0..batch.num_rows() { + out.entry(parents.value(row)) + .or_default() + .insert(read_str(key_col, row), read_str(val_col, row)); + } + out +} + +fn extract_resource_attrs( + batch: Option<&arrow_array::RecordBatch>, +) -> std::collections::BTreeMap { + use std::collections::BTreeMap; + + let mut out = BTreeMap::new(); + let Some(batch) = batch else { + return out; + }; + let key_col = batch.column_by_name("key").unwrap(); + let val_col = batch.column_by_name("str").unwrap(); + let read_str = |col: &arrow_array::ArrayRef, row: usize| -> String { + if let Some(d) = col.as_any().downcast_ref::>() { + let vals = d.values().as_any().downcast_ref::().unwrap(); + vals.value(usize::from(d.keys().value(row))).to_owned() + } else if let Some(d) = col.as_any().downcast_ref::>() { + let vals = d.values().as_any().downcast_ref::().unwrap(); + vals.value(usize::from(d.keys().value(row))).to_owned() + } else { + col.as_any() + .downcast_ref::() + .unwrap() + .value(row) + .to_owned() + } + }; + for row in 0..batch.num_rows() { + out.insert(read_str(key_col, row), read_str(val_col, row)); + } + out +} + +#[test] +fn honor_labels_collision_resolution_and_exemplar_preservation() { + use std::collections::BTreeMap; + use std::sync::Arc; + + let target = Arc::new(TargetAttributes::from_target_labels([ + ("job", "prom-job"), + ("instance", "10.0.0.1:9090"), + ("foo", "target-foo"), + ("exported_foo", "target-exported-foo"), + ])); + + let payload = concat!( + "# TYPE req_total counter\n", + "req_total{job=\"sample-job\",foo=\"1\",exported_foo=\"2\",method=\"GET\"} 7 # {job=\"ex-job\",trace_id=\"00112233445566778899aabbccddeeff\"} 1 1700000000\n", + "# EOF\n", + ); + + let mut dec = ArrowDecoder::new(); + + // `honor_labels = false` (default): colliding series keys get `exported_` prefixing in + // ascending key-length order, while exemplar attributes stay untouched. + let opts_false = DecodeOptions::new() + .with_timestamp_ms(1_700_000_000_000) + .with_target_attributes(Arc::clone(&target)); + let rec_false = dec + .decode(payload.as_bytes(), &Format::OPEN_METRICS_1_0_0, &opts_false) + .unwrap(); + let dp_attrs = extract_attrs_by_parent_u32(rec_false.number_dp_attrs()); + assert_eq!( + dp_attrs.get(&0), + Some(&BTreeMap::from([ + ("exported_exported_exported_foo".to_owned(), "2".to_owned()), + ("exported_exported_foo".to_owned(), "1".to_owned()), + ("exported_job".to_owned(), "sample-job".to_owned()), + ("method".to_owned(), "GET".to_owned()), + ])) + ); + let ex_attrs = extract_attrs_by_parent_u32(rec_false.number_dp_exemplar_attrs()); + assert_eq!( + ex_attrs.get(&0), + Some(&BTreeMap::from([("job".to_owned(), "ex-job".to_owned())])) + ); + + // `honor_labels = true`: exposed metric labels stay unprefixed. + let opts_true = opts_false.with_honor_labels(true); + let rec_true = dec + .decode(payload.as_bytes(), &Format::OPEN_METRICS_1_0_0, &opts_true) + .unwrap(); + let dp_attrs_true = extract_attrs_by_parent_u32(rec_true.number_dp_attrs()); + assert_eq!( + dp_attrs_true.get(&0), + Some(&BTreeMap::from([ + ("exported_foo".to_owned(), "2".to_owned()), + ("foo".to_owned(), "1".to_owned()), + ("job".to_owned(), "sample-job".to_owned()), + ("method".to_owned(), "GET".to_owned()), + ])) + ); +} + +#[test] +fn stage1_pushdown_filters_wire_series_across_scalar_histogram_and_cooperative_streaming() { + use std::pin::pin; + use std::task::{Context, Poll, Waker}; + + use prometheus_relabel::{Action, Config, METRIC_NAME_LABEL, Regexp}; + + let payload = concat!( + "# TYPE http_requests_total counter\n", + "http_requests_total{method=\"GET\"} 10\n", + "http_requests_total{method=\"POST\"} 20\n", + "# TYPE go_goroutines gauge\n", + "go_goroutines 42\n", + "# TYPE http_latency_seconds histogram\n", + "http_latency_seconds_bucket{le=\"0.5\"} 3\n", + "http_latency_seconds_bucket{le=\"+Inf\"} 5\n", + "http_latency_seconds_sum 2.5\n", + "http_latency_seconds_count 5\n", + "# TYPE rpc_latency_seconds summary\n", + "rpc_latency_seconds{quantile=\"0.5\"} 0.1\n", + "rpc_latency_seconds_sum 1.0\n", + "rpc_latency_seconds_count 10\n", + ); + + // Keep only `http_*` wire series and drop histogram `*_bucket` series at Stage 1. + let plan = MetricRelabelPlan::new(vec![ + Config { + source_labels: vec![METRIC_NAME_LABEL.to_owned()], + regex: Regexp::must_new("http_.*"), + action: Action::Keep, + ..Config::default() + }, + Config { + source_labels: vec![METRIC_NAME_LABEL.to_owned()], + regex: Regexp::must_new(".*_bucket"), + action: Action::Drop, + ..Config::default() + }, + ]); + assert_eq!(plan.stage1_configs().len(), 2); + assert!(plan.stage2_configs().is_empty()); + + let opts = DecodeOptions::new() + .with_timestamp_ms(1_700_000_000_000) + .with_metric_relabel_plan(std::sync::Arc::new(plan)); + + let mut dec = ArrowDecoder::new(); + let rec = dec + .decode(payload.as_bytes(), &Format::TEXT, &opts) + .unwrap(); + let metrics = rec.univariate_metrics().unwrap(); + let names = metrics + .column_by_name("name") + .unwrap() + .as_any() + .downcast_ref::() + .unwrap(); + let emitted_names: Vec<&str> = (0..names.len()).map(|i| names.value(i)).collect(); + assert_eq!( + emitted_names, + vec!["http_requests_total", "http_latency_seconds"] + ); + assert!(rec.summary_data_points().is_none()); + let hist = rec.histogram_data_points().unwrap(); + assert_eq!(hist.num_rows(), 1); + let bounds = hist + .column_by_name("explicit_bounds") + .unwrap() + .as_any() + .downcast_ref::() + .unwrap(); + assert_eq!(bounds.value(0).len(), 0); + + // Cooperative decoding still respects budgets even when Stage 1 drops 100% of series. + let drop_all_opts = DecodeOptions::new().with_metric_relabel_configs(vec![Config { + source_labels: vec![METRIC_NAME_LABEL.to_owned()], + regex: Regexp::must_new(".*"), + action: Action::Drop, + ..Config::default() + }]); + let mut yields = 0usize; + let budget = DecodeBudget::new(2, 8 << 20, std::time::Duration::from_secs(60)); + let dropped_res = { + let mut fut = pin!(dec.decode_cooperative( + payload.as_bytes(), + &Format::TEXT, + &drop_all_opts, + budget, + || { + yields += 1; + std::future::ready(()) + }, + )); + let mut cx = Context::from_waker(Waker::noop()); + loop { + if let Poll::Ready(res) = fut.as_mut().poll(&mut cx) { + break res.unwrap(); + } + } + }; + assert!(dropped_res.is_empty()); + assert!(yields > 0); +} + +#[test] +fn stage2_dictionary_relabeling_covers_labeldrop_filters_transforms_targets_and_empty_chunks() { + use std::collections::BTreeMap; + use std::sync::Arc; + + use prometheus_relabel::{Action, Config, Regexp, ValidationScheme}; + + let target = Arc::new( + TargetAttributes::from_target_labels([ + ("job", "api"), + ("instance", "10.0.0.1:9090"), + ("env", "prod"), + ("drop_target", "bye"), + ]) + .with_resource_attribute("cloud.region", "us-east1"), + ); + + let payload = concat!( + "# TYPE drop_me_gauge gauge\n", + "drop_me_gauge{env_tag=\"DEV\",pod=\"worker-1111\",ephemeral_a=\"x\"} 1\n", + "# TYPE keep_me_total counter\n", + "keep_me_total{env_tag=\"DEV\",pod=\"api-dead\",ephemeral_a=\"x\"} 2 # {trace_id=\"00112233445566778899aabbccddeeff\",ex_k=\"dropped\"} 2 1700000000\n", + "keep_me_total{env_tag=\"PROD\",pod=\"api-7f8b\",ephemeral_a=\"x\"} 5 # {trace_id=\"ffeeddccbbaa99887766554433221100\",ex_k=\"kept\"} 5 1700000000\n", + "# EOF\n", + ); + + let plan = Arc::new( + MetricRelabelPlan::try_new( + vec![ + Config { + regex: Regexp::must_new("ephemeral_.*|drop_target"), + action: Action::LabelDrop, + ..Config::default() + }, + Config { + source_labels: vec!["env".to_owned()], + regex: Regexp::must_new("prod"), + action: Action::Keep, + ..Config::default() + }, + Config { + source_labels: vec!["env_tag".to_owned()], + regex: Regexp::must_new("PROD"), + action: Action::Keep, + ..Config::default() + }, + Config { + source_labels: vec!["env_tag".to_owned()], + target_label: "env_tag".to_owned(), + action: Action::Lowercase, + ..Config::default() + }, + Config { + source_labels: vec!["pod".to_owned()], + regex: Regexp::must_new("([a-z0-9-]+)-[0-9a-f]+"), + target_label: "app".to_owned(), + replacement: "$1".to_owned(), + action: Action::Replace, + ..Config::default() + }, + Config { + source_labels: vec!["job".to_owned()], + target_label: "job".to_owned(), + action: Action::Uppercase, + ..Config::default() + }, + ], + ValidationScheme::Utf8, + ) + .unwrap(), + ); + + let opts = DecodeOptions::new() + .with_timestamp_ms(1_700_000_000_000) + .with_target_attributes(target) + .with_metric_relabel_plan(plan); + + let mut dec = ArrowDecoder::new(); + let rec = dec + .decode(payload.as_bytes(), &Format::OPEN_METRICS_1_0_0, &opts) + .unwrap(); + + // `drop_me_gauge` was completely pruned; only `keep_me_total` with `env_tag="prod"` survives. + let metrics = rec.univariate_metrics().unwrap(); + assert_eq!(metrics.num_rows(), 1); + let names = metrics + .column_by_name("name") + .unwrap() + .as_any() + .downcast_ref::() + .unwrap(); + assert_eq!(names.value(0), "keep_me_total"); + + let dps = rec.number_data_points().unwrap(); + assert_eq!(dps.num_rows(), 1); + let dp_attrs = extract_attrs_by_parent_u32(rec.number_dp_attrs()); + assert_eq!( + dp_attrs.get(&0), + Some(&BTreeMap::from([ + ("app".to_owned(), "api".to_owned()), + ("env_tag".to_owned(), "prod".to_owned()), + ("pod".to_owned(), "api-7f8b".to_owned()), + ])) + ); + + // Only the surviving data point's exemplar remains, re-indexed to `parent_id = 0`. + let exemplars = rec.number_dp_exemplars().unwrap(); + assert_eq!(exemplars.num_rows(), 1); + let ex_attrs = extract_attrs_by_parent_u32(rec.number_dp_exemplar_attrs()); + assert_eq!( + ex_attrs.get(&0), + Some(&BTreeMap::from([("ex_k".to_owned(), "kept".to_owned())])) + ); + + // `drop_target` was removed and `job` was uppercased to `"API"` -> `service.name = "API"`. + let res_attrs = extract_resource_attrs(rec.resource_attrs()); + assert_eq!( + res_attrs, + BTreeMap::from([ + ("cloud.region".to_owned(), "us-east1".to_owned()), + ("env".to_owned(), "prod".to_owned()), + ( + SERVICE_INSTANCE_ID_ATTR.to_owned(), + "10.0.0.1:9090".to_owned() + ), + (SERVICE_NAME_ATTR.to_owned(), "API".to_owned()), + ]) + ); + + // Streaming with `max_data_points_per_batch = 1` skips chunks whose points are all dropped. + let stream_opts = opts.with_max_data_points_per_batch(1); + let chunks: Vec<_> = dec + .decode_stream( + payload.as_bytes(), + &Format::OPEN_METRICS_1_0_0, + &stream_opts, + ) + .collect::, _>>() + .unwrap(); + assert_eq!(chunks.len(), 1); + assert_eq!(chunks[0].num_data_points(), 1); +} + +#[test] +fn stage2_general_fallback_and_end_to_end_oracle_match_prometheus() { + use std::collections::BTreeMap; + use std::sync::Arc; + + use prometheus_relabel::{ + Action, Config, LabelSet, METRIC_NAME_LABEL, Regexp, merge_target_and_metric_labels, + process_in_place, + }; + + // 1. General rules: metric rename splitting one family into two, `labelmap`, and multi-label `replace`. + let target_labels = LabelSet::from([ + ("job".to_owned(), "checkout".to_owned()), + ("instance".to_owned(), "10.0.0.2:8080".to_owned()), + ("region".to_owned(), "eu".to_owned()), + ]); + let target = Arc::new(TargetAttributes::from_target_labels(&target_labels)); + + let cfgs = vec![ + Config { + source_labels: vec![METRIC_NAME_LABEL.to_owned()], + regex: Regexp::must_new("(http|app)_.*"), + action: Action::Keep, + ..Config::default() + }, + Config { + regex: Regexp::must_new("tmp_.*"), + action: Action::LabelDrop, + ..Config::default() + }, + Config { + source_labels: vec!["region".to_owned(), "method".to_owned()], + separator: ":".to_owned(), + regex: Regexp::must_new("(.+):(.+)"), + target_label: "route".to_owned(), + replacement: "$1/$2".to_owned(), + action: Action::Replace, + ..Config::default() + }, + Config { + regex: Regexp::must_new("meta_(.+)"), + replacement: "m_$1".to_owned(), + action: Action::LabelMap, + ..Config::default() + }, + Config { + source_labels: vec![METRIC_NAME_LABEL.to_owned(), "v".to_owned()], + separator: "_".to_owned(), + regex: Regexp::must_new("app_events_(v[12])"), + target_label: METRIC_NAME_LABEL.to_owned(), + replacement: "app_events_$1".to_owned(), + action: Action::Replace, + ..Config::default() + }, + ]; + + type OracleSample<'a> = (&'a str, &'a [(&'a str, &'a str)], f64); + + let samples: &[OracleSample<'_>] = &[ + ( + "http_reqs_total", + &[ + ("job", "inner"), + ("method", "GET"), + ("tmp_x", "1"), + ("meta_a", "z"), + ], + 10.0, + ), + ("go_gc_seconds", &[("method", "GET")], 1.0), + ("app_events", &[("v", "v1"), ("method", "POST")], 3.0), + ("app_events", &[("v", "v2"), ("method", "PUT")], 4.0), + ]; + + let mut payload = String::new(); + for (name, labels, val) in samples { + payload.push_str(name); + payload.push('{'); + for (i, (k, v)) in labels.iter().enumerate() { + if i > 0 { + payload.push(','); + } + payload.push_str(&format!("{k}=\"{v}\"")); + } + payload.push_str(&format!("}} {val}\n")); + } + + for honor_labels in [false, true] { + let mut expected: Vec = Vec::new(); + for (name, labels, _) in samples { + let mut ls = LabelSet::new(); + ls.insert(METRIC_NAME_LABEL.to_owned(), (*name).to_owned()); + for (k, v) in *labels { + ls.insert((*k).to_owned(), (*v).to_owned()); + } + merge_target_and_metric_labels(&mut ls, &target_labels, honor_labels); + if process_in_place(&mut ls, &cfgs) { + expected.push(ls); + } + } + + let opts = DecodeOptions::new() + .with_target_attributes(Arc::clone(&target)) + .with_honor_labels(honor_labels) + .with_metric_relabel_configs(cfgs.clone()); + let mut dec = ArrowDecoder::new(); + let rec = dec + .decode(payload.as_bytes(), &Format::TEXT, &opts) + .unwrap(); + + // Reconstruct each surviving data point's complete Prometheus label set from + // `UnivariateMetrics.name` + `ResourceAttrs` (reverse-mapping `service.name`/`service.instance.id`) + `NumberDpAttrs`. + let res_attrs = extract_resource_attrs(rec.resource_attrs()); + let dp_attrs = extract_attrs_by_parent_u32(rec.number_dp_attrs()); + let metrics = rec.univariate_metrics().unwrap(); + let metric_names = metrics + .column_by_name("name") + .unwrap() + .as_any() + .downcast_ref::() + .unwrap(); + let dps = rec.number_data_points().unwrap(); + let dp_parents = dps + .column_by_name("parent_id") + .unwrap() + .as_any() + .downcast_ref::() + .unwrap(); + + let mut actual: Vec = Vec::new(); + for row in 0..dps.num_rows() { + let mut ls = BTreeMap::new(); + ls.insert( + METRIC_NAME_LABEL.to_owned(), + metric_names + .value(usize::from(dp_parents.value(row))) + .to_owned(), + ); + for (rk, rv) in &res_attrs { + let prom_key = if rk == SERVICE_NAME_ATTR { + "job" + } else if rk == SERVICE_INSTANCE_ID_ATTR { + "instance" + } else { + rk.as_str() + }; + ls.insert(prom_key.to_owned(), rv.clone()); + } + if let Some(attrs) = dp_attrs.get(&(row as u32)) { + for (k, v) in attrs { + ls.insert(k.clone(), v.clone()); + } + } + actual.push(ls); + } + assert_eq!(actual, expected, "mismatch for honor_labels={honor_labels}"); + } + + // 2. Removing `__name__` while other labels remain returns `DecodeError::MissingMetricName`, + // matching Go Prometheus `errNameLabelMandatory`. + let strip_name_opts = DecodeOptions::new().with_metric_relabel_configs(vec![Config { + regex: Regexp::must_new(METRIC_NAME_LABEL), + action: Action::LabelDrop, + ..Config::default() + }]); + let mut dec = ArrowDecoder::new(); + let err = dec + .decode(b"foo{a=\"1\"} 1\n", &Format::TEXT, &strip_name_opts) + .unwrap_err(); + assert!(matches!(err, DecodeError::MissingMetricName)); + + // Removing all labels (leaving an empty label set) drops the series cleanly like Go. + let drop_empty = dec + .decode(b"foo 1\n", &Format::TEXT, &strip_name_opts) + .unwrap(); + assert!(drop_empty.is_empty()); +} diff --git a/specs/SPEC.md b/specs/SPEC.md index c23feb3..dd3106f 100644 --- a/specs/SPEC.md +++ b/specs/SPEC.md @@ -124,9 +124,9 @@ scrape bytes - `ArrowDecoder` appends parsed metrics, attributes, number data points, summary data points, classic and exponential histogram data points, and exemplars directly into Arrow array builders (`arrow-array` and `arrow-schema`), matching the relational `id` and `parent_id` tables in [`rust/otap-dataflow/crates/pdata`](https://github.com/open-telemetry/otel-arrow/tree/main/rust/otap-dataflow/crates/pdata). Callers can materialize one batch set per scrape with `ArrowDecoder::decode`, pull bounded chunks on demand with `ArrowDecoder::decode_stream` to cap scratch memory and stay within OTAP's `u16` per-batch metric ID limit, or yield cooperatively between bounded steps with `DecodeBudget`, `DecodeStep`, `DecodeStream::step`, `DecodeCursor` (`ArrowDecoder::start_decode` / `start_decode_stream` / `step_decode`), `ArrowDecoder::decode_cooperative`, and `DecodeStream::next_cooperative` so multi-megabyte scrapes do not starve timers or peer tasks on single-threaded `!Send` `LocalSet` runtimes. - Metric families in text exposition are decoded as contiguous runs, with `# HELP`, `# TYPE`, and `# UNIT` metadata lines preceding that family's samples. Like OpenMetrics 1.0/2.0 and Prometheus's scrape loop, `ArrowDecoder` tracks only the active family cursor instead of maintaining a whole-scrape hash table to reassemble or reject previously seen names, so a non-contiguous repetition of an earlier metric name starts a fresh untyped run unless preceded by its own metadata. -- Rather than materializing a per-sample `BTreeMap` or running regular expressions on every scraped text line, `metric_relabel_configs` and `honor_labels` will wire into `ArrowDecoder` (Phase 4, `#35`) as a two-stage pipeline (see [Target and metric relabeling architecture](#target-and-metric-relabeling-architecture)): - 1. **Stage 1 (`__name__` series filter pushdown)**: Leading `keep`, `drop`, `keepequal`, and `dropequal` rules that inspect only `__name__` will run once per contiguous wire series-name transition (e.g. `foo_bucket`, `foo_sum`, `foo_count`, matching Prometheus `scrape/scrape.go`) so dropped series runs skip float parsing, label unescaping, string interning, and family assembly. - 2. **Stage 2 (dictionary-vectorized relabeling and `honor_labels`)**: Once kept series have been assembled into metric families (collapsing classic histogram `_bucket`, `_sum`, and `_count` lines into a single `HistogramDataPoints` row) and their label keys and values have been deduplicated in `key_interner` and `val_interner`, attribute-level `honor_labels` collision resolution, `labeldrop` / `labelkeep`, and single-label `keep` / `drop` / value transformations (`replace`, `lowercase`, `uppercase`, `hashmod`) will execute across unique dictionary entries (memoized per `source_labels[0]` value ID) instead of $O(N_{\text{samples}})$. +- Rather than materializing a per-sample `BTreeMap` or running regular expressions on every scraped text line, `metric_relabel_configs` (`MetricRelabelPlan`) and `honor_labels` wire into `ArrowDecoder` as a two-stage pipeline (see [Target and metric relabeling architecture](#target-and-metric-relabeling-architecture)): + 1. **Stage 1 (`__name__` series filter pushdown)**: Leading `keep`, `drop`, `keepequal`, and `dropequal` rules that inspect only `__name__` run once per contiguous wire series-name transition (e.g. `foo_bucket`, `foo_sum`, `foo_count`, matching Prometheus `scrape/scrape.go`) so dropped series runs skip label unescaping, string interning, and family assembly. + 2. **Stage 2 (dictionary-vectorized relabeling and `honor_labels`)**: Once kept series have been assembled into metric families (collapsing classic histogram `_bucket`, `_sum`, and `_count` lines into a single `HistogramDataPoints` row) and their label keys and values have been deduplicated in `key_interner` and `val_interner`, attribute-level `honor_labels` collision resolution, `labeldrop` / `labelkeep`, and single-label `keep` / `drop` / value transformations (`replace`, `lowercase`, `uppercase`, `hashmod`) execute across unique dictionary entries (memoized per `source_labels[0]` value ID) instead of $O(N_{\text{samples}})$, falling back to per-data-point `process_in_place` only for general multi-label, `labelmap`, `keepequal`/`dropequal`, dynamic `target_label`, or `__name__`-mutating rules. - The metric family assembler groups classic histogram `_bucket`, `_sum`, and `_count` lines and summary `quantile`, `_sum`, and `_count` lines (plus OpenMetrics `_created` start timestamps) into complete metric families. - Configurable translation policies control counter `_total` and unit suffix handling and untyped series handling. - `ArrowDecoder` owns its scratch buffers and Arrow builders without internal locks or global state, so a per-core `!Send` receiver can reuse allocations across scrapes with bounded memory. @@ -139,10 +139,10 @@ The `relabel` module implements Prometheus `relabel_configs`, `metric_relabel_co - Runs once per discovered target endpoint (cold path) over `relabel::LabelSet` (`BTreeMap`) via `populate_discovered_labels` and `populate_labels`. - Populates reserved discovery labels (`__address__`, `__scheme__`, `__metrics_path__`, `__scrape_interval__`, `__scrape_timeout__`, `__param_*`, `job`), executes all 11 Prometheus relabel actions, strips `__meta_*` labels, and defaults `instance` to `__address__`. - Non-reserved target labels (`PopulatedTarget::public_labels()`) attach once per scrape to the batch's `ResourceAttrs` (`job` -> `service.name`, `instance` -> `service.instance.id`) rather than duplicating unchanged target labels onto every data-point attribute row. When a `metric_relabel_configs` rule reads or mutates a public target label key (such as `source_labels: ["job"]`, `target_label: "job"`, `labeldrop`, `labelkeep`, or `labelmap`), Stage 2 resolves that key against the post-`honor_labels` target label value (using the target label when `honor_labels = false` or when the series omits that key under `honor_labels = true`) and materializes per-point attribute overrides only if a rule mutates or drops the target label. -2. **Stage 1 pre-staging `__name__` filter pushdown (Layer 1 ingestion, wired in Phase 4 / `#35`)**: +2. **Stage 1 pre-staging `__name__` filter pushdown (Layer 1 ingestion)**: - `relabel::split_metric_name_pushdown` extracts the leading prefix of `metric_relabel_configs` rules (`keep`, `drop`, `keepequal`, `dropequal`) that depend exclusively on `__name__`. - - `ArrowDecoder` will evaluate `relabel::keep_metric_name` against the wire series `__name__` (such as `foo_bucket` or `foo_count`, not the stripped family base name `foo`) once when transitioning to a new contiguous series-name run, discarding dropped series runs before parsing sample floats, unescaping labels, interning strings, or staging histogram buckets. -3. **Stage 2 dictionary-vectorized relabeling and Layer 3 DataFusion SIMD execution (`ArrowDecoder` wiring in Phase 4 / `#35`)**: + - `ArrowDecoder` evaluates `relabel::keep_metric_name` against the wire series `__name__` (such as `foo_bucket` or `foo_count`, not the stripped family base name `foo`) once when transitioning to a new contiguous series-name run, discarding dropped series runs before unescaping labels, interning strings, or staging histogram buckets. +3. **Stage 2 dictionary-vectorized relabeling and Layer 3 DataFusion SIMD execution**: - After `ArrowDecoder` interns label keys into `key_interner` ($U_{\text{keys}}$ unique keys, typically ~32) and label values into `val_interner` ($U_{\text{vals}}$ unique values across all keys), dictionary-level primitives in `relabel` avoid per-sample regex and string allocations: - **`honor_labels = false` (`relabel::resolve_conflicting_exposed_keys`)**: Checks `key_interner` against public target labels in $O(U_{\text{keys}})$. When no sample label key collides with a target label key (the common case), `honor_labels` is a zero-copy no-op. When a collision occurs, only the colliding dictionary entries are renamed to `exported_` in ascending key-length order. Note that whereas Go [`resolveConflictingExposedLabels`](https://github.com/prometheus/prometheus/blob/236a2b1fe8e0471586ff29cb8fd8929372643650/scrape/scrape.go#L682-L697) checks `exported_` occupancy per series (like scalar `merge_target_and_metric_labels`), `resolve_conflicting_exposed_keys` intentionally resolves collisions once across the batch-wide `key_interner` dictionary so key indices do not have to be rewritten per series; if another series in the same batch already exposes `exported_`, `` is renamed to `exported_exported_` across the batch dictionary. - **`labeldrop` / `labelkeep` (`relabel::eval_key_keep_mask`)**: Evaluates the key regex once per unique entry in `key_interner` ($O(U_{\text{keys}})$) to build a boolean key-ID mask used to filter `(key_id, val_id)` attribute rows. diff --git a/tests/otap-compat/tests/arrow_otap.rs b/tests/otap-compat/tests/arrow_otap.rs index ec4c8e6..8f7a1c9 100644 --- a/tests/otap-compat/tests/arrow_otap.rs +++ b/tests/otap-compat/tests/arrow_otap.rs @@ -1095,6 +1095,125 @@ fn target_attributes_round_trip_through_otap_resource_attrs_and_downstream_upser assert!(res_attrs.contains(&kv_str("gcp.project_id", "gpe-test-1"))); } +#[test] +fn honor_labels_and_two_stage_metric_relabeling_round_trip_through_otap_and_otlp() { + use std::sync::Arc; + + use prometheus_expfmt::arrow::MetricRelabelPlan; + use prometheus_expfmt::relabel::{Action, Config, METRIC_NAME_LABEL, Regexp, ValidationScheme}; + + let target = Arc::new( + TargetAttributes::from_target_labels([ + ("__address__", "10.0.0.9:9090"), + ("job", "checkout"), + ("instance", "10.0.0.9:9090"), + ("env", "prod"), + ("drop_me_target", "unused"), + ]) + .with_resource_attribute("cloud.region", "us-central1"), + ); + + let plan = Arc::new( + MetricRelabelPlan::try_new( + vec![ + Config { + source_labels: vec![METRIC_NAME_LABEL.to_owned()], + regex: Regexp::must_new("http_.*"), + action: Action::Keep, + ..Config::default() + }, + Config { + regex: Regexp::must_new("debug_.*|drop_me_target"), + action: Action::LabelDrop, + ..Config::default() + }, + Config { + source_labels: vec!["status".to_owned()], + regex: Regexp::must_new("2.."), + action: Action::Keep, + ..Config::default() + }, + Config { + source_labels: vec!["pod".to_owned()], + regex: Regexp::must_new("([a-z]+)-[0-9a-f]+"), + target_label: "app".to_owned(), + replacement: "$1".to_owned(), + action: Action::Replace, + ..Config::default() + }, + ], + ValidationScheme::Utf8, + ) + .expect("valid relabel plan"), + ); + + let payload = concat!( + "# TYPE go_goroutines gauge\n", + "go_goroutines{status=\"200\"} 10\n", + "# TYPE http_requests_total counter\n", + "http_requests_total{job=\"exporter\",status=\"500\",pod=\"web-aaaa\",debug_id=\"1\"} 1 # {job=\"ex\",trace_id=\"00112233445566778899aabbccddeeff\"} 1 1700000000\n", + "http_requests_total{job=\"exporter\",status=\"200\",pod=\"api-7f8b\",debug_id=\"2\"} 9 # {job=\"ex\",trace_id=\"ffeeddccbbaa99887766554433221100\"} 9 1700000000\n", + "# TYPE http_latency_seconds histogram\n", + "http_latency_seconds_bucket{status=\"200\",pod=\"api-7f8b\",le=\"0.5\"} 2\n", + "http_latency_seconds_bucket{status=\"200\",pod=\"api-7f8b\",le=\"+Inf\"} 2\n", + "http_latency_seconds_sum{status=\"200\",pod=\"api-7f8b\"} 0.4\n", + "http_latency_seconds_count{status=\"200\",pod=\"api-7f8b\"} 2\n", + "# EOF\n", + ); + + let mut decoder = ArrowDecoder::new(); + let opts = DecodeOptions::new() + .with_timestamp_ms(1_700_000_000_000) + .with_target_attributes(target) + .with_honor_labels(false) + .with_metric_relabel_plan(plan); + let decoded = decoder + .decode(payload.as_bytes(), &Format::OPEN_METRICS_1_0_0, &opts) + .expect("relabeled decode succeeds"); + + let mut otap = to_otap_arrow_records(&decoded); + otap.encode_transport_optimized() + .expect("transport optimize succeeds"); + otap.decode_transport_optimized_ids() + .expect("transport decode IDs succeeds"); + + let OtlpProtoMessage::Metrics(otlp) = otap_to_otlp(&otap) else { + panic!("expected OTLP MetricsData"); + }; + assert_eq!(otlp.resource_metrics.len(), 1); + let res_attrs = &otlp.resource_metrics[0] + .resource + .as_ref() + .expect("resource present") + .attributes; + assert!(res_attrs.contains(&kv_str(SERVICE_NAME_ATTR, "checkout"))); + assert!(res_attrs.contains(&kv_str(SERVICE_INSTANCE_ID_ATTR, "10.0.0.9:9090"))); + assert!(res_attrs.contains(&kv_str("env", "prod"))); + assert!(res_attrs.contains(&kv_str("cloud.region", "us-central1"))); + assert!(!res_attrs.iter().any(|kv| kv.key == "drop_me_target")); + + let metrics = &otlp.resource_metrics[0].scope_metrics[0].metrics; + assert_eq!(metrics.len(), 2); + assert_eq!(metrics[0].name, "http_requests_total"); + assert_eq!(metrics[1].name, "http_latency_seconds"); + + let Some(metric::Data::Sum(sum)) = &metrics[0].data else { + panic!("expected Sum for http_requests_total"); + }; + assert_eq!(sum.data_points.len(), 1); + let dp = &sum.data_points[0]; + assert!(dp.attributes.contains(&kv_str("exported_job", "exporter"))); + assert!(dp.attributes.contains(&kv_str("app", "api"))); + assert!(dp.attributes.contains(&kv_str("status", "200"))); + assert!(!dp.attributes.iter().any(|kv| kv.key == "debug_id")); + assert_eq!(dp.exemplars.len(), 1); + assert!( + dp.exemplars[0] + .filtered_attributes + .contains(&kv_str("job", "ex")) + ); +} + async fn probe_scheduling_lateness( mut completed: tokio::sync::oneshot::Receiver, period: Duration, diff --git a/tests/otap-compat/tests/dhat_bounded_mem.rs b/tests/otap-compat/tests/dhat_bounded_mem.rs index a62eaa3..979bf94 100644 --- a/tests/otap-compat/tests/dhat_bounded_mem.rs +++ b/tests/otap-compat/tests/dhat_bounded_mem.rs @@ -254,7 +254,22 @@ fn local_set_non_send_repeated_scrapes_keep_bounded_memory() { .with_instance("10.0.0.1:9090") .with_target_label("env", "prod"), ); - let om_opts = opts.with_target_attributes(target_attrs); + let relabel_plan = Arc::new(prometheus_expfmt::arrow::MetricRelabelPlan::new(vec![ + prometheus_expfmt::relabel::Config { + source_labels: vec![prometheus_expfmt::relabel::METRIC_NAME_LABEL.to_owned()], + regex: prometheus_expfmt::relabel::Regexp::must_new("go_.*"), + action: prometheus_expfmt::relabel::Action::Drop, + ..prometheus_expfmt::relabel::Config::default() + }, + prometheus_expfmt::relabel::Config { + regex: prometheus_expfmt::relabel::Regexp::must_new("ephemeral_.*"), + action: prometheus_expfmt::relabel::Action::LabelDrop, + ..prometheus_expfmt::relabel::Config::default() + }, + ])); + let om_opts = opts + .with_target_attributes(target_attrs) + .with_metric_relabel_plan(relabel_plan); let om_handle = tokio::task::spawn_local(async move { let mut warmup_om_dec_mem = 0usize; let mut warmup_om_live_heap = 0usize;