refactor(planner): rename latency_sla to optional latency_sla_ms

asap-planner-rs/src/bin/candidate_gen_dump.rs

@@ -61,7 +61,7 @@ fn main() -> anyhow::Result<()> {
                 query_string: q.clone(),
                 t_repeat_ms: qg.repetition_delay_ms,
                 accuracy_sla: qg.controller_options.accuracy_sla,
-                latency_sla: qg.controller_options.latency_sla,
+                latency_sla_ms: qg.controller_options.latency_sla_ms,
             })
         })
         .collect();
@@ -71,13 +71,13 @@ fn main() -> anyhow::Result<()> {
 
     for (i, aqe) in aqes.iter().enumerate() {
         println!(
-            "\n--- Item #{i}: metric={} stat={:?} range={}ms T={}ms accuracy_sla={} latency_sla={} freq={:.4}Hz ---",
+            "\n--- Item #{i}: metric={} stat={:?} range={}ms T={}ms accuracy_sla={} latency_sla_ms={:?} freq={:.4}Hz ---",
             aqe.requirements.metric,
             aqe.requirements.statistics,
             aqe.requirements.data_range_ms,
             aqe.t_repeat_ms,
             aqe.accuracy_sla,
-            aqe.latency_sla,
+            aqe.latency_sla_ms,
             aqe.query_frequency_hz,
         );
         println!("  queries: {:?}", aqe.query_strings);

asap-planner-rs/src/config/input.rs

@@ -32,16 +32,16 @@ pub struct ControllerConfig {
 }
 
 impl ControllerConfig {
-    /// Warn if any query group has both SLAs at 0.0 (the serde Default),
-    /// which indicates `controller_options` was omitted from the config.
+    /// Warn if any query group still has the serde-default SLAs, which
+    /// indicates `controller_options` was omitted from the config.
     pub fn warn_default_slas(&self) {
         for qg in &self.query_groups {
             let opts = &qg.controller_options;
-            if opts.accuracy_sla == 0.0 && opts.latency_sla == 0.0 {
+            if opts.accuracy_sla == 0.0 && opts.latency_sla_ms.is_none() {
                 warn!(
                     query_group_id = ?qg.id,
                     "controller_options not set in query group; \
-                     accuracy_sla=0.0 and latency_sla=0.0 will be used — \
+                     accuracy_sla=0.0 and no latency_sla_ms limit will be used — \
                      add controller_options to your config"
                 );
             }
@@ -63,6 +63,7 @@ impl ControllerConfig {
 }
 
 #[derive(Debug, Clone, Deserialize)]
+#[serde(deny_unknown_fields)]
 pub struct QueryGroup {
     pub id: Option<u32>,
     pub queries: Vec<String>,
@@ -79,11 +80,13 @@ pub struct QueryGroup {
 }
 
 #[derive(Debug, Clone, Deserialize, Default)]
+#[serde(deny_unknown_fields)]
 pub struct ControllerOptions {
     #[serde(deserialize_with = "deserialize_finite_f64")]
     pub accuracy_sla: f64,
-    #[serde(deserialize_with = "deserialize_finite_f64")]
-    pub latency_sla: f64,
+    /// Maximum modeled query latency in milliseconds; `None` means no limit.
+    #[serde(default, deserialize_with = "deserialize_optional_positive_f64")]
+    pub latency_sla_ms: Option<f64>,
 }
 
 fn deserialize_finite_f64<'de, D>(deserializer: D) -> Result<f64, D::Error>
@@ -98,6 +101,18 @@ where
     }
 }
 
+fn deserialize_optional_positive_f64<'de, D>(deserializer: D) -> Result<Option<f64>, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    match Option::<f64>::deserialize(deserializer)? {
+        Some(value) if !(value.is_finite() && value > 0.0) => Err(serde::de::Error::custom(
+            "must be a finite number greater than zero",
+        )),
+        value => Ok(value),
+    }
+}
+
 fn deserialize_positive_u64<'de, D>(deserializer: D) -> Result<u64, D::Error>
 where
     D: Deserializer<'de>,
@@ -211,6 +226,7 @@ pub struct HllParams {
 }
 
 #[derive(Debug, Clone, Deserialize)]
+#[serde(deny_unknown_fields)]
 pub struct SQLControllerConfig {
     pub query_groups: Vec<SQLQueryGroup>,
     pub tables: Vec<TableDefinition>,
@@ -220,6 +236,7 @@ pub struct SQLControllerConfig {
 }
 
 #[derive(Debug, Clone, Deserialize)]
+#[serde(deny_unknown_fields)]
 pub struct SQLQueryGroup {
     pub id: Option<u32>,
     pub queries: Vec<String>,
@@ -237,13 +254,15 @@ pub struct TableDefinition {
 }
 
 #[derive(Debug, Clone, Deserialize)]
+#[serde(deny_unknown_fields)]
 pub struct ElasticDSLControllerConfig {
     pub query_groups: Vec<ElasticDSLQueryGroup>,
     pub sketch_parameters: Option<SketchParameterOverrides>,
     pub aggregate_cleanup: Option<AggregateCleanupConfig>,
 }
 
 #[derive(Debug, Clone, Deserialize)]
+#[serde(deny_unknown_fields)]
 pub struct ElasticDSLQueryGroup {
     pub id: Option<u32>,
     pub queries: Vec<String>,
@@ -265,7 +284,6 @@ query_groups:
     repetition_delay_ms: 60000
     controller_options:
       accuracy_sla: .nan
-      latency_sla: .inf
 "#;
 
         let error = serde_yaml::from_str::<ControllerConfig>(yaml)
@@ -283,13 +301,126 @@ query_groups:
     repetition_delay_ms: 60000
     controller_options:
       accuracy_sla: 0.99
-      latency_sla: 1.0
+      latency_sla_ms: 250.0
 "#;
 
         let config: ControllerConfig = serde_yaml::from_str(yaml).unwrap();
         let options = &config.query_groups[0].controller_options;
         assert_eq!(options.accuracy_sla, 0.99);
-        assert_eq!(options.latency_sla, 1.0);
+        assert_eq!(options.latency_sla_ms, Some(250.0));
+    }
+
+    #[test]
+    fn omitted_latency_sla_ms_means_no_limit() {
+        let yaml = r#"
+query_groups:
+  - queries: [sum(metric)]
+    repetition_delay_ms: 60000
+    controller_options:
+      accuracy_sla: 0.99
+"#;
+
+        let config: ControllerConfig = serde_yaml::from_str(yaml).unwrap();
+        assert_eq!(
+            config.query_groups[0].controller_options.latency_sla_ms,
+            None
+        );
+    }
+
+    // Reject the unitless `latency_sla` key so it can't be silently ignored.
+    #[test]
+    fn rejects_legacy_latency_sla_key() {
+        let yaml = r#"
+query_groups:
+  - queries: [sum(metric)]
+    repetition_delay_ms: 60000
+    controller_options:
+      accuracy_sla: 0.99
+      latency_sla: 1.0
+"#;
+
+        let error = serde_yaml::from_str::<ControllerConfig>(yaml)
+            .expect_err("legacy latency_sla key must be rejected")
+            .to_string();
+        assert!(error.contains("unknown field `latency_sla`"), "{error}");
+    }
+
+    #[test]
+    fn rejects_misspelled_controller_options() {
+        // A typo would otherwise drop the whole SLA block to its defaults.
+        let yaml = r#"
+query_groups:
+  - queries: [sum(metric)]
+    repetition_delay_ms: 60000
+    controler_options:
+      accuracy_sla: 0.99
+"#;
+
+        let error = serde_yaml::from_str::<ControllerConfig>(yaml)
+            .expect_err("unknown query group key must be rejected")
+            .to_string();
+        assert!(
+            error.contains("unknown field `controler_options`"),
+            "{error}"
+        );
+    }
+
+    #[test]
+    fn sql_and_elastic_configs_reject_unknown_group_keys() {
+        let sql = r#"
+tables: []
+query_groups:
+  - queries: ["SELECT 1"]
+    repetition_delay_ms: 60000
+    latency_sla: 1.0
+    controller_options:
+      accuracy_sla: 0.99
+"#;
+        let error = serde_yaml::from_str::<SQLControllerConfig>(sql)
+            .expect_err("unknown SQL group key must be rejected")
+            .to_string();
+        assert!(error.contains("unknown field `latency_sla`"), "{error}");
+
+        let elastic = r#"
+query_groups:
+  - queries: ["{}"]
+    repetition_delay_ms: 60000
+    index: i
+    time_field: t
+    controler_options:
+      accuracy_sla: 0.99
+"#;
+        let error = serde_yaml::from_str::<ElasticDSLControllerConfig>(elastic)
+            .expect_err("unknown Elastic group key must be rejected")
+            .to_string();
+        assert!(
+            error.contains("unknown field `controler_options`"),
+            "{error}"
+        );
+    }
+
+    #[test]
+    fn rejects_non_positive_or_non_finite_latency_sla_ms() {
+        for bad in ["0.0", "-5.0", ".inf", ".nan"] {
+            let yaml = format!(
+                r#"
+query_groups:
+  - queries: [sum(metric)]
+    repetition_delay_ms: 60000
+    controller_options:
+      accuracy_sla: 0.99
+      latency_sla_ms: {bad}
+"#
+            );
+
+            let error = serde_yaml::from_str::<ControllerConfig>(&yaml)
+                .expect_err("invalid latency_sla_ms must be rejected")
+                .to_string();
+            assert!(
+                error.contains("must be a finite number greater than zero"),
+                "{bad}: {error}"
+            );
+        }
     }
 
     #[test]

asap-planner-rs/src/optimizer/aqe_extractor.rs

@@ -20,7 +20,7 @@ pub struct RQE {
     pub query_string: String,
     pub t_repeat_ms: u64,
     pub accuracy_sla: f64,
-    pub latency_sla: f64,
+    pub latency_sla_ms: Option<f64>,
 }
 
 /// Stable key for merging identical optimizer demand.
@@ -36,7 +36,7 @@ struct OptimizerItemKey {
     topk_by_labels: Option<KeyByLabelNames>,
     t_repeat_ms: u64,
     accuracy_sla_bits: u64,
-    latency_sla_bits: u64,
+    latency_sla_ms_bits: Option<u64>,
 }
 
 impl OptimizerItemKey {
@@ -51,7 +51,7 @@ impl OptimizerItemKey {
             topk_by_labels: req.topk_by_labels.clone(),
             t_repeat_ms: rqe.t_repeat_ms,
             accuracy_sla_bits: normalized_f64_bits(rqe.accuracy_sla),
-            latency_sla_bits: normalized_f64_bits(rqe.latency_sla),
+            latency_sla_ms_bits: rqe.latency_sla_ms.map(normalized_f64_bits),
         }
     }
 }
@@ -110,7 +110,7 @@ pub fn extract_aqes(
                 query_frequency_hz,
                 t_repeat_ms: key.t_repeat_ms,
                 accuracy_sla: f64::from_bits(key.accuracy_sla_bits),
-                latency_sla: f64::from_bits(key.latency_sla_bits),
+                latency_sla_ms: key.latency_sla_ms_bits.map(f64::from_bits),
             },
         )
         .collect())
@@ -236,7 +236,7 @@ mod tests {
             query_string: query.to_string(),
             t_repeat_ms: t_ms,
             accuracy_sla: 0.0,
-            latency_sla: 0.0,
+            latency_sla_ms: None,
         }
     }
 
@@ -309,10 +309,24 @@ mod tests {
         assert_eq!(items.len(), 2);
     }
 
+    #[test]
+    fn different_latency_slas_become_distinct_items() {
+        let unlimited = rqe("sum_over_time(metric[5m])", 60_000);
+        let mut fast = rqe("sum_over_time(metric[5m])", 60_000);
+        fast.latency_sla_ms = Some(100.0);
+        let mut slow = rqe("sum_over_time(metric[5m])", 60_000);
+        slow.latency_sla_ms = Some(1_000.0);
+
+        let items = extract_aqes(&[unlimited, fast, slow], &empty_schema(), 15_000).unwrap();
+        let mut slas: Vec<_> = items.iter().map(|item| item.latency_sla_ms).collect();
+        slas.sort_by(|a, b| a.partial_cmp(b).unwrap());
+        assert_eq!(slas, vec![None, Some(100.0), Some(1_000.0)]);
+    }
+
     #[test]
     fn signed_zero_slas_merge_into_one_item() {
         let mut negative_zero = rqe("sum_over_time(metric[5m])", 60_000);
-        negative_zero.latency_sla = -0.0;
+        negative_zero.accuracy_sla = -0.0;
         let items = extract_aqes(
             &[negative_zero, rqe("sum_over_time(metric[5m])", 60_000)],
             &empty_schema(),

asap-planner-rs/src/optimizer/candidate_gen.rs

@@ -408,7 +408,7 @@ mod tests {
             query_frequency_hz: 1.0 / 60.0,
             t_repeat_ms: min_t,
             accuracy_sla: 0.0,
-            latency_sla: 0.0,
+            latency_sla_ms: None,
         }
     }
 

asap-planner-rs/src/optimizer/cost_model.rs

@@ -216,7 +216,7 @@ mod tests {
             query_frequency_hz: 1.0 / 60.0,
             t_repeat_ms: min_t,
             accuracy_sla: 0.0,
-            latency_sla: 0.0,
+            latency_sla_ms: None,
         }
     }
 

asap-planner-rs/src/optimizer/error.rs

@@ -24,6 +24,6 @@ pub struct UnservableItem {
     pub data_range_ms: u64,
     pub t_repeat_ms: u64,
     pub accuracy_sla: f64,
-    pub latency_sla: f64,
+    pub latency_sla_ms: Option<f64>,
     pub reason: String,
 }

asap-planner-rs/src/optimizer/greedy.rs

@@ -66,7 +66,7 @@ pub fn greedy_assign(
                 data_range_ms: aqe.requirements.data_range_ms,
                 t_repeat_ms: aqe.t_repeat_ms,
                 accuracy_sla: aqe.accuracy_sla,
-                latency_sla: aqe.latency_sla,
+                latency_sla_ms: aqe.latency_sla_ms,
                 reason: "no candidate remained after structural and atomic-cost filters".into(),
             });
             continue;
