diff --git a/Cargo.lock b/Cargo.lock
index 906cd06..1903b1e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -240,6 +240,12 @@ dependencies = [
  "slab",
 ]
 
+[[package]]
+name = "lazy_static"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
+
 [[package]]
 name = "libc"
 version = "0.2.152"
@@ -262,6 +268,12 @@ version = "0.4.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "01cda141df6706de531b6c46c3a33ecca755538219bd484262fa09410c13539c"
 
+[[package]]
+name = "log"
+version = "0.4.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5e6163cb8c49088c2c36f57875e58ccd8c87c7427f7fbd50ea6710b2f3f2e8f"
+
 [[package]]
 name = "luau0-src"
 version = "0.8.0+luau609"
@@ -306,6 +318,8 @@ dependencies = [
  "event-listener",
  "futures-lite",
  "mlua",
+ "tracing",
+ "tracing-subscriber",
 ]
 
 [[package]]
@@ -320,6 +334,16 @@ dependencies = [
  "pkg-config",
 ]
 
+[[package]]
+name = "nu-ansi-term"
+version = "0.46.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77a8165726e8236064dbb45459242600304b42a5ea24ee2948e18e023bf7ba84"
+dependencies = [
+ "overload",
+ "winapi",
+]
+
 [[package]]
 name = "num-traits"
 version = "0.2.17"
@@ -344,6 +368,12 @@ dependencies = [
  "num-traits",
 ]
 
+[[package]]
+name = "overload"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b15813163c1d831bf4a13c3610c05c0d03b39feb07f7e09fa234dac9b15aaf39"
+
 [[package]]
 name = "parking"
 version = "2.2.0"
@@ -460,6 +490,15 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "sharded-slab"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f40ca3c46823713e0d4209592e8d6e826aa57e928f09752619fc696c499637f6"
+dependencies = [
+ "lazy_static",
+]
+
 [[package]]
 name = "slab"
 version = "0.4.9"
@@ -469,6 +508,12 @@ dependencies = [
  "autocfg",
 ]
 
+[[package]]
+name = "smallvec"
+version = "1.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6ecd384b10a64542d77071bd64bd7b231f4ed5940fba55e98c3de13824cf3d7"
+
 [[package]]
 name = "syn"
 version = "2.0.48"
@@ -480,6 +525,16 @@ dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "thread_local"
+version = "1.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3fdd6f064ccff2d6567adcb3873ca630700f00b5ad3f060c25b5dcfd9a4ce152"
+dependencies = [
+ "cfg-if",
+ "once_cell",
+]
+
 [[package]]
 name = "tracing"
 version = "0.1.40"
@@ -487,14 +542,55 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c3523ab5a71916ccf420eebdf5521fcef02141234bbc0b8a49f2fdc4544364ef"
 dependencies = [
  "pin-project-lite",
+ "tracing-attributes",
  "tracing-core",
 ]
 
+[[package]]
+name = "tracing-attributes"
+version = "0.1.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34704c8d6ebcbc939824180af020566b01a7c01f80641264eba0999f6c2b6be7"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "tracing-core"
 version = "0.1.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c06d3da6113f116aaee68e4d601191614c9053067f9ab7f6edbcb161237daa54"
+dependencies = [
+ "once_cell",
+ "valuable",
+]
+
+[[package]]
+name = "tracing-log"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ee855f1f400bd0e5c02d150ae5de3840039a3f54b025156404e34c23c03f47c3"
+dependencies = [
+ "log",
+ "once_cell",
+ "tracing-core",
+]
+
+[[package]]
+name = "tracing-subscriber"
+version = "0.3.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ad0f048c97dbd9faa9b7df56362b8ebcaa52adb06b498c050d2f4e32f90a7a8b"
+dependencies = [
+ "nu-ansi-term",
+ "sharded-slab",
+ "smallvec",
+ "thread_local",
+ "tracing-core",
+ "tracing-log",
+]
 
 [[package]]
 name = "unicode-ident"
@@ -502,6 +598,34 @@ version = "1.0.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"
 
