shotgun-sh 0.2.8.dev2__py3-none-any.whl → 0.2.17__py3-none-any.whl

shotgun/sentry_telemetry.py

@@ -1,14 +1,132 @@
 """Sentry observability setup for Shotgun."""
 
-import os
+from pathlib import Path
+from typing import Any
 
 from shotgun import __version__
 from shotgun.logging_config import get_early_logger
+from shotgun.settings import settings
 
 # Use early logger to prevent automatic StreamHandler creation
 logger = get_early_logger(__name__)
 
 
+def _scrub_path(path: str) -> str:
+    """Scrub sensitive information from file paths.
+
+    Removes home directory and current working directory prefixes to prevent
+    leaking usernames that might be part of the path.
+
+    Args:
+        path: The file path to scrub
+
+    Returns:
+        The scrubbed path with sensitive prefixes removed
+    """
+    if not path:
+        return path
+
+    try:
+        # Get home and cwd as Path objects for comparison
+        home = Path.home()
+        cwd = Path.cwd()
+
+        # Convert path to Path object
+        path_obj = Path(path)
+
+        # Try to make path relative to cwd first (most common case)
+        try:
+            relative_to_cwd = path_obj.relative_to(cwd)
+            return str(relative_to_cwd)
+        except ValueError:
+            pass
+
+        # Try to replace home directory with ~
+        try:
+            relative_to_home = path_obj.relative_to(home)
+            return f"~/{relative_to_home}"
+        except ValueError:
+            pass
+
+        # If path is absolute but not under cwd or home, just return filename
+        if path_obj.is_absolute():
+            return path_obj.name
+
+        # Return as-is if already relative
+        return path
+
+    except Exception:
+        # If anything goes wrong, return the original path
+        # Better to leak a path than break error reporting
+        return path
+
+
+def _scrub_sensitive_paths(event: dict[str, Any]) -> None:
+    """Scrub sensitive paths from Sentry event data.
+
+    Modifies the event in-place to remove:
+    - Home directory paths (might contain usernames)
+    - Current working directory paths (might contain usernames)
+    - Server name/hostname
+    - Paths in sys.argv
+
+    Args:
+        event: The Sentry event dictionary to scrub
+    """
+    extra = event.get("extra", {})
+    if "sys.argv" in extra:
+        argv = extra["sys.argv"]
+        if isinstance(argv, list):
+            extra["sys.argv"] = [
+                _scrub_path(arg) if isinstance(arg, str) else arg for arg in argv
+            ]
+
+    # Scrub server name if present
+    if "server_name" in event:
+        event["server_name"] = ""
+
+    # Scrub contexts that might contain paths
+    if "contexts" in event:
+        contexts = event["contexts"]
+        # Remove runtime context if it has CWD
+        if "runtime" in contexts:
+            if "cwd" in contexts["runtime"]:
+                del contexts["runtime"]["cwd"]
+            # Scrub sys.argv to remove paths
+            if "sys.argv" in contexts["runtime"]:
+                argv = contexts["runtime"]["sys.argv"]
+                if isinstance(argv, list):
+                    contexts["runtime"]["sys.argv"] = [
+                        _scrub_path(arg) if isinstance(arg, str) else arg
+                        for arg in argv
+                    ]
+
+    # Scrub exception stack traces
+    if "exception" in event and "values" in event["exception"]:
+        for exception in event["exception"]["values"]:
+            if "stacktrace" in exception and "frames" in exception["stacktrace"]:
+                for frame in exception["stacktrace"]["frames"]:
+                    # Scrub file paths
+                    if "abs_path" in frame:
+                        frame["abs_path"] = _scrub_path(frame["abs_path"])
+                    if "filename" in frame:
+                        frame["filename"] = _scrub_path(frame["filename"])
+
+                    # Scrub local variables that might contain paths
+                    if "vars" in frame:
+                        for var_name, var_value in frame["vars"].items():
+                            if isinstance(var_value, str):
+                                frame["vars"][var_name] = _scrub_path(var_value)
+
+    # Scrub breadcrumbs that might contain paths
+    if "breadcrumbs" in event and "values" in event["breadcrumbs"]:
+        for breadcrumb in event["breadcrumbs"]["values"]:
+            if "data" in breadcrumb:
+                for key, value in breadcrumb["data"].items():
+                    if isinstance(value, str):
+                        breadcrumb["data"][key] = _scrub_path(value)
+
+
 def setup_sentry_observability() -> bool:
     """Set up Sentry observability for error tracking.
 
@@ -23,48 +141,77 @@ def setup_sentry_observability() -> bool:
             logger.debug("Sentry is already initialized, skipping")
             return True
 
-        # Try to get DSN from build constants first (production builds)
-        dsn = None
-        try:
-            from shotgun import build_constants
-
-            dsn = build_constants.SENTRY_DSN
-            logger.debug("Using Sentry DSN from build constants")
-        except ImportError:
-            # Fallback to environment variable (development)
-            dsn = os.getenv("SENTRY_DSN", "")
-            if dsn:
-                logger.debug("Using Sentry DSN from environment variable")
+        # Get DSN from settings (handles build constants + env vars automatically)
+        dsn = settings.telemetry.sentry_dsn
 
         if not dsn:
             logger.debug("No Sentry DSN configured, skipping Sentry initialization")
             return False
 
-        logger.debug("Found DSN, proceeding with Sentry setup")
+        logger.debug("Using Sentry DSN from settings, proceeding with setup")
 
         # Determine environment based on version
-        # Dev versions contain "dev", "rc", "alpha", or "beta"
+        # Dev versions contain "dev", "rc", "alpha", "beta"
         if any(marker in __version__ for marker in ["dev", "rc", "alpha", "beta"]):
             environment = "development"
         else:
             environment = "production"
 
+        def before_send(event: Any, hint: dict[str, Any]) -> Any:
+            """Filter out user-actionable errors and scrub sensitive paths.
+
+            User-actionable errors (like context size limits) are expected conditions
+            that users need to resolve, not bugs that need tracking.
+
+            Also scrubs sensitive information like usernames from file paths and
+            working directories to protect user privacy.
+            """
+
+            log_record = hint.get("log_record")
+            if log_record:
+                # Scrub pathname using the helper function
+                log_record.pathname = _scrub_path(log_record.pathname)
+
+                # Scrub traceback text if it exists
+                if hasattr(log_record, "exc_text") and isinstance(
+                    log_record.exc_text, str
+                ):
+                    # Replace home directory in traceback text
+                    home = Path.home()
+                    log_record.exc_text = log_record.exc_text.replace(str(home), "~")
+
+            if "exc_info" in hint:
+                _, exc_value, _ = hint["exc_info"]
+                from shotgun.exceptions import ErrorNotPickedUpBySentry
+
+                if isinstance(exc_value, ErrorNotPickedUpBySentry):
+                    # Don't send to Sentry - this is user-actionable, not a bug
+                    return None
+
+            # Scrub sensitive paths from the event
+            _scrub_sensitive_paths(event)
+            return event
+
         # Initialize Sentry
         sentry_sdk.init(
             dsn=dsn,
             release=f"shotgun-sh@{__version__}",
             environment=environment,
             send_default_pii=False,  # Privacy-first: never send PII
+            server_name="",  # Privacy: don't send hostname (may contain username)
             traces_sample_rate=0.1 if environment == "production" else 1.0,
             profiles_sample_rate=0.1 if environment == "production" else 1.0,
+            before_send=before_send,
         )
 
         # Set user context with anonymous shotgun instance ID from config
         try:
+            import asyncio
+
             from shotgun.agents.config import get_config_manager
 
             config_manager = get_config_manager()
-            shotgun_instance_id = config_manager.get_shotgun_instance_id()
+            shotgun_instance_id = asyncio.run(config_manager.get_shotgun_instance_id())
             sentry_sdk.set_user({"id": shotgun_instance_id})
             logger.debug("Sentry user context set with anonymous ID")
         except Exception as e:

shotgun/settings.py

@@ -0,0 +1,238 @@
+"""Centralized application settings using Pydantic Settings.
+
+All environment variables use the SHOTGUN_ prefix to avoid conflicts with other tools.
+Settings are loaded with the following priority:
+1. Environment variables (highest priority)
+2. Build constants (embedded at build time)
+3. Default values (lowest priority)
+
+Example usage:
+    from shotgun.settings import settings
+
+    # Access telemetry settings
+    if settings.telemetry.sentry_dsn:
+        sentry_sdk.init(dsn=settings.telemetry.sentry_dsn)
+
+    # Access logging settings
+    logger.setLevel(settings.logging.log_level)
+
+    # Access API settings
+    response = httpx.get(settings.api.web_base_url)
+"""
+
+from typing import Any
+
+from pydantic import Field, field_validator
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+def _get_build_constant(name: str, default: Any = None) -> Any:
+    """Get a value from build_constants.py, falling back to default.
+
+    Args:
+        name: The constant name to retrieve (e.g., "SENTRY_DSN")
+        default: Default value if constant not found
+
+    Returns:
+        The constant value, or default if not found/import fails
+    """
+    try:
+        from shotgun import build_constants
+
+        return getattr(build_constants, name, default)
+    except ImportError:
+        return default
+
+
+class TelemetrySettings(BaseSettings):
+    """Telemetry and observability settings.
+
+    These settings control error tracking (Sentry), analytics (PostHog),
+    and observability (Logfire) integrations.
+    """
+
+    sentry_dsn: str = Field(
+        default_factory=lambda: _get_build_constant("SENTRY_DSN", ""),
+        description="Sentry DSN for error tracking",
+    )
+    posthog_api_key: str = Field(
+        default_factory=lambda: _get_build_constant("POSTHOG_API_KEY", ""),
+        description="PostHog API key for analytics",
+    )
+    posthog_project_id: str = Field(
+        default_factory=lambda: _get_build_constant("POSTHOG_PROJECT_ID", ""),
+        description="PostHog project ID",
+    )
+    logfire_enabled: bool = Field(
+        default_factory=lambda: _get_build_constant("LOGFIRE_ENABLED", False),
+        description="Enable Logfire observability (dev builds only)",
+    )
+    logfire_token: str = Field(
+        default_factory=lambda: _get_build_constant("LOGFIRE_TOKEN", ""),
+        description="Logfire authentication token",
+    )
+
+    model_config = SettingsConfigDict(
+        env_prefix="SHOTGUN_",
+        env_file=".env",
+        env_file_encoding="utf-8",
+        extra="ignore",
+    )
+
+    @field_validator("logfire_enabled", mode="before")
+    @classmethod
+    def parse_bool(cls, v: Any) -> bool:
+        """Parse boolean values from strings (matches is_truthy behavior)."""
+        if isinstance(v, bool):
+            return v
+        if isinstance(v, str):
+            return v.lower() in ("true", "1", "yes")
+        return bool(v)
+
+
+class LoggingSettings(BaseSettings):
+    """Logging configuration settings.
+
+    Controls log level, console output, and file logging behavior.
+    """
+
+    log_level: str = Field(
+        default="INFO",
+        description="Logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL)",
+    )
+    logging_to_console: bool = Field(
+        default=False,
+        description="Enable console logging output",
+    )
+    logging_to_file: bool = Field(
+        default=True,
+        description="Enable file logging output",
+    )
+
+    model_config = SettingsConfigDict(
+        env_prefix="SHOTGUN_",
+        env_file=".env",
+        env_file_encoding="utf-8",
+        extra="ignore",
+    )
+
+    @field_validator("log_level")
+    @classmethod
+    def validate_log_level(cls, v: str) -> str:
+        """Validate log level is one of the allowed values."""
+        v = v.upper()
+        valid_levels = ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]
+        if v not in valid_levels:
+            return "INFO"  # Default to INFO if invalid
+        return v
+
+    @field_validator("logging_to_console", "logging_to_file", mode="before")
+    @classmethod
+    def parse_bool(cls, v: Any) -> bool:
+        """Parse boolean values from strings (matches is_truthy behavior)."""
+        if isinstance(v, bool):
+            return v
+        if isinstance(v, str):
+            return v.lower() in ("true", "1", "yes")
+        return bool(v)
+
+
+class ApiSettings(BaseSettings):
+    """API endpoint settings.
+
+    Configuration for Shotgun backend services.
+    """
+
+    web_base_url: str = Field(
+        default="https://api-219702594231.us-east4.run.app",
+        description="Shotgun Web API base URL (authentication/subscription)",
+    )
+    account_llm_base_url: str = Field(
+        default="https://litellm-219702594231.us-east4.run.app",
+        description="Shotgun's LiteLLM proxy base URL (AI model requests)",
+    )
+
+    model_config = SettingsConfigDict(
+        env_prefix="SHOTGUN_",
+        env_file=".env",
+        env_file_encoding="utf-8",
+        extra="ignore",
+    )
+
+
+class DevelopmentSettings(BaseSettings):
+    """Development and testing settings.
+
+    These settings are primarily used for testing and development purposes.
+    """
+
+    home: str | None = Field(
+        default=None,
+        description="Override Shotgun home directory (for testing)",
+    )
+    pipx_simulate: bool = Field(
+        default=False,
+        description="Simulate pipx installation (for testing)",
+    )
+
+    model_config = SettingsConfigDict(
+        env_prefix="SHOTGUN_",
+        env_file=".env",
+        env_file_encoding="utf-8",
+        extra="ignore",
+    )
+
+    @field_validator("pipx_simulate", mode="before")
+    @classmethod
+    def parse_bool(cls, v: Any) -> bool:
+        """Parse boolean values from strings (matches is_truthy behavior)."""
+        if isinstance(v, bool):
+            return v
+        if isinstance(v, str):
+            return v.lower() in ("true", "1", "yes")
+        return bool(v)
+
+
+class Settings(BaseSettings):
+    """Main application settings with SHOTGUN_ prefix.
+
+    This is the main settings class that composes all other settings groups.
+    Access settings via the global `settings` singleton instance.
+
+    Example:
+        from shotgun.settings import settings
+
+        # Telemetry settings
+        settings.telemetry.sentry_dsn
+        settings.telemetry.posthog_api_key
+        settings.telemetry.logfire_enabled
+
+        # Logging settings
+        settings.logging.log_level
+        settings.logging.logging_to_console
+
+        # API settings
+        settings.api.web_base_url
+        settings.api.account_llm_base_url
+
+        # Development settings
+        settings.dev.home
+        settings.dev.pipx_simulate
+    """
+
+    telemetry: TelemetrySettings = Field(default_factory=TelemetrySettings)
+    logging: LoggingSettings = Field(default_factory=LoggingSettings)
+    api: ApiSettings = Field(default_factory=ApiSettings)
+    dev: DevelopmentSettings = Field(default_factory=DevelopmentSettings)
+
+    model_config = SettingsConfigDict(
+        env_prefix="SHOTGUN_",
+        env_file=".env",
+        env_file_encoding="utf-8",
+        extra="ignore",
+    )
+
+
+# Global settings singleton
+# Import this in your modules: from shotgun.settings import settings
+settings = Settings()

shotgun/telemetry.py

@@ -1,9 +1,7 @@
 """Observability setup for Logfire."""
 
-import os
-
 from shotgun.logging_config import get_early_logger
-from shotgun.utils.env_utils import is_falsy, is_truthy
+from shotgun.settings import settings
 
 # Use early logger to prevent automatic StreamHandler creation
 logger = get_early_logger(__name__)
@@ -15,36 +13,13 @@ def setup_logfire_observability() -> bool:
     Returns:
         True if Logfire was successfully set up, False otherwise
     """
