fix(uptime): only download body bytes if the assertion needs them (#483)

Author: klochek

src/assertions/mod.rs

@@ -9,6 +9,35 @@ pub struct Assertion {
     pub(crate) root: Op,
 }
 
+impl Assertion {
+    fn requires_body_impl(op: &Op) -> bool {
+        match op {
+            Op::And { children } => children.iter().any(Assertion::requires_body_impl),
+            Op::Or { children } => children.iter().any(Assertion::requires_body_impl),
+            Op::Not { operand } => Assertion::requires_body_impl(operand),
+            Op::StatusCodeCheck {
+                value: _,
+                operator: _,
+            } => false,
+            Op::JsonPath {
+                value: _,
+                operator: _,
+                operand: _,
+            } => true,
+            Op::HeaderCheck {
+                key_op: _,
+                key_operand: _,
+                value_op: _,
+                value_operand: _,
+            } => false,
+        }
+    }
+
+    pub fn requires_body(&self) -> bool {
+        Assertion::requires_body_impl(&self.root)
+    }
+}
+
 #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, Hash)]
 #[serde(tag = "cmp", rename_all = "snake_case")]
 #[derive(Default)]

src/checker/reqwest_checker.rs

@@ -531,7 +531,11 @@ impl Checker for ReqwestChecker {
             || (self.response_capture_enabled && check.get_config().capture_response_on_failure);
 
         // Read body bytes if we have an assertion OR if we should capture on failure.
-        let needs_body_for_assertion = check.get_config().assertion.is_some();
+        let needs_body_for_assertion = if let Some(assertion) = &check.get_config().assertion {
+            assertion.requires_body()
+        } else {
+            false
+        };
         let body_bytes = if (needs_body_for_assertion || should_capture) && response.is_ok() {
             let Ok((resp, _req_id)) = &mut response else {
                 unreachable!("enclosing if-statement means this cannot happen");
@@ -718,7 +722,7 @@ impl Checker for ReqwestChecker {
 
 #[cfg(test)]
 mod tests {
-    use crate::assertions;
+    use crate::assertions::{self, Assertion};
     use crate::check_executor::ScheduledCheck;
     use crate::checker::Checker;
     use crate::config_store::Tick;
@@ -1020,6 +1024,58 @@ mod tests {
         mock.assert();
     }
 
+    #[tokio::test]
+    async fn test_jsonpath_body_downloads() {
+        let server = MockServer::start();
+        let checker = ReqwestChecker::new_internal(
+            Options {
+                validate_url: false,
+                disable_connection_reuse: true,
+                response_capture_enabled: false, // disabled
+                ..Default::default()
+            },
+            assertions::cache::Cache::new(),
+        );
+
+        let mock = server.mock(|when, then| {
+            when.method(Method::GET)
+                .path("/no-head")
+                .header_exists("sentry-trace")
+                .header("User-Agent", UPTIME_USER_AGENT.to_string());
+            then.status(200).body("{ \"foo\":\"bar\"}");
+        });
+
+        let config = CheckConfig {
+            url: server.url("/no-head").to_string(),
+            assertion: Assertion {
+                root: assertions::Op::And {
+                    children: vec![assertions::Op::Or {
+                        children: vec![assertions::Op::Not {
+                            operand: assertions::Op::JsonPath {
+                                value: "$.foo".to_owned(),
+                                operator: assertions::Comparison::Equals,
+                                operand: assertions::JSONPathOperand::Literal {
+                                    value: "baz".to_owned(),
+                                },
+                            }
+                            .into(),
+                        }],
+                    }],
+                },
+            }
+            .into(),
+            ..Default::default()
+        };
+
+        let tick = make_tick();
+        let check = ScheduledCheck::new_for_test(tick, config);
+        let result = checker.check_url(&check, "us-west").await;
+
+        assert_eq!(result.status, CheckStatus::Success);
+
+        mock.assert();
+    }
+
     #[tokio::test]
     async fn test_response_capture_forced() {
         let server = MockServer::start();