Convert leftover derive_builders

Author: Sushisource

Cargo.toml

@@ -15,7 +15,6 @@ license-file = "LICENSE.txt"
 
 [workspace.dependencies]
 bon = "3"
-derive_builder = "0.20"
 derive_more = { version = "2.0", features = [
     "constructor",
     "display",

crates/common/Cargo.toml

@@ -25,7 +25,6 @@ async-trait = "0.1"
 base64 = "0.22"
 bon = { workspace = true }
 dirs = { version = "6.0", optional = true }
-derive_builder = { workspace = true }
 derive_more = { workspace = true }
 opentelemetry = { workspace = true, optional = true }
 prost = { workspace = true }

crates/sdk-core-c-bridge/src/worker.rs

@@ -1323,25 +1323,22 @@ impl TryFrom<&TunerHolder> for temporalio_sdk_core::TunerHolder {
         }
 
         let resource_based = first.map(|f| {
-            temporalio_sdk_core::ResourceBasedSlotsOptionsBuilder::default()
+            temporalio_sdk_core::ResourceBasedSlotsOptions::builder()
                 .target_mem_usage(f.target_memory_usage)
                 .target_cpu_usage(f.target_cpu_usage)
                 .build()
-                .expect("Failed to build ResourceBasedSlotsOptions")
         });
 
-        let mut builder = temporalio_sdk_core::TunerHolderOptionsBuilder::default();
-        builder
+        let builder = temporalio_sdk_core::TunerHolderOptions::builder()
             .workflow_slot_options(holder.workflow_slot_supplier.try_into()?)
             .activity_slot_options(holder.activity_slot_supplier.try_into()?)
             .local_activity_slot_options(holder.local_activity_slot_supplier.try_into()?)
-            .nexus_slot_options(holder.nexus_task_slot_supplier.try_into()?);
-        if let Some(rb) = resource_based {
-            builder.resource_based_options(rb);
-        }
+            .nexus_slot_options(holder.nexus_task_slot_supplier.try_into()?)
+            .maybe_resource_based_options(resource_based);
+
         builder
             .build()
-            .context("Failed building tuner holder options")?
+            .map_err(|e| anyhow::anyhow!("Failed building tuner holder options: {}", e))?
             .build_tuner_holder()
             .context("Failed building tuner holder")
     }

crates/sdk-core/Cargo.toml

@@ -41,7 +41,6 @@ crossbeam-channel = "0.5"
 crossbeam-queue = "0.3"
 crossbeam-utils = "0.8"
 dashmap = "6.1"
-derive_builder = { workspace = true }
 derive_more = { workspace = true }
 enum_dispatch = "0.3"
 enum-iterator = "2"

crates/sdk-core/benches/workflow_replay_bench.rs

@@ -15,7 +15,7 @@ use std::{
 };
 use temporalio_common::{
     protos::{DEFAULT_WORKFLOW_TYPE, canned_histories},
-    telemetry::metrics::{MetricKeyValue, MetricParametersBuilder, NewAttributes},
+    telemetry::metrics::{MetricKeyValue, MetricParameters, NewAttributes},
 };
 use temporalio_sdk::{WfContext, WorkflowFunction};
 use temporalio_sdk_core::{CoreRuntime, replay::HistoryForReplay};
@@ -87,22 +87,19 @@ pub fn bench_metrics(c: &mut Criterion) {
         b.iter_batched(
             || {
                 let c = meter.counter(
-                    MetricParametersBuilder::default()
+                    MetricParameters::builder()
                         .name("c")
-                        .build()
-                        .unwrap(),
+                        .build(),
                 );
                 let h = meter.histogram(
-                    MetricParametersBuilder::default()
+                    MetricParameters::builder()
                         .name("h")
-                        .build()
-                        .unwrap(),
+                        .build(),
                 );
                 let g = meter.gauge(
-                    MetricParametersBuilder::default()
+                    MetricParameters::builder()
                         .name("g")
-                        .build()
-                        .unwrap(),
+                        .build(),
                 );
 
                 let vals = [1, 2, 3, 4, 5];

crates/sdk-core/src/worker/tuner.rs

@@ -25,25 +25,20 @@ pub struct TunerHolder {
 
 /// Can be used to construct a [TunerHolder] without needing to manually construct each
 /// [SlotSupplier]. Useful for lang bridges to allow more easily passing through user options.
-#[derive(Clone, Debug, derive_builder::Builder)]
-#[builder(build_fn(validate = "Self::validate"))]
+#[derive(Clone, Debug, bon::Builder)]
+#[builder(finish_fn(vis = "", name = build_internal))]
 #[non_exhaustive]
 pub struct TunerHolderOptions {
     /// Options for workflow slots
-    #[builder(default, setter(strip_option))]
     pub workflow_slot_options: Option<SlotSupplierOptions<WorkflowSlotKind>>,
     /// Options for activity slots
-    #[builder(default, setter(strip_option))]
     pub activity_slot_options: Option<SlotSupplierOptions<ActivitySlotKind>>,
     /// Options for local activity slots
-    #[builder(default, setter(strip_option))]
     pub local_activity_slot_options: Option<SlotSupplierOptions<LocalActivitySlotKind>>,
     /// Options for nexus slots
-    #[builder(default, setter(strip_option))]
     pub nexus_slot_options: Option<SlotSupplierOptions<NexusSlotKind>>,
     /// Options that will apply to all resource based slot suppliers. Must be set if any slot
     /// options are [SlotSupplierOptions::ResourceBased]
-    #[builder(default, setter(strip_option))]
     pub resource_based_options: Option<ResourceBasedSlotsOptions>,
 }
 
@@ -150,35 +145,42 @@ pub enum SlotSupplierOptions<SK: SlotKind> {
     Custom(Arc<dyn SlotSupplier<SlotKind = SK> + Send + Sync>),
 }
 
-impl TunerHolderOptionsBuilder {
+impl<State: tuner_holder_options_builder::IsComplete> TunerHolderOptionsBuilder<State> {
+    /// Build the [TunerHolderOptions] with validation
+    pub fn build(self) -> Result<TunerHolderOptions, String> {
+        let options = self.build_internal();
+        validate_tuner_holder_options(&options)?;
+        Ok(options)
+    }
+
     /// Create a [TunerHolder] from this builder
     pub fn build_tuner_holder(self) -> Result<TunerHolder, anyhow::Error> {
-        let s = self.build()?;
+        let s = self.build().map_err(|e: String| anyhow::anyhow!(e))?;
         s.build_tuner_holder()
     }
+}
 
-    fn validate(&self) -> Result<(), String> {
-        let any_is_resource_based = matches!(
-            self.workflow_slot_options,
-            Some(Some(SlotSupplierOptions::ResourceBased(_)))
-        ) || matches!(
-            self.activity_slot_options,
-            Some(Some(SlotSupplierOptions::ResourceBased(_)))
-        ) || matches!(
-            self.local_activity_slot_options,
-            Some(Some(SlotSupplierOptions::ResourceBased(_)))
-        ) || matches!(
-            self.nexus_slot_options,
-            Some(Some(SlotSupplierOptions::ResourceBased(_)))
+fn validate_tuner_holder_options(options: &TunerHolderOptions) -> Result<(), String> {
+    let any_is_resource_based = matches!(
+        options.workflow_slot_options,
+        Some(SlotSupplierOptions::ResourceBased(_))
+    ) || matches!(
+        options.activity_slot_options,
+        Some(SlotSupplierOptions::ResourceBased(_))
+    ) || matches!(
+        options.local_activity_slot_options,
+        Some(SlotSupplierOptions::ResourceBased(_))
+    ) || matches!(
+        options.nexus_slot_options,
+        Some(SlotSupplierOptions::ResourceBased(_))
+    );
+    if any_is_resource_based && options.resource_based_options.is_none() {
+        return Err(
+            "`resource_based_options` must be set if any slot options are ResourceBased"
+                .to_string(),
         );
-        if any_is_resource_based && matches!(self.resource_based_options, None | Some(None)) {
-            return Err(
-                "`resource_based_options` must be set if any slot options are ResourceBased"
-                    .to_string(),
-            );
-        }
-        Ok(())
     }
+    Ok(())
 }
 
 /// Can be used to construct a `TunerHolder` from individual slot suppliers. Any supplier which is
@@ -348,11 +350,10 @@ mod tests {
 
     #[test]
     fn tuner_holder_options_nexus_resource_based() {
-        let resource_opts = ResourceBasedSlotsOptionsBuilder::default()
+        let resource_opts = ResourceBasedSlotsOptions::builder()
             .target_mem_usage(0.8)
             .target_cpu_usage(0.9)
-            .build()
-            .unwrap();
+            .build();
 
         let options = TunerHolderOptions {
             workflow_slot_options: None,
@@ -403,7 +404,7 @@ mod tests {
     #[test]
     fn tuner_holder_options_builder_validates_resource_based_requirements() {
         // Should fail when nexus uses ResourceBased but resource_based_options is not set
-        let result = TunerHolderOptionsBuilder::default()
+        let result = TunerHolderOptions::builder()
             .nexus_slot_options(SlotSupplierOptions::ResourceBased(
                 ResourceSlotOptions::new(5, 100, Duration::from_millis(100)),
             ))
@@ -420,11 +421,10 @@ mod tests {
 
     #[test]
     fn tuner_holder_options_all_slot_types() {
-        let resource_opts = ResourceBasedSlotsOptionsBuilder::default()
+        let resource_opts = ResourceBasedSlotsOptions::builder()
             .target_mem_usage(0.8)
             .target_cpu_usage(0.9)
-            .build()
-            .unwrap();
+            .build();
 
         let options = TunerHolderOptions {
             workflow_slot_options: Some(SlotSupplierOptions::FixedSize { slots: 10 }),

crates/sdk-core/src/worker/tuner/resource_based.rs

@@ -43,11 +43,10 @@ impl ResourceBasedTuner<RealSysInfo> {
     /// Create an instance attempting to target the provided memory and cpu thresholds as values
     /// between 0 and 1.
     pub fn new(target_mem_usage: f64, target_cpu_usage: f64) -> Self {
-        let opts = ResourceBasedSlotsOptionsBuilder::default()
+        let opts = ResourceBasedSlotsOptions::builder()
             .target_mem_usage(target_mem_usage)
             .target_cpu_usage(target_cpu_usage)
-            .build()
-            .expect("default resource based slot options can't fail to build");
+            .build();
         let controller = ResourceController::new_with_sysinfo(opts, Arc::new(RealSysInfo::new()));
         Self::new_from_controller(controller)
     }
@@ -163,7 +162,7 @@ pub(crate) struct ResourceBasedSlotsForType<MI, SK> {
     _slot_kind: PhantomData<SK>,
 }
 /// Allows for the full customization of the PID options for a resource based tuner
-#[derive(Clone, Debug, derive_builder::Builder)]
+#[derive(Clone, Debug, bon::Builder)]
 #[non_exhaustive]
 pub struct ResourceBasedSlotsOptions {
     /// A value in the range [0.0, 1.0] representing the target memory usage.
@@ -172,30 +171,30 @@ pub struct ResourceBasedSlotsOptions {
     pub target_cpu_usage: f64,
 
     /// See [pid::Pid::p]
-    #[builder(default = "5.0")]
+    #[builder(default = 5.0)]
     pub mem_p_gain: f64,
     /// See [pid::Pid::i]
-    #[builder(default = "0.0")]
+    #[builder(default = 0.0)]
     pub mem_i_gain: f64,
     /// See [pid::Pid::d]
-    #[builder(default = "1.0")]
+    #[builder(default = 1.0)]
     pub mem_d_gain: f64,
     /// If the mem PID controller outputs a value higher than this, we say the mem half of things
     /// will allow a slot
-    #[builder(default = "0.25")]
+    #[builder(default = 0.25)]
     pub mem_output_threshold: f64,
     /// See [pid::Pid::d]
-    #[builder(default = "5.0")]
+    #[builder(default = 5.0)]
     pub cpu_p_gain: f64,
     /// See [pid::Pid::i]
-    #[builder(default = "0.0")]
+    #[builder(default = 0.0)]
     pub cpu_i_gain: f64,
     /// See [pid::Pid::d]
-    #[builder(default = "1.0")]
+    #[builder(default = 1.0)]
     pub cpu_d_gain: f64,
     /// If the CPU PID controller outputs a value higher than this, we say the CPU half of things
     /// will allow a slot
-    #[builder(default = "0.05")]
+    #[builder(default = 0.05)]
     pub cpu_output_threshold: f64,
 }
 struct PidControllers {
@@ -765,11 +764,10 @@ mod tests {
     }
 
     fn test_options() -> ResourceBasedSlotsOptions {
-        ResourceBasedSlotsOptionsBuilder::default()
+        ResourceBasedSlotsOptions::builder()
             .target_mem_usage(0.8)
             .target_cpu_usage(1.0)
             .build()
-            .expect("default resource based slot options can't fail to build")
     }
 
     #[test]