karaoke-gen 0.90.1__py3-none-any.whl → 0.99.3__py3-none-any.whl

backend/services/stripe_service.py

@@ -0,0 +1,371 @@
+"""
+Stripe service for payment processing.
+
+Handles:
+- Creating checkout sessions for credit purchases
+- Processing webhook events
+- Managing customer records
+"""
+import logging
+import os
+from typing import Optional, Dict, Any, Tuple
+
+import stripe
+
+from backend.config import get_settings
+
+
+logger = logging.getLogger(__name__)
+
+
+# Credit packages available for purchase
+CREDIT_PACKAGES = {
+    "1_credit": {
+        "credits": 1,
+        "price_cents": 500,  # $5.00
+        "name": "1 Karaoke Credit",
+        "description": "Create 1 professional karaoke video",
+    },
+    "3_credits": {
+        "credits": 3,
+        "price_cents": 1200,  # $12.00 (20% discount)
+        "name": "3 Karaoke Credits",
+        "description": "Create 3 professional karaoke videos (Save 20%)",
+    },
+    "5_credits": {
+        "credits": 5,
+        "price_cents": 1750,  # $17.50 (30% discount)
+        "name": "5 Karaoke Credits",
+        "description": "Create 5 professional karaoke videos (Save 30%)",
+    },
+    "10_credits": {
+        "credits": 10,
+        "price_cents": 3000,  # $30.00 (40% discount)
+        "name": "10 Karaoke Credits",
+        "description": "Create 10 professional karaoke videos (Save 40%)",
+    },
+}
+
+# Done-for-you service package (not a credit package - creates a job directly)
+DONE_FOR_YOU_PACKAGE = {
+    "price_cents": 1500,  # $15.00
+    "name": "Done For You Karaoke Video",
+    "description": "Full-service karaoke video creation with 24-hour delivery",
+}
+
+
+class StripeService:
+    """Service for Stripe payment processing."""
+
+    def __init__(self):
+        """Initialize Stripe with API key."""
+        self.settings = get_settings()
+        self.secret_key = os.getenv("STRIPE_SECRET_KEY")
+        self.webhook_secret = os.getenv("STRIPE_WEBHOOK_SECRET")
+        self.frontend_url = os.getenv("FRONTEND_URL", "https://gen.nomadkaraoke.com")
+        # After consolidation, buy URL is the same as frontend URL
+        self.buy_url = os.getenv("BUY_URL", self.frontend_url)
+
+        if self.secret_key:
+            stripe.api_key = self.secret_key
+            logger.info("Stripe initialized with API key")
+        else:
+            logger.warning("STRIPE_SECRET_KEY not set - payments disabled")
+
+    def is_configured(self) -> bool:
+        """Check if Stripe is properly configured."""
+        return bool(self.secret_key)
+
+    def get_credit_packages(self) -> Dict[str, Dict[str, Any]]:
+        """Get available credit packages."""
+        return CREDIT_PACKAGES
+
+    def create_checkout_session(
+        self,
+        package_id: str,
+        user_email: str,
+        success_url: Optional[str] = None,
+        cancel_url: Optional[str] = None,
+    ) -> Tuple[bool, Optional[str], str]:
+        """
+        Create a Stripe Checkout session for purchasing credits.
+
+        Args:
+            package_id: ID of the credit package to purchase
+            user_email: Email of the purchasing user
+            success_url: URL to redirect to on success (optional)
+            cancel_url: URL to redirect to on cancel (optional)
+
+        Returns:
+            (success, checkout_url, message)
+        """
+        if not self.is_configured():
+            return False, None, "Payment processing is not configured"
+
+        package = CREDIT_PACKAGES.get(package_id)
+        if not package:
+            return False, None, f"Invalid package: {package_id}"
+
+        try:
+            # Default URLs
+            if not success_url:
+                success_url = f"{self.frontend_url}/payment/success?session_id={{CHECKOUT_SESSION_ID}}"
+            if not cancel_url:
+                cancel_url = f"{self.buy_url}?cancelled=true"
+
+            # Create checkout session
+            session = stripe.checkout.Session.create(
+                payment_method_types=['card'],
+                line_items=[{
+                    'price_data': {
+                        'currency': 'usd',
+                        'product_data': {
+                            'name': package['name'],
+                            'description': package['description'],
+                        },
+                        'unit_amount': package['price_cents'],
+                    },
+                    'quantity': 1,
+                }],
+                mode='payment',
+                success_url=success_url,
+                cancel_url=cancel_url,
+                customer_email=user_email,
+                metadata={
+                    'package_id': package_id,
+                    'credits': str(package['credits']),
+                    'user_email': user_email,
+                },
+                # Allow promotion codes
+                allow_promotion_codes=True,
+            )
+
+            logger.info(f"Created checkout session {session.id} for {user_email}, package {package_id}")
+            return True, session.url, "Checkout session created"
+
+        except stripe.error.StripeError as e:
+            logger.error(f"Stripe error creating checkout session: {e}")
+            return False, None, f"Payment error: {str(e)}"
+        except Exception as e:
+            logger.error(f"Error creating checkout session: {e}")
+            return False, None, "Failed to create checkout session"
+
+    def create_done_for_you_checkout_session(
+        self,
+        customer_email: str,
+        artist: str,
+        title: str,
+        source_type: str = "search",
+        youtube_url: Optional[str] = None,
+        notes: Optional[str] = None,
+        success_url: Optional[str] = None,
+        cancel_url: Optional[str] = None,
+    ) -> Tuple[bool, Optional[str], str]:
+        """
+        Create a Stripe Checkout session for a done-for-you order.
+
+        This is for the full-service karaoke video creation where Nomad Karaoke
+        handles all the work (lyrics review, instrumental selection, etc.).
+
+        Args:
+            customer_email: Customer's email for delivery
+            artist: Song artist
+            title: Song title
+            source_type: Audio source type (search, youtube, upload)
+            youtube_url: YouTube URL if source_type is youtube
+            notes: Any special requests from customer
+            success_url: URL to redirect to on success (optional)
+            cancel_url: URL to redirect to on cancel (optional)
+
+        Returns:
+            (success, checkout_url, message)
+        """
+        if not self.is_configured():
+            return False, None, "Payment processing is not configured"
+
+        try:
+            # Default URLs - redirect to homepage success page
+            if not success_url:
+                success_url = "https://nomadkaraoke.com/order/success/?session_id={CHECKOUT_SESSION_ID}"
+            if not cancel_url:
+                cancel_url = "https://nomadkaraoke.com/#do-it-for-me"
+
+            # Build metadata for job creation after payment
+            metadata = {
+                'order_type': 'done_for_you',
+                'customer_email': customer_email,
+                'artist': artist,
+                'title': title,
+                'source_type': source_type,
+            }
+            if youtube_url:
+                metadata['youtube_url'] = youtube_url
+            if notes:
+                # Truncate notes to fit Stripe's 500 char limit per metadata value
+                metadata['notes'] = notes[:500] if len(notes) > 500 else notes
+
+            # Create checkout session
+            session = stripe.checkout.Session.create(
+                payment_method_types=['card'],
+                line_items=[{
+                    'price_data': {
+                        'currency': 'usd',
+                        'product_data': {
+                            'name': DONE_FOR_YOU_PACKAGE['name'],
+                            'description': f"{artist} - {title}",
+                        },
+                        'unit_amount': DONE_FOR_YOU_PACKAGE['price_cents'],
+                    },
+                    'quantity': 1,
+                }],
+                mode='payment',
+                success_url=success_url,
+                cancel_url=cancel_url,
+                customer_email=customer_email,
+                metadata=metadata,
+                allow_promotion_codes=True,
+            )
+
+            logger.info(
+                f"Created done-for-you checkout session {session.id} for {customer_email}, "
+                f"song: {artist} - {title}"
+            )
+            return True, session.url, "Checkout session created"
+
+        except stripe.error.StripeError as e:
+            logger.error(f"Stripe error creating done-for-you checkout session: {e}")
+            return False, None, f"Payment error: {str(e)}"
+        except Exception as e:
+            logger.error(f"Error creating done-for-you checkout session: {e}")
+            return False, None, "Failed to create checkout session"
+
+    def verify_webhook_signature(self, payload: bytes, signature: str) -> Tuple[bool, Optional[Dict], str]:
+        """
+        Verify a Stripe webhook signature.
+
+        Args:
+            payload: Raw request body
+            signature: Stripe-Signature header value
+
+        Returns:
+            (valid, event_data, message)
+        """
+        if not self.webhook_secret:
+            logger.error("STRIPE_WEBHOOK_SECRET not configured")
+            return False, None, "Webhook secret not configured"
+
+        try:
+            event = stripe.Webhook.construct_event(
+                payload, signature, self.webhook_secret
+            )
+            return True, event, "Webhook verified"
+        except stripe.error.SignatureVerificationError as e:
+            logger.error(f"Invalid webhook signature: {e}")
+            return False, None, "Invalid signature"
+        except Exception as e:
+            logger.error(f"Error verifying webhook: {e}")
+            return False, None, str(e)
+
+    def handle_checkout_completed(self, session: Dict) -> Tuple[bool, Optional[str], int, str]:
+        """
+        Handle a completed checkout session.
+
+        Args:
+            session: Stripe checkout session object
+
+        Returns:
+            (success, user_email, credits_to_add, message)
+        """
+        try:
+            metadata = session.get('metadata', {})
+            user_email = metadata.get('user_email') or session.get('customer_email')
+            try:
+                credits = int(metadata.get('credits', 0))
+            except (ValueError, TypeError):
+                logger.error(f"Invalid credits metadata in session {session.get('id')}: {metadata.get('credits')}")
+                return False, user_email, 0, "Invalid credit amount in session metadata"
+            package_id = metadata.get('package_id')
+
+            if not user_email:
+                logger.error(f"No user email in checkout session {session.get('id')}")
+                return False, None, 0, "No user email found"
+
+            if credits <= 0:
+                logger.error(f"Invalid credits in checkout session {session.get('id')}")
+                return False, user_email, 0, "Invalid credit amount"
+
+            logger.info(
+                f"Checkout completed: {user_email} purchased {credits} credits "
+                f"(package: {package_id}, session: {session.get('id')})"
+            )
+
+            return True, user_email, credits, f"Successfully purchased {credits} credits"
+
+        except Exception as e:
+            logger.error(f"Error handling checkout completed: {e}")
+            return False, None, 0, str(e)
+
+    def get_session(self, session_id: str) -> Optional[Dict]:
+        """
+        Get a checkout session by ID.
+
+        Args:
+            session_id: Stripe checkout session ID
+
+        Returns:
+            Session data or None
+        """
+        if not self.is_configured():
+            return None
+
+        try:
+            session = stripe.checkout.Session.retrieve(session_id)
+            return dict(session)
+        except Exception as e:
+            logger.error(f"Error retrieving session {session_id}: {e}")
+            return None
+
+    def create_customer(self, email: str, name: Optional[str] = None) -> Optional[str]:
+        """
+        Create or get a Stripe customer for a user.
+
+        Args:
+            email: User's email
+            name: User's display name (optional)
+
+        Returns:
+            Stripe customer ID or None
+        """
+        if not self.is_configured():
+            return None
+
+        try:
+            # Check if customer already exists
+            customers = stripe.Customer.list(email=email, limit=1)
+            if customers.data:
+                return customers.data[0].id
+
+            # Create new customer
+            customer = stripe.Customer.create(
+                email=email,
+                name=name,
+                metadata={'source': 'nomad_karaoke'},
+            )
+            logger.info(f"Created Stripe customer {customer.id} for {email}")
+            return customer.id
+
+        except Exception as e:
+            logger.error(f"Error creating Stripe customer: {e}")
+            return None
+
+
+# Global instance
+_stripe_service = None
+
+
+def get_stripe_service() -> StripeService:
+    """Get the global Stripe service instance."""
+    global _stripe_service
+    if _stripe_service is None:
+        _stripe_service = StripeService()
+    return _stripe_service

