DRAFT: v0.1.0

.codecov.yml

@@ -117,14 +117,14 @@ coverage:
       # BOT COMMANDS AND FEATURES (High standards - 75% target)
       # User-facing commands and Discord integrations
       # High standards because these directly impact user experience
-      cogs:
+      modules:
         target: 75%
         threshold: 2%
         informational: true  # Don't block PRs while building up test suite
         flags:
           - unit
         paths:
-          - tux/cogs/**/*  # All command cogs and Discord slash commands
+          - tux/modules/**/*  # All command modules and Discord slash commands
         only_pulls: true
 
       # UTILITIES AND HELPERS (Moderate standards - 70% target)
@@ -366,10 +366,10 @@ component_management:
     # User-facing Discord commands and integrations
         - unit
         - database
-    - component_id: cogs
+    - component_id: modules
       name: Bot Commands & Features
       paths:
-        - tux/cogs/**/*  # All command cogs organized by category
+        - tux/modules/**/*  # All command modules organized by category
       flag_regexes:
         - unit
 

tux/database/client.py → .database-archive/src/tux/services/database/client.py

@@ -3,7 +3,6 @@
 from typing import TypeVar
 
 from loguru import logger
-
 from prisma import Prisma
 
 T = TypeVar("T")
@@ -76,7 +75,7 @@ async def connect(self) -> None:
         Notes
         -----
         The DATABASE_URL environment variable should be set before calling
-        this method, which is handled by the tux.utils.env module.
+        this method, which is handled by the tux.shared.config.env module.
         """
         if self._client is not None:
             logger.warning(CLIENT_ALREADY_CONNECTED)

tux/database/controllers/__init__.py → .database-archive/src/tux/services/database/controllers/__init__.py

@@ -1,20 +1,23 @@
 """Database controller module providing access to all model controllers."""
 
-import functools
-import inspect
+import importlib
 from typing import Any, ClassVar, TypeVar
 
-import sentry_sdk
-
-from tux.database.controllers.afk import AfkController
-from tux.database.controllers.case import CaseController
-from tux.database.controllers.guild import GuildController
-from tux.database.controllers.guild_config import GuildConfigController
-from tux.database.controllers.levels import LevelsController
-from tux.database.controllers.note import NoteController
-from tux.database.controllers.reminder import ReminderController
-from tux.database.controllers.snippet import SnippetController
-from tux.database.controllers.starboard import StarboardController, StarboardMessageController
+from tux.services.database.controllers.afk import AfkController
+from tux.services.database.controllers.case import CaseController
+from tux.services.database.controllers.guild import GuildController
+from tux.services.database.controllers.guild_config import GuildConfigController
+from tux.services.database.controllers.levels import LevelsController
+from tux.services.database.controllers.note import NoteController
+from tux.services.database.controllers.reminder import ReminderController
+from tux.services.database.controllers.snippet import SnippetController
+from tux.services.database.controllers.starboard import (
+    StarboardController,
+    StarboardMessageController,
+)
+
+# Note: Avoid importing tracing at module import time to prevent circular imports.
+_TRACING_AVAILABLE = True
 
 # Define a TypeVar that can be any BaseController subclass
 ControllerType = TypeVar("ControllerType")
@@ -67,7 +70,9 @@ def __init__(self) -> None:
 
     def _get_controller(self, controller_type: type[ControllerType]) -> ControllerType:
         """
-        Helper method to instantiate a controller with proper Sentry instrumentation.
+        Helper to instantiate a controller with selective Sentry instrumentation.
+
+        Only instruments meaningful database operations to reduce span noise.
 
         Parameters
         ----------
@@ -77,84 +82,65 @@ def _get_controller(self, controller_type: type[ControllerType]) -> ControllerTy
         Returns
         -------
         ControllerType
