feat: silent flow retries on failure (#131)

* retries

* bump version

* apply clippy

Author: NickKhalow

core/src/analytics/event.rs

@@ -2,6 +2,8 @@ use serde::Serialize;
 use std::fmt;
 use std::fmt::Display;
 
+use crate::errors::AttemptError;
+
 #[allow(non_camel_case_types)]
 #[derive(Clone, Serialize)]
 #[serde(rename_all = "camelCase", tag = "event", content = "data")]
@@ -65,6 +67,10 @@ pub enum Event {
     LAUNCHER_UPDATE_DOWNLOADED {
         version: String,
     },
+    FLOW_ATTEMPT_ERROR {
+        message: String,
+        attempt: u8,
+    }
 }
 
 impl Display for Event {
@@ -93,7 +99,14 @@ impl Display for Event {
                 Event::LAUNCHER_UPDATE_CANCELLED { .. } => "Launcher Update Cancelled",
                 Event::LAUNCHER_UPDATE_ERROR { .. } => "Launcher Update Error",
                 Event::LAUNCHER_UPDATE_DOWNLOADED { .. } => "Launcher Update Downloaded",
+                Event::FLOW_ATTEMPT_ERROR { .. } => "Launcher Attempt Error",
             }
         )
     }
 }
+
+impl From<&AttemptError> for Event {
+    fn from(value: &AttemptError) -> Self {
+        Self::FLOW_ATTEMPT_ERROR { message: value.error.to_string(), attempt: value.attempt }
+    }
+}

core/src/errors.rs

@@ -20,6 +20,23 @@ impl From<&FlowError> for Status {
     }
 }
 
+#[derive(Error, Debug)]
+pub struct AttemptError {
+    #[source]
+    pub(crate) error: StepError,
+    pub(crate) attempt: u8,
+}
+
+impl Display for AttemptError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "Error on attempt: {}, cause: {}",
+            self.attempt, self.error
+        )
+    }
+}
+
 pub type StepResult = std::result::Result<(), StepError>;
 
 pub type StepResultTyped<T> = std::result::Result<T, StepError>;

core/src/flow.rs

@@ -2,7 +2,7 @@ use crate::channel::EventChannel;
 use crate::deeplink_bridge::{
     PlaceDeeplinkError, PlaceDeeplinkResult, place_deeplink_and_wait_until_consumed,
 };
-use crate::errors::{StepError, StepResultTyped};
+use crate::errors::{AttemptError, StepError, StepResultTyped};
 use crate::instances::RunningInstances;
 use crate::protocols::Protocol;
 use crate::{
@@ -73,6 +73,8 @@ pub struct LaunchFlow {
     download_step: DownloadStep,
     install_step: InstallStep,
     app_launch_step: AppLaunchStep,
+
+    analytics: Arc<Mutex<Analytics>>,
 }
 
 impl LaunchFlow {
@@ -87,12 +89,15 @@ impl LaunchFlow {
             download_step: DownloadStep {
                 analytics: analytics.clone(),
             },
-            install_step: InstallStep { analytics },
+            install_step: InstallStep {
+                analytics: analytics.clone(),
+            },
             app_launch_step: AppLaunchStep {
                 installs_hub,
                 running_instances,
                 protocol,
             },
+            analytics,
         }
     }
 
@@ -101,17 +106,43 @@ impl LaunchFlow {
         channel: &T,
         state: Arc<Mutex<LaunchFlowState>>,
     ) -> std::result::Result<(), FlowError> {
-        let result = self.launch_internal(channel, state.clone()).await;
-        if let Err(e) = result {
-            log::error!("Error during the flow {} {:#?}", e, e);
-            sentry::capture_error(&e);
+        const SILENT_ATTEMPTS_COUNT: u8 = 3;
+
+        let mut last_error: Option<AttemptError> = None;
+
+        for attempt in 1..=SILENT_ATTEMPTS_COUNT {
+            let result = self.launch_internal(channel, state.clone()).await;
+
+            if let Err(e) = result {
+                log::error!(
+                    "Error during the flow. Attempt: {}, Cause {} {:#?}",
+                    attempt,
+                    e,
+                    e
+                );
+                let e = AttemptError {
+                    error: e,
+                    attempt,
+                };
+
+                sentry::capture_error(&e);
+                self.analytics.lock().await.track_and_flush_silent((&e).into()).await;
+
+                last_error = Some(e);
+                continue;
+            }
+
+            return std::result::Result::Ok(());
+        }
+
+        if let Some(e) = last_error {
             let error = FlowError {
-                user_message: e.user_message().to_owned(),
+                user_message: e.error.user_message().to_owned(),
             };
-            return std::result::Result::Err(error);
+            std::result::Result::Err(error)
+        } else {
+            std::result::Result::Ok(())
         }
-
-        std::result::Result::Ok(())
     }
 
     async fn launch_internal<T: EventChannel>(