[nexus] config flag to disable SP ereport ingestion

dev-tools/omdb/src/bin/omdb/nexus.rs

@@ -2787,7 +2787,7 @@ fn print_task_sp_ereport_ingester(details: &serde_json::Value) {
     use nexus_types::internal_api::background::SpEreportIngesterStatus;
     use nexus_types::internal_api::background::SpEreporterStatus;
 
-    let SpEreportIngesterStatus { sps, errors } =
+    let SpEreportIngesterStatus { sps, errors, disabled } =
         match serde_json::from_value(details.clone()) {
             Err(error) => {
                 eprintln!(
@@ -2813,9 +2813,19 @@ fn print_task_sp_ereport_ingester(details: &serde_json::Value) {
         }
     }
 
-    print_ereporter_status_totals(sps.iter().map(|sp| &sp.status));
+    if disabled {
+        println!("    SP ereport ingestion explicitly disabled by config!");
+    } else {
+        print_ereporter_status_totals(sps.iter().map(|sp| &sp.status));
+    }
 
     if !sps.is_empty() {
+        if disabled {
+            println!(
+                "/!\\ WEIRD: SP ereport ingestion disabled by config, but \
+                 some SP statuses were recorded!"
+            )
+        }
         println!("\n    service processors:");
         for SpEreporterStatus { sp_type, slot, status } in &sps {
             println!(

nexus-config/src/nexus_config.rs

@@ -815,11 +815,19 @@ pub struct SpEreportIngesterConfig {
     /// period (in seconds) for periodic activations of this background task
     #[serde_as(as = "DurationSeconds<u64>")]
     pub period_secs: Duration,
+
+    /// disable inventory collection altogether
+    ///
+    /// This is an emergency lever for support / operations.  It should never be
+    /// necessary.
+    ///
+    /// Default: Off
+    pub disable: bool,
 }
 
 impl Default for SpEreportIngesterConfig {
     fn default() -> Self {
-        Self { period_secs: Duration::from_secs(30) }
+        Self { period_secs: Duration::from_secs(30), disable: false }
     }
 }
 
@@ -1320,6 +1328,7 @@ mod test {
                         },
                         sp_ereport_ingester: SpEreportIngesterConfig {
                             period_secs: Duration::from_secs(47),
+                            disable: false,
                         },
                     },
                     default_region_allocation_strategy:

nexus/src/app/background/init.rs

@@ -985,7 +985,10 @@ impl BackgroundTasksInitializer {
             description: "collects error reports from service processors",
             period: config.sp_ereport_ingester.period_secs,
             task_impl: Box::new(ereport_ingester::SpEreportIngester::new(
-                datastore, resolver, nexus_id,
+                datastore,
+                resolver,
+                nexus_id,
+                config.sp_ereport_ingester.disable,
             )),
             opctx: opctx.child(BTreeMap::new()),
             watchers: vec![],

nexus/src/app/background/tasks/ereport_ingester.rs

@@ -31,6 +31,7 @@ use std::sync::Arc;
 
 pub struct SpEreportIngester {
     resolver: internal_dns_resolver::Resolver,
+    disabled: bool,
     inner: Ingester,
 }
 
@@ -58,15 +59,24 @@ impl SpEreportIngester {
         datastore: Arc<DataStore>,
         resolver: internal_dns_resolver::Resolver,
         nexus_id: OmicronZoneUuid,
+        disabled: bool,
     ) -> Self {
-        Self { resolver, inner: Ingester { datastore, nexus_id } }
+        Self { resolver, inner: Ingester { datastore, nexus_id }, disabled }
     }
 
     async fn actually_activate(
         &mut self,
         opctx: &OpContext,
     ) -> SpEreportIngesterStatus {
         let mut status = SpEreportIngesterStatus::default();
+        if self.disabled {
+            status.disabled = true;
+            slog::trace!(
+                &opctx.log,
+                "SP ereport ingestion disabled, doing nothing",
+            );
+            return status;
+        }
         // Find MGS clients.
         // TODO(eliza): reuse the same client across activations; qorb, etc.
         let mgs_clients = {
@@ -478,6 +488,7 @@ mod tests {
             datastore.clone(),
             nexus.internal_resolver.clone(),
             nexus.id(),
+            false,
         );
 
         let activation1 = ingester.actually_activate(&opctx).await;

nexus/types/src/internal_api/background.rs

@@ -555,6 +555,9 @@ pub struct ReadOnlyRegionReplacementStartStatus {
 
 #[derive(Serialize, Deserialize, Default, Debug, PartialEq, Eq)]
 pub struct SpEreportIngesterStatus {
+    /// If `true`, then ereport ingestion has been explicitly disabled by
+    /// the config file.
+    pub disabled: bool,
     pub sps: Vec<SpEreporterStatus>,
     pub errors: Vec<String>,
 }

smf/nexus/multi-sled/config-partial.toml

@@ -83,6 +83,10 @@ read_only_region_replacement_start.period_secs = 30
 alert_dispatcher.period_secs = 60
 webhook_deliverator.period_secs = 60
 sp_ereport_ingester.period_secs = 30
+# Disabled in R16, as the Hubris task that handles ereport ingestion requests
+# has not merged yet, and trying to ingest them will just result in Nexus
+# logging a bunch of errors.
+sp_ereport_ingester.disable = true
 
 [default_region_allocation_strategy]
 # by default, allocate across 3 distinct sleds

smf/nexus/single-sled/config-partial.toml

@@ -83,6 +83,10 @@ read_only_region_replacement_start.period_secs = 30
 alert_dispatcher.period_secs = 60
 webhook_deliverator.period_secs = 60
 sp_ereport_ingester.period_secs = 30
+# Disabled in R16, as the Hubris task that handles ereport ingestion requests
+# has not merged yet, and trying to ingest them will just result in Nexus
+# logging a bunch of errors.
+sp_ereport_ingester.disable = true
 
 [default_region_allocation_strategy]
 # by default, allocate without requirement for distinct sleds.