diff --git a/Cargo.toml b/Cargo.toml
index 54c54ebf1..9cc7caaea 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -83,6 +83,8 @@ dioxus-hot-reload = { path = "packages/hot-reload", version = "0.4.0" }
 dioxus-fullstack = { path = "packages/fullstack", version = "0.4.1"  }
 dioxus_server_macro = { path = "packages/server-macro", version = "0.4.1" }
 log = "0.4.19"
+tracing = "0.1.37"
+tracing-futures = "0.2.5"
 tokio = "1.28"
 slab = "0.4.2"
 futures-channel = "0.3.21"
diff --git a/packages/core/Cargo.toml b/packages/core/Cargo.toml
index 71afe5825..ce7c6bccf 100644
--- a/packages/core/Cargo.toml
+++ b/packages/core/Cargo.toml
@@ -28,7 +28,7 @@ slab = { workspace = true }
 futures-channel = { workspace = true }
 
 smallbox = "0.8.1"
-log = { workspace = true }
+tracing = { workspace = true }
 
 # Serialize the Edits for use in Webview/Liveview instances
 serde = { version = "1", features = ["derive"], optional = true }
diff --git a/packages/core/src/any_props.rs b/packages/core/src/any_props.rs
index de403e5c6..f14a78065 100644
--- a/packages/core/src/any_props.rs
+++ b/packages/core/src/any_props.rs
@@ -68,7 +68,7 @@ unsafe impl<'a, P> AnyProps<'a> for VProps<'a, P> {
             Ok(None) => RenderReturn::default(),
             Err(err) => {
                 let component_name = cx.name();
-                log::error!("Error while rendering component `{component_name}`: {err:?}");
+                tracing::error!("Error while rendering component `{component_name}`: {err:?}");
                 RenderReturn::default()
             }
         }
diff --git a/packages/core/src/diff.rs b/packages/core/src/diff.rs
index dd4cf8147..e75001df2 100644
--- a/packages/core/src/diff.rs
+++ b/packages/core/src/diff.rs
@@ -196,7 +196,8 @@ impl<'b> VirtualDom {
         right.scope.set(Some(scope_id));
 
         // copy out the box for both
-        let old = self.scopes[scope_id.0].props.as_ref();
+        let old_scope = &self.scopes[scope_id.0];
+        let old = old_scope.props.as_ref();
         let new: Box<dyn AnyProps> = right.props.take().unwrap();
         let new: Box<dyn AnyProps> = unsafe { std::mem::transmute(new) };
 
@@ -204,6 +205,11 @@ impl<'b> VirtualDom {
         // The target scopestate still has the reference to the old props, so there's no need to update anything
         // This also implicitly drops the new props since they're not used
         if left.static_props && unsafe { old.as_ref().unwrap().memoize(new.as_ref()) } {
+            tracing::trace!(
+                "Memoized props for component {:#?} ({})",
+                scope_id,
+                old_scope.context().name
+            );
             return;
         }
 
