- adding usage to specialist execution

- Correcting implementation of usage
- Removed some obsolete debug statements

common/utils/cache/base.py

@@ -120,9 +120,6 @@ class CacheHandler(Generic[T]):
 
         region_name = getattr(self.region, 'name', 'default_region')
 
-        current_app.logger.debug(f"Generating cache key in region {region_name} with prefix {self.prefix} "
-                                 f"for {self._key_components}")
-
         key = CacheKey({k: identifiers[k] for k in self._key_components})
         return f"{region_name}_{self.prefix}:{str(key)}"
 
@@ -138,13 +135,10 @@ class CacheHandler(Generic[T]):
             Cached or newly created value
         """
         cache_key = self.generate_key(**identifiers)
-        current_app.logger.debug(f"Getting Cache key: {cache_key}")
 
         def creator():
             instance = creator_func(**identifiers)
-            current_app.logger.debug("Caching object created and received. Now serializing...")
             serialized_instance = self._to_cache_data(instance)
-            current_app.logger.debug(f"Caching object serialized and received:\n{serialized_instance}")
             return serialized_instance
 
         cached_data = self.region.get_or_create(

common/utils/cache/config_cache.py

@@ -69,10 +69,8 @@ class BaseConfigCacheHandler(CacheHandler[Dict[str, Any]]):
         Returns:
             Configuration data
         """
-        current_app.logger.debug(f"Loading specific configuration for {type_name}, version: {version_str} - no cache")
         version_tree = self.version_tree_cache.get_versions(type_name)
         versions = version_tree['versions']
-        current_app.logger.debug(f"Loaded specific versions for {type_name}, versions: {versions}")
 
         if version_str == 'latest':
             version_str = version_tree['latest_version']
@@ -81,12 +79,10 @@ class BaseConfigCacheHandler(CacheHandler[Dict[str, Any]]):
             raise ValueError(f"Version {version_str} not found for {type_name}")
 
         file_path = versions[version_str]['file_path']
-        current_app.logger.debug(f'Trying to load configuration from {file_path}')
 
         try:
             with open(file_path) as f:
                 config = yaml.safe_load(f)
-                current_app.logger.debug(f"Loaded config for {type_name}{version_str}: {config}")
                 return config
         except Exception as e:
             raise ValueError(f"Error loading config from {file_path}: {e}")
@@ -103,8 +99,6 @@ class BaseConfigCacheHandler(CacheHandler[Dict[str, Any]]):
         Returns:
             Configuration data
         """
-        current_app.logger.debug(f"Trying to retrieve config for {self.config_type}, type name: {type_name}, "
-                                 f"version: {version}")
         if version is None:
             version_str = self.version_tree_cache.get_latest_version(type_name)
         elif is_major_minor(version):
@@ -145,7 +139,6 @@ class BaseConfigVersionTreeCacheHandler(CacheHandler[Dict[str, Any]]):
         Returns:
             Dict containing available versions and their metadata
         """
-        current_app.logger.debug(f"Loading version tree for {type_name} - no cache")
         type_path = Path(self._config_dir) / type_name
         if not type_path.exists():
             raise ValueError(f"No configuration found for type {type_name}")
@@ -180,8 +173,6 @@ class BaseConfigVersionTreeCacheHandler(CacheHandler[Dict[str, Any]]):
                 current_app.logger.error(f"Error loading version {ver}: {e}")
                 continue
 
-        current_app.logger.debug(f"Loaded versions for {type_name}: {versions}")
-        current_app.logger.debug(f"Latest version for {type_name}: {latest_version}")
         return {
             'versions': versions,
             'latest_version': latest_version
@@ -221,7 +212,6 @@ class BaseConfigVersionTreeCacheHandler(CacheHandler[Dict[str, Any]]):
         Returns:
             Dict with version information
         """
-        current_app.logger.debug(f"Trying to get version tree for {self.config_type}, {type_name}")
         return self.get(
             lambda type_name: self._load_version_tree(type_name),
             type_name=type_name
@@ -319,7 +309,6 @@ class BaseConfigTypesCacheHandler(CacheHandler[Dict[str, Any]]):
 
     def _load_type_definitions(self) -> Dict[str, Dict[str, str]]:
         """Load type definitions from the corresponding type_defs module"""
-        current_app.logger.debug(f"Loading type definitions for {self.config_type} - no cache")
         if not self._types_module:
             raise ValueError("_types_module must be set by subclass")
 
@@ -331,13 +320,10 @@ class BaseConfigTypesCacheHandler(CacheHandler[Dict[str, Any]]):
             for type_id, info in self._types_module.items()
         }
 
-        current_app.logger.debug(f"Loaded type definitions: {type_definitions}")
-
         return type_definitions
 
     def get_types(self) -> Dict[str, Dict[str, str]]:
         """Get dictionary of available types with name and description"""
-        current_app.logger.debug(f"Trying to retrieve type definitions for {self.config_type}")
         result = self.get(
             lambda type_name: self._load_type_definitions(),
             type_name=f'{self.config_type}_types',

common/utils/cache/crewai_config_processor.py

@@ -211,8 +211,6 @@ class BaseCrewAIConfigProcessor:
                 tasks=self._process_task_configs(specialist_config),
                 tools=self._process_tool_configs(specialist_config)
             )
-            current_app.logger.debug(f"Processed config for tenant {self.tenant_id}, specialist {self.specialist_id}:\n"
-                                     f"{processed_config}")
             return processed_config
 
         except Exception as e: