Follow up for: Use the umbrella crate for the parachain template #5993

prdoc/pr_7464.prdoc

@@ -0,0 +1,9 @@
+title: 'Enable importing sc-tracing macros through polkadot-sdk'
+doc:
+- audience: Node Dev
+  description: |-
+    This PR makes it possible to use the sc-tracing macros when they are imported through the umbrella crate.
+
+crates:
+- name: parachain-template-node
+  bump: minor

substrate/client/tracing/proc-macro/src/lib.rs

@@ -16,10 +16,8 @@
 // limitations under the License.
 
 use proc_macro::TokenStream;
-use proc_macro2::Span;
-use proc_macro_crate::{crate_name, FoundCrate};
 use quote::quote;
-use syn::{Error, Expr, Ident, ItemFn};
+use syn::{Error, Expr, ItemFn};
 
 /// Add a log prefix to the function.
 ///
@@ -102,40 +100,49 @@ use syn::{Error, Expr, Ident, ItemFn};
 /// 2020-10-16 08:12:58  [open-harbor-1619] 〽️ Prometheus server started at 127.0.0.1:9615
 /// 2020-10-16 08:12:58  [open-harbor-1619] Listening for new connections on 127.0.0.1:9944.
 /// ```
+mod utils;
+
 #[proc_macro_attribute]
 pub fn prefix_logs_with(arg: TokenStream, item: TokenStream) -> TokenStream {
-	let item_fn = syn::parse_macro_input!(item as ItemFn);
-
+	// Ensure an argument was provided.
 	if arg.is_empty() {
 		return Error::new(
-			Span::call_site(),
-			"missing argument: name of the node. Example: sc_cli::prefix_logs_with(<expr>)",
+			proc_macro2::Span::call_site(),
+			"missing argument: prefix. Example: prefix_logs_with(\"Relaychain\")",
 		)
 		.to_compile_error()
-		.into()
+		.into();
 	}
 
-	let name = syn::parse_macro_input!(arg as Expr);
+	let prefix_expr = syn::parse_macro_input!(arg as Expr);
+	let item_fn = syn::parse_macro_input!(item as ItemFn);
 
-	let crate_name = match crate_name("sc-tracing") {
-		Ok(FoundCrate::Itself) => Ident::new("sc_tracing", Span::call_site()),
-		Ok(FoundCrate::Name(crate_name)) => Ident::new(&crate_name, Span::call_site()),
-		Err(e) => return Error::new(Span::call_site(), e).to_compile_error().into(),
+	// Resolve the proper sc_tracing path.
+	let resolved_crate = match utils::resolve_sc_tracing() {
+		Ok(path) => path,
+		Err(err) => return err.to_compile_error().into(),
 	};
 
-	let ItemFn { attrs, vis, sig, block } = item_fn;
+	let syn::ItemFn { attrs, vis, sig, block } = item_fn;
 
-	(quote! {
-		#(#attrs)*
-		#vis #sig {
-			let span = #crate_name::tracing::info_span!(
-				#crate_name::logging::PREFIX_LOG_SPAN,
-				name = #name,
-			);
-			let _enter = span.enter();
-
-			#block
+	// Generate different output based on whether the function is async.
+	let output = if sig.asyncness.is_some() {
+		// Async branch: wrap the block in a closure that returns an async block.
+		quote! {
+			#(#attrs)*
+			#vis #sig {
+				#resolved_crate::logging::apply_prefix_async(#prefix_expr, || async { #block }).await
+			}
+		}
+	} else {
+		// Sync branch: call the synchronous logging helper.
+		quote! {
+			#(#attrs)*
+			#vis #sig {
+				#resolved_crate::logging::apply_prefix_sync(#prefix_expr, || { #block })
+			}
 		}
-	})
-	.into()
+	};
+
+	output.into()
 }

substrate/client/tracing/proc-macro/src/utils.rs

@@ -0,0 +1,34 @@
+// This file is part of Substrate.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+use proc_macro2::Span;
+use proc_macro_crate::{crate_name, FoundCrate};
+use syn::{Path, Result};
+
+/// Resolve the correct path for sc_tracing:
+/// - If `polkadot-sdk` is in scope, returns a Path corresponding to `polkadot_sdk::sc_tracing`
+/// - Otherwise, falls back to `sc_tracing`
+pub fn resolve_sc_tracing() -> Result<Path> {
+	match crate_name("polkadot-sdk") {
+		Ok(FoundCrate::Itself) => syn::parse_str("polkadot_sdk::sc_tracing"),
+		Ok(FoundCrate::Name(sdk_name)) => syn::parse_str(&format!("{}::sc_tracing", sdk_name)),
+		Err(_) => match crate_name("sc-tracing") {
+			Ok(FoundCrate::Itself) => syn::parse_str("sc_tracing"),
+			Ok(FoundCrate::Name(name)) => syn::parse_str(&name),
+			Err(e) => Err(syn::Error::new(Span::call_site(), e)),
+		},
+	}
+}

substrate/client/tracing/src/logging/mod.rs

@@ -77,6 +77,25 @@ macro_rules! enable_log_reloading {
 	}};
 }
 
+/// Synchronous helper: applies the log prefix for the duration of the function call.
+pub fn apply_prefix_sync<F, R>(prefix: impl AsRef<str>, f: F) -> R
+where
+	F: FnOnce() -> R,
+{
+	::log::info!("Applying log prefix (sync): {}", prefix.as_ref());
+	f()
+}
+
+/// Asynchronous helper: applies the log prefix for the duration of the async function call.
+pub async fn apply_prefix_async<F, Fut, R>(prefix: impl AsRef<str>, f: F) -> R
+where
+	F: FnOnce() -> Fut,
+	Fut: std::future::Future<Output = R>,
+{
+	::log::info!("Applying log prefix (async): {}", prefix.as_ref());
+	f().await
+}
+
 /// Convert a `Option<LevelFilter>` to a [`log::LevelFilter`].
 ///
 /// `None` is interpreted as `Info`.

templates/parachain/node/Cargo.toml

@@ -12,22 +12,19 @@ build = "build.rs"
 
 [dependencies]
 clap = { features = ["derive"], workspace = true }
-codec = { workspace = true, default-features = true }
 color-print = { workspace = true }
 docify = { workspace = true }
 futures = { workspace = true }
 jsonrpsee = { features = ["server"], workspace = true }
 log = { workspace = true, default-features = true }
 serde = { features = ["derive"], workspace = true, default-features = true }
-serde_json = { workspace = true, default-features = true }
 
 polkadot-sdk = { workspace = true, features = ["node"] }
 
 parachain-template-runtime = { workspace = true }
 
 # Substrate
 prometheus-endpoint = { workspace = true, default-features = true }
-sc-tracing = { workspace = true, default-features = true }
 
 [build-dependencies]
 polkadot-sdk = { workspace = true, features = ["substrate-build-script-utils"] }