Merge branch 'main' of gitlab.hackers.town:veilid/veilid

setup_macos.sh

@@ -13,10 +13,10 @@ rustup target add aarch64-apple-darwin aarch64-apple-ios x86_64-apple-darwin x86
 cargo install wasm-bindgen-cli
 
 # install bitcode compatible ios toolchain
-echo Manual Step:
+# echo Manual Step:
-echo   install +ios-arm64-1.57.0 toolchain for bitcode from https://github.com/getditto/rust-bitcode/releases/latest and unzip
+# echo   install +ios-arm64-1.57.0 toolchain for bitcode from https://github.com/getditto/rust-bitcode/releases/latest and unzip
-echo   xattr -d -r com.apple.quarantine .
+# echo   xattr -d -r com.apple.quarantine .
-echo   ./install.sh
+# echo   ./install.sh
 
 # ensure brew is installed
 if command -v brew &> /dev/null; then 
@@ -39,8 +39,16 @@ xcode-select --install
 
 # ensure packages are installed
 if [ "$BREW_USER" == "" ]; then
+    if [ -d /opt/homebrew ]; then
         BREW_USER=`ls -lad /opt/homebrew/. | cut -d\  -f4`
         echo "Must sudo to homebrew user \"$BREW_USER\" to install capnp package:"
+    elif [ -d /usr/local/Homebrew ]; then
+        BREW_USER=`ls -lad /usr/local/Homebrew/. | cut -d\  -f4`
+        echo "Must sudo to homebrew user \"$BREW_USER\" to install capnp package:"
+    else
+        echo "Homebrew is not installed in the normal place. Trying as current user"
+        BREW_USER=`whoami`
+    fi
 fi
 sudo -H -u $BREW_USER brew install capnp
 

veilid-core/ios_build.sh

@@ -15,8 +15,8 @@ do
     if [ "$arch" == "arm64" ]; then
         echo arm64
         CARGO_TARGET=aarch64-apple-ios
-        CARGO_TOOLCHAIN=+ios-arm64-1.57.0
+        #CARGO_TOOLCHAIN=+ios-arm64-1.57.0
-        #CARGO_TOOLCHAIN=
+        CARGO_TOOLCHAIN=
     elif [ "$arch" == "x86_64" ]; then
         echo x86_64
         CARGO_TARGET=x86_64-apple-ios

veilid-core/src/api_tracing_layer.rs

@@ -52,6 +52,7 @@ impl ApiTracingLayer {
         }
     }
 
