feat: add event_logger to test_connection and create_database commands

superset/databases/commands/create.py

@@ -32,7 +32,7 @@
 )
 from superset.databases.commands.test_connection import TestConnectionDatabaseCommand
 from superset.databases.dao import DatabaseDAO
-from superset.extensions import db, security_manager
+from superset.extensions import db, event_logger, security_manager
 
 logger = logging.getLogger(__name__)
 
@@ -50,9 +50,13 @@ def run(self) -> Model:
 
             try:
                 TestConnectionDatabaseCommand(self._actor, self._properties).run()
-            except Exception:
-                db.session.rollback()
-                raise DatabaseConnectionFailedError()
+            except Exception:  # pylint: disable=broad-except
+                with event_logger(
+                    action="db_connection_failed",
+                    engine=database.db_engine_spec.__name__,
+                ):
+                    db.session.rollback()
+                    raise DatabaseConnectionFailedError()
 
             # adding a new database we always want to force refresh schema list
             schemas = database.get_all_schema_names(cache=False)
@@ -63,8 +67,11 @@ def run(self) -> Model:
             security_manager.add_permission_view_menu("database_access", database.perm)
             db.session.commit()
         except DAOCreateFailedError as ex:
-            logger.exception(ex.exception)
-            raise DatabaseCreateFailedError()
+            with event_logger(
+                action=f"db_creation_failed.{ex.exception}",
+                engine=database.db_engine_spec.__name__,
+            ):
+                raise DatabaseCreateFailedError()
         return database
 
     def validate(self) -> None:
@@ -84,4 +91,5 @@ def validate(self) -> None:
         if exceptions:
             exception = DatabaseInvalidError()
             exception.add_list(exceptions)
-            raise exception
+            with event_logger(action="db_connection_failed"):
+                raise exception

superset/databases/commands/test_connection.py

@@ -32,6 +32,7 @@
 )
 from superset.databases.dao import DatabaseDAO
 from superset.exceptions import SupersetSecurityException
+from superset.extensions import event_logger
 from superset.models.core import Database
 
 logger = logging.getLogger(__name__)
@@ -55,25 +56,49 @@ def run(self) -> None:
                 impersonate_user=self._properties.get("impersonate_user", False),
                 encrypted_extra=self._properties.get("encrypted_extra", "{}"),
             )
-            if database is not None:
-                database.set_sqlalchemy_uri(uri)
-                database.db_engine_spec.mutate_db_for_connection_test(database)
-                username = self._actor.username if self._actor is not None else None
-                engine = database.get_sqla_engine(user_name=username)
+            if database is None:
+                raise DBAPIError("Database is not found", None, None)
+
+            database.set_sqlalchemy_uri(uri)
+            database.db_engine_spec.mutate_db_for_connection_test(database)
+            username = self._actor.username if self._actor is not None else None
+            engine = database.get_sqla_engine(user_name=username)
             with closing(engine.raw_connection()) as conn:
                 if not engine.dialect.do_ping(conn):
                     raise DBAPIError(None, None, None)
-        except (NoSuchModuleError, ModuleNotFoundError):
+
+            with event_logger(
+                action="test_connection_success", engine=make_url(uri).drivername
+            ):
+                pass
+
+        except (NoSuchModuleError, ModuleNotFoundError) as ex:
             driver_name = make_url(uri).drivername
-            raise DatabaseTestConnectionDriverError(
-                message=_("Could not load database driver: {}").format(driver_name),
-            )
-        except DBAPIError:
-            raise DatabaseTestConnectionFailedError()
+            with event_logger(
+                action=f"test_connection_error.{ex.__class__.__name__}",
+                engine=make_url(uri).drivername,
+            ):
+                raise DatabaseTestConnectionDriverError(
+                    message=_("Could not load database driver: {}").format(driver_name),
+                )
+        except DBAPIError as ex:
+            with event_logger(
+                action=f"test_connection_error.{ex.__class__.__name__}",
+                engine=make_url(uri).drivername,
+            ):
+                raise DatabaseTestConnectionFailedError()
         except SupersetSecurityException as ex:
-            raise DatabaseSecurityUnsafeError(message=str(ex))
-        except Exception:
-            raise DatabaseTestConnectionUnexpectedError()
+            with event_logger(
+                action=f"test_connection_error.{ex.__class__.__name__}",
+                engine=make_url(uri).drivername,
+            ):
+                raise DatabaseSecurityUnsafeError(message=str(ex))
+        except Exception as ex:  # pylint: disable=broad-except
+            with event_logger(
+                action=f"test_connection_error.{ex.__class__.__name__}",
+                engine=make_url(uri).drivername,
+            ):
+                raise DatabaseTestConnectionUnexpectedError()
 
     def validate(self) -> None:
         database_name = self._properties.get("database_name")