Simplified plugin log messages

autogpt/plugins/__init__.py

@@ -221,7 +221,7 @@
     """
     loaded_plugins = []
     # Generic plugins
-    plugins_path_path = Path(config.plugins_dir)
+    plugins_path = Path(config.plugins_dir)
 
     plugins_config = config.plugins_config
     # Directory-based plugins
@@ -238,7 +238,9 @@
         plugin = sys.modules[qualified_module_name]
 
         if not plugins_config.is_enabled(plugin_module_name):
-            logger.warn(f"Plugin {plugin_module_name} found but not configured")
+            logger.warn(
+                f"Plugin folder {plugin_module_name} found but not configured. If this is a legitimate plugin, please add it to plugins_config.yaml (key: {plugin_module_name})."
+            )
             continue
 
         for _, class_obj in inspect.getmembers(plugin):
@@ -249,23 +251,25 @@
                 loaded_plugins.append(class_obj())
 
     # Zip-based plugins
-    for plugin in plugins_path_path.glob("*.zip"):
+    for plugin in plugins_path.glob("*.zip"):
         if moduleList := inspect_zip_for_modules(str(plugin), debug):
             for module in moduleList:
                 plugin = Path(plugin)
                 module = Path(module)
-                logger.debug(f"Plugin: {plugin} Module: {module}")
+                logger.debug(f"Zipped Plugin: {plugin}, Module: {module}")
                 zipped_package = zipimporter(str(plugin))
                 zipped_module = zipped_package.load_module(str(module.parent))
 
                 for key in dir(zipped_module):
                     if key.startswith("__"):
                         continue
+
                     a_module = getattr(zipped_module, key)
+                    if not inspect.isclass(a_module):
+                        continue
 
                     if (
-                        inspect.isclass(a_module)
-                        and issubclass(a_module, AutoGPTPluginTemplate)
+                        issubclass(a_module, AutoGPTPluginTemplate)
                         and a_module.__name__ != "AutoGPTPluginTemplate"
                     ):
                         plugin_name = a_module.__name__
@@ -274,24 +278,23 @@
 
                         if plugin_configured and plugin_enabled:
                             logger.debug(
-                                f"Loading plugin {plugin_name} as it was enabled in config."
+                                f"Loading plugin {plugin_name}. Enabled in plugins_config.yaml."
                             )
                             loaded_plugins.append(a_module())
                         elif plugin_configured and not plugin_enabled:
                             logger.debug(
-                                f"Not loading plugin {plugin_name} as it was disabled in config."
+                                f"Not loading plugin {plugin_name}. Disabled in plugins_config.yaml."
                             )
                         elif not plugin_configured:
                             logger.warn(
-                                f"Not loading plugin {plugin_name} as it was not found in config. "
-                                f"Please check your config. Starting with 0.4.1, plugins will not be loaded unless "
-                                f"they are enabled in plugins_config.yaml. Zipped plugins should use the class "
-                                f"name ({plugin_name}) as the key."
+                                f"Not loading plugin {plugin_name}. Key '{plugin_name}' was not found in plugins_config.yaml. "
+                                f"Zipped plugins should use the class name ({plugin_name}) as the key."
                             )
                     else:
-                        logger.debug(
-                            f"Skipping {key}: {a_module.__name__} because it doesn't subclass AutoGPTPluginTemplate."
-                        )
+                        if a_module.__name__ != "AutoGPTPluginTemplate":
+                            logger.debug(
+                                f"Skipping '{key}' because it doesn't subclass AutoGPTPluginTemplate."
+                            )
 
     # OpenAI plugins
     if config.plugins_openai:
@@ -302,7 +305,9 @@
             )
             for url, openai_plugin_meta in manifests_specs_clients.items():
                 if not plugins_config.is_enabled(url):
-                    logger.warn(f"Plugin {plugin_module_name} found but not configured")
+                    logger.warn(
+                        f"OpenAI Plugin {plugin_module_name} found but not configured"
+                    )
                     continue
 
                 plugin = BaseOpenAIPlugin(openai_plugin_meta)

autogpt/plugins/plugins_config.py

@@ -75,13 +75,19 @@ def create_empty_plugins_config(global_config: Config):
         """Create an empty plugins_config.yaml file. Fill it with values from old env variables."""
         base_config = {}
 
+        logger.debug(f"Legacy plugin denylist: {global_config.plugins_denylist}")
+        logger.debug(f"Legacy plugin allowlist: {global_config.plugins_allowlist}")
+
         # Backwards-compatibility shim
         for plugin_name in global_config.plugins_denylist:
             base_config[plugin_name] = {"enabled": False, "config": {}}
 
         for plugin_name in global_config.plugins_allowlist:
             base_config[plugin_name] = {"enabled": True, "config": {}}
 
+        logger.debug(f"Constructed base plugins config: {base_config}")
+
+        logger.debug(f"Creating plugin config file {global_config.plugins_config_file}")
         with open(global_config.plugins_config_file, "w+") as f:
             f.write(yaml.dump(base_config))
             return base_config