index_scheduler.features() is no longer fallible

index-scheduler/src/batch.rs

@@ -896,7 +896,7 @@ impl IndexScheduler {
                 })?;
 
                 // 4. Dump experimental feature settings
-                let features = self.features()?.runtime_features();
+                let features = self.features().runtime_features();
                 dump.create_experimental_features(features)?;
 
                 let dump_uid = started_at.format(format_description!(

index-scheduler/src/error.rs

@@ -113,8 +113,6 @@ pub enum Error {
     Dump(#[from] dump::Error),
     #[error(transparent)]
     Heed(#[from] heed::Error),
-    #[error("Unable to record metrics for request.")]
-    CannotRecordMetrics,
     #[error(transparent)]
     Milli(#[from] milli::Error),
     #[error("An unexpected crash occurred when processing the task.")]
@@ -127,8 +125,6 @@ pub enum Error {
     Persist(#[from] tempfile::PersistError),
     #[error(transparent)]
     FeatureNotEnabled(#[from] FeatureNotEnabledError),
-    #[error("An unexpected error occurred when accessing the runtime features.")]
-    RuntimeFeatureToggleError,
 
     #[error(transparent)]
     Anyhow(#[from] anyhow::Error),
@@ -181,14 +177,12 @@ impl Error {
             | Error::TaskCancelationWithEmptyQuery
             | Error::Dump(_)
             | Error::Heed(_)
-            | Error::CannotRecordMetrics
             | Error::Milli(_)
             | Error::ProcessBatchPanicked
             | Error::FileStore(_)
             | Error::IoError(_)
             | Error::Persist(_)
             | Error::FeatureNotEnabled(_)
-            | Error::RuntimeFeatureToggleError
             | Error::Anyhow(_) => true,
             Error::CreateBatch(_)
             | Error::CorruptedTaskQueue
@@ -229,13 +223,11 @@ impl ErrorCode for Error {
             Error::Milli(e) => e.error_code(),
             Error::ProcessBatchPanicked => Code::Internal,
             Error::Heed(e) => e.error_code(),
-            Error::CannotRecordMetrics => Code::Internal,
             Error::HeedTransaction(e) => e.error_code(),
             Error::FileStore(e) => e.error_code(),
             Error::IoError(e) => e.error_code(),
             Error::Persist(e) => e.error_code(),
             Error::FeatureNotEnabled(_) => Code::FeatureNotEnabled,
-            Error::RuntimeFeatureToggleError => Code::Internal,
 
             // Irrecoverable errors
             Error::Anyhow(_) => Code::Internal,

index-scheduler/src/features.rs

@@ -4,7 +4,6 @@ use meilisearch_types::features::{InstanceTogglableFeatures, RuntimeTogglableFea
 use meilisearch_types::heed::types::{SerdeJson, Str};
 use meilisearch_types::heed::{Database, Env, RwTxn};
 
-use crate::error::Error::RuntimeFeatureToggleError;
 use crate::error::FeatureNotEnabledError;
 use crate::Result;
 
@@ -22,9 +21,9 @@ pub struct RoFeatures {
 }
 
 impl RoFeatures {
-    fn new(data: &FeatureData) -> Result<Self> {
-        let runtime = data.runtime_features()?;
-        Ok(Self { runtime })
+    fn new(data: &FeatureData) -> Self {
+        let runtime = data.runtime_features();
+        Self { runtime }
     }
 
     pub fn runtime_features(&self) -> RuntimeTogglableFeatures {
@@ -109,16 +108,22 @@ impl FeatureData {
         self.persisted.put(&mut wtxn, EXPERIMENTAL_FEATURES, &features)?;
         wtxn.commit()?;
 
-        let mut toggled_features = self.runtime.write().map_err(|_| RuntimeFeatureToggleError)?;
+        // safe to unwrap, the lock will only fail if:
+        // 1. requested by the same thread concurrently -> it is called and released in methods that don't call each other
+        // 2. there's a panic while the thread is held -> it is only used for an assignment here.
+        let mut toggled_features = self.runtime.write().unwrap();
         *toggled_features = features;
         Ok(())
     }
 
-    fn runtime_features(&self) -> Result<RuntimeTogglableFeatures> {
-        Ok(*self.runtime.read().map_err(|_| RuntimeFeatureToggleError)?)
+    fn runtime_features(&self) -> RuntimeTogglableFeatures {
+        // sound to unwrap, the lock will only fail if:
+        // 1. requested by the same thread concurrently -> it is called and released in methods that don't call each other
+        // 2. there's a panic while the thread is held -> it is only used for copying the data here
+        *self.runtime.read().unwrap()
     }
 
-    pub fn features(&self) -> Result<RoFeatures> {
+    pub fn features(&self) -> RoFeatures {
         RoFeatures::new(self)
     }
 }

index-scheduler/src/lib.rs

@@ -579,13 +579,7 @@ impl IndexScheduler {
                 run.wake_up.wait();
 
                 loop {
-                    let puffin_enabled = match run.features() {
-                        Ok(features) => features.check_puffin().is_ok(),
-                        Err(e) => {
-                            log::error!("{e}");
-                            continue;
-                        }
-                    };
+                    let puffin_enabled = run.features().check_puffin().is_ok();
                     puffin::set_scopes_on(puffin_enabled);
                     puffin::GlobalProfiler::lock().new_frame();
 
@@ -1299,7 +1293,7 @@ impl IndexScheduler {
         Ok(IndexStats { is_indexing, inner_stats: index_stats })
     }
 
-    pub fn features(&self) -> Result<RoFeatures> {
+    pub fn features(&self) -> RoFeatures {
         self.features.features()
     }