-            The instantiated controller
+            The instantiated controller with selectively instrumented methods
         """
         instance = controller_type()
-        if sentry_sdk.is_initialized():
-            # Get all public methods to wrap
-            methods = [attr for attr in dir(instance) if callable(getattr(instance, attr)) and not attr.startswith("_")]
 
-            # Wrap each public method with Sentry transaction
-            for method_name in methods:
+        # Exclude internal/utility helpers that create noise
+        excluded_methods = {
+            "safe_get_attr",
+            "connect_or_create_relation",
+            "_add_include_arg_if_present",
+            "_build_find_args",
+            "_build_simple_args",
+            "_build_create_args",
+            "_build_update_args",
+            "_build_delete_args",
+            "_build_upsert_args",
+            "_execute_query",
+            "_set_scope_context",
+        }
+
+        # Include common CRUD/meaningful patterns
+        include_prefixes = (
+            "get_",
+            "find_",
+            "create_",
+            "update_",
+            "delete_",
+            "count_",
+            "increment_",
+            "toggle_",
+            "lock_",
+            "unlock_",
+            "bulk_",
+        )
+
+        # Lazy import via importlib to avoid circular import during package init
+        try:
+            _tracing = importlib.import_module("tux.services.tracing")
+            _span = getattr(_tracing, "span", None)
+        except Exception:
+            _span = None
+
+        # Get public methods that aren't excluded
+        method_names = [
+            attr
+            for attr in dir(instance)
+            if callable(getattr(instance, attr)) and not attr.startswith("_") and attr not in excluded_methods
+        ]
+
+        # Wrap only methods that match meaningful operation patterns
+        for method_name in method_names:
+            if method_name.startswith(include_prefixes):
                 original_method = getattr(instance, method_name)
-                # Use a factory function to capture loop variables
-                self._create_wrapped_method(instance, method_name, original_method)
+                if _span is not None:
+                    op = f"db.controller.{method_name}"
+                    wrapped = _span(op=op)(original_method)
+                    setattr(instance, method_name, wrapped)
 
         return instance
 
-    def _create_wrapped_method(self, instance: Any, method_name: str, original_method: Any) -> None:
-        """
-        Create a wrapped method with proper sentry instrumentation.
-
-        Parameters
-        ----------
-        instance : Any
-            The controller instance
-        method_name : str
-            The name of the method to wrap
-        original_method : Any
-            The original method to wrap
-        """
-
-        # 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,
         "case": CaseController,

tux/database/controllers/afk.py → .database-archive/src/tux/services/database/controllers/afk.py

@@ -2,8 +2,9 @@
 
 from prisma.actions import GuildActions
 from prisma.models import AFKModel, Guild
-from tux.database.client import db
-from tux.database.controllers.base import BaseController
+
+from tux.services.database.client import db
+from tux.services.database.controllers.base import BaseController
 
 
 class AfkController(BaseController[AFKModel]):

tux/database/controllers/base.py → .database-archive/src/tux/services/database/controllers/base.py

@@ -1,11 +1,10 @@
 """Base controller module providing common database functionality."""
 
+import importlib
 from collections.abc import Callable
 from typing import Any, TypeVar
 
-import sentry_sdk
 from loguru import logger
-
 from prisma.models import (
     AFKModel,
     Case,
@@ -18,7 +17,8 @@
     Starboard,
     StarboardMessage,
 )
-from tux.database.client import db
+
+from tux.services.database.client import db
 
 # Explicitly define ModelType to cover all potential models used by controllers
 ModelType = TypeVar(
@@ -84,6 +84,7 @@ async def _execute_query(
         self,
         operation: Callable[[], Any],
         error_msg: str,
+        op_name: str,
     ) -> Any:
         """Executes a database query with standardized error logging.
 