+    #[instrument(level = "debug", skip(update_callback))]
     pub async fn init(max_level: Option<VeilidLogLevel>, update_callback: UpdateCallback) {
         let api_logger = API_LOGGER.get_or_init(|| ApiTracingLayer {
             inner: Arc::new(Mutex::new(None)),
@@ -60,6 +61,7 @@ impl ApiTracingLayer {
         *api_logger.inner.lock() = apilogger_inner;
     }
 
+    #[instrument(level = "debug")]
     pub async fn terminate() {
         if let Some(api_logger) = API_LOGGER.get() {
             let mut inner = api_logger.inner.lock();
@@ -75,6 +77,7 @@ impl ApiTracingLayer {
             .clone()
     }
 
+    #[instrument(level = "trace")]
     pub fn change_api_log_level(max_level: Option<VeilidLogLevel>) {
         if let Some(api_logger) = API_LOGGER.get() {
             if let Some(inner) = &mut *api_logger.inner.lock() {

veilid-core/src/attachment_manager.rs

@@ -221,6 +221,7 @@ impl AttachmentManager {
         }
     }
 
+    #[instrument(level = "debug", skip(self))]
     async fn attachment_maintainer(self) {
         trace!("attachment starting");
         let netman = {
@@ -229,7 +230,6 @@ impl AttachmentManager {
             inner.network_manager.clone()
         };
 
-        trace!("starting network");
         let mut started = true;
         if let Err(err) = netman.startup().await {
             error!("network startup failed: {}", err);
@@ -266,6 +266,7 @@ impl AttachmentManager {
         self.inner.lock().attach_timestamp = None;
     }
 
+    #[instrument(level = "debug", skip_all, err)]
     pub async fn init(&self, update_callback: UpdateCallback) -> Result<(), String> {
         trace!("init");
         let network_manager = {
@@ -286,6 +287,8 @@ impl AttachmentManager {
 
         Ok(())
     }
+
+    #[instrument(level = "debug", skip(self))]
     pub async fn terminate(&self) {
         // Ensure we detached
         self.detach().await;
@@ -298,8 +301,8 @@ impl AttachmentManager {
         inner.update_callback = None;
     }
 
+    #[instrument(level = "trace", skip(self))]
     fn attach(&self) {
-        trace!("attach");
         // Create long-running connection maintenance routine
         let this = self.clone();
         self.inner.lock().maintain_peers = true;
@@ -307,8 +310,8 @@ impl AttachmentManager {
             Some(intf::spawn(this.attachment_maintainer()));
     }
 
+    #[instrument(level = "trace", skip(self))]
     async fn detach(&self) {
-        trace!("detach");
         let attachment_maintainer_jh = self.inner.lock().attachment_maintainer_jh.take();
         if let Some(jh) = attachment_maintainer_jh {
             // Terminate long-running connection maintenance routine
@@ -343,16 +346,18 @@ impl AttachmentManager {
         }
     }
 
+    #[instrument(level = "trace", skip(self), err)]
     pub async fn request_attach(&self) -> Result<(), String> {
         self.process_input(&AttachmentInput::AttachRequested)
             .await
             .map_err(|e| format!("Attach request failed: {}", e))
     }
 
+    #[instrument(level = "trace", skip(self), err)]
     pub async fn request_detach(&self) -> Result<(), String> {
         self.process_input(&AttachmentInput::DetachRequested)
             .await
-            .map_err(|e| format!("Attach request failed: {}", e))
+            .map_err(|e| format!("Detach request failed: {}", e))
     }
 
     pub fn get_state(&self) -> AttachmentState {

veilid-core/src/core_context.rs

@@ -10,7 +10,6 @@ cfg_if! {
     if #[cfg(target_arch = "wasm32")] {
         pub type UpdateCallback = Arc<dyn Fn(VeilidUpdate)>;
     } else {
-
         pub type UpdateCallback = Arc<dyn Fn(VeilidUpdate) + Send + Sync>;
     }
 }
@@ -59,6 +58,7 @@ impl ServicesContext {
         }
     }
 
+    #[instrument(err, skip_all)]
     pub async fn startup(&mut self) -> Result<(), VeilidAPIError> {
         let api_log_level: VeilidConfigLogLevel = self.config.get().api_log_level;
         if api_log_level != VeilidConfigLogLevel::Off {
@@ -131,6 +131,7 @@ impl ServicesContext {
         Ok(())
     }
 
+    #[instrument(skip_all)]
     pub async fn shutdown(&mut self) {
         info!("Veilid API shutting down");
 
@@ -179,6 +180,7 @@ pub struct VeilidCoreContext {
 }
 
 impl VeilidCoreContext {
+    #[instrument(err, skip_all)]
     async fn new_with_config_callback(
         update_callback: UpdateCallback,
         config_callback: ConfigCallback,
@@ -193,6 +195,7 @@ impl VeilidCoreContext {
         Self::new_common(update_callback, config).await
     }
 
+    #[instrument(err, skip(update_callback))]
     async fn new_with_config_json(
         update_callback: UpdateCallback,
         config_json: String,
@@ -206,6 +209,7 @@ impl VeilidCoreContext {
         Self::new_common(update_callback, config).await
     }
 
+    #[instrument(err, skip(update_callback))]
     async fn new_common(
         update_callback: UpdateCallback,
         config: VeilidConfig,
@@ -233,6 +237,7 @@ impl VeilidCoreContext {
         })
     }
 
+    #[instrument(skip_all)]
     async fn shutdown(self) {
         let mut sc = ServicesContext::new_full(
             self.config.clone(),
@@ -251,6 +256,7 @@ impl VeilidCoreContext {
 
 static INITIALIZED: AsyncMutex<bool> = AsyncMutex::new(false);
 
+#[instrument(err, skip_all)]
 pub async fn api_startup(
     update_callback: UpdateCallback,
     config_callback: ConfigCallback,
@@ -273,6 +279,7 @@ pub async fn api_startup(
     Ok(veilid_api)
 }
 
+#[instrument(err, skip(update_callback))]
 pub async fn api_startup_json(
     update_callback: UpdateCallback,
     config_json: String,
@@ -294,6 +301,7 @@ pub async fn api_startup_json(
     Ok(veilid_api)
 }
 
+#[instrument(skip_all)]
 pub(crate) async fn api_shutdown(context: VeilidCoreContext) {
     let mut initialized_lock = INITIALIZED.lock().await;
     context.shutdown().await;

veilid-core/src/intf/native/protected_store.rs

@@ -29,6 +29,7 @@ impl ProtectedStore {
         }
     }
 
+    #[instrument(level = "trace", skip(self), err)]
     pub async fn delete_all(&self) -> Result<(), String> {
         // Delete all known keys
         if self.remove_user_secret_string("node_id").await? {
@@ -43,6 +44,7 @@ impl ProtectedStore {
         Ok(())
     }
 
+    #[instrument(level = "debug", skip(self), err)]
     pub async fn init(&self) -> Result<(), String> {
         let delete = {
             let c = self.config.get();
@@ -95,6 +97,7 @@ impl ProtectedStore {
         Ok(())
     }
 
+    #[instrument(level = "debug", skip(self))]
     pub async fn terminate(&self) {
         *self.inner.lock() = Self::new_inner();
     }
@@ -108,6 +111,7 @@ impl ProtectedStore {
         }
     }
 
+    #[instrument(level = "trace", skip(self, value), ret, err)]
     pub async fn save_user_secret_string(&self, key: &str, value: &str) -> Result<bool, String> {
         let inner = self.inner.lock();
         inner
@@ -124,6 +128,7 @@ impl ProtectedStore {
             .map_err(logthru_pstore!())
     }
 
+    #[instrument(level = "trace", skip(self), err)]
     pub async fn load_user_secret_string(&self, key: &str) -> Result<Option<String>, String> {
         let inner = self.inner.lock();
         match inner
@@ -139,6 +144,7 @@ impl ProtectedStore {
         }
     }
 
+    #[instrument(level = "trace", skip(self), ret, err)]
     pub async fn remove_user_secret_string(&self, key: &str) -> Result<bool, String> {
         let inner = self.inner.lock();
         match inner
@@ -154,6 +160,7 @@ impl ProtectedStore {
         }
     }
 
+    #[instrument(level = "trace", skip(self, value), ret, err)]
     pub async fn save_user_secret(&self, key: &str, value: &[u8]) -> Result<bool, String> {
         let mut s = BASE64URL_NOPAD.encode(value);
         s.push('!');
@@ -161,6 +168,7 @@ impl ProtectedStore {
         self.save_user_secret_string(key, s.as_str()).await
     }
 
+    #[instrument(level = "trace", skip(self), err)]
     pub async fn load_user_secret(&self, key: &str) -> Result<Option<Vec<u8>>, String> {
         let mut s = match self.load_user_secret_string(key).await? {
             Some(s) => s,
@@ -191,6 +199,7 @@ impl ProtectedStore {
         }
     }
 
+    #[instrument(level = "trace", skip(self), ret, err)]
     pub async fn remove_user_secret(&self, key: &str) -> Result<bool, String> {
         self.remove_user_secret_string(key).await
     }

veilid-core/src/network_manager/mod.rs

@@ -233,6 +233,7 @@ impl NetworkManager {
         self.inner.lock().relay_node.clone()
     }
 
+    #[instrument(level = "debug", skip_all, err)]
     pub async fn init(&self, update_callback: UpdateCallback) -> Result<(), String> {
         let routing_table = RoutingTable::new(self.clone());
         routing_table.init().await?;
@@ -240,6 +241,8 @@ impl NetworkManager {
         self.inner.lock().update_callback = Some(update_callback);
         Ok(())
     }
+
+    #[instrument(level = "debug", skip_all)]
     pub async fn terminate(&self) {
         let routing_table = {
             let mut inner = self.inner.lock();
@@ -251,6 +254,7 @@ impl NetworkManager {
         self.inner.lock().update_callback = None;
     }
 
+    #[instrument(level = "debug", skip_all, err)]
     pub async fn internal_startup(&self) -> Result<(), String> {
         trace!("NetworkManager::internal_startup begin");
         if self.inner.lock().components.is_some() {
@@ -281,6 +285,7 @@ impl NetworkManager {
         Ok(())
     }
 
+    #[instrument(level = "debug", skip_all, err)]
     pub async fn startup(&self) -> Result<(), String> {
         if let Err(e) = self.internal_startup().await {
             self.shutdown().await;
@@ -292,6 +297,7 @@ impl NetworkManager {
         Ok(())
     }
 
+    #[instrument(level = "debug", skip_all)]
     pub async fn shutdown(&self) {
         trace!("NetworkManager::shutdown begin");
 
@@ -339,6 +345,7 @@ impl NetworkManager {
         }
     }
 
+    #[instrument(level = "trace", skip(self), ret)]
     pub fn check_client_whitelist(&self, client: DHTKey) -> bool {
         let mut inner = self.inner.lock();
 
@@ -351,6 +358,7 @@ impl NetworkManager {
         }
     }
 
+    #[instrument(level = "trace", skip(self))]
     pub fn purge_client_whitelist(&self) {
         let timeout_ms = self.config.get().network.client_whitelist_timeout_ms;
         let mut inner = self.inner.lock();
@@ -366,6 +374,15 @@ impl NetworkManager {
         }
     }
 
+    #[instrument(level = "debug", skip_all, err)]
+    async fn restart_net(&self, net: Network) -> Result<(), String> {
+        net.shutdown().await;
+        self.send_network_update();
+        net.startup().await?;
+        self.send_network_update();
+        Ok(())
+    }
+
     pub async fn tick(&self) -> Result<(), String> {
         let (routing_table, net, receipt_manager) = {
             let inner = self.inner.lock();
@@ -380,10 +397,7 @@ impl NetworkManager {
         // If the network needs to be reset, do it
         // if things can't restart, then we fail out of the attachment manager
         if net.needs_restart() {
-            net.shutdown().await;
+            self.restart_net(net.clone()).await?;
-            self.send_network_update();
-            net.startup().await?;
-            self.send_network_update();
         }
 
         // Run the rolling transfers task
@@ -448,6 +462,7 @@ impl NetworkManager {
     }
 
     // Generates a multi-shot/normal receipt
+    #[instrument(level = "trace", skip(self, extra_data, callback), err)]
     pub fn generate_receipt<D: AsRef<[u8]>>(
         &self,
         expiration_us: u64,
@@ -473,6 +488,7 @@ impl NetworkManager {
     }
 
     // Generates a single-shot/normal receipt
+    #[instrument(level = "trace", skip(self, extra_data), err)]
     pub fn generate_single_shot_receipt<D: AsRef<[u8]>>(
         &self,
         expiration_us: u64,
@@ -498,6 +514,7 @@ impl NetworkManager {
     }
 
     // Process a received out-of-band receipt
+    #[instrument(level = "trace", skip(self, receipt_data), err)]
     pub async fn handle_out_of_band_receipt<R: AsRef<[u8]>>(
         &self,
         receipt_data: R,
@@ -511,6 +528,7 @@ impl NetworkManager {
     }
 
     // Process a received in-band receipt
+    #[instrument(level = "trace", skip(self, receipt_data), err)]
     pub async fn handle_in_band_receipt<R: AsRef<[u8]>>(
         &self,
         receipt_data: R,
@@ -527,6 +545,7 @@ impl NetworkManager {
     }
 
     // Process a received signal
+    #[instrument(level = "trace", skip(self), err)]
     pub async fn handle_signal(&self, signal_info: SignalInfo) -> Result<(), String> {
         match signal_info {
             SignalInfo::ReverseConnect { receipt, peer_info } => {
@@ -588,6 +607,7 @@ impl NetworkManager {
     }
 
     // Builds an envelope for sending over the network
+    #[instrument(level = "trace", skip(self, body), err)]
     fn build_envelope<B: AsRef<[u8]>>(
         &self,
         dest_node_id: DHTKey,
@@ -614,6 +634,7 @@ impl NetworkManager {
     // node_ref is the direct destination to which the envelope will be sent
     // If 'node_id' is specified, it can be different than node_ref.node_id()
     // which will cause the envelope to be relayed
+    #[instrument(level = "trace", skip(self, body), ret, err)]
     pub async fn send_envelope<B: AsRef<[u8]>>(
         &self,
         node_ref: NodeRef,
@@ -665,6 +686,7 @@ impl NetworkManager {
     }
 
     // Called by the RPC handler when we want to issue an direct receipt
+    #[instrument(level = "trace", skip(self, rcpt_data), err)]
     pub async fn send_out_of_band_receipt(
         &self,
         dial_info: DialInfo,
@@ -683,6 +705,7 @@ impl NetworkManager {
     }
 
     // Figure out how to reach a node
+    #[instrument(level = "trace", skip(self), ret, err)]
     fn get_contact_method(&self, mut target_node_ref: NodeRef) -> Result<ContactMethod, String> {
         let routing_table = self.routing_table();
 
@@ -802,6 +825,7 @@ impl NetworkManager {
 
     // Send a reverse connection signal and wait for the return receipt over it
     // Then send the data across the new connection
+    #[instrument(level = "trace", skip(self, data), err)]
     pub async fn do_reverse_connect(
         &self,
         relay_nr: NodeRef,
@@ -872,6 +896,7 @@ impl NetworkManager {
 
     // Send a hole punch signal and do a negotiating ping and wait for the return receipt
     // Then send the data across the new connection
+    #[instrument(level = "trace", skip(self, data), err)]
     pub async fn do_hole_punch(
         &self,
         relay_nr: NodeRef,
@@ -1036,6 +1061,7 @@ impl NetworkManager {
     // Called when a packet potentially containing an RPC envelope is received by a low-level
     // network protocol handler. Processes the envelope, authenticates and decrypts the RPC message
     // and passes it to the RPC handler
+    #[instrument(level="trace", err, skip(self, data), fields(data.len = data.len()))]
     async fn on_recv_envelope(
         &self,
         data: &[u8],
@@ -1175,6 +1201,7 @@ impl NetworkManager {
     }
 
     // Keep relays assigned and accessible
+    #[instrument(level = "trace", skip(self), err)]
     async fn relay_management_task_routine(self, _last_ts: u64, cur_ts: u64) -> Result<(), String> {
         // log_net!("--- network manager relay_management task");
 
@@ -1227,6 +1254,7 @@ impl NetworkManager {
     }
 
     // Compute transfer statistics for the low level network
+    #[instrument(level = "trace", skip(self), err)]
     async fn rolling_transfers_task_routine(self, last_ts: u64, cur_ts: u64) -> Result<(), String> {
         // log_net!("--- network manager rolling_transfers task");
         {

veilid-core/src/network_manager/native/mod.rs

@@ -267,6 +267,7 @@ impl Network {
     // This creates a short-lived connection in the case of connection-oriented protocols
     // for the purpose of sending this one message.
     // This bypasses the connection table as it is not a 'node to node' connection.
+    #[instrument(level="trace", err, skip(self, data), fields(data.len = data.len()))]
     pub async fn send_data_unbound_to_dial_info(
         &self,
         dial_info: DialInfo,
@@ -300,6 +301,7 @@ impl Network {
         res
     }
 
+    #[instrument(level="trace", err, skip(self, data), fields(data.len = data.len()))]
     pub async fn send_data_to_existing_connection(
         &self,
         descriptor: ConnectionDescriptor,
@@ -357,6 +359,7 @@ impl Network {
     }
 
     // Send data directly to a dial info, possibly without knowing which node it is going to
+    #[instrument(level="trace", err, skip(self, data), fields(data.len = data.len()))]
     pub async fn send_data_to_dial_info(
         &self,
         dial_info: DialInfo,
@@ -404,9 +407,8 @@ impl Network {
         self.inner.lock().protocol_config
     }
 
+    #[instrument(level = "debug", err, skip_all)]
     pub async fn startup(&self) -> Result<(), String> {
-        trace!("startup network");
-
         // initialize interfaces
         let mut interfaces = NetworkInterfaces::new();
         interfaces.refresh().await?;
@@ -492,10 +494,12 @@ impl Network {
         self.inner.lock().network_started
     }
 
+    #[instrument(level = "debug", skip_all)]
     pub fn restart_network(&self) {
         self.inner.lock().network_needs_restart = true;
     }
 
+    #[instrument(level = "debug", skip_all)]
     pub async fn shutdown(&self) {
         info!("stopping network");
 
@@ -524,6 +528,7 @@ impl Network {
         inner.network_class
     }
 
+    #[instrument(level = "debug", skip_all)]
     pub fn reset_network_class(&self) {
         let mut inner = self.inner.lock();
         inner.network_class = None;

veilid-core/src/network_manager/native/network_class_discovery.rs

@@ -51,30 +51,30 @@ impl DiscoveryContext {
     // Pick the best network class we have seen so far
     pub fn set_detected_network_class(&self, network_class: NetworkClass) {
         let mut inner = self.inner.lock();
-        log_net!( debug
+        debug!(target: "net",
-            "=== set_detected_network_class {:?} {:?}: {:?} ===",
+            protocol_type=?inner.protocol_type,
-            inner.protocol_type,
+            address_type=?inner.address_type,
-            inner.address_type,
+            ?network_class,
-            network_class
+            "set_detected_network_class"
         );
-
         inner.detected_network_class = Some(network_class);
     }
 
     pub fn set_detected_public_dial_info(&self, dial_info: DialInfo, class: DialInfoClass) {
         let mut inner = self.inner.lock();
-        log_net!( debug
+        debug!(target: "net",
-            "=== set_detected_public_dial_info {:?} {:?}: {} {:?} ===",
+            protocol_type=?inner.protocol_type,
-            inner.protocol_type,
+            address_type=?inner.address_type,
-            inner.address_type,
+            ?dial_info,
-            dial_info,
+            ?class,
-            class
+            "set_detected_public_dial_info"
         );
         inner.detected_public_dial_info = Some(DetectedPublicDialInfo { dial_info, class });
     }
 
     // Ask for a public address check from a particular noderef
     // This is done over the normal port using RPC
+    #[instrument(level = "trace", skip(self), ret)]
     async fn request_public_address(&self, node_ref: NodeRef) -> Option<SocketAddress> {
         let rpc = self.routing_table.rpc_processor();
         rpc.rpc_call_status(node_ref.clone())
@@ -93,6 +93,7 @@ impl DiscoveryContext {
 
     // find fast peers with a particular address type, and ask them to tell us what our external address is
     // This is done over the normal port using RPC
+    #[instrument(level = "trace", skip(self), ret)]
     async fn discover_external_address(
         &self,
         protocol_type: ProtocolType,
@@ -122,6 +123,7 @@ impl DiscoveryContext {
     }
 
     // This pulls the already-detected local interface dial info from the routing table
+    #[instrument(level = "trace", skip(self), ret)]
     fn get_local_addresses(
         &self,
         protocol_type: ProtocolType,
@@ -143,6 +145,7 @@ impl DiscoveryContext {
             .collect()
     }
 
+    #[instrument(level = "trace", skip(self), ret)]
     async fn validate_dial_info(
         &self,
         node_ref: NodeRef,
@@ -165,6 +168,7 @@ impl DiscoveryContext {
             .unwrap_or(false)
     }
 
+    #[instrument(level = "trace", skip(self), ret)]
     async fn try_port_mapping(&self) -> Option<DialInfo> {
         //xxx
         None
@@ -189,6 +193,7 @@ impl DiscoveryContext {
     ///////
     // Per-protocol discovery routines
 
+    #[instrument(level = "trace", skip(self))]
     pub fn protocol_begin(&self, protocol_type: ProtocolType, address_type: AddressType) {
         // Get our interface addresses
         let intf_addrs = self.get_local_addresses(protocol_type, address_type);
@@ -203,6 +208,7 @@ impl DiscoveryContext {
     }
 
     // Get our first node's view of our external IP address via normal RPC
+    #[instrument(level = "trace", skip(self), ret)]
     pub async fn protocol_get_external_address_1(&self) -> bool {
         let (protocol_type, address_type) = {
             let inner = self.inner.lock();
@@ -234,6 +240,7 @@ impl DiscoveryContext {
     }
 
     // If we know we are not behind NAT, check our firewall status
+    #[instrument(level = "trace", skip(self), err)]
     pub async fn protocol_process_no_nat(&self) -> Result<(), String> {
         let (node_1, external_1_dial_info) = {
             let inner = self.inner.lock();
@@ -264,6 +271,7 @@ impl DiscoveryContext {
     }
 
     // If we know we are behind NAT check what kind
+    #[instrument(level = "trace", skip(self), ret, err)]
     pub async fn protocol_process_nat(&self) -> Result<bool, String> {
         let (node_1, external_1_dial_info, external_1_address, protocol_type, address_type) = {
             let inner = self.inner.lock();
@@ -353,6 +361,7 @@ impl DiscoveryContext {
 }
 
 impl Network {
+    #[instrument(level = "trace", skip(self, context), err)]
     pub async fn update_ipv4_protocol_dialinfo(
         &self,
         context: &DiscoveryContext,
@@ -414,6 +423,7 @@ impl Network {
         Ok(())
     }
 
+    #[instrument(level = "trace", skip(self, context), err)]
     pub async fn update_ipv6_protocol_dialinfo(
         &self,
         context: &DiscoveryContext,
@@ -454,9 +464,8 @@ impl Network {
         Ok(())
     }
 
+    #[instrument(level = "trace", skip(self), err)]
     pub async fn update_network_class_task_routine(self, _l: u64, _t: u64) -> Result<(), String> {
-        log_net!("--- updating network class");
-
         // Ensure we aren't trying to update this without clearing it first
         let old_network_class = self.inner.lock().network_class;
         assert_eq!(old_network_class, None);

veilid-core/src/network_manager/wasm/mod.rs

@@ -51,6 +51,7 @@ impl Network {
 
     /////////////////////////////////////////////////////////////////
 
+    #[instrument(level="trace", err, skip(self, data), fields(data.len = data.len()))]
     pub async fn send_data_unbound_to_dial_info(
         &self,
         dial_info: DialInfo,
@@ -79,6 +80,7 @@ impl Network {
         res
     }
 
+    #[instrument(level="trace", err, skip(self, data), fields(data.len = data.len()))]
     pub async fn send_data_to_existing_connection(
         &self,
         descriptor: ConnectionDescriptor,
@@ -115,6 +117,7 @@ impl Network {
         }
     }
 
+    #[instrument(level="trace", err, skip(self, data), fields(data.len = data.len()))]
     pub async fn send_data_to_dial_info(
         &self,
         dial_info: DialInfo,

veilid-core/src/receipt_manager.rs

@@ -234,6 +234,7 @@ impl ReceiptManager {
         }
     }
 
+    #[instrument(level = "trace", skip(self))]
     pub async fn timeout_task_routine(self, now: u64) {
         // Go through all receipts and build a list of expired nonces
         let mut new_next_oldest_ts: Option<u64> = None;

veilid-core/src/routing_table/mod.rs

@@ -730,6 +730,7 @@ impl RoutingTable {
         best_inbound_relay.map(|(k, e)| NodeRef::new(self.clone(), *k, e, None))
     }
 
+    #[instrument(level = "trace", skip(self), ret, err)]
     pub fn register_find_node_answer(&self, fna: FindNodeAnswer) -> Result<Vec<NodeRef>, String> {
         let node_id = self.node_id();
 
@@ -755,6 +756,7 @@ impl RoutingTable {
         Ok(out)
     }
 
+    #[instrument(level = "trace", skip(self), ret, err)]
     pub async fn find_node(
         &self,
         node_ref: NodeRef,
@@ -773,26 +775,24 @@ impl RoutingTable {
             .await
             .map_err(map_to_string)
             .map_err(logthru_rtab!())?;
-        log_rtab!(
-            "find_self for at {:?} answered in {}ms",
-            &node_ref,
-            timestamp_to_secs(res.latency) * 1000.0f64
-        );
 
         // register nodes we'd found
         self.register_find_node_answer(res)
     }
 
+    #[instrument(level = "trace", skip(self), ret, err)]
     pub async fn find_self(&self, node_ref: NodeRef) -> Result<Vec<NodeRef>, String> {
         let node_id = self.node_id();
         self.find_node(node_ref, node_id).await
     }
 
+    #[instrument(level = "trace", skip(self), ret, err)]
     pub async fn find_target(&self, node_ref: NodeRef) -> Result<Vec<NodeRef>, String> {
         let node_id = node_ref.node_id();
         self.find_node(node_ref, node_id).await
     }
 
+    #[instrument(level = "trace", skip(self))]
     pub async fn reverse_find_node(&self, node_ref: NodeRef, wide: bool) {
         // Ask bootstrap node to 'find' our own node so we can get some more nodes near ourselves
         // and then contact those nodes to inform -them- that we exist
@@ -827,6 +827,7 @@ impl RoutingTable {
     }
 
     // Bootstrap lookup process
+    #[instrument(level = "trace", skip(self), ret, err)]
     async fn resolve_bootstrap(
         &self,
         bootstrap: Vec<String>,
@@ -990,6 +991,7 @@ impl RoutingTable {
         Ok(bsmap)
     }
 
+    #[instrument(level = "trace", skip(self), err)]
     async fn bootstrap_task_routine(self) -> Result<(), String> {
         let (bootstrap, bootstrap_nodes) = {
             let c = self.config.get();
@@ -1092,9 +1094,8 @@ impl RoutingTable {
 
     // Ask our remaining peers to give us more peers before we go
     // back to the bootstrap servers to keep us from bothering them too much
+    #[instrument(level = "trace", skip(self), err)]
     async fn peer_minimum_refresh_task_routine(self) -> Result<(), String> {
-        // log_rtab!("--- peer_minimum_refresh task");
-
         // get list of all peers we know about, even the unreliable ones, and ask them to find nodes close to our node too
         let noderefs = {
             let mut inner = self.inner.lock();
@@ -1125,6 +1126,7 @@ impl RoutingTable {
 
     // Ping each node in the routing table if they need to be pinged
     // to determine their reliability
+    #[instrument(level = "trace", skip(self), err)]
     async fn ping_validator_task_routine(self, _last_ts: u64, cur_ts: u64) -> Result<(), String> {
         // log_rtab!("--- ping_validator task");
 
@@ -1149,6 +1151,7 @@ impl RoutingTable {
     }
 
     // Compute transfer statistics to determine how 'fast' a node is
+    #[instrument(level = "trace", skip(self), err)]
     async fn rolling_transfers_task_routine(self, last_ts: u64, cur_ts: u64) -> Result<(), String> {
         // log_rtab!("--- rolling_transfers task");
         let inner = &mut *self.inner.lock();

veilid-core/src/veilid_api/mod.rs

@@ -1742,6 +1742,7 @@ pub struct VeilidAPI {
 }
 
 impl VeilidAPI {
+    #[instrument(skip_all)]
     pub(crate) fn new(context: VeilidCoreContext) -> Self {
         Self {
             inner: Arc::new(Mutex::new(VeilidAPIInner {
@@ -1750,6 +1751,7 @@ impl VeilidAPI {
         }
     }
 
+    #[instrument(skip_all)]
     pub async fn shutdown(self) {
         let context = { self.inner.lock().context.take() };
         if let Some(context) = context {
@@ -1840,6 +1842,7 @@ impl VeilidAPI {
     // get network connectedness
 
     // connect to the network
+    #[instrument(level = "debug", err, skip_all)]
     pub async fn attach(&self) -> Result<(), VeilidAPIError> {
         let attachment_manager = self.attachment_manager()?;
         attachment_manager
@@ -1849,6 +1852,7 @@ impl VeilidAPI {
     }
 
     // disconnect from the network
+    #[instrument(level = "debug", err, skip_all)]
     pub async fn detach(&self) -> Result<(), VeilidAPIError> {
         let attachment_manager = self.attachment_manager()?;
         attachment_manager
@@ -1858,6 +1862,7 @@ impl VeilidAPI {
     }
 
     // Change api logging level if it is enabled
+    #[instrument(skip(self))]
     pub async fn change_api_log_level(&self, log_level: VeilidConfigLogLevel) {
         ApiTracingLayer::change_api_log_level(log_level.to_veilid_log_level());
     }
@@ -1865,6 +1870,7 @@ impl VeilidAPI {
     ////////////////////////////////////////////////////////////////
     // Direct Node Access (pretty much for testing only)
 
+    #[instrument(level = "debug", err, skip(self))]
     pub async fn status(&self, node_id: NodeId) -> Result<StatusAnswer, VeilidAPIError> {
         let rpc = self.rpc_processor()?;
         let routing_table = rpc.routing_table();
@@ -1879,6 +1885,7 @@ impl VeilidAPI {
         Ok(status_answer)
     }
 
+    #[instrument(level = "debug", err, skip(self))]
     pub async fn validate_dial_info(
         &self,
         node_id: NodeId,
@@ -1896,6 +1903,7 @@ impl VeilidAPI {
             .map_err(map_rpc_error!())
     }
 
+    #[instrument(level = "debug", err, skip(self))]
     pub async fn search_dht(&self, node_id: NodeId) -> Result<PeerInfo, VeilidAPIError> {
         let rpc_processor = self.rpc_processor()?;
         let config = self.config()?;
@@ -1923,6 +1931,7 @@ impl VeilidAPI {
         }
     }
 
+    #[instrument(level = "debug", err, skip(self))]
     pub async fn search_dht_multi(&self, node_id: NodeId) -> Result<Vec<PeerInfo>, VeilidAPIError> {
         let rpc_processor = self.rpc_processor()?;
         let config = self.config()?;
@@ -1948,6 +1957,7 @@ impl VeilidAPI {
     ////////////////////////////////////////////////////////////////
     // Safety / Private Route Handling
 
+    #[instrument(level = "debug", err, skip(self))]
     pub async fn new_safety_route_spec(
         &self,
         _hops: u8,
@@ -1955,6 +1965,7 @@ impl VeilidAPI {
         panic!("unimplemented");
     }
 
+    #[instrument(level = "debug", err, skip(self))]
     pub async fn new_private_route_spec(
         &self,
         _hops: u8,
@@ -1968,6 +1979,7 @@ impl VeilidAPI {
     // Safety route specified here is for _this_ node's anonymity as a sender, used via the 'route' operation
     // Private route specified here is for _this_ node's anonymity as a receiver, passed out via the 'respond_to' field for replies
 
+    #[instrument(skip(self))]
     pub async fn safe_private(
         &self,
         safety_route_spec: SafetyRouteSpec,
@@ -1980,6 +1992,7 @@ impl VeilidAPI {
         .await
     }
 
+    #[instrument(level = "debug", skip(self))]
     pub async fn safe_public(&self, safety_route_spec: SafetyRouteSpec) -> RoutingContext {
         self.routing_context(RoutingContextOptions {
             safety_route_spec: Some(safety_route_spec),
@@ -1988,6 +2001,7 @@ impl VeilidAPI {
         .await
     }
 
+    #[instrument(level = "debug", skip(self))]
     pub async fn unsafe_private(&self, private_route_spec: PrivateRouteSpec) -> RoutingContext {
         self.routing_context(RoutingContextOptions {
             safety_route_spec: None,
@@ -1996,6 +2010,7 @@ impl VeilidAPI {
         .await
     }
 
+    #[instrument(level = "debug", skip(self))]
     pub async fn unsafe_public(&self) -> RoutingContext {
         self.routing_context(RoutingContextOptions {
             safety_route_spec: None,
@@ -2003,6 +2018,8 @@ impl VeilidAPI {
         })
         .await
     }
+
+    #[instrument(level = "debug", skip(self))]
     pub async fn routing_context(&self, options: RoutingContextOptions) -> RoutingContext {
         RoutingContext::new(self.clone(), options)
     }
@@ -2010,6 +2027,7 @@ impl VeilidAPI {
     ////////////////////////////////////////////////////////////////
     // Tunnel Building
 
+    #[instrument(level = "debug", err, skip(self))]
     pub async fn start_tunnel(
         &self,
         _endpoint_mode: TunnelMode,
@@ -2018,6 +2036,7 @@ impl VeilidAPI {
         panic!("unimplemented");
     }
 
+    #[instrument(level = "debug", err, skip(self))]
     pub async fn complete_tunnel(
         &self,
         _endpoint_mode: TunnelMode,
@@ -2027,6 +2046,7 @@ impl VeilidAPI {
         panic!("unimplemented");
     }
 
+    #[instrument(level = "debug", err, skip(self))]
     pub async fn cancel_tunnel(&self, _tunnel_id: TunnelId) -> Result<bool, VeilidAPIError> {
         panic!("unimplemented");
     }

veilid-core/src/veilid_api/serialize_helpers.rs

@@ -1,24 +1,40 @@
 use super::*;
+use core::fmt::Debug;
 
-pub fn deserialize_json<'a, T: de::Deserialize<'a>>(
+#[instrument(level = "trace", ret, err)]
+pub fn deserialize_json<'a, T: de::Deserialize<'a> + Debug>(
     arg: &'a str,
-) -> Result<T, super::VeilidAPIError> {
+) -> Result<T, VeilidAPIError> {
     serde_json::from_str(arg).map_err(|e| VeilidAPIError::ParseError {
         message: e.to_string(),
-        value: String::new(),
+        value: format!(
+            "deserialize_json:\n---\n{}\n---\n to type {}",
+            arg,
+            std::any::type_name::<T>()
+        ),
     })
 }
 
-pub fn deserialize_opt_json<T: de::DeserializeOwned>(
+#[instrument(level = "trace", ret, err)]
+pub fn deserialize_opt_json<T: de::DeserializeOwned + Debug>(
     arg: Option<String>,
 ) -> Result<T, VeilidAPIError> {
-    let arg = arg.ok_or_else(|| VeilidAPIError::ParseError {
+    let arg = arg.as_ref().ok_or_else(|| VeilidAPIError::ParseError {
         message: "invalid null string".to_owned(),
-        value: String::new(),
+        value: format!(
+            "deserialize_json_opt: null to type {}",
+            std::any::type_name::<T>()
+        ),
     })?;
-    deserialize_json(&arg)
+    deserialize_json(arg)
 }
 
-pub fn serialize_json<T: Serialize>(val: T) -> String {
+#[instrument(level = "trace", ret)]
-    serde_json::to_string(&val).expect("failed to serialize json value")
+pub fn serialize_json<T: Serialize + Debug>(val: T) -> String {
+    match serde_json::to_string(&val) {
+        Ok(v) => v,
+        Err(e) => {
+            panic!("failed to serialize json value: {}\nval={:?}", e, val);
+        }
+    }
 }

veilid-core/src/veilid_config.rs

@@ -237,6 +237,15 @@ pub struct VeilidConfig {
     inner: Arc<RwLock<VeilidConfigInner>>,
 }
 
+impl fmt::Debug for VeilidConfig {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let inner = self.inner.read();
+        f.debug_struct("VeilidConfig")
+            .field("inner", &*inner)
+            .finish()
+    }
+}
+
 impl Default for VeilidConfig {
     fn default() -> Self {
         Self::new()

veilid-flutter/example/lib/config.dart

@@ -7,7 +7,7 @@ Future<VeilidConfig> getDefaultVeilidConfig() async {
   return VeilidConfig(
     programName: "Veilid Plugin Test",
     namespace: "",
-    logLevel: VeilidConfigLogLevel.info,
+    apiLogLevel: VeilidConfigLogLevel.info,
     capabilities: VeilidConfigCapabilities(
       protocolUDP: !kIsWeb,
       protocolConnectTCP: !kIsWeb,

veilid-flutter/example/lib/main.dart

@@ -36,8 +36,28 @@ LogOptions getLogOptions(LogLevel? level) {
   );
 }
 
+VeilidConfigLogLevel convertToVeilidConfigLogLevel(LogLevel? level) {
+  if (level == null) {
+    return VeilidConfigLogLevel.off;
+  }
+  switch (level) {
+    case LogLevel.error:
+      return VeilidConfigLogLevel.error;
+    case LogLevel.warning:
+      return VeilidConfigLogLevel.warn;
+    case LogLevel.info:
+      return VeilidConfigLogLevel.info;
+    case LogLevel.debug:
+      return VeilidConfigLogLevel.debug;
+    case traceLevel:
+      return VeilidConfigLogLevel.trace;
+  }
+  return VeilidConfigLogLevel.off;
+}
+
 void setRootLogLevel(LogLevel? level) {
   Loggy('').level = getLogOptions(level);
+  Veilid.instance.changeApiLogLevel(convertToVeilidConfigLogLevel(level));
 }
 
 void initLoggy() {
@@ -138,7 +158,7 @@ class _MyAppState extends State<MyApp> with UiLoggy {
         if (update is VeilidUpdateLog) {
           await processUpdateLog(update);
         } else {
-          loggy.trace("Update: " + update.toString());
+          loggy.trace("Update: " + update.json.toString());
         }
       }
     }

veilid-flutter/example/linux/flutter/generated_plugins.cmake

@@ -6,6 +6,9 @@ list(APPEND FLUTTER_PLUGIN_LIST
   veilid
 )
 
+list(APPEND FLUTTER_FFI_PLUGIN_LIST
+)
+
 set(PLUGIN_BUNDLED_LIBRARIES)
 
 foreach(plugin ${FLUTTER_PLUGIN_LIST})
@@ -14,3 +17,8 @@ foreach(plugin ${FLUTTER_PLUGIN_LIST})
   list(APPEND PLUGIN_BUNDLED_LIBRARIES $<TARGET_FILE:${plugin}_plugin>)
   list(APPEND PLUGIN_BUNDLED_LIBRARIES ${${plugin}_bundled_libraries})
 endforeach(plugin)
+
+foreach(ffi_plugin ${FLUTTER_FFI_PLUGIN_LIST})
+  add_subdirectory(flutter/ephemeral/.plugin_symlinks/${ffi_plugin}/linux plugins/${ffi_plugin})
+  list(APPEND PLUGIN_BUNDLED_LIBRARIES ${${ffi_plugin}_bundled_libraries})
+endforeach(ffi_plugin)

veilid-flutter/example/macos/Podfile.lock

@@ -21,8 +21,8 @@ EXTERNAL SOURCES:
 SPEC CHECKSUMS:
   FlutterMacOS: 57701585bf7de1b3fc2bb61f6378d73bbdea8424
   path_provider_macos: 160cab0d5461f0c0e02995469a98f24bdb9a3f1f
-  veilid: f6b04d095ac7058ddf9c00215eb2699de8cc4673
+  veilid: 6bed3adec63fd8708a2ace498e0e17941c9fc32b
 
 PODFILE CHECKSUM: 6eac6b3292e5142cfc23bdeb71848a40ec51c14c
 
-COCOAPODS: 1.11.2
+COCOAPODS: 1.11.3

veilid-flutter/example/pubspec.lock

@@ -49,7 +49,7 @@ packages:
       name: collection
       url: "https://pub.dartlang.org"
     source: hosted
-    version: "1.15.0"
+    version: "1.16.0"
   cupertino_icons:
     dependency: "direct main"
     description:
@@ -63,7 +63,7 @@ packages:
       name: fake_async
       url: "https://pub.dartlang.org"
     source: hosted
-    version: "1.2.0"
+    version: "1.3.0"
   ffi:
     dependency: transitive
     description:
@@ -113,7 +113,7 @@ packages:
       name: js
       url: "https://pub.dartlang.org"
     source: hosted
-    version: "0.6.3"
+    version: "0.6.4"
   lints:
     dependency: transitive
     description:
@@ -141,7 +141,7 @@ packages:
       name: material_color_utilities
       url: "https://pub.dartlang.org"
     source: hosted
-    version: "0.1.3"
+    version: "0.1.4"
   meta:
     dependency: transitive
     description:
@@ -155,7 +155,7 @@ packages:
       name: path
       url: "https://pub.dartlang.org"
     source: hosted
-    version: "1.8.0"
+    version: "1.8.1"
   path_provider:
     dependency: transitive
     description:
@@ -244,7 +244,7 @@ packages:
       name: source_span
       url: "https://pub.dartlang.org"
     source: hosted
-    version: "1.8.1"
+    version: "1.8.2"
   stack_trace:
     dependency: transitive
     description:
@@ -279,21 +279,14 @@ packages:
       name: test_api
       url: "https://pub.dartlang.org"
     source: hosted
-    version: "0.4.8"
+    version: "0.4.9"
-  typed_data:
-    dependency: transitive
-    description:
-      name: typed_data
-      url: "https://pub.dartlang.org"
-    source: hosted
-    version: "1.3.0"
   vector_math:
     dependency: transitive
     description:
       name: vector_math
       url: "https://pub.dartlang.org"
     source: hosted
-    version: "2.1.1"
+    version: "2.1.2"
   veilid:
     dependency: "direct main"
     description:
@@ -316,5 +309,5 @@ packages:
     source: hosted
     version: "0.2.0+1"
 sdks:
-  dart: ">=2.16.1 <3.0.0"
+  dart: ">=2.17.0-0 <3.0.0"
   flutter: ">=2.8.0"

veilid-flutter/example/windows/flutter/generated_plugins.cmake

@@ -6,6 +6,9 @@ list(APPEND FLUTTER_PLUGIN_LIST
   veilid
 )
 
+list(APPEND FLUTTER_FFI_PLUGIN_LIST
+)
+
 set(PLUGIN_BUNDLED_LIBRARIES)
 
 foreach(plugin ${FLUTTER_PLUGIN_LIST})
@@ -14,3 +17,8 @@ foreach(plugin ${FLUTTER_PLUGIN_LIST})
   list(APPEND PLUGIN_BUNDLED_LIBRARIES $<TARGET_FILE:${plugin}_plugin>)
   list(APPEND PLUGIN_BUNDLED_LIBRARIES ${${plugin}_bundled_libraries})
 endforeach(plugin)
+
+foreach(ffi_plugin ${FLUTTER_FFI_PLUGIN_LIST})
+  add_subdirectory(flutter/ephemeral/.plugin_symlinks/${ffi_plugin}/windows plugins/${ffi_plugin})
+  list(APPEND PLUGIN_BUNDLED_LIBRARIES ${${ffi_plugin}_bundled_libraries})
+endforeach(ffi_plugin)

veilid-flutter/ios/veilid.podspec

@@ -33,8 +33,8 @@ Veilid Network Plugin
   s.script_phase = { 
     :name => 'Cargo Build', 
     :script => File.join(File.dirname(__dir__), 'rust', 'ios_build.sh'), 
-    :execution_position => :before_compile,
+    :execution_position => :before_compile
-    :output_files => [ File.join(cargo_target_dir, 'ios_lib', 'libveilid_flutter.a') ]
+    # :output_files => [ File.join(cargo_target_dir, 'ios_lib', 'libveilid_flutter.a') ]
   }
 
 end

veilid-flutter/lib/veilid.dart

@@ -815,6 +815,7 @@ abstract class VeilidUpdate {
         }
     }
   }
+  Map<String, dynamic> get json;
 }
 
 class VeilidUpdateLog implements VeilidUpdate {
@@ -822,12 +823,29 @@ class VeilidUpdateLog implements VeilidUpdate {
   final String message;
   //
   VeilidUpdateLog(this.logLevel, this.message);
+
+  @override
+  Map<String, dynamic> get json {
+    return {
+      'kind': "Log",
+      'log_level': logLevel.json,
+      'message': message,
+    };
+  }
 }
 
 class VeilidUpdateAttachment implements VeilidUpdate {
   final AttachmentState state;
   //
   VeilidUpdateAttachment(this.state);
+
+  @override
+  Map<String, dynamic> get json {
+    return {
+      'kind': "Attachment",
+      'state': state.json,
+    };
+  }
 }
 
 class VeilidUpdateNetwork implements VeilidUpdate {
@@ -836,6 +854,16 @@ class VeilidUpdateNetwork implements VeilidUpdate {
   final int bpsUp;
   //
   VeilidUpdateNetwork(this.started, this.bpsDown, this.bpsUp);
+
+  @override
+  Map<String, dynamic> get json {
+    return {
+      'kind': "Network",
+      'started': started,
+      'bps_down': bpsDown,
+      'bps_up': bpsUp
+    };
+  }
 }
 
 //////////////////////////////////////

veilid-flutter/lib/veilid_ffi.dart

@@ -300,7 +300,9 @@ class VeilidFFI implements Veilid {
 
   @override
   Future<void> changeApiLogLevel(VeilidConfigLogLevel logLevel) async {
-    var nativeLogLevel = logLevel.json.toNativeUtf8();
+    var nativeLogLevel =
+        jsonEncode(logLevel.json, toEncodable: veilidApiToEncodable)
+            .toNativeUtf8();
     final recvPort = ReceivePort("change_api_log_level");
     final sendPort = recvPort.sendPort;
     _changeApiLogLevel(sendPort.nativePort, nativeLogLevel);

veilid-flutter/macos/veilid.podspec

@@ -27,8 +27,8 @@ Veilid Network Plugin
   s.script_phase = { 
     :name => 'Cargo Build', 
     :script => File.join(File.dirname(__dir__), 'rust', 'macos_build.sh'), 
-    :execution_position => :before_compile,
+    :execution_position => :before_compile
-    :output_files => [ File.join(cargo_target_dir, 'macos_lib', 'libveilid_flutter.dylib') ]
+    #:output_files => [ File.join(cargo_target_dir, 'macos_lib', 'libveilid_flutter.dylib') ]
   }
 
 end

veilid-flutter/rust/ios_build.sh

@@ -1,11 +1,13 @@
 #!/bin/bash
+set -e
+echo Running veilid-flutter rust iOS build script
 
 # Setup varaiables
 SCRIPTDIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
 FLUTTER_DIR=$(dirname `which flutter`)
 HOMEBREW_DIR=$(dirname `which brew`)
 CARGO_DIR=$(dirname `which cargo`)
-CARGO_MANIFEST_PATH=$(python -c "import os; print(os.path.realpath(\"$SCRIPTDIR/Cargo.toml\"))")
+CARGO_MANIFEST_PATH=$(python3 -c "import os; print(os.path.realpath(\"$SCRIPTDIR/Cargo.toml\"))")
 TARGET_DIR=$(dirname `cargo locate-project --message-format plain`)/target
 
 # Configure outputs
@@ -30,7 +32,8 @@ do
     if [ "$arch" == "arm64" ]; then
         echo arm64
         CARGO_TARGET=aarch64-apple-ios
-        CARGO_TOOLCHAIN=+ios-arm64-1.57.0
+        #CARGO_TOOLCHAIN=+ios-arm64-1.57.0
+        CARGO_TOOLCHAIN=
     elif [ "$arch" == "x86_64" ]; then
         echo x86_64
         CARGO_TARGET=x86_64-apple-ios

veilid-flutter/rust/macos_build.sh

@@ -1,11 +1,13 @@
 #!/bin/bash
+set -e
+echo Running veilid-flutter rust MacOS build script
 
 # Setup varaiables
 SCRIPTDIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
 FLUTTER_DIR=$(dirname `which flutter`)
 HOMEBREW_DIR=$(dirname `which brew`)
 CARGO_DIR=$(dirname `which cargo`)
-CARGO_MANIFEST_PATH=$(python -c "import os; print(os.path.realpath(\"$SCRIPTDIR/Cargo.toml\"))")
+CARGO_MANIFEST_PATH=$(python3 -c "import os; print(os.path.realpath(\"$SCRIPTDIR/Cargo.toml\"))")
 TARGET_DIR=$(dirname `cargo locate-project --message-format plain`)/target
 
 # Configure outputs

veilid-flutter/rust/src/dart_ffi.rs

@@ -54,6 +54,7 @@ macro_rules! check_err_json {
 /////////////////////////////////////////
 // Initializer
 #[no_mangle]
+#[instrument]
 pub extern "C" fn initialize_veilid_flutter(dart_post_c_object_ptr: ffi::DartPostCObjectFnType) {
     unsafe {
         store_dart_post_cobject(dart_post_c_object_ptr);
@@ -91,6 +92,7 @@ pub extern "C" fn initialize_veilid_flutter(dart_post_c_object_ptr: ffi::DartPos
 /// C-compatible FFI Functions
 
 #[no_mangle]
+#[instrument]
 pub extern "C" fn startup_veilid_core(port: i64, config: FfiStr) {
     let config = config.into_opt_string();
     let stream = DartIsolateStream::new(port);
@@ -141,6 +143,7 @@ pub extern "C" fn get_veilid_state(port: i64) {
 }
 
 #[no_mangle]
+#[instrument(level = "debug")]
 pub extern "C" fn change_api_log_level(port: i64, log_level: FfiStr) {
     let log_level = log_level.into_opt_string();
     DartIsolateWrapper::new(port).spawn_result_json(async move {
@@ -153,6 +156,7 @@ pub extern "C" fn change_api_log_level(port: i64, log_level: FfiStr) {
 }
 
 #[no_mangle]
+#[instrument]
 pub extern "C" fn shutdown_veilid_core(port: i64) {
     DartIsolateWrapper::new(port).spawn_result_json(async move {
         let veilid_api = take_veilid_api().await?;
@@ -184,6 +188,7 @@ pub struct VeilidVersion {
 }
 
 #[no_mangle]
+#[instrument]
 pub extern "C" fn veilid_version() -> VeilidVersion {
     let (major, minor, patch) = veilid_core::veilid_version();
     VeilidVersion {

veilid-flutter/rust/src/dart_isolate_wrapper.rs

@@ -1,6 +1,7 @@
 pub use allo_isolate::ffi::DartCObject;
 pub use allo_isolate::IntoDart;
 use allo_isolate::Isolate;
+use core::fmt::Debug;
 use core::future::Future;
 use parking_lot::Mutex;
 use serde::*;
@@ -31,8 +32,8 @@ impl DartIsolateWrapper {
     pub fn spawn_result<F, T, E>(self, future: F)
     where
         F: Future<Output = Result<T, E>> + Send + 'static,
-        T: IntoDart,
+        T: IntoDart + Debug,
-        E: Serialize,
+        E: Serialize + Debug,
     {
         async_std::task::spawn(async move {
             self.result(future.await);
@@ -42,21 +43,24 @@ impl DartIsolateWrapper {
     pub fn spawn_result_json<F, T, E>(self, future: F)
     where
         F: Future<Output = Result<T, E>> + Send + 'static,
-        T: Serialize,
+        T: Serialize + Debug,
-        E: Serialize,
+        E: Serialize + Debug,
     {
         async_std::task::spawn(async move {
             self.result_json(future.await);
         });
     }
 
-    pub fn result<T: IntoDart, E: Serialize>(self, result: Result<T, E>) -> bool {
+    pub fn result<T: IntoDart + Debug, E: Serialize + Debug>(self, result: Result<T, E>) -> bool {
         match result {
             Ok(v) => self.ok(v),
             Err(e) => self.err_json(e),
         }
     }
-    pub fn result_json<T: Serialize, E: Serialize>(self, result: Result<T, E>) -> bool {
+    pub fn result_json<T: Serialize + Debug, E: Serialize + Debug>(
+        self,
+        result: Result<T, E>,
+    ) -> bool {
         match result {
             Ok(v) => self.ok_json(v),
             Err(e) => self.err_json(e),
@@ -67,19 +71,19 @@ impl DartIsolateWrapper {
             .post(vec![MESSAGE_OK.into_dart(), value.into_dart()])
     }
 
-    pub fn ok_json<T: Serialize>(self, value: T) -> bool {
+    pub fn ok_json<T: Serialize + Debug>(self, value: T) -> bool {
         self.isolate.post(vec![
             MESSAGE_OK_JSON.into_dart(),
             veilid_core::serialize_json(value).into_dart(),
         ])
     }
 
-    // pub fn err<E: IntoDart>(self, error: E) -> bool {
+    // pub fn err<E: IntoDart + Debug>(self, error: E) -> bool {
     //     self.isolate
     //         .post(vec![MESSAGE_ERR.into_dart(), error.into_dart()])
     // }
 
-    pub fn err_json<E: Serialize>(self, error: E) -> bool {
+    pub fn err_json<E: Serialize + Debug>(self, error: E) -> bool {
         self.isolate.post(vec![
             MESSAGE_ERR_JSON.into_dart(),
             veilid_core::serialize_json(error).into_dart(),
@@ -122,7 +126,7 @@ impl DartIsolateStream {
     //     }
     // }
 
-    pub fn item_json<T: Serialize>(&self, value: T) -> bool {
+    pub fn item_json<T: Serialize + Debug>(&self, value: T) -> bool {
         let inner = self.inner.lock();
         if let Some(isolate) = &inner.isolate {
             isolate.post(vec![
@@ -134,7 +138,7 @@ impl DartIsolateStream {
         }
     }
 
-    // pub fn abort<E: IntoDart>(self, error: E) -> bool {
+    // pub fn abort<E: IntoDart + Debug>(self, error: E) -> bool {
     //     let mut inner = self.inner.lock();
     //     if let Some(isolate) = inner.isolate.take() {
     //         isolate.post(vec![MESSAGE_STREAM_ABORT.into_dart(), error.into_dart()])
@@ -143,7 +147,7 @@ impl DartIsolateStream {
     //     }
     // }
 
-    pub fn abort_json<E: Serialize>(self, error: E) -> bool {
+    pub fn abort_json<E: Serialize + Debug>(self, error: E) -> bool {
         let mut inner = self.inner.lock();
         if let Some(isolate) = inner.isolate.take() {
             isolate.post(vec![

veilid-server/src/client_api.rs

@@ -73,6 +73,7 @@ struct VeilidServerImpl {
 }
 
 impl VeilidServerImpl {
+    #[instrument(level = "trace", skip_all)]
     pub fn new(veilid_api: veilid_core::VeilidAPI) -> Self {
         Self {
             next_id: 0,
@@ -83,6 +84,7 @@ impl VeilidServerImpl {
 }
 
 impl veilid_server::Server for VeilidServerImpl {
+    #[instrument(level = "trace", skip_all)]
     fn register(
         &mut self,
         params: veilid_server::RegisterParams,
@@ -126,6 +128,7 @@ impl veilid_server::Server for VeilidServerImpl {
         })
     }
 
+    #[instrument(level = "trace", skip_all)]
     fn debug(
         &mut self,
         params: veilid_server::DebugParams,
@@ -145,6 +148,7 @@ impl veilid_server::Server for VeilidServerImpl {
         })
     }
 
+    #[instrument(level = "trace", skip_all)]
     fn attach(
         &mut self,
         _params: veilid_server::AttachParams,
@@ -160,6 +164,7 @@ impl veilid_server::Server for VeilidServerImpl {
         })
     }
 
+    #[instrument(level = "trace", skip_all)]
     fn detach(
         &mut self,
         _params: veilid_server::DetachParams,
@@ -175,6 +180,7 @@ impl veilid_server::Server for VeilidServerImpl {
         })
     }
 
+    #[instrument(level = "trace", skip_all)]
     fn shutdown(
         &mut self,
         _params: veilid_server::ShutdownParams,
@@ -194,6 +200,7 @@ impl veilid_server::Server for VeilidServerImpl {
         Promise::ok(())
     }
 
+    #[instrument(level = "trace", skip_all)]
     fn get_state(
         &mut self,
         _params: veilid_server::GetStateParams,
@@ -239,6 +246,7 @@ pub struct ClientApi {
 }
 
 impl ClientApi {
+    #[instrument(level = "trace", skip_all)]
     pub fn new(veilid_api: veilid_core::VeilidAPI) -> Rc<Self> {
         Rc::new(Self {
             inner: RefCell::new(ClientApiInner {
@@ -250,6 +258,7 @@ impl ClientApi {
         })
     }
 
+    #[instrument(level = "trace", skip(self))]
     pub async fn stop(self: Rc<Self>) {
         trace!("ClientApi::stop requested");
         let jh = {
@@ -268,6 +277,7 @@ impl ClientApi {
         trace!("ClientApi::stop: stopped");
     }
 
+    #[instrument(level = "trace", skip(self, client), err)]
     async fn handle_incoming(
         self: Rc<Self>,
         bind_addr: SocketAddr,
@@ -301,6 +311,7 @@ impl ClientApi {
         incoming_loop.await
     }
 
+    #[instrument(level = "trace", skip_all)]
     fn send_request_to_all_clients<F, T>(self: Rc<Self>, request: F)
     where
         F: Fn(u64, &mut RegistrationHandle) -> Option<::capnp::capability::RemotePromise<T>>,
@@ -338,6 +349,7 @@ impl ClientApi {
         }
     }
 
+    #[instrument(level = "trace", skip(self))]
     pub fn handle_update(self: Rc<Self>, veilid_update: veilid_core::VeilidUpdate) {
         // serialize update
         let veilid_update = serialize_json(veilid_update);
@@ -360,6 +372,7 @@ impl ClientApi {
         });
     }
 
+    #[instrument(level = "trace", skip(self))]
     pub fn run(self: Rc<Self>, bind_addrs: Vec<SocketAddr>) {
         // Create client api VeilidServer
         let veilid_server_impl = VeilidServerImpl::new(self.inner.borrow().veilid_api.clone());

veilid-server/src/main.rs

@@ -15,6 +15,7 @@ mod windows;
 use async_std::task;
 use cfg_if::*;
 use server::*;
+use tracing::*;
 use veilid_logs::*;
 
 #[allow(clippy::all)]
@@ -22,6 +23,7 @@ pub mod veilid_client_capnp {
     include!(concat!(env!("OUT_DIR"), "/proto/veilid_client_capnp.rs"));
 }
 
+#[instrument(err)]
 fn main() -> Result<(), String> {
     #[cfg(windows)]
     let _ = ansi_term::enable_ansi_support();

veilid-server/src/server.rs

@@ -8,7 +8,7 @@ use std::time::{Duration, Instant};
 use tracing::*;
 use veilid_core::xx::SingleShotEventual;
 
-#[derive(Copy, Clone, PartialEq, Eq)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub enum ServerMode {
     Normal,
     ShutdownImmediate,
@@ -20,6 +20,7 @@ lazy_static! {
         Mutex::new(Some(SingleShotEventual::new(Some(()))));
 }
 
+#[instrument]
 pub fn shutdown() {
     let shutdown_switch = SHUTDOWN_SWITCH.lock().take();
     if let Some(shutdown_switch) = shutdown_switch {
@@ -28,13 +29,10 @@ pub fn shutdown() {
 }
 
 pub async fn run_veilid_server(settings: Settings, server_mode: ServerMode) -> Result<(), String> {
-    run_veilid_server_internal(settings, server_mode)
+    run_veilid_server_internal(settings, server_mode).await
-        .await
-        .map_err(|e| {
-            error!("{}", e);
-            e
-        })
 }
+
+#[instrument(err)]
 pub async fn run_veilid_server_internal(
     settings: Settings,
     server_mode: ServerMode,

veilid-server/src/unix.rs

@@ -7,7 +7,9 @@ use clap::ArgMatches;
 use signal_hook::consts::signal::*;
 use signal_hook_async_std::Signals;
 use std::io::Read;
+use tracing::*;
 
+#[instrument(skip(signals))]
 async fn handle_signals(mut signals: Signals) {
     while let Some(signal) = signals.next().await {
         match signal {
@@ -23,6 +25,7 @@ async fn handle_signals(mut signals: Signals) {
     }
 }
 
+#[instrument(err)]
 pub fn run_daemon(settings: Settings, _matches: ArgMatches) -> Result<(), String> {
     let daemon = {
         let mut daemon = daemonize::Daemonize::new();