30s -> 5mins

crates/atuin-client/src/settings.rs

@@ -344,7 +344,14 @@ pub struct Preview {
 
 #[derive(Clone, Debug, Deserialize, Serialize)]
 pub struct Daemon {
+    /// Use the daemon to sync
+    /// If enabled, requires a running daemon with `atuin daemon`
     pub enabled: bool,
+
+    /// The daemon will handle sync on an interval. How often to sync, in seconds.
+    pub sync_frequency: u64,
+
+    /// The path to the unix socket used by the daemon
     pub socket_path: String,
 }
 
@@ -360,6 +367,7 @@ impl Default for Daemon {
     fn default() -> Self {
         Self {
             enabled: false,
+            sync_frequency: 300,
             socket_path: "".to_string(),
         }
     }
@@ -693,6 +701,7 @@ impl Settings {
             .set_default("keymap_cursor", HashMap::<String, String>::new())?
             .set_default("smart_sort", false)?
             .set_default("store_failed", true)?
+            .set_default("daemon.sync_frequency", 300)?
             .set_default(
                 "prefers_reduced_motion",
                 std::env::var("NO_MOTION")

crates/atuin-daemon/Cargo.toml

@@ -28,6 +28,7 @@ tonic = "0.11"
 prost = "0.12"
 prost-types = "0.12"
 tokio-stream = {version="0.1.14", features=["net"]}
+rand.workspace = true
 
 [build-dependencies]
 tonic-build = "0.11"

crates/atuin-daemon/src/server/sync.rs

@@ -1,16 +1,16 @@
-use eyre::{Result, WrapErr};
+use eyre::Result;
+use rand::Rng;
 use tokio::time::{self, MissedTickBehavior};
 
 use atuin_client::{
-    encryption,
-    history::store::HistoryStore,
     record::{sqlite_store::SqliteStore, sync},
     settings::Settings,
 };
 
 pub async fn worker(settings: Settings, store: SqliteStore) -> Result<()> {
     tracing::info!("booting sync worker");
-    let mut ticker = time::interval(time::Duration::from_secs(5));
+
+    let mut ticker = time::interval(time::Duration::from_secs(settings.daemon.sync_frequency));
 
     // IMPORTANT: without this, if we miss ticks because a sync takes ages or is otherwise delayed,
     // we may end up running a lot of syncs in a hot loop. No bueno!
@@ -20,12 +20,36 @@ pub async fn worker(settings: Settings, store: SqliteStore) -> Result<()> {
         ticker.tick().await;
         tracing::info!("sync worker tick");
 
-        let (uploaded, downloaded) = sync::sync(&settings, &store).await?;
+        let res = sync::sync(&settings, &store).await;
+
+        if let Err(e) = res {
+            tracing::error!("sync tick failed with {e}");
+            let mut rng = rand::thread_rng();
+
+            let new_interval = ticker.period().as_secs_f64() * rng.gen_range(2.0..2.2);
+
+            // Don't backoff by more than 2hrs
+            if new_interval > 2.0 * 60.0 * 60.0 {
+                continue;
+            }
+
+            ticker = time::interval(time::Duration::from_secs(new_interval as u64));
+            ticker.reset_after(time::Duration::from_secs(new_interval as u64));
+
+            tracing::error!("backing off, next sync tick in {new_interval}");
+        } else {
+            let (uploaded, downloaded) = res.unwrap();
+
+            tracing::info!(
+                uploaded = ?uploaded,
+                downloaded = ?downloaded,
+                "sync complete"
+            );
 
-        tracing::info!(
-            uploaded = ?uploaded,
-            downloaded = ?downloaded,
-            "sync complete"
-        );
+            // Reset backoff on success
+            if ticker.period().as_secs() != settings.daemon.sync_frequency {
+                ticker = time::interval(time::Duration::from_secs(settings.daemon.sync_frequency));
+            }
+        }
     }
 }