@@ -107,17 +108,25 @@ async def _execute_query(
         Exception
             Re-raises any exception caught during the database operation.
         """
-        # Create a Sentry span to track database query performance
-        if sentry_sdk.is_initialized():
-            with sentry_sdk.start_span(op="db.query", description=f"Database query: {self.table_name}") as span:
-                span.set_tag("db.table", self.table_name)
+        # Lazy import via importlib to avoid circular import through package __init__
+        try:
+            _tracing = importlib.import_module("tux.services.tracing")
+            _start_span = getattr(_tracing, "start_span", None)
+        except Exception:
+            _start_span = None
+
+        if _start_span is not None:
+            with _start_span(op=f"db.query.{op_name}", name=self.table_name) as span:  # type: ignore
                 try:
                     result = await operation()
-                    span.set_status("ok")
+                    if hasattr(span, "set_status"):
+                        span.set_status("ok")
                     return result  # noqa: TRY300
                 except Exception as e:
-                    span.set_status("internal_error")
-                    span.set_data("error", str(e))
+                    if hasattr(span, "set_status"):
+                        span.set_status("internal_error")
+                    if hasattr(span, "set_data"):
+                        span.set_data("error", str(e))
                     logger.error(f"{error_msg}: {e}")
                     raise
         else:
@@ -238,6 +247,7 @@ async def find_one(
         return await self._execute_query(
             lambda: self.table.find_first(**find_args),
             f"Failed to find record in {self.table_name} with criteria {where}",
+            "find_one",
         )
 
     async def find_unique(
@@ -263,6 +273,7 @@ async def find_unique(
         return await self._execute_query(
             lambda: self.table.find_unique(**find_args),
             f"Failed to find unique record in {self.table_name} with criteria {where}",
+            "find_unique",
         )
 
     async def find_many(
@@ -307,6 +318,7 @@ async def find_many(
         return await self._execute_query(
             lambda: self.table.find_many(**find_args),
             f"Failed to find records in {self.table_name} with criteria {where}",
+            "find_many",
         )
 
     async def count(
@@ -328,6 +340,7 @@ async def count(
         return await self._execute_query(
             lambda: self.table.count(where=where),
             f"Failed to count records in {self.table_name} with criteria {where}",
+            "count",
         )
 
     async def create(
@@ -353,6 +366,7 @@ async def create(
         return await self._execute_query(
             lambda: self.table.create(**create_args),
             f"Failed to create record in {self.table_name} with data {data}",
+            "create",
         )
 
     async def update(
@@ -381,6 +395,7 @@ async def update(
         return await self._execute_query(
             lambda: self.table.update(**update_args),
             f"Failed to update record in {self.table_name} with criteria {where} and data {data}",
+            "update",
         )
 
     async def delete(
@@ -406,6 +421,7 @@ async def delete(
         return await self._execute_query(
             lambda: self.table.delete(**delete_args),
             f"Failed to delete record in {self.table_name} with criteria {where}",
+            "delete",
         )
 
     async def upsert(
@@ -437,6 +453,7 @@ async def upsert(
         return await self._execute_query(
             lambda: self.table.upsert(**upsert_args),
             f"Failed to upsert record in {self.table_name} with where={where}, create={create}, update={update}",
+            "upsert",
         )
 
     async def update_many(
@@ -466,6 +483,7 @@ async def update_many(
         result = await self._execute_query(
             lambda: self.table.update_many(where=where, data=data),
             f"Failed to update records in {self.table_name} with criteria {where} and data {data}",
+            "update_many",
         )
         # Validate and return count
         count_val = getattr(result, "count", None)
@@ -498,6 +516,7 @@ async def delete_many(
         result = await self._execute_query(
             lambda: self.table.delete_many(where=where),
             f"Failed to delete records in {self.table_name} with criteria {where}",
+            "delete_many",
         )
         # Validate and return count
         count_val = getattr(result, "count", None)

tux/database/controllers/case.py → .database-archive/src/tux/services/database/controllers/case.py

@@ -5,8 +5,9 @@
 from prisma.enums import CaseType
 from prisma.models import Case, Guild
 from prisma.types import CaseWhereInput
-from tux.database.client import db
-from tux.database.controllers.base import BaseController
+
+from tux.services.database.client import db
+from tux.services.database.controllers.base import BaseController
 
 
 class CaseController(BaseController[Case]):