-    # Try to get Logfire configuration from build constants first, fall back to env vars
-    logfire_enabled = None
-    logfire_token = None
-
-    try:
-        from shotgun.build_constants import LOGFIRE_ENABLED, LOGFIRE_TOKEN
-
-        # Use build constants if they're not empty
-        if LOGFIRE_ENABLED:
-            logfire_enabled = LOGFIRE_ENABLED
-        if LOGFIRE_TOKEN:
-            logfire_token = LOGFIRE_TOKEN
-    except ImportError:
-        # No build constants available
-        pass
-
-    # Fall back to environment variables if not set from build constants
-    if not logfire_enabled:
-        logfire_enabled = os.getenv("LOGFIRE_ENABLED", "false")
-    if not logfire_token:
-        logfire_token = os.getenv("LOGFIRE_TOKEN")
-
-    # Allow environment variable to override and disable Logfire
-    env_override = os.getenv("LOGFIRE_ENABLED")
-    if env_override and is_falsy(env_override):
-        logfire_enabled = env_override
+    # Get Logfire configuration from settings (handles build constants + env vars)
+    logfire_enabled = settings.telemetry.logfire_enabled
+    logfire_token = settings.telemetry.logfire_token
 
     # Check if Logfire observability is enabled
-    if not is_truthy(logfire_enabled):
-        logger.debug("Logfire observability disabled via LOGFIRE_ENABLED")
+    if not logfire_enabled:
+        logger.debug("Logfire observability disabled")
         return False
 
     try:
@@ -52,7 +27,7 @@ def setup_logfire_observability() -> bool:
 
         # Check for Logfire token
         if not logfire_token:
-            logger.warning("LOGFIRE_TOKEN not set, Logfire observability disabled")
+            logger.warning("Logfire token not set, Logfire observability disabled")
             return False
 
         # Configure Logfire
@@ -75,12 +50,14 @@ def setup_logfire_observability() -> bool:
 
         # Set user context using baggage for all logs and spans
         try:
+            import asyncio
+
             from opentelemetry import baggage, context
 
             from shotgun.agents.config import get_config_manager
 
             config_manager = get_config_manager()
-            shotgun_instance_id = config_manager.get_shotgun_instance_id()
+            shotgun_instance_id = asyncio.run(config_manager.get_shotgun_instance_id())
 
             # Set shotgun_instance_id as baggage in global context - this will be included in all logs/spans
             ctx = baggage.set_baggage("shotgun_instance_id", shotgun_instance_id)