backend/services/structured_logging.py

@@ -0,0 +1,254 @@
+"""
+Structured logging with trace correlation for Cloud Logging.
+
+This module provides JSON-formatted logging that integrates with Google Cloud Logging
+and correlates logs with OpenTelemetry traces in Cloud Trace.
+
+When running in Cloud Run:
+- Logs are output as JSON for Cloud Logging to parse
+- Each log entry includes trace ID and span ID for correlation
+- Custom fields (job_id, worker) are preserved in the log structure
+
+Usage:
+    # In main.py, before any logging:
+    from backend.services.structured_logging import setup_structured_logging
+    setup_structured_logging()
+    
+    # Then use standard logging:
+    logger = logging.getLogger(__name__)
+    logger.info("Processing started", extra={"job_id": "abc123"})
+"""
+import json
+import logging
+import os
+import sys
+from datetime import datetime
+from typing import Any, Dict, Optional
+
+
+# Cloud Logging severity mapping (compatible with GCP)
+# https://cloud.google.com/logging/docs/reference/v2/rest/v2/LogEntry#LogSeverity
+SEVERITY_MAP = {
+    "DEBUG": "DEBUG",
+    "INFO": "INFO",
+    "WARNING": "WARNING",
+    "ERROR": "ERROR",
+    "CRITICAL": "CRITICAL",
+}
+
+
+class StructuredFormatter(logging.Formatter):
+    """
+    JSON formatter with trace correlation for Google Cloud Logging.
+    
+    Produces log entries in the format expected by Cloud Logging, including:
+    - logging.googleapis.com/trace: Links to Cloud Trace
+    - logging.googleapis.com/spanId: Current span ID
+    - severity: Cloud Logging severity level
+    - Custom fields passed via 'extra' dict
+    """
+    
+    def __init__(self, project_id: Optional[str] = None):
+        """
+        Initialize the structured formatter.
+        
+        Args:
+            project_id: GCP project ID for trace URLs (auto-detected if not provided)
+        """
+        super().__init__()
+        self.project_id = project_id or os.environ.get("GOOGLE_CLOUD_PROJECT") or os.environ.get("GCP_PROJECT")
+    
+    def format(self, record: logging.LogRecord) -> str:
+        """
+        Format a log record as JSON.
+        
+        Args:
+            record: The log record to format
+            
+        Returns:
+            JSON string for Cloud Logging
+        """
+        from backend.services.tracing import get_current_trace_id, get_current_span_id
+        
+        # Build base log entry
+        log_entry: Dict[str, Any] = {
+            "timestamp": datetime.utcfromtimestamp(record.created).isoformat() + "Z",
+            "severity": SEVERITY_MAP.get(record.levelname, record.levelname),
+            "message": record.getMessage(),
+            "logger": record.name,
+        }
+        
+        # Add trace correlation if available
+        trace_id = get_current_trace_id()
+        span_id = get_current_span_id()
+        
+        if trace_id and self.project_id:
+            # Format for Cloud Logging trace correlation
+            log_entry["logging.googleapis.com/trace"] = f"projects/{self.project_id}/traces/{trace_id}"
+        
+        if span_id:
+            log_entry["logging.googleapis.com/spanId"] = span_id
+        
+        # Add custom fields from 'extra' dict
+        # Common fields we want to extract from log records
+        custom_fields = [
+            # Job-related fields
+            "job_id", "worker", "operation", "duration", "status", "error",
+            # Audit logging fields (from middleware and auth)
+            "request_id", "user_email", "client_ip", "latency_ms",
+            "audit_type", "method", "path", "status_code", "query_string",
+            "user_agent", "user_type", "is_admin", "remaining_uses",
+            "auth_message", "token_provided", "token_length", "auth_header_present",
+        ]
+        for field in custom_fields:
+            value = getattr(record, field, None)
+            if value is not None:
+                log_entry[field] = value
+        
+        # Add source location for debugging
+        if record.pathname and record.lineno:
+            log_entry["logging.googleapis.com/sourceLocation"] = {
+                "file": record.pathname,
+                "line": record.lineno,
+                "function": record.funcName,
+            }
+        
+        # Add exception info if present
+        if record.exc_info:
+            log_entry["exception"] = self.formatException(record.exc_info)
+        
+        # Remove None values for cleaner output
+        return json.dumps({k: v for k, v in log_entry.items() if v is not None})
+
+
+class HumanReadableFormatter(logging.Formatter):
+    """
+    Human-readable formatter for local development.
+    
+    Includes trace context when available but outputs in traditional format.
+    """
+    
+    def format(self, record: logging.LogRecord) -> str:
+        """Format a log record for human readability."""
+        from backend.services.tracing import get_current_trace_id
+        
+        # Build base message
+        timestamp = datetime.utcfromtimestamp(record.created).strftime("%Y-%m-%d %H:%M:%S")
+        
+        # Add job_id prefix if available
+        job_id = getattr(record, "job_id", None)
+        job_prefix = f"[job:{job_id[:8]}] " if job_id else ""
+        
+        # Add trace ID suffix if available
+        trace_id = get_current_trace_id()
+        trace_suffix = f" [trace:{trace_id[:8]}]" if trace_id else ""
+        
+        message = f"{timestamp} - {record.name} - {record.levelname} - {job_prefix}{record.getMessage()}{trace_suffix}"
+        
+        # Add exception info if present
+        if record.exc_info:
+            message += "\n" + self.formatException(record.exc_info)
+        
+        return message
+
+
+def is_cloud_run() -> bool:
+    """Check if we're running in Cloud Run."""
+    return os.environ.get("K_SERVICE") is not None
+
+
+def setup_structured_logging(force_json: bool = False, log_level: Optional[str] = None) -> None:
+    """
+    Configure structured logging for the application.
+    
+    In Cloud Run: Uses JSON format with trace correlation for Cloud Logging
+    In development: Uses human-readable format with optional trace context
+    
+    Args:
+        force_json: Force JSON output even in development
+        log_level: Override log level (default from settings or INFO)
+    """
+    from backend.config import settings
+    
+    # Determine log level
+    level = log_level or getattr(settings, "log_level", "INFO")
+    level = getattr(logging, level.upper(), logging.INFO)
+    
+    # Choose formatter based on environment
+    if is_cloud_run() or force_json:
+        formatter = StructuredFormatter()
+    else:
+        formatter = HumanReadableFormatter()
+    
+    # Create handler
+    handler = logging.StreamHandler(sys.stdout)
+    handler.setFormatter(formatter)
+    handler.setLevel(level)
+    
+    # Configure root logger
+    root_logger = logging.getLogger()
+    root_logger.setLevel(level)
+    
+    # Remove existing handlers and add our handler
+    root_logger.handlers = [handler]
+    
+    # Also configure uvicorn loggers to use our format
+    for logger_name in ["uvicorn", "uvicorn.access", "uvicorn.error"]:
+        logger = logging.getLogger(logger_name)
+        logger.handlers = [handler]
+        logger.propagate = False
+
+
+class JobLogAdapter(logging.LoggerAdapter):
+    """
+    Logger adapter that automatically adds job context to log records.
+    
+    Usage:
+        logger = logging.getLogger(__name__)
+        job_logger = JobLogAdapter(logger, job_id="abc123", worker="audio")
+        job_logger.info("Processing started")  # Automatically includes job_id and worker
+    """
+    
+    def __init__(self, logger: logging.Logger, job_id: str, worker: Optional[str] = None, **extra):
+        """
+        Initialize the adapter.
+        
+        Args:
+            logger: Base logger instance
+            job_id: Job ID to include in all log records
+            worker: Optional worker name
+            **extra: Additional fields to include in all log records
+        """
+        super().__init__(logger, {"job_id": job_id, "worker": worker, **extra})
+    
+    def process(self, msg: str, kwargs: Dict[str, Any]) -> tuple:
+        """Process a logging call to add extra context."""
+        # Merge extra dict from adapter with any extra passed to the log call
+        extra = kwargs.get("extra", {})
+        extra.update(self.extra)
+        kwargs["extra"] = extra
+        return msg, kwargs
+
+
+def get_job_logger(job_id: str, worker: Optional[str] = None, name: Optional[str] = None) -> JobLogAdapter:
+    """
+    Get a logger adapter configured for a specific job.
+    
+    This is a convenience function for creating job-specific loggers.
+    
+    Args:
+        job_id: Job ID to include in all log records
+        worker: Optional worker name
+        name: Logger name (defaults to "job")
+        
+    Returns:
+        JobLogAdapter configured for the job
+        
+    Usage:
+        logger = get_job_logger("abc123", "audio")
+        logger.info("Starting audio separation")
+        logger.error("Failed to process", extra={"error": str(e)})
+    """
+    base_logger = logging.getLogger(name or "job")
+    return JobLogAdapter(base_logger, job_id=job_id, worker=worker)
+