feat(database): add support for synchronous methods in DatabaseController

Enhance the DatabaseController to handle both asynchronous and
synchronous methods. Previously, only asynchronous methods were
wrapped with Sentry spans for monitoring. By checking if the original
method is asynchronous, the code now conditionally wraps it with
either an async or sync wrapper. This change increases the flexibility
of the DatabaseController, allowing it to support a wider range of
method types while maintaining error tracking and performance
monitoring capabilities.

Author: kzndotsh

tux/database/controllers/__init__.py

@@ -101,27 +101,56 @@ def _create_wrapped_method(self, instance: Any, method_name: str, original_metho
         original_method : Any
             The original method to wrap
         """
-
-        @functools.wraps(original_method)
-        async def wrapped_method(*args: Any, **kwargs: Any) -> Any:
-            controller_name = instance.__class__.__name__
-            with sentry_sdk.start_span(
-                op=f"db.controller.{method_name}",
-                description=f"{controller_name}.{method_name}",
-            ) as span:
-                span.set_tag("db.controller", controller_name)
-                span.set_tag("db.operation", method_name)
-                try:
-                    result = await original_method(*args, **kwargs)
-                except Exception as e:
-                    span.set_status("internal_error")
-                    span.set_data("error", str(e))
-                    raise
-                else:
-                    span.set_status("ok")
-                    return result
-
-        setattr(instance, method_name, wrapped_method)
+        import inspect
+
+        # Check if the original method is async
+        is_async = inspect.iscoroutinefunction(original_method)
+
+        if is_async:
+
+            @functools.wraps(original_method)
+            async def async_wrapped_method(*args: Any, **kwargs: Any) -> Any:
+                controller_name = instance.__class__.__name__
+                with sentry_sdk.start_span(
+                    op=f"db.controller.{method_name}",
+                    description=f"{controller_name}.{method_name}",
+                ) as span:
+                    span.set_tag("db.controller", controller_name)
+                    span.set_tag("db.operation", method_name)
+                    try:
+                        result = await original_method(*args, **kwargs)
+                    except Exception as e:
+                        span.set_status("internal_error")
+                        span.set_data("error", str(e))
+                        raise
+                    else:
+                        span.set_status("ok")
+                        return result
+
+            setattr(instance, method_name, async_wrapped_method)
+
+        else:
+
+            @functools.wraps(original_method)
+            def sync_wrapped_method(*args: Any, **kwargs: Any) -> Any:
+                controller_name = instance.__class__.__name__
+                with sentry_sdk.start_span(
+                    op=f"db.controller.{method_name}",
+                    description=f"{controller_name}.{method_name}",
+                ) as span:
+                    span.set_tag("db.controller", controller_name)
+                    span.set_tag("db.operation", method_name)
+                    try:
+                        result = original_method(*args, **kwargs)
+                    except Exception as e:
+                        span.set_status("internal_error")
+                        span.set_data("error", str(e))
+                        raise
+                    else:
+                        span.set_status("ok")
+                        return result
+
+            setattr(instance, method_name, sync_wrapped_method)
 
     _controller_mapping: ClassVar[dict[str, type]] = {
         "afk": AfkController,