+[[package]]
+name = "valuable"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "830b7e5d4d90034032940e4ace0d9a9a057e7a45cd94e6c007832e39edb82f6d"
+
+[[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+
 [[package]]
 name = "windows-sys"
 version = "0.48.0"
diff --git a/Cargo.toml b/Cargo.toml
index c3309c3..353926e 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -14,6 +14,7 @@ async-executor = "1.8"
 concurrent-queue = "2.4"
 event-listener = "4.0"
 futures-lite = "2.2"
+tracing = "0.1"
 
 mlua = { version = "0.9.5", features = [
     "luau",
@@ -25,6 +26,7 @@ mlua = { version = "0.9.5", features = [
 [dev-dependencies]
 async-fs = "2.1"
 async-io = "2.3"
+tracing-subscriber = "0.3"
 
 [lints.clippy]
 all = { level = "deny", priority = -3 }
diff --git a/examples/basic_sleep.rs b/examples/basic_sleep.rs
index 1add4b4..fa19ed6 100644
--- a/examples/basic_sleep.rs
+++ b/examples/basic_sleep.rs
@@ -10,6 +10,8 @@ use mlua_luau_runtime::Runtime;
 const MAIN_SCRIPT: &str = include_str!("./lua/basic_sleep.luau");
 
 pub fn main() -> LuaResult<()> {
+    tracing_subscriber::fmt::init();
+
     // Set up persistent Lua environment
     let lua = Lua::new();
     lua.globals().set(
diff --git a/examples/basic_spawn.rs b/examples/basic_spawn.rs
index 1e9e319..07643c3 100644
--- a/examples/basic_spawn.rs
+++ b/examples/basic_spawn.rs
@@ -11,6 +11,8 @@ use mlua_luau_runtime::{LuaSpawnExt, Runtime};
 const MAIN_SCRIPT: &str = include_str!("./lua/basic_spawn.luau");
 
 pub fn main() -> LuaResult<()> {
+    tracing_subscriber::fmt::init();
+
     // Set up persistent Lua environment
     let lua = Lua::new();
     lua.globals().set(
diff --git a/examples/callbacks.rs b/examples/callbacks.rs
index 4c52a47..a51356d 100644
--- a/examples/callbacks.rs
+++ b/examples/callbacks.rs
@@ -8,6 +8,8 @@ use async_io::block_on;
 const MAIN_SCRIPT: &str = include_str!("./lua/callbacks.luau");
 
 pub fn main() -> LuaResult<()> {
+    tracing_subscriber::fmt::init();
+
     // Set up persistent Lua environment
     let lua = Lua::new();
 
diff --git a/examples/lots_of_threads.rs b/examples/lots_of_threads.rs
index ef6345c..ad54f43 100644
--- a/examples/lots_of_threads.rs
+++ b/examples/lots_of_threads.rs
@@ -12,6 +12,8 @@ const MAIN_SCRIPT: &str = include_str!("./lua/lots_of_threads.luau");
 const ONE_NANOSECOND: Duration = Duration::from_nanos(1);
 
 pub fn main() -> LuaResult<()> {
+    tracing_subscriber::fmt::init();
+
     // Set up persistent Lua environment
     let lua = Lua::new();
     let rt = Runtime::new(&lua);
diff --git a/examples/scheduler_ordering.rs b/examples/scheduler_ordering.rs
index 23f29bd..2d5800c 100644
--- a/examples/scheduler_ordering.rs
+++ b/examples/scheduler_ordering.rs
@@ -10,6 +10,8 @@ use mlua_luau_runtime::Runtime;
 const MAIN_SCRIPT: &str = include_str!("./lua/scheduler_ordering.luau");
 
 pub fn main() -> LuaResult<()> {
+    tracing_subscriber::fmt::init();
+
     // Set up persistent Lua environment
     let lua = Lua::new();
     let rt = Runtime::new(&lua);
diff --git a/lib/queue.rs b/lib/queue.rs
index 51e9ebf..2dd2303 100644
--- a/lib/queue.rs
+++ b/lib/queue.rs
@@ -33,6 +33,8 @@ impl ThreadQueue {
     ) -> LuaResult<()> {
         let thread = thread.into_lua_thread(lua)?;
         let args = args.into_lua_multi(lua)?;
+
+        tracing::trace!("pushing item to queue with {} args", args.len());
         let stored = ThreadWithArgs::new(lua, thread, args)?;
 
         self.queue.push(stored).into_lua_err()?;
diff --git a/lib/runtime.rs b/lib/runtime.rs
index 9e48b86..8dcb8bd 100644
--- a/lib/runtime.rs
+++ b/lib/runtime.rs
@@ -4,6 +4,7 @@ use futures_lite::prelude::*;
 use mlua::prelude::*;
 
 use async_executor::{Executor, LocalExecutor};
+use tracing::Instrument;
 
 use super::{
     error_callback::ThreadErrorCallback, queue::ThreadQueue, traits::IntoLuaThread,
@@ -71,6 +72,7 @@ impl<'lua> Runtime<'lua> {
         thread: impl IntoLuaThread<'lua>,
         args: impl IntoLuaMulti<'lua>,
     ) -> LuaResult<()> {
+        tracing::debug!(deferred = false, "new runtime thread");
         self.queue_spawn.push_item(self.lua, thread, args)
     }
 
@@ -90,6 +92,7 @@ impl<'lua> Runtime<'lua> {
         thread: impl IntoLuaThread<'lua>,
         args: impl IntoLuaMulti<'lua>,
     ) -> LuaResult<()> {
+        tracing::debug!(deferred = true, "new runtime thread");
         self.queue_defer.push_item(self.lua, thread, args)
     }
 
@@ -207,38 +210,65 @@ impl<'lua> Runtime<'lua> {
             when there are new Lua threads to enqueue and potentially more work to be done.
         */
         let fut = async {
+            let process_thread = |thread: LuaThread<'lua>, args| {
+                // NOTE: Thread may have been cancelled from Lua
+                // before we got here, so we need to check it again
+                if thread.status() == LuaThreadStatus::Resumable {
+                    let mut stream = thread.clone().into_async::<_, LuaValue>(args);
+                    lua_exec
+                        .spawn(async move {
+                            // Only run stream until first coroutine.yield or completion. We will
+                            // drop it right away to clear stack space since detached tasks dont drop
+                            // until the executor drops (https://github.com/smol-rs/smol/issues/294)
+                            let res = stream.next().await.unwrap();
+                            if let Err(e) = &res {
+                                self.error_callback.call(e);
+                            }
+                        })
+                        .detach();
+                }
+            };
+
             loop {
                 let fut_spawn = self.queue_spawn.wait_for_item(); // 1
                 let fut_defer = self.queue_defer.wait_for_item(); // 2
-                let fut_tick = lua_exec.tick(); // 3
 
-                fut_spawn.or(fut_defer).or(fut_tick).await;
-
-                let process_thread = |thread: LuaThread<'lua>, args| {
-                    // NOTE: Thread may have been cancelled from Lua
-                    // before we got here, so we need to check it again
-                    if thread.status() == LuaThreadStatus::Resumable {
-                        let mut stream = thread.clone().into_async::<_, LuaValue>(args);
-                        lua_exec
-                            .spawn(async move {
-                                // Only run stream until first coroutine.yield or completion. We will
-                                // drop it right away to clear stack space since detached tasks dont drop
-                                // until the executor drops (https://github.com/smol-rs/smol/issues/294)
-                                let res = stream.next().await.unwrap();
-                                if let Err(e) = &res {
-                                    self.error_callback.call(e);
-                                }
-                            })
-                            .detach();
+                // 3
+                let mut num_processed = 0;
+                let span_tick = tracing::debug_span!("tick_executor");
+                let fut_tick = async {
+                    lua_exec.tick().await;
+                    // NOTE: Try to do as much work as possible instead of just a single tick()
+                    num_processed += 1;
+                    while lua_exec.try_tick() {
+                        num_processed += 1;
                     }
                 };
 
+                // 1 + 2 + 3
+                fut_spawn
+                    .or(fut_defer)
+                    .or(fut_tick.instrument(span_tick.or_current()))
+                    .await;
+
+                // Emit traces
+                if num_processed > 0 {
+                    tracing::trace!(num_processed, "tasks_processed");
+                }
+
                 // Process spawned threads first, then deferred threads
+                let mut num_spawned = 0;
+                let mut num_deferred = 0;
                 for (thread, args) in self.queue_spawn.drain_items(self.lua) {
                     process_thread(thread, args);
+                    num_spawned += 1;
                 }
                 for (thread, args) in self.queue_defer.drain_items(self.lua) {
                     process_thread(thread, args);
+                    num_deferred += 1;
+                }
+                if num_spawned > 0 || num_deferred > 0 {
+                    tracing::trace!(num_spawned, num_deferred, "tasks_spawned");
                 }
 
                 // Empty executor = we didn't spawn any new Lua tasks
@@ -249,7 +279,9 @@ impl<'lua> Runtime<'lua> {
             }
         };
 
-        main_exec.run(fut).await;
+        // Run the executor inside a span until all lua threads complete
+        let span = tracing::debug_span!("run_executor");
+        main_exec.run(fut).instrument(span.or_current()).await;
 
         // Clean up
         self.lua.remove_app_data::<Weak<Executor>>();
diff --git a/lib/traits.rs b/lib/traits.rs
index c9f5170..5d45659 100644
--- a/lib/traits.rs
+++ b/lib/traits.rs
@@ -105,6 +105,7 @@ impl<'lua> LuaSpawnExt<'lua> for Lua {
             .expect("futures can only be spawned within a runtime")
             .upgrade()
             .expect("executor was dropped");
+        tracing::trace!("spawning future on executor");
         exec.spawn(fut)
     }
 }