diff --git a/packages/core/src/events.rs b/packages/core/src/events.rs
index 4778ff4d3..3b8edb05c 100644
--- a/packages/core/src/events.rs
+++ b/packages/core/src/events.rs
@@ -118,7 +118,7 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Event<T> {
 ///
 /// ```rust, ignore
 /// rsx!{
-///     MyComponent { onclick: move |evt| log::info!("clicked") }
+///     MyComponent { onclick: move |evt| tracing::debug!("clicked") }
 /// }
 ///
 /// #[derive(Props)]
diff --git a/packages/core/src/scope_arena.rs b/packages/core/src/scope_arena.rs
index 138431740..1ed5b816c 100644
--- a/packages/core/src/scope_arena.rs
+++ b/packages/core/src/scope_arena.rs
@@ -64,6 +64,7 @@ impl VirtualDom {
             let props: &dyn AnyProps = scope.props.as_ref().unwrap().as_ref();
             let props: &dyn AnyProps = std::mem::transmute(props);
 
+            let _span = tracing::trace_span!("render", scope = %scope.context().name);
             props.render(scope).extend_lifetime()
         };
 
diff --git a/packages/core/src/virtual_dom.rs b/packages/core/src/virtual_dom.rs
index c2e56c776..500b2d888 100644
--- a/packages/core/src/virtual_dom.rs
+++ b/packages/core/src/virtual_dom.rs
@@ -306,6 +306,7 @@ impl VirtualDom {
     pub fn mark_dirty(&mut self, id: ScopeId) {
         if let Some(scope) = self.get_scope(id) {
             let height = scope.height();
+            tracing::trace!("Marking scope {:?} ({}) as dirty", id, scope.context().name);
             self.dirty_scopes.insert(DirtyScope { height, id });
         }
     }
@@ -558,7 +559,7 @@ impl VirtualDom {
             }
             // If an error occurs, we should try to render the default error component and context where the error occured
             RenderReturn::Aborted(placeholder) => {
-                log::info!("Ran into suspended or aborted scope during rebuild");
+                tracing::debug!("Ran into suspended or aborted scope during rebuild");
                 let id = self.next_null();
                 placeholder.id.set(Some(id));
                 self.mutations.push(Mutation::CreatePlaceholder { id });
diff --git a/packages/desktop/Cargo.toml b/packages/desktop/Cargo.toml
index 4b2b6df9f..8749199c3 100644
--- a/packages/desktop/Cargo.toml
+++ b/packages/desktop/Cargo.toml
@@ -18,7 +18,7 @@ dioxus-hot-reload = { workspace = true, optional = true }
 serde = "1.0.136"
 serde_json = "1.0.79"
 thiserror = { workspace = true }
-log = { workspace = true }
+tracing = { workspace = true }
 wry = { version = "0.28.0" }
 futures-channel = { workspace = true }
 tokio = { workspace = true, features = [
diff --git a/packages/desktop/src/desktop_context.rs b/packages/desktop/src/desktop_context.rs
index 166366379..897f8eba8 100644
--- a/packages/desktop/src/desktop_context.rs
+++ b/packages/desktop/src/desktop_context.rs
@@ -194,7 +194,7 @@ impl DesktopService {
     /// launch print modal
     pub fn print(&self) {
         if let Err(e) = self.webview.print() {
-            log::warn!("Open print modal failed: {e}");
+            tracing::warn!("Open print modal failed: {e}");
         }
     }
 
@@ -209,7 +209,7 @@ impl DesktopService {
         self.webview.open_devtools();
 
         #[cfg(not(debug_assertions))]
-        log::warn!("Devtools are disabled in release builds");
+        tracing::warn!("Devtools are disabled in release builds");
     }
 
     /// Create a wry event handler that listens for wry events.
diff --git a/packages/desktop/src/lib.rs b/packages/desktop/src/lib.rs
index 070bfa7d1..badbe3276 100644
--- a/packages/desktop/src/lib.rs
+++ b/packages/desktop/src/lib.rs
@@ -330,7 +330,7 @@ pub fn launch_with_props<P: 'static>(root: Component<P>, props: P, cfg: Config)
                         if temp.contains_key("href") {
                             let open = webbrowser::open(temp["href"].as_str().unwrap());
                             if let Err(e) = open {
-                                log::error!("Open Browser error: {:?}", e);
+                                tracing::error!("Open Browser error: {:?}", e);
                             }
                         }
                     }
diff --git a/packages/desktop/src/query.rs b/packages/desktop/src/query.rs
index 247f333e8..d38478c61 100644
--- a/packages/desktop/src/query.rs
+++ b/packages/desktop/src/query.rs
@@ -123,7 +123,7 @@ impl QueryEngine {
                 }})
             }})();"#
         )) {
-            log::warn!("Query error: {err}");
+            tracing::warn!("Query error: {err}");
         }
 
         Query {
diff --git a/packages/dioxus/Cargo.toml b/packages/dioxus/Cargo.toml
index ea052230b..72da45013 100644
--- a/packages/dioxus/Cargo.toml
+++ b/packages/dioxus/Cargo.toml
@@ -30,7 +30,7 @@ hot-reload = ["dioxus-hot-reload"]
 
 [dev-dependencies]
 futures-util = { workspace = true }
-log = { workspace = true }
+tracing = { workspace = true }
 rand = { version = "0.8.4", features = ["small_rng"] }
 criterion = "0.3.5"
 thiserror = { workspace = true }
diff --git a/packages/fermi/Cargo.toml b/packages/fermi/Cargo.toml
index a50a06852..92a0ede71 100644
--- a/packages/fermi/Cargo.toml
+++ b/packages/fermi/Cargo.toml
@@ -14,7 +14,7 @@ keywords = ["dom", "ui", "gui", "react", "state-management"]
 [dependencies]
 dioxus-core = { workspace = true }
 im-rc = { version = "15.0.0", features = ["serde"] }
-log = { workspace = true }
+tracing = { workspace = true }
 
 [dev-dependencies]
 closure = "0.3.0"
diff --git a/packages/fermi/src/root.rs b/packages/fermi/src/root.rs
index f77930c75..67f6514c7 100644
--- a/packages/fermi/src/root.rs
+++ b/packages/fermi/src/root.rs
@@ -66,14 +66,14 @@ impl AtomRoot {
 
         if let Some(slot) = atoms.get_mut(&ptr) {
             slot.value = Rc::new(value);
-            log::trace!("found item with subscribers {:?}", slot.subscribers);
+            tracing::trace!("found item with subscribers {:?}", slot.subscribers);
 
             for scope in &slot.subscribers {
-                log::trace!("updating subcsriber");
+                tracing::trace!("updating subcsriber");
                 (self.update_any)(*scope);
             }
         } else {
-            log::trace!("no atoms found for {:?}", ptr);
+            tracing::trace!("no atoms found for {:?}", ptr);
             atoms.insert(
                 ptr,
                 Slot {
@@ -96,7 +96,7 @@ impl AtomRoot {
     pub fn force_update(&self, ptr: AtomId) {
         if let Some(slot) = self.atoms.borrow_mut().get(&ptr) {
             for scope in slot.subscribers.iter() {
-                log::trace!("updating subcsriber");
+                tracing::trace!("updating subcsriber");
                 (self.update_any)(*scope);
             }
         }
diff --git a/packages/fullstack/Cargo.toml b/packages/fullstack/Cargo.toml
index 82ed7c8d7..8ab213e78 100644
--- a/packages/fullstack/Cargo.toml
+++ b/packages/fullstack/Cargo.toml
@@ -44,7 +44,8 @@ dioxus-desktop = { workspace = true, optional = true }
 # Router Integration
 dioxus-router = { workspace = true, optional = true }
 
-log = { workspace = true }
+tracing = { workspace = true }
+tracing-futures = { workspace = true }
 once_cell = "1.17.1"
 thiserror = { workspace = true }
 tokio = { workspace = true, features = ["full"], optional = true }
diff --git a/packages/fullstack/examples/axum-hello-world/src/main.rs b/packages/fullstack/examples/axum-hello-world/src/main.rs
index 985a5a717..953c6cd7e 100644
--- a/packages/fullstack/examples/axum-hello-world/src/main.rs
+++ b/packages/fullstack/examples/axum-hello-world/src/main.rs
@@ -66,7 +66,7 @@ async fn get_server_data() -> Result<String, ServerFnError> {
 
 fn main() {
     #[cfg(feature = "web")]
-    wasm_logger::init(wasm_logger::Config::new(log::Level::Trace));
+    wasm_logger::init(wasm_logger::Config::new(tracing::Level::Trace));
     #[cfg(feature = "ssr")]
     simple_logger::SimpleLogger::new().init().unwrap();
 
diff --git a/packages/fullstack/examples/salvo-hello-world/src/main.rs b/packages/fullstack/examples/salvo-hello-world/src/main.rs
index df119b4dd..a2c2f0954 100644
--- a/packages/fullstack/examples/salvo-hello-world/src/main.rs
+++ b/packages/fullstack/examples/salvo-hello-world/src/main.rs
@@ -60,7 +60,7 @@ async fn get_server_data() -> Result<String, ServerFnError> {
 
 fn main() {
     #[cfg(feature = "web")]
-    wasm_logger::init(wasm_logger::Config::new(log::Level::Trace));
+    wasm_logger::init(wasm_logger::Config::new(tracing::Level::Trace));
     #[cfg(feature = "ssr")]
     simple_logger::SimpleLogger::new().init().unwrap();
 
diff --git a/packages/fullstack/examples/warp-hello-world/src/main.rs b/packages/fullstack/examples/warp-hello-world/src/main.rs
index df119b4dd..a2c2f0954 100644
--- a/packages/fullstack/examples/warp-hello-world/src/main.rs
+++ b/packages/fullstack/examples/warp-hello-world/src/main.rs
@@ -60,7 +60,7 @@ async fn get_server_data() -> Result<String, ServerFnError> {
 
 fn main() {
     #[cfg(feature = "web")]
-    wasm_logger::init(wasm_logger::Config::new(log::Level::Trace));
+    wasm_logger::init(wasm_logger::Config::new(tracing::Level::Trace));
     #[cfg(feature = "ssr")]
     simple_logger::SimpleLogger::new().init().unwrap();
 
diff --git a/packages/fullstack/src/adapters/axum_adapter.rs b/packages/fullstack/src/adapters/axum_adapter.rs
index 330d15bc3..f7bc4dfe1 100644
--- a/packages/fullstack/src/adapters/axum_adapter.rs
+++ b/packages/fullstack/src/adapters/axum_adapter.rs
@@ -389,7 +389,7 @@ pub async fn render_handler<P: Clone + serde::Serialize + Send + Sync + 'static>
             response
         }
         Err(e) => {
-            log::error!("Failed to render page: {}", e);
+            tracing::error!("Failed to render page: {}", e);
             report_err(e).into_response()
         }
     }
diff --git a/packages/fullstack/src/adapters/salvo_adapter.rs b/packages/fullstack/src/adapters/salvo_adapter.rs
index 671128b65..674722665 100644
--- a/packages/fullstack/src/adapters/salvo_adapter.rs
+++ b/packages/fullstack/src/adapters/salvo_adapter.rs
@@ -423,7 +423,7 @@ impl<P: Clone + serde::Serialize + Send + Sync + 'static> Handler for SSRHandler
                 freshness.write(res.headers_mut());
             }
             Err(err) => {
-                log::error!("Error rendering SSR: {}", err);
+                tracing::error!("Error rendering SSR: {}", err);
                 res.write_body("Error rendering SSR").unwrap();
             }
         };
diff --git a/packages/fullstack/src/adapters/warp_adapter.rs b/packages/fullstack/src/adapters/warp_adapter.rs
index 723314ca3..e5239c01a 100644
--- a/packages/fullstack/src/adapters/warp_adapter.rs
+++ b/packages/fullstack/src/adapters/warp_adapter.rs
@@ -84,7 +84,7 @@ use warp::{
 ///             async move {
 ///                 let req = warp::hyper::Request::from_parts(parts, bytes.into());
 ///                 service.run(req).await.map_err(|err| {
-///                     log::error!("Server function error: {}", err);
+///                     tracing::error!("Server function error: {}", err);
 ///                     warp::reject::reject()
 ///                 })
 ///             }
@@ -142,7 +142,7 @@ pub fn register_server_fns(server_fn_route: &'static str) -> BoxedFilter<(impl R
                 async move {
                     let req = warp::hyper::Request::from_parts(parts, bytes.into());
                     service.run(req).await.map_err(|err| {
-                        log::error!("Server function error: {}", err);
+                        tracing::error!("Server function error: {}", err);
                         warp::reject::reject()
                     })
                 }
@@ -222,7 +222,7 @@ pub fn render_ssr<P: Clone + serde::Serialize + Send + Sync + 'static>(
                         res
                     }
                     Err(err) => {
-                        log::error!("Failed to render ssr: {}", err);
+                        tracing::error!("Failed to render ssr: {}", err);
                         Response::builder()
                             .status(500)
                             .body("Failed to render ssr".into())
diff --git a/packages/fullstack/src/hooks/server_cached.rs b/packages/fullstack/src/hooks/server_cached.rs
index 80bb93008..519f70dae 100644
--- a/packages/fullstack/src/hooks/server_cached.rs
+++ b/packages/fullstack/src/hooks/server_cached.rs
@@ -23,7 +23,7 @@ pub fn server_cached<O: 'static + Serialize + DeserializeOwned>(server_fn: impl
         let data = server_fn();
         let sc = crate::prelude::server_context();
         if let Err(err) = sc.push_html_data(&data) {
-            log::error!("Failed to push HTML data: {}", err);
+            tracing::error!("Failed to push HTML data: {}", err);
         }
         data
     }
diff --git a/packages/fullstack/src/hooks/server_future.rs b/packages/fullstack/src/hooks/server_future.rs
index 9a13df235..e4d89480e 100644
--- a/packages/fullstack/src/hooks/server_future.rs
+++ b/packages/fullstack/src/hooks/server_future.rs
@@ -47,13 +47,13 @@ where
         if first_run {
             match crate::html_storage::deserialize::take_server_data() {
                 Some(data) => {
-                    log::trace!("Loaded {data:?} from server");
+                    tracing::trace!("Loaded {data:?} from server");
                     *state.value.borrow_mut() = Some(Box::new(data));
                     state.needs_regen.set(false);
                     return Some(state);
                 }
                 None => {
-                    log::trace!("Failed to load from server... running future");
+                    tracing::trace!("Failed to load from server... running future");
                 }
             };
         }
@@ -82,7 +82,7 @@ where
                 data = fut.await;
                 if first_run {
                     if let Err(err) = crate::prelude::server_context().push_html_data(&data) {
-                        log::error!("Failed to push HTML data: {}", err);
+                        tracing::error!("Failed to push HTML data: {}", err);
                     };
                 }
             }
@@ -99,7 +99,7 @@ where
     if first_run {
         #[cfg(feature = "ssr")]
         {
-            log::trace!("Suspending first run of use_server_future");
+            tracing::trace!("Suspending first run of use_server_future");
             cx.suspend();
         }
         None
diff --git a/packages/fullstack/src/hot_reload.rs b/packages/fullstack/src/hot_reload.rs
index b94df4811..87f219df8 100644
--- a/packages/fullstack/src/hot_reload.rs
+++ b/packages/fullstack/src/hot_reload.rs
@@ -30,7 +30,7 @@ impl Default for HotReloadState {
                     }
 
                     if let Err(err) = tx.send(Some(template)) {
-                        log::error!("Failed to send hot reload message: {}", err);
+                        tracing::error!("Failed to send hot reload message: {}", err);
                     }
                 }
                 dioxus_hot_reload::HotReloadMsg::Shutdown => {
diff --git a/packages/fullstack/src/html_storage/deserialize.rs b/packages/fullstack/src/html_storage/deserialize.rs
index 822b45076..7fc70ba6c 100644
--- a/packages/fullstack/src/html_storage/deserialize.rs
+++ b/packages/fullstack/src/html_storage/deserialize.rs
@@ -10,7 +10,7 @@ pub(crate) fn serde_from_bytes<T: DeserializeOwned>(string: &[u8]) -> Option<T>
     let decompressed = match STANDARD.decode(string) {
         Ok(bytes) => bytes,
         Err(err) => {
-            log::error!("Failed to decode base64: {}", err);
+            tracing::error!("Failed to decode base64: {}", err);
             return None;
         }
     };
@@ -18,7 +18,7 @@ pub(crate) fn serde_from_bytes<T: DeserializeOwned>(string: &[u8]) -> Option<T>
     match postcard::from_bytes(&decompressed) {
         Ok(data) => Some(data),
         Err(err) => {
-            log::error!("Failed to deserialize: {}", err);
+            tracing::error!("Failed to deserialize: {}", err);
             None
         }
     }
@@ -32,14 +32,14 @@ static SERVER_DATA: once_cell::sync::Lazy<Option<HTMLDataCursor>> =
             let element = match window.get_element_by_id("dioxus-storage-data") {
                 Some(element) => element,
                 None => {
-                    log::error!("Failed to get element by id: dioxus-storage-data");
+                    tracing::error!("Failed to get element by id: dioxus-storage-data");
                     return None;
                 }
             };
             let attribute = match element.get_attribute("data-serialized") {
                 Some(attribute) => attribute,
                 None => {
-                    log::error!("Failed to get attribute: data-serialized");
+                    tracing::error!("Failed to get attribute: data-serialized");
                     return None;
                 }
             };
diff --git a/packages/fullstack/src/html_storage/mod.rs b/packages/fullstack/src/html_storage/mod.rs
index 2d64953ae..5b4d2804f 100644
--- a/packages/fullstack/src/html_storage/mod.rs
+++ b/packages/fullstack/src/html_storage/mod.rs
@@ -36,7 +36,7 @@ impl HTMLDataCursor {
     pub fn take<T: DeserializeOwned>(&self) -> Option<T> {
         let current = self.index.load(std::sync::atomic::Ordering::SeqCst);
         if current >= self.data.len() {
-            log::error!(
+            tracing::error!(
                 "Tried to take more data than was available, len: {}, index: {}",
                 self.data.len(),
                 current
@@ -48,7 +48,7 @@ impl HTMLDataCursor {
         match postcard::from_bytes(cursor) {
             Ok(x) => Some(x),
             Err(e) => {
-                log::error!("Error deserializing data: {:?}", e);
+                tracing::error!("Error deserializing data: {:?}", e);
                 None
             }
         }
diff --git a/packages/fullstack/src/layer.rs b/packages/fullstack/src/layer.rs
index cf5633db2..10e67b3f5 100644
--- a/packages/fullstack/src/layer.rs
+++ b/packages/fullstack/src/layer.rs
@@ -1,4 +1,5 @@
 use std::pin::Pin;
+use tracing_futures::Instrument;
 
 use http::{Request, Response};
 
@@ -45,7 +46,11 @@ where
                 > + Send,
         >,
     > {
-        let fut = self.call(req);
+        let fut = self.call(req).instrument(tracing::trace_span!(
+            "service",
+            "{}",
+            std::any::type_name::<S>()
+        ));
         Box::pin(async move { fut.await.map_err(|err| err.into()) })
     }
 }
diff --git a/packages/fullstack/src/render.rs b/packages/fullstack/src/render.rs
index d389fa54e..cda41f82c 100644
--- a/packages/fullstack/src/render.rs
+++ b/packages/fullstack/src/render.rs
@@ -50,10 +50,10 @@ impl SsrRendererPool {
                             let prev_context =
                                 SERVER_CONTEXT.with(|ctx| ctx.replace(server_context));
                             // poll the future, which may call server_context()
-                            log::info!("Rebuilding vdom");
+                            tracing::info!("Rebuilding vdom");
                             let _ = vdom.rebuild();
                             vdom.wait_for_suspense().await;
-                            log::info!("Suspense resolved");
+                            tracing::info!("Suspense resolved");
                             // after polling the future, we need to restore the context
                             SERVER_CONTEXT.with(|ctx| ctx.replace(prev_context));
 
@@ -116,10 +116,10 @@ impl SsrRendererPool {
                                             let prev_context = SERVER_CONTEXT
                                                 .with(|ctx| ctx.replace(Box::new(server_context)));
                                             // poll the future, which may call server_context()
-                                            log::info!("Rebuilding vdom");
+                                            tracing::info!("Rebuilding vdom");
                                             let _ = vdom.rebuild();
                                             vdom.wait_for_suspense().await;
-                                            log::info!("Suspense resolved");
+                                            tracing::info!("Suspense resolved");
                                             // after polling the future, we need to restore the context
                                             SERVER_CONTEXT.with(|ctx| ctx.replace(prev_context));
                                         })
diff --git a/packages/fullstack/src/router.rs b/packages/fullstack/src/router.rs
index eee282c01..b556aa000 100644
--- a/packages/fullstack/src/router.rs
+++ b/packages/fullstack/src/router.rs
@@ -29,7 +29,7 @@ where
                                 .to_string()
                                 .parse()
                                 .unwrap_or_else(|err| {
-                                    log::error!("Failed to parse uri: {}", err);
+                                    tracing::error!("Failed to parse uri: {}", err);
                                     "/"
                                         .parse()
                                         .unwrap_or_else(|err| {
diff --git a/packages/hooks/Cargo.toml b/packages/hooks/Cargo.toml
index caa25cb1e..bf07389ff 100644
--- a/packages/hooks/Cargo.toml
+++ b/packages/hooks/Cargo.toml
@@ -16,7 +16,7 @@ nightly-features = []
 [dependencies]
 dioxus-core = { workspace = true }
 futures-channel = { workspace = true }
-log = { workspace = true }
+tracing = { workspace = true }
 thiserror = { workspace = true }
 slab = { workspace = true }
 dioxus-debug-cell = "0.1.1"
diff --git a/packages/html/src/events/mouse.rs b/packages/html/src/events/mouse.rs
index 7899393ff..55d081900 100644
--- a/packages/html/src/events/mouse.rs
+++ b/packages/html/src/events/mouse.rs
@@ -108,7 +108,7 @@ impl_event! {
     ///
     /// ## Example
     /// ```rust, ignore
-    /// rsx!( button { "click me", onclick: move |_| log::info!("Clicked!`") } )
+    /// rsx!( button { "click me", onclick: move |_| tracing::info!("Clicked!`") } )
     /// ```
     ///
     /// ## Reference
diff --git a/packages/liveview/Cargo.toml b/packages/liveview/Cargo.toml
index 3dfce5bf4..6b4e49eb2 100644
--- a/packages/liveview/Cargo.toml
+++ b/packages/liveview/Cargo.toml
@@ -11,7 +11,7 @@ license = "MIT OR Apache-2.0"
 
 [dependencies]
 thiserror = { workspace = true }
-log = { workspace = true }
+tracing = { workspace = true }
 slab = { workspace = true }
 futures-util = { workspace = true, default-features = false, features = [
     "sink",
diff --git a/packages/liveview/src/query.rs b/packages/liveview/src/query.rs
index 8052c2afa..a638625c1 100644
--- a/packages/liveview/src/query.rs
+++ b/packages/liveview/src/query.rs
@@ -126,7 +126,7 @@ impl QueryEngine {
                 }})
             }})();"#
         )) {
-            log::warn!("Query error: {err}");
+            tracing::warn!("Query error: {err}");
         }
 
         Query {
diff --git a/packages/router/Cargo.toml b/packages/router/Cargo.toml
index f8f967ef2..80923d539 100644
--- a/packages/router/Cargo.toml
+++ b/packages/router/Cargo.toml
@@ -14,7 +14,7 @@ anyhow = "1.0.66"
 dioxus = { workspace = true }
 dioxus-router-macro = { workspace = true }
 gloo = { version = "0.8.0", optional = true }
-log = { workspace = true }
+tracing = { workspace = true }
 thiserror = { workspace = true }
 futures-util = { workspace = true }
 urlencoding = "2.1.3"
diff --git a/packages/router/src/components/history_buttons.rs b/packages/router/src/components/history_buttons.rs
index 6bd23d860..ad3d63583 100644
--- a/packages/router/src/components/history_buttons.rs
+++ b/packages/router/src/components/history_buttons.rs
@@ -1,5 +1,5 @@
 use dioxus::prelude::*;
-use log::error;
+use tracing::error;
 
 use crate::utils::use_router_internal::use_router_internal;
 
diff --git a/packages/router/src/components/link.rs b/packages/router/src/components/link.rs
index bc55fec8c..c46fc49ef 100644
--- a/packages/router/src/components/link.rs
+++ b/packages/router/src/components/link.rs
@@ -3,7 +3,7 @@ use std::fmt::Debug;
 use std::rc::Rc;
 
 use dioxus::prelude::*;
-use log::error;
+use tracing::error;
 
 use crate::navigation::NavigationTarget;
 use crate::prelude::Routable;
diff --git a/packages/router/src/history/web.rs b/packages/router/src/history/web.rs
index 8b6089b20..375dba5ff 100644
--- a/packages/router/src/history/web.rs
+++ b/packages/router/src/history/web.rs
@@ -139,7 +139,7 @@ impl<R: Routable> WebHistory<R> {
         );
 
         let current_route = myself.current_route();
-        log::trace!("initial route: {:?}", current_route);
+        tracing::trace!("initial route: {:?}", current_route);
         let current_url = current_route.to_string();
         let state = myself.create_state(current_route);
         let _ = replace_state_with_url(&myself.history, &state, Some(&current_url));
diff --git a/packages/router/src/history/web_hash.rs b/packages/router/src/history/web_hash.rs
index c910b1c97..c23bca237 100644
--- a/packages/router/src/history/web_hash.rs
+++ b/packages/router/src/history/web_hash.rs
@@ -1,8 +1,8 @@
 use std::sync::{Arc, Mutex};
 
 use gloo::{events::EventListener, render::AnimationFrame, utils::window};
-use log::error;
 use serde::{de::DeserializeOwned, Serialize};
+use tracing::error;
 use url::Url;
 use web_sys::{History, ScrollRestoration, Window};
 
diff --git a/packages/router/src/incremental.rs b/packages/router/src/incremental.rs
index 79f4e24bf..cf1bc5d70 100644
--- a/packages/router/src/incremental.rs
+++ b/packages/router/src/incremental.rs
@@ -59,8 +59,8 @@ where
                     .await?;
                 }
                 Err(e) => {
-                    log::info!("@ route: {}", full_path);
-                    log::error!("Error pre-caching static route: {}", e);
+                    tracing::info!("@ route: {}", full_path);
+                    tracing::error!("Error pre-caching static route: {}", e);
                 }
             }
         }
diff --git a/packages/router/src/routable.rs b/packages/router/src/routable.rs
index 39a5245a9..debd84087 100644
--- a/packages/router/src/routable.rs
+++ b/packages/router/src/routable.rs
@@ -57,7 +57,7 @@ where
         match urlencoding::decode(route) {
             Ok(segment) => T::from_str(&segment),
             Err(err) => {
-                log::error!("Failed to decode url encoding: {}", err);
+                tracing::error!("Failed to decode url encoding: {}", err);
                 T::from_str(route)
             }
         }
@@ -87,7 +87,7 @@ where
             match urlencoding::decode(&segment) {
                 Ok(segment) => write!(f, "{}", segment)?,
                 Err(err) => {
-                    log::error!("Failed to decode url encoding: {}", err);
+                    tracing::error!("Failed to decode url encoding: {}", err);
                     write!(f, "{}", segment)?
                 }
             }
diff --git a/packages/signals/Cargo.toml b/packages/signals/Cargo.toml
index 0017a1545..56e19bbd8 100644
--- a/packages/signals/Cargo.toml
+++ b/packages/signals/Cargo.toml
@@ -9,7 +9,7 @@ edition = "2018"
 [dependencies]
 dioxus-core = { workspace = true }
 generational-box = { workspace = true }
-log.workspace = true
+tracing = { workspace = true }
 simple_logger = "4.2.0"
 serde = { version = "1", features = ["derive"], optional = true }
 
diff --git a/packages/signals/src/signal.rs b/packages/signals/src/signal.rs
index f41624f96..c20d95005 100644
--- a/packages/signals/src/signal.rs
+++ b/packages/signals/src/signal.rs
@@ -177,7 +177,7 @@ impl<T: 'static> Signal<T> {
         } else if let Some(current_scope_id) = current_scope_id() {
             // only subscribe if the vdom is rendering
             if dioxus_core::vdom_is_rendering() {
-                log::trace!(
+                tracing::trace!(
                     "{:?} subscribed to {:?}",
                     self.inner.value,
                     current_scope_id
@@ -209,7 +209,7 @@ impl<T: 'static> Signal<T> {
         {
             let inner = self.inner.read();
             for &scope_id in &*inner.subscribers.borrow() {
-                log::trace!(
+                tracing::trace!(
                     "Write on {:?} triggered update on {:?}",
                     self.inner.value,
                     scope_id
@@ -224,7 +224,7 @@ impl<T: 'static> Signal<T> {
             std::mem::take(&mut *effects)
         };
         for effect in subscribers {
-            log::trace!(
+            tracing::trace!(
                 "Write on {:?} triggered effect {:?}",
                 self.inner.value,
                 effect
diff --git a/packages/ssr/Cargo.toml b/packages/ssr/Cargo.toml
index 1450bd46e..5804c6b5e 100644
--- a/packages/ssr/Cargo.toml
+++ b/packages/ssr/Cargo.toml
@@ -15,14 +15,14 @@ askama_escape = "0.10.3"
 thiserror = "1.0.23"
 rustc-hash = "1.1.0"
 lru = "0.10.0"
-log = "0.4.13"
+tracing = { workspace = true }
 http = "0.2.9"
 tokio = { version = "1.28", features = ["full"], optional = true }
 
 [dev-dependencies]
 dioxus = { workspace = true }
 thiserror = { workspace = true }
-log = { workspace = true }
+tracing = { workspace = true }
 fern = { version = "0.6.0", features = ["colored"] }
 anyhow = "1.0"
 argh = "0.1.4"
diff --git a/packages/ssr/src/incremental.rs b/packages/ssr/src/incremental.rs
index 9647124de..c3bb25314 100644
--- a/packages/ssr/src/incremental.rs
+++ b/packages/ssr/src/incremental.rs
@@ -139,13 +139,13 @@ impl IncrementalRenderer {
                 let age = elapsed.as_secs();
                 if let Some(invalidate_after) = self.invalidate_after {
                     if elapsed < invalidate_after {
-                        log::trace!("memory cache hit {:?}", route);
+                        tracing::trace!("memory cache hit {:?}", route);
                         output.write_all(cache_hit).await?;
                         let max_age = invalidate_after.as_secs();
                         return Ok(Some(RenderFreshness::new(age, max_age)));
                     }
                 } else {
-                    log::trace!("memory cache hit {:?}", route);
+                    tracing::trace!("memory cache hit {:?}", route);
                     output.write_all(cache_hit).await?;
                     return Ok(Some(RenderFreshness::new_age(age)));
                 }
@@ -157,7 +157,7 @@ impl IncrementalRenderer {
                 if let Ok(file) = tokio::fs::File::open(file_path.full_path).await {
                     let mut file = BufReader::new(file);
                     tokio::io::copy_buf(&mut file, output).await?;
-                    log::trace!("file cache hit {:?}", route);
+                    tracing::trace!("file cache hit {:?}", route);
                     self.promote_memory_cache(&route);
                     return Ok(Some(freshness));
                 }
@@ -184,7 +184,7 @@ impl IncrementalRenderer {
             let freshness = self
                 .render_and_cache(route, component, props, output, rebuild_with, renderer)
                 .await?;
-            log::trace!("cache miss");
+            tracing::trace!("cache miss");
             Ok(freshness)
         }
     }
@@ -206,7 +206,7 @@ impl IncrementalRenderer {
                         }
                         // if the timestamp is invalid or passed, delete the file
                         if let Err(err) = std::fs::remove_file(entry.path()) {
-                            log::error!("Failed to remove file: {}", err);
+                            tracing::error!("Failed to remove file: {}", err);
                         }
                     }
                 }
diff --git a/packages/web/Cargo.toml b/packages/web/Cargo.toml
index 8de282869..bb84fbb2b 100644
--- a/packages/web/Cargo.toml
+++ b/packages/web/Cargo.toml
@@ -20,6 +20,7 @@ dioxus-interpreter-js = { workspace = true, features = [
 js-sys = "0.3.56"
 wasm-bindgen = { workspace = true, features = ["enable-interning"] }
 wasm-bindgen-futures = "0.4.29"
+tracing = { workspace = true }
 log = { workspace = true }
 rustc-hash = { workspace = true }
 console_error_panic_hook = { version = "0.1.7", optional = true }
diff --git a/packages/web/examples/hydrate.rs b/packages/web/examples/hydrate.rs
index 3491bba81..a03589db7 100644
--- a/packages/web/examples/hydrate.rs
+++ b/packages/web/examples/hydrate.rs
@@ -49,7 +49,7 @@ fn main() {
     let _ = dom.rebuild();
 
     let pre = dioxus_ssr::pre_render(&dom);
-    log::trace!("{}", pre);
+    tracing::trace!("{}", pre);
 
     // set the inner content of main to the pre-rendered content
     window()
diff --git a/packages/web/src/dom.rs b/packages/web/src/dom.rs
index 52f2ab1a9..d98987b81 100644
--- a/packages/web/src/dom.rs
+++ b/packages/web/src/dom.rs
@@ -249,7 +249,7 @@ impl WebsysDom {
         for id in to_mount {
             let node = get_node(id.0 as u32);
             if let Some(element) = node.dyn_ref::<Element>() {
-                log::info!("mounted event fired: {}", id.0);
+                tracing::info!("mounted event fired: {}", id.0);
                 let data: MountedData = element.into();
                 let data = Rc::new(data);
                 let _ = self.event_channel.unbounded_send(UiEvent {
diff --git a/packages/web/src/eval.rs b/packages/web/src/eval.rs
index 954bb1b54..eefece50e 100644
--- a/packages/web/src/eval.rs
+++ b/packages/web/src/eval.rs
@@ -46,7 +46,7 @@ impl WebEvaluator {
                 Ok(data) => _ = channel_sender.send_blocking(data),
                 Err(e) => {
                     // Can't really do much here.
-                    log::error!("failed to serialize JsValue to serde_json::Value (eval communication) - {}", e);
+                    tracing::error!("failed to serialize JsValue to serde_json::Value (eval communication) - {}", e);
                 }
             }
         });
diff --git a/packages/web/src/lib.rs b/packages/web/src/lib.rs
index 261232607..60f84de37 100644
--- a/packages/web/src/lib.rs
+++ b/packages/web/src/lib.rs
@@ -170,7 +170,7 @@ pub fn launch_with_props<T: 'static>(
 /// }
 /// ```
 pub async fn run_with_props<T: 'static>(root: fn(Scope<T>) -> Element, root_props: T, cfg: Config) {
-    log::info!("Starting up");
+    tracing::info!("Starting up");
 
     let mut dom = VirtualDom::new_with_props(root, root_props);
 
@@ -205,7 +205,7 @@ pub async fn run_with_props<T: 'static>(root: fn(Scope<T>) -> Element, root_prop
 
     let mut websys_dom = dom::WebsysDom::new(cfg, tx);
 
-    log::info!("rebuilding app");
+    tracing::info!("rebuilding app");
 
     if should_hydrate {
         #[cfg(feature = "hydrate")]
@@ -217,7 +217,7 @@ pub async fn run_with_props<T: 'static>(root: fn(Scope<T>) -> Element, root_prop
             websys_dom.load_templates(&templates);
 
             if let Err(err) = websys_dom.rehydrate(&dom) {
-                log::error!(
+                tracing::error!(
                     "Rehydration failed {:?}. Rebuild DOM into element from scratch",
                     &err
                 );
@@ -240,7 +240,7 @@ pub async fn run_with_props<T: 'static>(root: fn(Scope<T>) -> Element, root_prop
     websys_dom.mount();
 
     loop {
-        log::trace!("waiting for work");
+        tracing::trace!("waiting for work");
 
         // if virtualdom has nothing, wait for it to have something before requesting idle time
         // if there is work then this future resolves immediately.
diff --git a/packages/web/src/rehydrate.rs b/packages/web/src/rehydrate.rs
index c7ea6d87d..4415ceb37 100644
--- a/packages/web/src/rehydrate.rs
+++ b/packages/web/src/rehydrate.rs
@@ -114,9 +114,9 @@ impl WebsysDom {
         node: &TemplateNode,
         last_node_was_static_text: &mut bool,
     ) -> Result<(), RehydrationError> {
-        log::trace!("rehydrate template node: {:?}", node);
+        tracing::trace!("rehydrate template node: {:?}", node);
         if let Ok(current_child) = current_child {
-            if log::log_enabled!(log::Level::Trace) {
+            if tracing::event_enabled!(tracing::Level::TRACE) {
                 web_sys::console::log_1(&current_child.clone().into());
             }
         }
@@ -203,9 +203,9 @@ impl WebsysDom {
         dynamic: &DynamicNode,
         last_node_was_static_text: &mut bool,
     ) -> Result<(), RehydrationError> {
-        log::trace!("rehydrate dynamic node: {:?}", dynamic);
+        tracing::trace!("rehydrate dynamic node: {:?}", dynamic);
         if let Ok(current_child) = current_child {
-            if log::log_enabled!(log::Level::Trace) {
+            if tracing::event_enabled!(tracing::Level::TRACE) {
                 web_sys::console::log_1(&current_child.clone().into());
             }
         }