temporalio 0.0.0 → 0.0.2

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

@@ -0,0 +1,202 @@
+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

@@ -0,0 +1,190 @@
+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()));
+    }
+}