Updated tracing logging

src/private/sources/cache/policy.rs

@@ -74,9 +74,7 @@ impl Cache for GetPolicyOutputCache {
                 policy_updates.insert(policy_id.clone(), CacheChange::Updated);
             }
         }
-
         debug!("Policy Cache Pending Updates: policy_updates={policy_updates:?}");
-
         policy_updates
     }
 }

src/private/sources/policy/loader.rs

@@ -50,11 +50,14 @@ impl Load for ListPolicies {
                 for policy in policies {
                     if let Some(policy_id) = policy.policy_id.as_ref() {
                         policy_ids_map.insert(PolicyId(policy_id.to_string()), policy.clone());
-                        debug!("Loaded Policy from Policy Store: policy_id={policy_id:?}");
                     }
                 }
             }
         }
+        debug!(
+            "Loaded all Policies from Policy Store: policy_ids={:?}",
+            policy_ids_map.keys().collect::<Vec<_>>()
+        );
         Ok(policy_ids_map)
     }
 }

src/private/sources/template/loader.rs

@@ -57,14 +57,14 @@ impl Load for ListPolicyTemplates {
                             TemplateId(template_id.to_string()),
                             policy_template_item.clone(),
                         );
-                        debug!(
-                            "Loaded Template from Policy Store: policy_template_id={template_id:?}"
-                        );
                     }
                 }
             }
         }
-
+        debug!(
+            "Loaded all Templates from Policy Store: policy_template_ids={:?}",
+            policy_template_ids_map.keys().collect::<Vec<_>>()
+        );
         Ok(policy_template_ids_map)
     }
 }

src/private/translator/avp_to_cedar.rs

@@ -132,7 +132,6 @@ fn update_entity_map(
         let entity_name = EntityTypeName::from_str(identifier_type.as_str())?;
         let entity_id = EntityId::from_str(identifier_id.as_str())?;
         let entity = EntityUid::from_type_name_and_id(entity_name, entity_id);
-        debug!("Set Principal and Resource to the Entity Map: entity_name={identifier_type:?}: entity_id={identifier_id:?}");
         entity_map.insert(slot_id, entity);
     }
     Ok(())

src/public/entity_provider.rs

@@ -11,7 +11,7 @@ use thiserror::Error;
 use tokio::runtime::Handle;
 use tokio::sync::{Mutex, RwLock};
 use tokio::task;
-use tracing::error;
+use tracing::{debug, error, info, instrument};
 
 use cedar_local_agent::public::{
     EntityProviderError, SimpleEntityProvider, UpdateProviderData, UpdateProviderDataError,
@@ -90,6 +90,7 @@ impl EntityProvider {
     ///
     /// Can error if the builder is incorrect or if the `new` constructor fails to gather the
     /// applicable data on initialization.
+    #[instrument(skip(verified_permissions_client), err(Debug))]
     pub fn from_client(
         policy_store_id: String,
         verified_permissions_client: Client,
@@ -104,6 +105,7 @@ impl EntityProvider {
         )
     }
 
+    #[instrument(skip(config), err(Debug))]
     fn new(config: Config) -> Result<Self, ProviderError> {
         let Config {
             policy_store_id,
@@ -135,6 +137,9 @@ impl EntityProvider {
                         entities: RwLock::new(Arc::new(schema.action_entities()?)),
                     })
                 } else {
+                    debug!(
+                        "No Schema defined at Policy Store: policy_store_id={policy_store_id:?}"
+                    );
                     Ok(Self {
                         policy_store_id,
                         schema_source,
@@ -162,13 +167,15 @@ impl EntityProvider {
 
 #[async_trait]
 impl SimpleEntityProvider for EntityProvider {
+    #[instrument(skip_all, err(Debug))]
     async fn get_entities(&self, _: &Request) -> Result<Arc<Entities>, EntityProviderError> {
         Ok(self.entities.read().await.clone())
     }
 }
 
 #[async_trait]
 impl UpdateProviderData for EntityProvider {
+    #[instrument(skip(self), err(Debug))]
     async fn update_provider_data(&self) -> Result<(), UpdateProviderDataError> {
         let fetch_schema_result = self
             .schema_source
@@ -187,6 +194,10 @@ impl UpdateProviderData for EntityProvider {
                         .action_entities()
                         .map_err(|e| UpdateProviderDataError::General(Box::new(e)))?
                 } else {
+                    debug!(
+                        "No Schema defined at Policy Store: policy_store_id={:?}",
+                        self.policy_store_id.clone()
+                    );
                     Entities::empty()
                 }
             }
@@ -206,7 +217,7 @@ impl UpdateProviderData for EntityProvider {
             let mut entities_data = self.entities.write().await;
             *entities_data = Arc::new(entities);
         }
-
+        info!("Updated Entity Provider");
         Ok(())
     }
 }

src/public/policy_set_provider.rs

@@ -11,7 +11,7 @@ use thiserror::Error;
 use tokio::runtime::Handle;
 use tokio::sync::{Mutex, RwLock};
 use tokio::task;
-use tracing::error;
+use tracing::{error, info, instrument};
 
 use cedar_local_agent::public::{
     PolicySetProviderError, SimplePolicySetProvider, UpdateProviderData, UpdateProviderDataError,
@@ -106,6 +106,7 @@ impl PolicySetProvider {
     ///
     /// Can error if the builder is incorrect or if the `new` constructor fails to gather the
     /// applicable data on initialization.
+    #[instrument(skip(verified_permissions_client), err(Debug))]
     pub fn from_client(
         policy_store_id: String,
         verified_permissions_client: Client,
@@ -123,6 +124,7 @@ impl PolicySetProvider {
         )
     }
 
+    #[instrument(skip(config), err(Debug))]
     fn new(config: Config) -> Result<Self, ProviderError> {
         let Config {
             policy_store_id,
@@ -186,13 +188,15 @@ impl PolicySetProvider {
 
 #[async_trait]
 impl SimplePolicySetProvider for PolicySetProvider {
+    #[instrument(skip_all, err(Debug))]
     async fn get_policy_set(&self, _: &Request) -> Result<Arc<PolicySet>, PolicySetProviderError> {
         Ok(self.policy_set.read().await.clone())
     }
 }
 
 #[async_trait]
 impl UpdateProviderData for PolicySetProvider {
+    #[instrument(skip(self), err(Debug))]
     async fn update_provider_data(&self) -> Result<(), UpdateProviderDataError> {
         let templates;
         {
@@ -246,7 +250,7 @@ impl UpdateProviderData for PolicySetProvider {
             let mut policy_set = self.policy_set.write().await;
             *policy_set = Arc::new(policy_set_data);
         }
-
+        info!("Updated Policy Set Provider");
         Ok(())
     }
 }