@@ -139,7 +139,7 @@ mod tests {
             query_frequency_hz: freq_hz,
             t_repeat_ms: min_t,
             accuracy_sla: 0.0,
-            latency_sla: 0.0,
+            latency_sla_ms: None,
         }
     }
 
@@ -196,7 +196,7 @@ mod tests {
             query_frequency_hz: 1.0 / 60.0,
             t_repeat_ms: 60_000,
             accuracy_sla: 0.0,
-            latency_sla: 0.0,
+            latency_sla_ms: None,
         };
         let error = greedy_assign(
             vec![aqe.clone()],

asap-planner-rs/src/optimizer/label_set_facts.rs

@@ -308,7 +308,7 @@ mod tests {
             query_frequency_hz: 1.0 / 60.0,
             t_repeat_ms: 60_000,
             accuracy_sla: 0.0,
-            latency_sla: 0.0,
+            latency_sla_ms: None,
         }
     }
 

asap-planner-rs/src/optimizer/pipeline.rs

@@ -104,7 +104,7 @@ fn config_to_rqes(config: &ControllerConfig) -> Vec<RQE> {
                 query_string: q.clone(),
                 t_repeat_ms: qg.repetition_delay_ms,
                 accuracy_sla: qg.controller_options.accuracy_sla,
-                latency_sla: qg.controller_options.latency_sla,
+                latency_sla_ms: qg.controller_options.latency_sla_ms,
             })
         })
         .collect()