temporalio 0.1.0 → 0.2.0

data/bridge/sdk-core/core/src/retry_logic.rs

@@ -1,202 +0,0 @@
-use std::time::Duration;
-use temporal_sdk_core_protos::{
-    temporal::api::{common::v1::RetryPolicy, failure::v1::ApplicationFailureInfo},
-    utilities::TryIntoOrNone,
-};
-
-pub(crate) trait RetryPolicyExt {
-    /// Ask this retry policy if a retry should be performed. Caller provides the current attempt
-    /// number - the first attempt should start at 1.
-    ///
-    /// Returns `None` if it should not, otherwise a duration indicating how long to wait before
-    /// performing the retry.
-    ///
-    /// Applies defaults to missing fields:
-    /// `initial_interval` - 1 second
-    /// `maximum_interval` - 100 x initial_interval
-    /// `backoff_coefficient` - 2.0
-    fn should_retry(
-        &self,
-        attempt_number: usize,
-        application_failure: Option<&ApplicationFailureInfo>,
-    ) -> Option<Duration>;
-}
-
-impl RetryPolicyExt for RetryPolicy {
-    fn should_retry(
-        &self,
-        attempt_number: usize,
-        application_failure: Option<&ApplicationFailureInfo>,
-    ) -> Option<Duration> {
-        let non_retryable = application_failure
-            .map(|f| f.non_retryable)
-            .unwrap_or_default();
-        if non_retryable {
-            return None;
-        }
-        let err_type_str = application_failure.map_or("", |f| &f.r#type);
-        let realmax = self.maximum_attempts.max(0);
-        if realmax > 0 && attempt_number >= realmax as usize {
-            return None;
-        }
-
-        for pat in &self.non_retryable_error_types {
-            if err_type_str.to_lowercase() == pat.to_lowercase() {
-                return None;
-            }
-        }
-
-        let converted_interval = self
-            .initial_interval
-            .clone()
-            .try_into_or_none()
-            .or(Some(Duration::from_secs(1)));
-        if attempt_number == 1 {
-            return converted_interval;
-        }
-        let coeff = if self.backoff_coefficient != 0. {
-            self.backoff_coefficient
-        } else {
-            2.0
-        };
-
-        if let Some(interval) = converted_interval {
-            let max_iv = self
-                .maximum_interval
-                .clone()
-                .try_into_or_none()
-                .unwrap_or_else(|| interval.saturating_mul(100));
-            let mul_factor = coeff.powi(attempt_number as i32 - 1);
-            let tried_mul = try_from_secs_f64(mul_factor * interval.as_secs_f64());
-            Some(tried_mul.unwrap_or(max_iv).min(max_iv))
-        } else {
-            // No retries if initial interval is not specified
-            None
-        }
-    }
-}
-
-const NANOS_PER_SEC: u32 = 1_000_000_000;
-/// modified from rust stdlib since this feature is currently nightly only
-fn try_from_secs_f64(secs: f64) -> Option<Duration> {
-    const MAX_NANOS_F64: f64 = ((u64::MAX as u128 + 1) * (NANOS_PER_SEC as u128)) as f64;
-    let nanos = secs * (NANOS_PER_SEC as f64);
-    if !nanos.is_finite() || !(0.0..MAX_NANOS_F64).contains(&nanos) {
-        None
-    } else {
-        Some(Duration::from_secs_f64(secs))
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::prost_dur;
-
-    #[test]
-    fn calcs_backoffs_properly() {
-        let rp = RetryPolicy {
-            initial_interval: Some(prost_dur!(from_secs(1))),
-            backoff_coefficient: 2.0,
-            maximum_interval: Some(prost_dur!(from_secs(10))),
-            maximum_attempts: 10,
-            non_retryable_error_types: vec![],
-        };
-        let res = rp.should_retry(1, None).unwrap();
-        assert_eq!(res.as_millis(), 1_000);
-        let res = rp.should_retry(2, None).unwrap();
-        assert_eq!(res.as_millis(), 2_000);
-        let res = rp.should_retry(3, None).unwrap();
-        assert_eq!(res.as_millis(), 4_000);
-        let res = rp.should_retry(4, None).unwrap();
-        assert_eq!(res.as_millis(), 8_000);
-        let res = rp.should_retry(5, None).unwrap();
-        assert_eq!(res.as_millis(), 10_000);
-        let res = rp.should_retry(6, None).unwrap();
-        assert_eq!(res.as_millis(), 10_000);
-        // Max attempts - no retry
-        assert!(rp.should_retry(10, None).is_none());
-    }
-
-    #[test]
-    fn no_interval_no_backoff() {
-        let rp = RetryPolicy {
-            initial_interval: None,
-            backoff_coefficient: 0.,
-            maximum_interval: None,
-            maximum_attempts: 10,
-            non_retryable_error_types: vec![],
-        };
-        assert!(rp.should_retry(1, None).is_some());
-    }
-
-    #[test]
-    fn max_attempts_zero_retry_forever() {
-        let rp = RetryPolicy {
-            initial_interval: Some(prost_dur!(from_secs(1))),
-            backoff_coefficient: 1.2,
-            maximum_interval: None,
-            maximum_attempts: 0,
-            non_retryable_error_types: vec![],
-        };
-        for i in 0..50 {
-            assert!(rp.should_retry(i, None).is_some());
-        }
-    }
-
-    #[test]
-    fn no_overflows() {
-        let rp = RetryPolicy {
-            initial_interval: Some(prost_dur!(from_secs(1))),
-            backoff_coefficient: 10.,
-            maximum_interval: None,
-            maximum_attempts: 0,
-            non_retryable_error_types: vec![],
-        };
-        for i in 0..50 {
-            assert!(rp.should_retry(i, None).is_some());
-        }
-    }
-
-    #[test]
-    fn no_retry_err_str_match() {
-        let rp = RetryPolicy {
-            initial_interval: Some(prost_dur!(from_secs(1))),
-            backoff_coefficient: 2.0,
-            maximum_interval: Some(prost_dur!(from_secs(10))),
-            maximum_attempts: 10,
-            non_retryable_error_types: vec!["no retry".to_string()],
-        };
-        assert!(rp
-            .should_retry(
-                1,
-                Some(&ApplicationFailureInfo {
-                    r#type: "no retry".to_string(),
-                    non_retryable: false,
-                    details: None,
-                })
-            )
-            .is_none());
-    }
-
-    #[test]
-    fn no_non_retryable_application_failure() {
-        let rp = RetryPolicy {
-            initial_interval: Some(prost_dur!(from_secs(1))),
-            backoff_coefficient: 2.0,
-            maximum_interval: Some(prost_dur!(from_secs(10))),
-            maximum_attempts: 10,
-            non_retryable_error_types: vec![],
-        };
-        assert!(rp
-            .should_retry(
-                1,
-                Some(&ApplicationFailureInfo {
-                    r#type: "".to_string(),
-                    non_retryable: true,
-                    details: None,
-                })
-            )
-            .is_none());
-    }
-}

data/bridge/sdk-core/core/src/telemetry/log_export.rs

@@ -1,190 +0,0 @@
-use parking_lot::Mutex;
-use ringbuf::{Consumer, HeapRb, Producer};
-use std::{collections::HashMap, sync::Arc, time::SystemTime};
-use temporal_sdk_core_api::telemetry::CoreLog;
-use tracing_subscriber::Layer;
-
-const RB_SIZE: usize = 2048;
-
-pub(super) type CoreLogsOut = Consumer<CoreLog, Arc<HeapRb<CoreLog>>>;
-
-pub(super) struct CoreLogExportLayer {
-    logs_in: Mutex<Producer<CoreLog, Arc<HeapRb<CoreLog>>>>,
-}
-
-#[derive(Debug)]
-struct CoreLogFieldStorage(HashMap<String, serde_json::Value>);
-
-impl CoreLogExportLayer {
-    pub(super) fn new() -> (Self, CoreLogsOut) {
-        let (lin, lout) = HeapRb::new(RB_SIZE).split();
-        (
-            Self {
-                logs_in: Mutex::new(lin),
-            },
-            lout,
-        )
-    }
-}
-
-impl<S> Layer<S> for CoreLogExportLayer
-where
-    S: tracing::Subscriber,
-    S: for<'lookup> tracing_subscriber::registry::LookupSpan<'lookup>,
-{
-    fn on_new_span(
-        &self,
-        attrs: &tracing::span::Attributes<'_>,
-        id: &tracing::span::Id,
-        ctx: tracing_subscriber::layer::Context<'_, S>,
-    ) {
-        let span = ctx.span(id).unwrap();
-        let mut fields = HashMap::new();
-        let mut visitor = JsonVisitor(&mut fields);
-        attrs.record(&mut visitor);
-        let storage = CoreLogFieldStorage(fields);
-        let mut extensions = span.extensions_mut();
-        extensions.insert(storage);
-    }
-
-    fn on_record(
-        &self,
-        id: &tracing::span::Id,
-        values: &tracing::span::Record<'_>,
-        ctx: tracing_subscriber::layer::Context<'_, S>,
-    ) {
-        let span = ctx.span(id).unwrap();
-
-        let mut extensions_mut = span.extensions_mut();
-        let custom_field_storage: &mut CoreLogFieldStorage =
-            extensions_mut.get_mut::<CoreLogFieldStorage>().unwrap();
-        let json_data = &mut custom_field_storage.0;
-
-        let mut visitor = JsonVisitor(json_data);
-        values.record(&mut visitor);
-    }
-
-    fn on_event(&self, event: &tracing::Event<'_>, ctx: tracing_subscriber::layer::Context<'_, S>) {
-        let mut fields = HashMap::new();
-        let mut visitor = JsonVisitor(&mut fields);
-        event.record(&mut visitor);
-
-        let mut spans = vec![];
-        if let Some(scope) = ctx.event_scope(event) {
-            for span in scope.from_root() {
-                let extensions = span.extensions();
-                let storage = extensions.get::<CoreLogFieldStorage>().unwrap();
-                let field_data = &storage.0;
-                for (k, v) in field_data {
-                    fields.insert(k.to_string(), v.clone());
-                }
-                spans.push(span.name().to_string());
-            }
-        }
-
-        // "message" is the magic default field keyname for the string passed to the event
-        let message = fields.remove("message").unwrap_or_default();
-        let log = CoreLog {
-            target: event.metadata().target().to_string(),
-            // This weird as_str dance prevents adding extra quotes
-            message: message.as_str().unwrap_or_default().to_string(),
-            timestamp: SystemTime::now(),
-            level: *event.metadata().level(),
-            fields,
-            span_contexts: spans,
-        };
-        let _ = self.logs_in.lock().push(log);
-    }
-}
-
-struct JsonVisitor<'a>(&'a mut HashMap<String, serde_json::Value>);
-
-impl<'a> tracing::field::Visit for JsonVisitor<'a> {
-    fn record_f64(&mut self, field: &tracing::field::Field, value: f64) {
-        self.0
-            .insert(field.name().to_string(), serde_json::json!(value));
-    }
-
-    fn record_i64(&mut self, field: &tracing::field::Field, value: i64) {
-        self.0
-            .insert(field.name().to_string(), serde_json::json!(value));
-    }
-
-    fn record_u64(&mut self, field: &tracing::field::Field, value: u64) {
-        self.0
-            .insert(field.name().to_string(), serde_json::json!(value));
-    }
-
-    fn record_bool(&mut self, field: &tracing::field::Field, value: bool) {
-        self.0
-            .insert(field.name().to_string(), serde_json::json!(value));
-    }
-
-    fn record_str(&mut self, field: &tracing::field::Field, value: &str) {
-        self.0
-            .insert(field.name().to_string(), serde_json::json!(value));
-    }
-
-    fn record_error(
-        &mut self,
-        field: &tracing::field::Field,
-        value: &(dyn std::error::Error + 'static),
-    ) {
-        self.0.insert(
-            field.name().to_string(),
-            serde_json::json!(value.to_string()),
-        );
-    }
-
-    fn record_debug(&mut self, field: &tracing::field::Field, value: &dyn std::fmt::Debug) {
-        self.0.insert(
-            field.name().to_string(),
-            serde_json::json!(format!("{value:?}")),
-        );
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::{telemetry::construct_filter_string, telemetry_init};
-    use temporal_sdk_core_api::telemetry::{CoreTelemetry, Logger, TelemetryOptionsBuilder};
-    use tracing::Level;
-
-    #[instrument(fields(bros = "brohemian"))]
-    fn instrumented(thing: &str) {
-        warn!("warn");
-        info!(foo = "bar", "info");
-        debug!("debug");
-    }
-
-    #[tokio::test]
-    async fn test_forwarding_output() {
-        let opts = TelemetryOptionsBuilder::default()
-            .logging(Logger::Forward {
-                filter: construct_filter_string(Level::INFO, Level::WARN),
-            })
-            .build()
-            .unwrap();
-        let instance = telemetry_init(opts).unwrap();
-        let _g = tracing::subscriber::set_default(instance.trace_subscriber.clone());
-
-        let top_span = span!(Level::INFO, "yayspan", huh = "wat");
-        let _guard = top_span.enter();
-        info!("Whata?");
-        instrumented("hi");
-        info!("Donezo");
-
-        let logs = instance.fetch_buffered_logs();
-        // Verify debug log was not forwarded
-        assert!(!logs.iter().any(|l| l.message == "debug"));
-        assert_eq!(logs.len(), 4);
-        // Ensure fields are attached to events properly
-        let info_msg = &logs[2];
-        assert_eq!(info_msg.message, "info");
-        assert_eq!(info_msg.fields.len(), 4);
-        assert_eq!(info_msg.fields.get("huh"), Some(&"wat".into()));
-        assert_eq!(info_msg.fields.get("foo"), Some(&"bar".into()));
-        assert_eq!(info_msg.fields.get("bros"), Some(&"brohemian".into()));
-        assert_eq!(info_msg.fields.get("thing"), Some(&"hi".into()));
-    }
-}