cleanup ugly codex impl

Author: THardy98

crates/sdk-core/src/abstractions.rs

@@ -427,10 +427,11 @@ macro_rules! dbg_panic {
     ($($arg:tt)*) => {{
         let message = format!($($arg)*);
         error!("{}", message);
-        crate::antithesis::assert_always_failure!(
+        crate::antithesis::assert_always!(
+            false,
             "dbg_panic invariant triggered",
             ::serde_json::json!({
-                "message": message.clone(),
+                "message": message,
                 "file": file!(),
                 "line": line!(),
                 "module": module_path!(),

crates/sdk-core/src/antithesis.rs

@@ -1,57 +1,62 @@
-#[cfg(feature = "antithesis_assertions")]
-use std::sync::OnceLock;
+//! Antithesis SDK integration for invariant testing.
+//!
+//! This module provides assertion macros that integrate with the Antithesis
+//! testing platform to detect invariant violations during fuzz testing.
+//!
+//! When the `antithesis_assertions` feature is disabled, assertions compile
+//! to no-ops.
 
-/// Ensure Antithesis is initialized exactly once.
 #[cfg(feature = "antithesis_assertions")]
-pub(crate) fn ensure_init() {
-    static INIT: OnceLock<()> = OnceLock::new();
-    INIT.get_or_init(|| {
-        ::antithesis_sdk::antithesis_init();
-    });
-}
+mod enabled {
+    use std::sync::OnceLock;
 
-#[cfg(not(feature = "antithesis_assertions"))]
-#[inline]
-pub(crate) fn ensure_init() {}
+    /// Ensure Antithesis is initialized exactly once.
+    pub(crate) fn ensure_init() {
+        static INIT: OnceLock<()> = OnceLock::new();
+        INIT.get_or_init(|| {
+            ::antithesis_sdk::antithesis_init();
+        });
+    }
 
-#[cfg(feature = "antithesis_assertions")]
-macro_rules! assert_always {
-    ($message:literal, $condition:expr, $details:expr) => {{
-        $crate::antithesis::ensure_init();
-        let details: ::serde_json::Value = $details;
-        ::antithesis_sdk::assert_always!($condition, $message, &details);
-    }};
-    ($message:literal, $condition:expr) => {{
-        $crate::antithesis::ensure_init();
-        ::antithesis_sdk::assert_always!($condition, $message);
-    }};
+    /// Assert that a condition is always true during Antithesis fuzz testing.
+    /// Use `false` as the condition to log an invariant violation.
+    macro_rules! assert_always {
+        ($condition:expr, $message:literal, $details:expr) => {{
+            $crate::antithesis::ensure_init();
+            let details: ::serde_json::Value = $details;
+            ::antithesis_sdk::assert_always!($condition, $message, &details);
+        }};
+        ($condition:expr, $message:literal) => {{
+            $crate::antithesis::ensure_init();
+            ::antithesis_sdk::assert_always!($condition, $message);
+        }};
+    }
+
+    pub(crate) use assert_always;
 }
 
 #[cfg(not(feature = "antithesis_assertions"))]
-macro_rules! assert_always {
-    ($message:literal, $condition:expr, $details:expr) => {{
-        let _ = ($message, $condition);
-        let _ = $details;
-    }};
-    ($message:literal, $condition:expr) => {{
-        let _ = ($message, $condition);
-    }};
+mod disabled {
+    /// No-op when feature is disabled.
+    #[inline(always)]
+    pub(crate) fn ensure_init() {}
+
+    /// No-op assertion when feature is disabled.
+    macro_rules! assert_always {
+        ($condition:expr, $message:literal, $details:expr) => {{
+            let _ = ($condition, $message);
+            let _ = $details;
+        }};
+        ($condition:expr, $message:literal) => {{
+            let _ = ($condition, $message);
+        }};
+    }
+
+    pub(crate) use assert_always;
 }
 
 #[cfg(feature = "antithesis_assertions")]
-macro_rules! assert_always_failure {
-    ($message:literal, $details:expr) => {{
-        $crate::antithesis::assert_always!($message, false, $details);
-    }};
-}
+pub(crate) use enabled::*;
 
 #[cfg(not(feature = "antithesis_assertions"))]
-macro_rules! assert_always_failure {
-    ($message:literal, $details:expr) => {{
-        let _ = $message;
-        let _ = $details;
-    }};
-}
-
-pub(crate) use assert_always;
-pub(crate) use assert_always_failure;
+pub(crate) use disabled::*;

crates/sdk-core/src/lib.rs

@@ -2,12 +2,7 @@
 #![allow(clippy::upper_case_acronyms)]
 
 //! This crate provides a basis for creating new Temporal SDKs without completely starting from
-//! scratch.
-//!
-//! ## Optional features
-//! - `antithesis_assertions`: Enables integration with Antithesis' Rust SDK. When active, core
-//!   initialization calls `antithesis_sdk::antithesis_init` and critical invariants emit
-//!   Antithesis assertions to aid fuzzing campaigns.
+//! scratch
 
 #[cfg(test)]
 #[macro_use]
@@ -92,17 +87,8 @@ pub fn init_worker<CT>(
 where
     CT: Into<sealed::AnyClient>,
 {
-    crate::antithesis::ensure_init();
     let namespace = worker_config.namespace.clone();
     if namespace.is_empty() {
-        crate::antithesis::assert_always_failure!(
-            "worker namespace must not be empty",
-            ::serde_json::json!({
-                "namespace": namespace.clone(),
-                "task_queue": worker_config.task_queue.clone(),
-                "has_identity_override": worker_config.client_identity_override.is_some(),
-            })
-        );
         bail!("Worker namespace cannot be empty");
     }
 
@@ -118,13 +104,6 @@ where
     let sticky_q = sticky_q_name_for_worker(&client_ident, worker_config.max_cached_workflows);
 
     if client_ident.is_empty() {
-        crate::antithesis::assert_always_failure!(
-            "client identity must not be empty",
-            ::serde_json::json!({
-                "namespace": namespace.clone(),
-                "task_queue": worker_config.task_queue.clone(),
-            })
-        );
         bail!("Client identity cannot be empty. Either lang or user should be setting this value");
     }
 
@@ -154,7 +133,6 @@ pub fn init_replay_worker<I>(rwi: ReplayWorkerInput<I>) -> Result<Worker, anyhow
 where
     I: Stream<Item = HistoryForReplay> + Send + 'static,
 {
-    crate::antithesis::ensure_init();
     info!(
         task_queue = rwi.config.task_queue.as_str(),
         "Registering replay worker"
@@ -313,7 +291,6 @@ impl CoreRuntime {
     where
         F: Fn() + Send + Sync + 'static,
     {
-        crate::antithesis::ensure_init();
         let telemetry = telemetry_init(runtime_options.telemetry_options)?;
         let subscriber = telemetry.trace_subscriber();
         let runtime = tokio_builder
@@ -341,7 +318,6 @@ impl CoreRuntime {
     /// # Panics
     /// If there is no currently active Tokio runtime
     pub fn new_assume_tokio(runtime_options: RuntimeOptions) -> Result<Self, anyhow::Error> {
-        crate::antithesis::ensure_init();
         let telemetry = telemetry_init(runtime_options.telemetry_options)?;
         Ok(Self::new_assume_tokio_initialized_telem(
             telemetry,
@@ -358,7 +334,6 @@ impl CoreRuntime {
         telemetry: TelemetryInstance,
         heartbeat_interval: Option<Duration>,
     ) -> Self {
-        crate::antithesis::ensure_init();
         let runtime_handle = tokio::runtime::Handle::current();
         if let Some(sub) = telemetry.trace_subscriber() {
             set_trace_subscriber_for_current_thread(sub);

crates/sdk-core/src/worker/workflow/machines/activity_state_machine.rs

@@ -195,8 +195,8 @@ impl ActivityMachine {
                 }
                 x => {
                     crate::antithesis::assert_always!(
-                        "activity cancel yields supported command",
                         false,
+                        "activity cancel yields supported command",
                         ::serde_json::json!({
                             "activity_seq": self.shared_state.attrs.seq,
                             "unexpected_command": format!("{x:?}"),

crates/sdk-core/src/worker/workflow/machines/child_workflow_state_machine.rs

@@ -498,8 +498,8 @@ impl ChildWorkflowMachine {
                 }
                 x => {
                     crate::antithesis::assert_always!(
-                        "child workflow cancel yields supported command",
                         false,
+                        "child workflow cancel yields supported command",
                         ::serde_json::json!({
                             "workflow_id": self.shared_state.workflow_id.clone(),
                             "run_id": self.shared_state.run_id.clone(),

crates/sdk-core/src/worker/workflow/machines/complete_workflow_state_machine.rs

@@ -43,8 +43,8 @@ pub(super) fn complete_workflow(attribs: CompleteWorkflowExecution) -> NewMachin
             Some(CompleteWFCommand::AddCommand(c)) => c,
             unexpected => {
                 crate::antithesis::assert_always!(
-                    "complete workflow scheduling yields command",
                     false,
+                    "complete workflow scheduling yields command",
                     ::serde_json::json!({
                         "unexpected": format!("{unexpected:?}"),
                     })