Use buck2_error instead of anyhow for soft_error

Summary:
We should be able to tag soft errors for the same reason we tag normal errors. Tags are not used yet but will be logged to logview later. This would also simplify logging these to buck2_errors, if we choose to do that.

This is used to pass `Deprecation` tags to soft errors in this stack, but seems useful regardless.

Reviewed By: JakobDegen

Differential Revision: D60694255

fbshipit-source-id: 673c100b6e9ecb8f2fabb200b2a55a7de003690e

Author: christolliday

app/buck2/src/panic.rs

@@ -150,7 +150,7 @@ mod imp {
     pub(crate) fn write_soft_error(
         fb: FacebookInit,
         category: &str,
-        err: &anyhow::Error,
+        err: &buck2_error::Error,
         location: Location,
         options: StructuredErrorOptions,
     ) {

app/buck2_action_impl/src/actions/impls/run/dep_files.rs

@@ -1251,7 +1251,7 @@ impl DeclaredDepFiles {
                     None => {
                         soft_error!(
                             "missing_dep_file",
-                            anyhow::anyhow!("Dep file is missing at {}", dep_file_path)
+                            anyhow::anyhow!("Dep file is missing at {}", dep_file_path).into()
                         )?;
                         return Ok(None);
                     }

app/buck2_build_signals/src/lib.rs

@@ -131,7 +131,7 @@ where
         .await
         .context("Error computing critical path");
     if let Err(e) = res {
-        soft_error!("critical_path_computation_failed", e)?;
+        soft_error!("critical_path_computation_failed", e.into())?;
     }
     result
 }

app/buck2_client/src/commands/debug/persist_event_logs.rs

@@ -297,7 +297,7 @@ fn status_from_result(res: anyhow::Result<()>) -> (Vec<String>, Option<String>,
             Some(categorize_error(&e).to_owned()),
             false,
         );
-        let _unused = soft_error!(categorize_error(&e), e);
+        let _unused = soft_error!(categorize_error(&e), e.into());
         status
     } else {
         (vec![], None, true)

app/buck2_configured/src/nodes/calculation.rs

@@ -1444,7 +1444,7 @@ impl ConfiguredTargetNodeCalculationImpl for ConfiguredTargetNodeCalculationInst
                     &reason.cause,
                     &IncompatiblePlatformReasonCause::Dependency(_)
                 ) {
-                    soft_error!("dep_only_incompatible", reason.to_err(), quiet: true)?;
+                    soft_error!("dep_only_incompatible", reason.to_err().into(), quiet: true)?;
                 }
             }
         }

app/buck2_core/BUCK

@@ -99,5 +99,6 @@ rust_unittest(
     deps = [
         "fbsource//third-party/rust:anyhow",
         ":buck2_core",
+        "//buck2/app/buck2_error:buck2_error",
     ],
 )

app/buck2_core/src/error.rs

@@ -22,7 +22,7 @@ use crate::env::__macro_refs::buck2_env;
 use crate::is_open_source;
 
 type StructuredErrorHandler = Box<
-    dyn for<'a> Fn(&'a str, &anyhow::Error, (&'a str, u32, u32), StructuredErrorOptions)
+    dyn for<'a> Fn(&'a str, &buck2_error::Error, (&'a str, u32, u32), StructuredErrorOptions)
         + Send
         + Sync
         + 'static,
@@ -49,7 +49,7 @@ static ALL_SOFT_ERROR_COUNTERS: Mutex<Vec<&'static AtomicUsize>> = Mutex::new(Ve
 ///
 /// * The category string that will remain constant and identifies this specific soft error
 ///   (used to report as a key).
-/// * The error is an `anyhow::Error` will in the future will be propagated as the error.
+/// * The error is an `buck2_error::Error` will in the future will be propagated as the error.
 ///
 /// Soft errors from Meta internal runs can be viewed
 /// [in logview](https://www.internalfb.com/logview/overview/buck2).
@@ -159,12 +159,12 @@ impl Default for StructuredErrorOptions {
 #[doc(hidden)]
 pub fn handle_soft_error(
     category: &str,
-    err: anyhow::Error,
+    err: buck2_error::Error,
     count: &'static AtomicUsize,
     once: &std::sync::Once,
     loc: (&'static str, u32, u32),
     options: StructuredErrorOptions,
-) -> anyhow::Result<anyhow::Error> {
+) -> Result<buck2_error::Error, buck2_error::Error> {
     validate_category(category)?;
 
     if cfg!(test) {
@@ -184,7 +184,9 @@ pub fn handle_soft_error(
     }
 
     if hard_error_config()?.should_hard_error(category) {
-        return Err(err.context("Upgraded warning to failure via $BUCK2_HARD_ERROR"));
+        return Err(err
+            .context("Upgraded warning to failure via $BUCK2_HARD_ERROR")
+            .into());
     }
 
     if is_open_source() {

app/buck2_core/src/provider/flavors.rs

@@ -55,7 +55,7 @@ pub fn map_flavors(flavors: &str, full_target: &str) -> anyhow::Result<Providers
             // rely on the wrapping span in order to find
             soft_error!(
                 "platform_flavor",
-                anyhow::anyhow!("Platform flavor found in target: {}", full_target),
+                anyhow::anyhow!("Platform flavor found in target: {}", full_target).into(),
                 quiet: true
             )?;
             flavors_parts.remove(index);

app/buck2_core/tests/soft_error.rs

@@ -21,7 +21,7 @@ static RESULT: Mutex<Vec<String>> = Mutex::new(Vec::new());
 
 fn mock_handler(
     category: &str,
-    err: &anyhow::Error,
+    err: &buck2_error::Error,
     loc: (&str, u32, u32),
     options: StructuredErrorOptions,
 ) {
@@ -57,7 +57,7 @@ fn test_soft_error() {
     let before_error_line = line!();
     let _ignore_hard_error = soft_error!(
         "test_logged_soft_error",
-        anyhow::anyhow!("Should be logged")
+        anyhow::anyhow!("Should be logged").into()
     );
     assert_eq!(
         Some(&format!(
@@ -79,7 +79,7 @@ fn test_reset_counters() {
     assert_eq!(0, RESULT.lock().unwrap().len(), "Sanity check");
 
     for _ in 0..100 {
-        let _ignore = soft_error!("test_reset_counters", anyhow::anyhow!("Message"));
+        let _ignore = soft_error!("test_reset_counters", anyhow::anyhow!("Message").into());
     }
 
     assert_eq!(
@@ -91,7 +91,7 @@ fn test_reset_counters() {
     reset_soft_error_counters();
 
     for _ in 0..100 {
-        let _ignore = soft_error!("test_reset_counters", anyhow::anyhow!("Message"));
+        let _ignore = soft_error!("test_reset_counters", anyhow::anyhow!("Message").into());
     }
 
     assert_eq!(

app/buck2_execute/src/re/uploader.rs

@@ -275,7 +275,7 @@ impl Uploader {
                                             "{} missing (origin: {})",
                                             file.digest,
                                             info.origin.as_display_for_not_found(),
-                                        ),
+                                        ).into(),
                                         daemon_in_memory_state_is_corrupted: true,
                                         action_cache_is_corrupted: info.origin.guaranteed_by_action_cache()
                                     )?;
@@ -297,7 +297,7 @@ impl Uploader {
                                         file.digest,
                                         file.digest.expires(),
                                         err
-                                    ),
+                                    ).into(),
                                     quiet: true
                                 )?;
 

app/buck2_execute_impl/src/executors/local.rs

@@ -879,7 +879,8 @@ pub async fn materialize_inputs(
                     task: false,
                     daemon_in_memory_state_is_corrupted: true,
                     action_cache_is_corrupted: corrupted
-                ));
+                )
+                .into());
             }
             Err(e) => {
                 return Err(e.into());
@@ -914,7 +915,7 @@ async fn check_inputs(
                                 // want to propagate it.
                                 let _ignored = tag_result!(
                                     "missing_local_inputs",
-                                    fs_util::symlink_metadata(&abs_path).context("Missing input"),
+                                    fs_util::symlink_metadata(&abs_path).context("Missing input").map_err(|e| e.into()),
                                     quiet: true,
                                     task: false,
                                     daemon_materializer_state_is_corrupted: true

app/buck2_execute_impl/src/executors/re.rs

@@ -252,6 +252,7 @@ impl ReExecutor {
                         execution_time.as_secs(),
                         timeout.as_secs(),
                     )
+                    .into()
                 );
 
                 if let Err(e) = res {

app/buck2_execute_impl/src/materializers/deferred.rs

@@ -1341,7 +1341,7 @@ impl<T: IoHandler> DeferredMaterializerCommandProcessor<T> {
                         // This should never happen
                         soft_error!(
                             "clean_stale_no_config",
-                            anyhow::anyhow!("clean scheduled without being configured"),
+                            anyhow::anyhow!("clean scheduled without being configured").into(),
                             quiet: true
                         )
                         .unwrap();
@@ -1519,7 +1519,7 @@ impl<T: IoHandler> DeferredMaterializerCommandProcessor<T> {
                 {
                     soft_error!(
                         "materializer_materialize_error",
-                        e.context(self.log_buffer.clone()),
+                        e.context(self.log_buffer.clone()).into(),
                         quiet: true
                     )
                     .unwrap();
@@ -1774,7 +1774,7 @@ impl<T: IoHandler> DeferredMaterializerCommandProcessor<T> {
                         .materializer_state_table()
                         .update_access_times(vec![&path])
                     {
-                        soft_error!("has_artifact_update_time", e.context(self.log_buffer.clone()), quiet: true).unwrap();
+                        soft_error!("has_artifact_update_time", e.context(self.log_buffer.clone()).into(), quiet: true).unwrap();
                     }
                 }
             }
@@ -2155,7 +2155,7 @@ fn on_materialization(
             .materializer_state_table()
             .insert(path, metadata, timestamp)
         {
-            soft_error!(error_name, e.context(log_buffer.clone()), quiet: true).unwrap();
+            soft_error!(error_name, e.context(log_buffer.clone()).into(), quiet: true).unwrap();
         }
     }
 
@@ -2299,7 +2299,7 @@ impl ArtifactTree {
             }
             Err(e) => {
                 // NOTE: This shouldn't normally happen?
-                soft_error!("cleanup_finished_vacant", e, quiet: true).unwrap();
+                soft_error!("cleanup_finished_vacant", e.into(), quiet: true).unwrap();
             }
         }
     }

app/buck2_execute_impl/src/materializers/deferred/clean_stale.rs

@@ -285,7 +285,8 @@ impl CleanStaleArtifactsCommand {
                     stats,
                 };
                 // quiet just because it's also returned, soft_error to log to scribe
-                return Err(soft_error!("clean_stale_error", error.into(), quiet: true)?);
+                return Err(soft_error!("clean_stale_error", error.into(), quiet: true)
+                    .map(|e| e.into())?);
             }
         }
 

app/buck2_forkserver/src/client.rs

@@ -102,7 +102,8 @@ impl ForkserverClient {
                 quiet: true,
                 task: false,
                 daemon_in_memory_state_is_corrupted: true,
-            ));
+            )
+            .into());
         }
 
         let stream = stream::once(future::ready(buck2_forkserver_proto::RequestEvent {

app/buck2_http/src/client/builder.rs

@@ -91,7 +91,7 @@ impl HttpClientBuilder {
         } else {
             soft_error!(
                 "http_client_no_certs",
-                anyhow::anyhow!("Using default http client with no certs"),
+                anyhow::anyhow!("Using default http client with no certs").into(),
                 quiet: true
             )?;
         }

app/buck2_interpreter/src/soft_error.rs

@@ -9,13 +9,14 @@
 
 use buck2_core::soft_error;
 use starlark::eval::SoftErrorHandler;
-
+use starlark::ErrorKind;
 pub struct Buck2StarlarkSoftErrorHandler;
 
 /// When starlark deprecates something, we propagate it to our `soft_error!` handler.
 impl SoftErrorHandler for Buck2StarlarkSoftErrorHandler {
     fn soft_error(&self, category: &str, error: starlark::Error) -> Result<(), starlark::Error> {
-        soft_error!(&format!("starlark_rust_{category}"), error.into_anyhow(), quiet:true)?;
+        soft_error!(&format!("starlark_rust_{category}"), error.into_anyhow().into(), quiet:true)
+            .map_err(|e| starlark::Error::new(ErrorKind::Other(e.into())))?;
         Ok(())
     }
 }

app/buck2_node/src/attrs/spec.rs

@@ -128,7 +128,7 @@ impl AttributeSpec {
             if name == "metadata" {
                 soft_error!(
                     "metadata_attribute",
-                    anyhow::anyhow!("Rules should not declare an attribute named metadata`"),
+                    anyhow::anyhow!("Rules should not declare an attribute named metadata`").into(),
                     quiet: true
                 )?;
             }

app/buck2_server/src/daemon/state.rs

@@ -711,7 +711,7 @@ impl DaemonState {
 
         tag_result!(
             "eden_not_connected",
-            check_working_dir::check_working_dir(),
+            check_working_dir::check_working_dir().map_err(|e| e.into()),
             quiet: true,
             daemon_in_memory_state_is_corrupted: true,
             task: false
@@ -765,7 +765,7 @@ impl DaemonState {
 
             tag_result!(
                 "stale_cwd",
-                res,
+                res.map_err(|e| e.into()),
                 quiet: true,
                 daemon_in_memory_state_is_corrupted: true,
                 task: false
@@ -817,6 +817,7 @@ impl DaemonState {
                      This will likely lead to failed or slow builds. \
                      To remediate, run `eden redirect fixup`."
                 )
+                .into()
             )?;
         }
 

app/buck2_server/src/host_info.rs

@@ -65,7 +65,7 @@ pub fn get_host_info(
             {
                 Ok(v) => v,
                 Err(e) => {
-                    soft_error!("invalid_xcode_version", e)?;
+                    soft_error!("invalid_xcode_version", e.into())?;
                     None
                 }
             }

app/buck2_server_ctx/src/concurrency.rs

@@ -644,6 +644,7 @@ impl ConcurrencyHandler {
                         active_commands,
                         current_command.format_argv(),
                     ))
+                    .into()
                 )?;
             }
             _ => {}

app/buck2_test/src/command.rs

@@ -476,7 +476,7 @@ async fn test_targets(
 
     let res = tag_result!(
         "executor_launch_failed",
-        res,
+        res.map_err(|e| e.into()),
         quiet: true,
         daemon_in_memory_state_is_corrupted: true,
         task: false

app/buck2_test/src/local_resource_setup.rs

@@ -92,7 +92,7 @@ async fn required_providers<'v>(
             Ok(Some(x)) => Some(Ok(x)),
             Ok(None) => None,
             Err(e) => {
-                let _ignore = soft_error!("missing_required_local_resource", e, quiet: true);
+                let _ignore = soft_error!("missing_required_local_resource", e.into(), quiet: true);
                 None
             }
         })