Remove InstrumentedAsset* and instead just annotate the loads at the callsites.

Author: andriyDev

crates/bevy_asset/src/processor/mod.rs

@@ -77,8 +77,6 @@ use tracing::{debug, error, trace, warn};
 #[cfg(feature = "trace")]
 use {
     alloc::string::ToString,
-    bevy_reflect::TypePath,
-    bevy_tasks::ConditionalSendFuture,
     tracing::{info_span, instrument::Instrument},
 };
 
@@ -754,8 +752,6 @@ impl AssetProcessor {
             .processors
             .write()
             .unwrap_or_else(PoisonError::into_inner);
-        #[cfg(feature = "trace")]
-        let processor = InstrumentedAssetProcessor(processor);
         let processor = Arc::new(processor);
         processors
             .type_path_to_processor
@@ -1195,9 +1191,17 @@ impl AssetProcessor {
                     reader_for_process,
                     &mut new_processed_info,
                 );
-                processor
-                    .process(&mut context, settings, &mut *writer)
-                    .await?
+                let process = processor.process(&mut context, settings, &mut *writer);
+                #[cfg(feature = "trace")]
+                let process = {
+                    let span = info_span!(
+                        "asset processing",
+                        processor = processor.type_path(),
+                        asset = asset_path.to_string(),
+                    );
+                    process.instrument(span)
+                };
+                process.await?
             };
 
             writer
@@ -1504,32 +1508,6 @@ impl ProcessingState {
     }
 }
 
-#[cfg(feature = "trace")]
-#[derive(TypePath)]
-struct InstrumentedAssetProcessor<T>(T);
-
-#[cfg(feature = "trace")]
-impl<T: Process> Process for InstrumentedAssetProcessor<T> {
-    type Settings = T::Settings;
-    type OutputLoader = T::OutputLoader;
-
-    fn process(
-        &self,
-        context: &mut ProcessContext,
-        settings: &Self::Settings,
-        writer: &mut crate::io::Writer,
-    ) -> impl ConditionalSendFuture<
-        Output = Result<<Self::OutputLoader as crate::AssetLoader>::Settings, ProcessError>,
-    > {
-        let span = info_span!(
-            "asset processing",
-            processor = T::type_path(),
-            asset = context.path().to_string(),
-        );
-        self.0.process(context, settings, writer).instrument(span)
-    }
-}
-
 /// The (successful) result of processing an asset
 #[derive(Debug, Clone)]
 pub enum ProcessResult {

crates/bevy_asset/src/processor/process.rs

@@ -245,6 +245,8 @@ pub trait ErasedProcessor: Send + Sync {
     /// Deserialized `meta` as type-erased [`AssetMeta`], operating under the assumption that it matches the meta
     /// for the underlying [`Process`] impl.
     fn deserialize_meta(&self, meta: &[u8]) -> Result<Box<dyn AssetMetaDyn>, DeserializeMetaError>;
+    /// Returns the type-path of the original [`Process`].
+    fn type_path(&self) -> &'static str;
     /// Returns the default type-erased [`AssetMeta`] for the underlying [`Process`] impl.
     fn default_meta(&self) -> Box<dyn AssetMetaDyn>;
 }
@@ -281,6 +283,10 @@ impl<P: Process> ErasedProcessor for P {
         Ok(Box::new(meta))
     }
 
+    fn type_path(&self) -> &'static str {
+        P::type_path()
+    }
+
     fn default_meta(&self) -> Box<dyn AssetMetaDyn> {
         Box::new(AssetMeta::<(), P>::new(AssetAction::Process {
             processor: P::type_path().to_string(),

crates/bevy_asset/src/server/loaders.rs

@@ -5,22 +5,12 @@ use crate::{
 use alloc::{boxed::Box, sync::Arc, vec::Vec};
 use async_broadcast::RecvError;
 use bevy_platform::collections::HashMap;
-#[cfg(feature = "trace")]
-use bevy_reflect::TypePath;
 use bevy_tasks::IoTaskPool;
 use bevy_utils::TypeIdMap;
 use core::any::TypeId;
 use thiserror::Error;
 use tracing::warn;
 
-#[cfg(feature = "trace")]
-use {
-    crate::io::ReaderRequiredFeatures,
-    alloc::string::ToString,
-    bevy_tasks::ConditionalSendFuture,
-    tracing::{info_span, instrument::Instrument},
-};
-
 #[derive(Default)]
 pub(crate) struct AssetLoaders {
     loaders: Vec<MaybeAssetLoader>,
@@ -43,8 +33,6 @@ impl AssetLoaders {
         let loader_asset_type = TypeId::of::<L::Asset>();
         let loader_asset_type_name = core::any::type_name::<L::Asset>();
 
-        #[cfg(feature = "trace")]
-        let loader = InstrumentedAssetLoader(loader);
         let loader = Arc::new(loader);
 
         let (loader_index, is_new) =
@@ -314,39 +302,6 @@ impl MaybeAssetLoader {
     }
 }
 
-#[cfg(feature = "trace")]
-#[derive(TypePath)]
-struct InstrumentedAssetLoader<T>(T);
-
-#[cfg(feature = "trace")]
-impl<T: AssetLoader> AssetLoader for InstrumentedAssetLoader<T> {
-    type Asset = T::Asset;
-    type Settings = T::Settings;
-    type Error = T::Error;
-
-    fn load(
-        &self,
-        reader: &mut dyn crate::io::Reader,
-        settings: &Self::Settings,
-        load_context: &mut crate::LoadContext,
-    ) -> impl ConditionalSendFuture<Output = Result<Self::Asset, Self::Error>> {
-        let span = info_span!(
-            "asset loading",
-            loader = T::type_path(),
-            asset = load_context.path().to_string(),
-        );
-        self.0.load(reader, settings, load_context).instrument(span)
-    }
-
-    fn reader_required_features(settings: &Self::Settings) -> ReaderRequiredFeatures {
-        T::reader_required_features(settings)
-    }
-
-    fn extensions(&self) -> &[&str] {
-        self.0.extensions()
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use alloc::{format, string::String};

crates/bevy_asset/src/server/mod.rs

@@ -1543,9 +1543,19 @@ impl AssetServer {
         let asset_path = asset_path.clone_owned();
         let load_context =
             LoadContext::new(self, asset_path.clone(), load_dependencies, populate_hashes);
-        AssertUnwindSafe(loader.load(reader, settings, load_context))
-            .catch_unwind()
-            .await
+        let load = AssertUnwindSafe(loader.load(reader, settings, load_context)).catch_unwind();
+        #[cfg(feature = "trace")]
+        let load = {
+            use tracing::Instrument;
+
+            let span = tracing::info_span!(
+                "asset loading",
+                loader = loader.type_path(),
+                asset = asset_path.to_string()
+            );
+            load.instrument(span)
+        };
+        load.await
             .map_err(|_| AssetLoadError::AssetLoaderPanic {
                 path: asset_path.clone_owned(),
                 loader_name: loader.type_path(),