diff --git a/external/cursive-flexi-logger-view b/external/cursive-flexi-logger-view
index a1ff3623..16ac289d 160000
--- a/external/cursive-flexi-logger-view
+++ b/external/cursive-flexi-logger-view
@@ -1 +1 @@
-Subproject commit a1ff362346bd93955d9126893e4f6afb21f00881
+Subproject commit 16ac289d156b327a1a3a2feeef103e3212e453b5
diff --git a/veilid-cli/src/main.rs b/veilid-cli/src/main.rs
index c2c664a7..e7da7048 100644
--- a/veilid-cli/src/main.rs
+++ b/veilid-cli/src/main.rs
@@ -101,6 +101,7 @@ fn main() -> Result<(), String> {
     {
         let mut specbuilder = LogSpecBuilder::new();
         specbuilder.default(settings::convert_loglevel(settings.logging.level));
+        specbuilder.module("cursive", LevelFilter::Off);
         specbuilder.module("cursive_core", LevelFilter::Off);
         specbuilder.module("cursive_buffered_backend", LevelFilter::Off);
         specbuilder.module("mio", LevelFilter::Off);
diff --git a/veilid-core/src/rpc_processor/debug.rs b/veilid-core/src/rpc_processor/debug.rs
index 5a294cab..29c4f637 100644
--- a/veilid-core/src/rpc_processor/debug.rs
+++ b/veilid-core/src/rpc_processor/debug.rs
@@ -24,7 +24,6 @@ pub fn rpc_error_protocol<T: AsRef<str>>(x: T) -> RPCError {
 }
 pub fn rpc_error_capnp_error(e: capnp::Error) -> RPCError {
     error!("RPCError Protocol: capnp error: {}", &e.description);
-    panic!("wtf");
     RPCError::Protocol(e.description)
 }
 pub fn rpc_error_capnp_notinschema(e: capnp::NotInSchema) -> RPCError {
diff --git a/veilid-core/src/tests/common/test_veilid_config.rs b/veilid-core/src/tests/common/test_veilid_config.rs
index b173cc67..3abf45c4 100644
--- a/veilid-core/src/tests/common/test_veilid_config.rs
+++ b/veilid-core/src/tests/common/test_veilid_config.rs
@@ -290,7 +290,6 @@ pub async fn test_config() {
     let inner = vc.get();
     assert_eq!(inner.program_name, String::from("Veilid"));
     assert_eq!(inner.namespace, String::from(""));
-    assert_eq!(inner.api_log_level, VeilidConfigLogLevel::Off);
     assert_eq!(inner.capabilities.protocol_udp, true);
     assert_eq!(inner.capabilities.protocol_connect_tcp, true);
     assert_eq!(inner.capabilities.protocol_accept_tcp, true);
diff --git a/veilid-core/src/veilid_api/mod.rs b/veilid-core/src/veilid_api/mod.rs
index 28b4424d..5196eb33 100644
--- a/veilid-core/src/veilid_api/mod.rs
+++ b/veilid-core/src/veilid_api/mod.rs
@@ -23,7 +23,6 @@ pub use network_manager::NetworkManager;
 pub use routing_table::RoutingTable;
 pub use rpc_processor::StatusAnswer;
 
-use api_tracing_layer::*;
 use core::fmt;
 use core_context::{api_shutdown, VeilidCoreContext};
 use enumset::*;
diff --git a/veilid-core/src/veilid_api/serialize_helpers.rs b/veilid-core/src/veilid_api/serialize_helpers.rs
index e2e6ecab..dde7986a 100644
--- a/veilid-core/src/veilid_api/serialize_helpers.rs
+++ b/veilid-core/src/veilid_api/serialize_helpers.rs
@@ -1,7 +1,9 @@
 use super::*;
 use core::fmt::Debug;
 
-#[instrument(level = "trace", ret, err)]
+// XXX: Don't trace these functions as they are used in the transfer of API logs, which will recurse!
+
+// #[instrument(level = "trace", ret, err)]
 pub fn deserialize_json<'a, T: de::Deserialize<'a> + Debug>(
     arg: &'a str,
 ) -> Result<T, VeilidAPIError> {
@@ -15,7 +17,7 @@ pub fn deserialize_json<'a, T: de::Deserialize<'a> + Debug>(
     })
 }
 
-#[instrument(level = "trace", ret, err)]
+// #[instrument(level = "trace", ret, err)]
 pub fn deserialize_opt_json<T: de::DeserializeOwned + Debug>(
     arg: Option<String>,
 ) -> Result<T, VeilidAPIError> {
@@ -29,7 +31,7 @@ pub fn deserialize_opt_json<T: de::DeserializeOwned + Debug>(
     deserialize_json(arg)
 }
 
-#[instrument(level = "trace", ret)]
+// #[instrument(level = "trace", ret)]
 pub fn serialize_json<T: Serialize + Debug>(val: T) -> String {
     match serde_json::to_string(&val) {
         Ok(v) => v,
diff --git a/veilid-core/src/veilid_config.rs b/veilid-core/src/veilid_config.rs
index c92efa33..3132cb79 100644
--- a/veilid-core/src/veilid_config.rs
+++ b/veilid-core/src/veilid_config.rs
@@ -244,7 +244,6 @@ impl Default for VeilidConfigLogLevel {
 pub struct VeilidConfigInner {
     pub program_name: String,
     pub namespace: String,
-    pub api_log_level: VeilidConfigLogLevel,
     pub capabilities: VeilidConfigCapabilities,
     pub protected_store: VeilidConfigProtectedStore,
     pub table_store: VeilidConfigTableStore,
@@ -309,7 +308,6 @@ impl VeilidConfig {
             let mut inner = self.inner.write();
             get_config!(inner.program_name);
             get_config!(inner.namespace);
-            get_config!(inner.api_log_level);
             get_config!(inner.capabilities.protocol_udp);
             get_config!(inner.capabilities.protocol_connect_tcp);
             get_config!(inner.capabilities.protocol_accept_tcp);
diff --git a/veilid-core/src/veilid_layer_filter.rs b/veilid-core/src/veilid_layer_filter.rs
index 727ba3ce..a40fbc7a 100644
--- a/veilid-core/src/veilid_layer_filter.rs
+++ b/veilid-core/src/veilid_layer_filter.rs
@@ -1,7 +1,7 @@
 use super::*;
 use crate::xx::*;
 use tracing::level_filters::LevelFilter;
-use tracing::subscriber;
+use tracing::subscriber::Interest;
 use tracing_subscriber::layer;
 
 struct VeilidLayerFilterInner {
@@ -54,33 +54,35 @@ impl VeilidLayerFilter {
         }
         callsite::rebuild_interest_cache();
     }
-}
 
-impl<S: tracing::Subscriber> layer::Filter<S> for VeilidLayerFilter {
-    fn enabled(&self, metadata: &tracing::Metadata<'_>, _: &layer::Context<'_, S>) -> bool {
+    fn interesting(&self, metadata: &tracing::Metadata<'_>) -> bool {
         let inner = self.inner.read();
+
         if *metadata.level() > inner.max_level {
-            false
-        } else {
-            true
+            return false;
         }
-    }
-
-    fn callsite_enabled(
-        &self,
-        metadata: &'static tracing::Metadata<'static>,
-    ) -> subscriber::Interest {
-        let inner = self.inner.read();
         let skip = inner
             .ignore_list
             .iter()
             .any(|v| metadata.target().starts_with(&**v));
         if skip {
-            subscriber::Interest::never()
-        } else if *metadata.level() > inner.max_level {
-            subscriber::Interest::never()
+            return false;
+        }
+
+        true
+    }
+}
+
+impl<S: tracing::Subscriber> layer::Filter<S> for VeilidLayerFilter {
+    fn enabled(&self, metadata: &tracing::Metadata<'_>, _: &layer::Context<'_, S>) -> bool {
+        self.interesting(metadata)
+    }
+
+    fn callsite_enabled(&self, metadata: &'static tracing::Metadata<'static>) -> Interest {
+        if self.interesting(metadata) {
+            Interest::always()
         } else {
-            subscriber::Interest::always()
+            Interest::never()
         }
     }
 
diff --git a/veilid-flutter/example/lib/main.dart b/veilid-flutter/example/lib/main.dart
index 5fa4cc17..d45ab418 100644
--- a/veilid-flutter/example/lib/main.dart
+++ b/veilid-flutter/example/lib/main.dart
@@ -86,7 +86,7 @@ void main() {
                 logsInConsole: true),
             api: VeilidWASMConfigLoggingApi(
                 enabled: true, level: VeilidConfigLogLevel.info)));
-    Veilid.instance.configureVeilidPlatform(platformConfig.json);
+    Veilid.instance.initializeVeilidCore(platformConfig.json);
   } else {
     var platformConfig = VeilidFFIConfig(
         logging: VeilidFFIConfigLogging(
@@ -101,7 +101,7 @@ void main() {
                 serviceName: "VeilidExample"),
             api: VeilidFFIConfigLoggingApi(
                 enabled: true, level: VeilidConfigLogLevel.info)));
-    Veilid.instance.configureVeilidPlatform(platformConfig.json);
+    Veilid.instance.initializeVeilidCore(platformConfig.json);
   }
 
   runApp(MaterialApp(
diff --git a/veilid-flutter/lib/veilid.dart b/veilid-flutter/lib/veilid.dart
index e0c2ec28..1cb38452 100644
--- a/veilid-flutter/lib/veilid.dart
+++ b/veilid-flutter/lib/veilid.dart
@@ -1297,7 +1297,7 @@ class VeilidVersion {
 abstract class Veilid {
   static late Veilid instance = getVeilid();
 
-  void configureVeilidPlatform(Map<String, dynamic> platformConfigJson);
+  void initializeVeilidCore(Map<String, dynamic> platformConfigJson);
   void changeLogLevel(String layer, VeilidConfigLogLevel logLevel);
   Stream<VeilidUpdate> startupVeilidCore(VeilidConfig config);
   Future<VeilidState> getVeilidState();
diff --git a/veilid-flutter/lib/veilid_ffi.dart b/veilid-flutter/lib/veilid_ffi.dart
index 9118c0a3..edd34cee 100644
--- a/veilid-flutter/lib/veilid_ffi.dart
+++ b/veilid-flutter/lib/veilid_ffi.dart
@@ -29,9 +29,9 @@ typedef _FreeStringDart = void Function(Pointer<Utf8>);
 // fn initialize_veilid_flutter(dart_post_c_object_ptr: ffi::DartPostCObjectFnType)
 typedef _InitializeVeilidFlutterC = Void Function(Pointer<_DartPostCObject>);
 typedef _InitializeVeilidFlutterDart = void Function(Pointer<_DartPostCObject>);
-// fn configure_veilid_platform(platform_config: FfiStr)
-typedef _ConfigureVeilidPlatformC = Void Function(Pointer<Utf8>);
-typedef _ConfigureVeilidPlatformDart = void Function(Pointer<Utf8>);
+// fn initialize_veilid_core(platform_config: FfiStr)
+typedef _InitializeVeilidCoreC = Void Function(Pointer<Utf8>);
+typedef _InitializeVeilidCoreDart = void Function(Pointer<Utf8>);
 // fn change_log_level(layer: FfiStr, log_level: FfiStr)
 typedef _ChangeLogLevelC = Void Function(Pointer<Utf8>, Pointer<Utf8>);
 typedef _ChangeLogLevelDart = void Function(Pointer<Utf8>, Pointer<Utf8>);
@@ -245,7 +245,7 @@ class VeilidFFI implements Veilid {
 
   // Shared library functions
   final _FreeStringDart _freeString;
-  final _ConfigureVeilidPlatformDart _configureVeilidPlatform;
+  final _InitializeVeilidCoreDart _initializeVeilidCore;
   final _ChangeLogLevelDart _changeLogLevel;
   final _StartupVeilidCoreDart _startupVeilidCore;
   final _GetVeilidStateDart _getVeilidState;
@@ -258,9 +258,8 @@ class VeilidFFI implements Veilid {
       : _dylib = dylib,
         _freeString =
             dylib.lookupFunction<_FreeStringC, _FreeStringDart>('free_string'),
-        _configureVeilidPlatform = dylib.lookupFunction<
-            _ConfigureVeilidPlatformC,
-            _ConfigureVeilidPlatformDart>('configure_veilid_platform'),
+        _initializeVeilidCore = dylib.lookupFunction<_InitializeVeilidCoreC,
+            _InitializeVeilidCoreDart>('initialize_veilid_core'),
         _changeLogLevel =
             dylib.lookupFunction<_ChangeLogLevelC, _ChangeLogLevelDart>(
                 'change_log_level'),
@@ -287,12 +286,12 @@ class VeilidFFI implements Veilid {
   }
 
   @override
-  void configureVeilidPlatform(Map<String, dynamic> platformConfigJson) {
+  void initializeVeilidCore(Map<String, dynamic> platformConfigJson) {
     var nativePlatformConfig =
         jsonEncode(platformConfigJson, toEncodable: veilidApiToEncodable)
             .toNativeUtf8();
 
-    _configureVeilidPlatform(nativePlatformConfig);
+    _initializeVeilidCore(nativePlatformConfig);
 
     malloc.free(nativePlatformConfig);
   }
diff --git a/veilid-flutter/lib/veilid_js.dart b/veilid-flutter/lib/veilid_js.dart
index 13d79329..c65cecb3 100644
--- a/veilid-flutter/lib/veilid_js.dart
+++ b/veilid-flutter/lib/veilid_js.dart
@@ -20,11 +20,11 @@ Future<T> _wrapApiPromise<T>(Object p) {
 
 class VeilidJS implements Veilid {
   @override
-  void configureVeilidPlatform(Map<String, dynamic> platformConfigJson) {
+  void initializeVeilidCore(Map<String, dynamic> platformConfigJson) {
     var platformConfigJsonString =
         jsonEncode(platformConfigJson, toEncodable: veilidApiToEncodable);
-    js_util.callMethod(
-        wasm, "configure_veilid_platform", [platformConfigJsonString]);
+    js_util
+        .callMethod(wasm, "initialize_veilid_core", [platformConfigJsonString]);
   }
 
   @override
diff --git a/veilid-flutter/rust/src/dart_ffi.rs b/veilid-flutter/rust/src/dart_ffi.rs
index 10290f4a..16a554af 100644
--- a/veilid-flutter/rust/src/dart_ffi.rs
+++ b/veilid-flutter/rust/src/dart_ffi.rs
@@ -142,7 +142,7 @@ pub extern "C" fn initialize_veilid_flutter(dart_post_c_object_ptr: ffi::DartPos
 
 #[no_mangle]
 #[instrument]
-pub extern "C" fn configure_veilid_platform(platform_config: FfiStr) {
+pub extern "C" fn initialize_veilid_core(platform_config: FfiStr) {
     let platform_config = platform_config.into_opt_string();
     let platform_config: VeilidFFIConfig = veilid_core::deserialize_opt_json(platform_config)
         .expect("failed to deserialize plaform config json");
diff --git a/veilid-server/src/settings.rs b/veilid-server/src/settings.rs
index b3154b61..69114bba 100644
--- a/veilid-server/src/settings.rs
+++ b/veilid-server/src/settings.rs
@@ -34,7 +34,7 @@ logging:
         append: true
         level: 'info'
     api:
-        enabled: false
+        enabled: true
         level: 'info'
     otlp:
         enabled: false
diff --git a/veilid-wasm/src/lib.rs b/veilid-wasm/src/lib.rs
index db22a989..5c13f7fb 100644
--- a/veilid-wasm/src/lib.rs
+++ b/veilid-wasm/src/lib.rs
@@ -108,7 +108,7 @@ where
 #[derive(Debug, Deserialize, Serialize)]
 pub struct VeilidWASMConfigLoggingPerformance {
     pub enabled: bool,
-    pub level: veilid_core::VeilidLogLevel,
+    pub level: veilid_core::VeilidConfigLogLevel,
     pub logs_in_timings: bool,
     pub logs_in_console: bool,
 }
@@ -116,7 +116,7 @@ pub struct VeilidWASMConfigLoggingPerformance {
 #[derive(Debug, Deserialize, Serialize)]
 pub struct VeilidWASMConfigLoggingAPI {
     pub enabled: bool,
-    pub level: veilid_core::VeilidLogLevel,
+    pub level: veilid_core::VeilidConfigLogLevel,
 }
 
 #[derive(Debug, Deserialize, Serialize)]
@@ -138,14 +138,14 @@ pub fn initialize_veilid_wasm() {
 }
 
 #[wasm_bindgen()]
-pub fn configure_veilid_platform(platform_config: String) {
+pub fn initialize_veilid_core(platform_config: String) {
     let platform_config: VeilidWASMConfig = veilid_core::deserialize_json(&platform_config)
-        .expect("failed to deserialize plaform config json");
+        .expect("failed to deserialize platform config json");
 
     // Set up subscriber and layers
     let subscriber = Registry::default();
     let mut layers = Vec::new();
-    let handles = (*FILTER_RELOAD_HANDLES).borrow_mut();
+    let mut filters = (*FILTERS).borrow_mut();
 
     // Performance logger
     if platform_config.logging.performance.enabled {
@@ -162,7 +162,7 @@ pub fn configure_veilid_platform(platform_config: String) {
                 .build(),
         )
         .with_filter(filter.clone());
-        handles.insert("performance", filter);
+        filters.insert("performance", filter);
         layers.push(layer.boxed());
     };
 
@@ -170,7 +170,7 @@ pub fn configure_veilid_platform(platform_config: String) {
     if platform_config.logging.api.enabled {
         let filter = veilid_core::VeilidLayerFilter::new(platform_config.logging.api.level, None);
         let layer = veilid_core::ApiTracingLayer::get().with_filter(filter.clone());
-        handles.insert("api", filter);
+        filters.insert("api", filter);
         layers.push(layer.boxed());
     }