django-cfg 1.2.29__py3-none-any.whl → 1.3.1__py3-none-any.whl

django_cfg/apps/payments/services/monitoring/provider_health.py

@@ -1,372 +0,0 @@
-"""
-Provider Health Monitoring System.
-
-Monitors the health of all payment providers and provides
-fallback mechanisms when providers are unavailable.
-"""
-
-import logging
-import time
-import asyncio
-import requests
-from typing import Dict, List, Optional, Any
-from datetime import datetime, timedelta
-from dataclasses import dataclass
-from enum import Enum
-
-from django.utils import timezone
-from django.core.cache import cache
-from pydantic import BaseModel, Field
-
-from ..providers.registry import ProviderRegistry
-from ...models.events import PaymentEvent
-from .api_schemas import parse_provider_response
-
-logger = logging.getLogger(__name__)
-
-
-class HealthStatus(Enum):
-    """Provider health status levels."""
-    HEALTHY = "healthy"
-    DEGRADED = "degraded" 
-    UNHEALTHY = "unhealthy"
-    UNKNOWN = "unknown"
-
-
-class ProviderHealthCheck(BaseModel):
-    """Provider health check result."""
-    provider_name: str = Field(..., description="Provider name")
-    status: HealthStatus = Field(..., description="Health status")
-    response_time_ms: float = Field(..., description="Response time in milliseconds")
-    status_code: Optional[int] = Field(None, description="HTTP status code")
-    error_message: Optional[str] = Field(None, description="Error message if unhealthy")
-    checked_at: datetime = Field(default_factory=timezone.now, description="Check timestamp")
-    metadata: Dict[str, Any] = Field(default_factory=dict, description="Additional metadata")
-
-
-class ProviderHealthSummary(BaseModel):
-    """Summary of all provider health statuses."""
-    total_providers: int = Field(..., description="Total number of providers")
-    healthy_count: int = Field(..., description="Number of healthy providers")
-    degraded_count: int = Field(..., description="Number of degraded providers")
-    unhealthy_count: int = Field(..., description="Number of unhealthy providers")
-    providers: List[ProviderHealthCheck] = Field(..., description="Individual provider health checks")
-    last_updated: datetime = Field(default_factory=timezone.now, description="Last update timestamp")
-
-
-class ProviderHealthMonitor:
-    """
-    Monitor the health of all payment providers.
-    
-    Features:
-    - Real-time health checks
-    - Provider availability tracking
-    - Automatic fallback recommendations
-    - Health history and trends
-    - Alert system integration
-    """
-    
-    def __init__(self):
-        """Initialize health monitor."""
-        self.provider_registry = ProviderRegistry()
-        self.cache_timeout = 300  # 5 minutes
-        self.health_check_timeout = 10  # 10 seconds
-        
-        # Health check endpoints for each provider
-        self.health_endpoints = {
-            'cryptapi': 'https://api.cryptapi.io/btc/info/',
-            'cryptomus': 'https://api.cryptomus.com',  # Base URL check (returns 204 No Content = healthy)
-            'nowpayments': 'https://api.nowpayments.io/v1/status',
-            'stripe': 'https://api.stripe.com/v1/account'  # Will return auth error = healthy
-        }
-    
-    def check_all_providers(self) -> ProviderHealthSummary:
-        """
-        Check health of all registered providers.
-        
-        Returns:
-            ProviderHealthSummary with all provider statuses
-        """
-        providers = self.provider_registry.get_all_providers()
-        health_checks = []
-        
-        for provider_name, provider_instance in providers.items():
-            try:
-                health_check = self.check_provider_health(provider_name)
-                health_checks.append(health_check)
-            except Exception as e:
-                logger.error(f"Failed to check health for {provider_name}: {e}")
-                health_checks.append(ProviderHealthCheck(
-                    provider_name=provider_name,
-                    status=HealthStatus.UNKNOWN,
-                    response_time_ms=0.0,
-                    error_message=str(e)
-                ))
-        
-        # Calculate summary
-        healthy_count = sum(1 for check in health_checks if check.status == HealthStatus.HEALTHY)
-        degraded_count = sum(1 for check in health_checks if check.status == HealthStatus.DEGRADED)
-        unhealthy_count = sum(1 for check in health_checks if check.status == HealthStatus.UNHEALTHY)
-        
-        summary = ProviderHealthSummary(
-            total_providers=len(health_checks),
-            healthy_count=healthy_count,
-            degraded_count=degraded_count,
-            unhealthy_count=unhealthy_count,
-            providers=health_checks
-        )
-        
-        # Cache summary
-        cache.set('provider_health_summary', summary.dict(), self.cache_timeout)
-        
-        # Log health summary
-        logger.info(f"Provider health check completed: {healthy_count}/{len(health_checks)} healthy")
-        
-        return summary
-    
-    def check_provider_health(self, provider_name: str) -> ProviderHealthCheck:
-        """
-        Check health of a specific provider.
-        
-        Args:
-            provider_name: Name of the provider to check
-            
-        Returns:
-            ProviderHealthCheck with health status
-        """
-        # Check cache first
-        cache_key = f'provider_health_{provider_name}'
-        cached_result = cache.get(cache_key)
-        if cached_result:
-            return ProviderHealthCheck(**cached_result)
-        
-        start_time = time.time()
-        health_check = None
-        
-        try:
-            # Get health endpoint for provider
-            endpoint = self.health_endpoints.get(provider_name)
-            if not endpoint:
-                raise ValueError(f"No health endpoint configured for {provider_name}")
-            
-            # Make health check request
-            response = requests.get(
-                endpoint,
-                timeout=self.health_check_timeout,
-                headers={'User-Agent': 'DjangoCFG-PaymentMonitor/1.0'}
-            )
-            
-            response_time = (time.time() - start_time) * 1000
-            
-            # Parse response using Pydantic schemas
-            response_body = response.text if response.text else ""
-            parsed_health = parse_provider_response(
-                provider_name=provider_name,
-                status_code=response.status_code,
-                response_body=response_body,
-                response_time_ms=response_time
-            )
-            
-            # Convert to our HealthStatus enum
-            if parsed_health.is_healthy:
-                status = HealthStatus.HEALTHY
-            elif 400 <= response.status_code < 500:
-                status = HealthStatus.DEGRADED
-            else:
-                status = HealthStatus.UNHEALTHY
-            
-            health_check = ProviderHealthCheck(
-                provider_name=provider_name,
-                status=status,
-                response_time_ms=round(response_time, 2),
-                status_code=response.status_code,
-                error_message=parsed_health.error_message,
-                metadata={
-                    'endpoint': endpoint,
-                    'response_size': len(response.content) if response.content else 0,
-                    'parsed_response': parsed_health.parsed_response,
-                    'pydantic_validated': True
-                }
-            )
-            
-        except requests.exceptions.Timeout:
-            response_time = (time.time() - start_time) * 1000
-            health_check = ProviderHealthCheck(
-                provider_name=provider_name,
-                status=HealthStatus.UNHEALTHY,
-                response_time_ms=round(response_time, 2),
-                error_message="Request timeout"
-            )
-            
-        except requests.exceptions.ConnectionError:
-            response_time = (time.time() - start_time) * 1000
-            health_check = ProviderHealthCheck(
-                provider_name=provider_name,
-                status=HealthStatus.UNHEALTHY,
-                response_time_ms=round(response_time, 2),
-                error_message="Connection error"
-            )
-            
-        except Exception as e:
-            response_time = (time.time() - start_time) * 1000
-            health_check = ProviderHealthCheck(
-                provider_name=provider_name,
-                status=HealthStatus.UNKNOWN,
-                response_time_ms=round(response_time, 2),
-                error_message=str(e)
-            )
-        
-        # Cache result
-        cache.set(cache_key, health_check.dict(), self.cache_timeout // 2)  # Shorter cache for individual checks
-        
-        # Log health check
-        logger.info(f"Health check for {provider_name}: {health_check.status.value} ({health_check.response_time_ms}ms)")
-        
-        return health_check
-    
-    def get_healthy_providers(self) -> List[str]:
-        """
-        Get list of currently healthy provider names.
-        
-        Returns:
-            List of healthy provider names
-        """
-        summary = self.check_all_providers()
-        return [
-            provider.provider_name 
-            for provider in summary.providers 
-            if provider.status == HealthStatus.HEALTHY
-        ]
-    
-    def get_fallback_provider(self, preferred_provider: str) -> Optional[str]:
-        """
-        Get fallback provider when preferred provider is unhealthy.
-        
-        Args:
-            preferred_provider: Name of preferred provider
-            
-        Returns:
-            Name of healthy fallback provider or None
-        """
-        healthy_providers = self.get_healthy_providers()
-        
-        # Remove preferred provider from list
-        fallback_providers = [p for p in healthy_providers if p != preferred_provider]
-        
-        if not fallback_providers:
-            logger.warning(f"No healthy fallback providers available for {preferred_provider}")
-            return None
-        
-        # Return first healthy provider as fallback
-        fallback = fallback_providers[0]
-        logger.info(f"Fallback provider for {preferred_provider}: {fallback}")
-        
-        return fallback
-    
-    def record_provider_incident(self, provider_name: str, incident_type: str, details: Dict[str, Any]):
-        """
-        Record provider incident for tracking.
-        
-        Args:
-            provider_name: Name of the provider
-            incident_type: Type of incident (outage, degradation, etc.)
-            details: Incident details
-        """
-        try:
-            PaymentEvent.objects.create(
-                payment_id=f"health_monitor_{timezone.now().timestamp()}",
-                event_type='provider_incident',
-                sequence_number=1,
-                event_data={
-                    'provider_name': provider_name,
-                    'incident_type': incident_type,
-                    'details': details,
-                    'timestamp': timezone.now().isoformat()
-                },
-                processed_by='health_monitor',
-                idempotency_key=f"incident_{provider_name}_{timezone.now().timestamp()}"
-            )
-            
-            logger.warning(f"Provider incident recorded: {provider_name} - {incident_type}")
-            
-        except Exception as e:
-            logger.error(f"Failed to record provider incident: {e}")
-    
-    def get_provider_uptime(self, provider_name: str, days: int = 7) -> float:
-        """
-        Calculate provider uptime percentage over specified period.
-        
-        Args:
-            provider_name: Name of the provider
-            days: Number of days to calculate uptime for
-            
-        Returns:
-            Uptime percentage (0.0 to 100.0)
-        """
-        try:
-            # Get provider incidents from last N days
-            since_date = timezone.now() - timedelta(days=days)
-            
-            incidents = PaymentEvent.objects.filter(
-                event_type='provider_incident',
-                event_data__provider_name=provider_name,
-                created_at__gte=since_date
-            ).count()
-            
-            # Simple uptime calculation (this could be more sophisticated)
-            total_checks = days * 24 * 12  # Assume checks every 5 minutes
-            uptime_percentage = max(0.0, ((total_checks - incidents) / total_checks) * 100.0)
-            
-            return round(uptime_percentage, 2)
-            
-        except Exception as e:
-            logger.error(f"Failed to calculate uptime for {provider_name}: {e}")
-            return 0.0
-    
-    def generate_health_report(self) -> Dict[str, Any]:
-        """
-        Generate comprehensive health report.
-        
-        Returns:
-            Dict with health report data
-        """
-        summary = self.check_all_providers()
-        
-        report = {
-            'summary': summary.dict(),
-            'uptime_stats': {},
-            'recommendations': [],
-            'generated_at': timezone.now().isoformat()
-        }
-        
-        # Calculate uptime for each provider
-        for provider in summary.providers:
-            uptime = self.get_provider_uptime(provider.provider_name)
-            report['uptime_stats'][provider.provider_name] = uptime
-        
-        # Generate recommendations
-        if summary.unhealthy_count > 0:
-            unhealthy_providers = [p.provider_name for p in summary.providers if p.status == HealthStatus.UNHEALTHY]
-            report['recommendations'].append({
-                'type': 'critical',
-                'message': f"Unhealthy providers detected: {', '.join(unhealthy_providers)}",
-                'action': 'Check provider API status and credentials'
-            })
-        
-        if summary.healthy_count < 2:
-            report['recommendations'].append({
-                'type': 'warning',
-                'message': 'Low number of healthy providers',
-                'action': 'Consider adding additional payment provider integrations'
-            })
-        
-        return report
-
-
-# Global health monitor instance
-health_monitor = ProviderHealthMonitor()
-
-
-def get_health_monitor() -> ProviderHealthMonitor:
-    """Get global health monitor instance."""
-    return health_monitor

django_cfg/apps/payments/services/providers/cryptapi.py

@@ -1,273 +0,0 @@
-"""
-CryptAPI provider implementation.
-
-Crypto payment provider using CryptAPI service.
-"""
-
-import logging
-import requests
-import secrets
-import string
-from typing import Optional, List
-from decimal import Decimal
-from pydantic import BaseModel, Field
-
-from .base import PaymentProvider
-from ..internal_types import ProviderResponse, WebhookData
-
-logger = logging.getLogger(__name__)
-
-
-class CryptAPIConfig(BaseModel):
-    """CryptAPI provider configuration."""
-    own_address: str = Field(..., description="Your cryptocurrency address")
-    callback_url: str = Field(..., description="Webhook callback URL")
-    convert_payments: bool = Field(default=True, description="Auto-convert payments")
-    multi_token: bool = Field(default=True, description="Support multi-token payments")
-    priority: str = Field(default='default', description="Transaction priority")
-    enabled: bool = Field(default=True, description="Provider enabled")
-
-
-class CryptAPIException(Exception):
-    """CryptAPI specific exception."""
-    pass
-
-
-class CryptAPIProvider(PaymentProvider):
-    """CryptAPI cryptocurrency payment provider."""
-    
-    CRYPTAPI_URL = 'https://api.cryptapi.io/'
-    
-    def __init__(self, config: CryptAPIConfig):
-        """Initialize CryptAPI provider."""
-        super().__init__(config.dict())
-        self.config = config
-        self.own_address = config.own_address
-        self.callback_url = config.callback_url
-        self.convert_payments = config.convert_payments
-        self.multi_token = config.multi_token
-        self.priority = config.priority
-    
-    def _make_request(self, coin: str, endpoint: str, params: Optional[dict] = None) -> Optional[dict]:
-        """Make HTTP request to CryptAPI."""
-        try:
-            if coin:
-                coin = coin.replace('/', '_')
-                url = f"{self.CRYPTAPI_URL}{coin}/{endpoint}/"
-            else:
-                url = f"{self.CRYPTAPI_URL}{endpoint}/"
-            
-            response = requests.get(url, params=params or {}, timeout=30)
-            response.raise_for_status()
-            
-            result = response.json()
-            
-            # Check for API errors
-            if 'error' in result:
-                logger.error(f"CryptAPI error: {result['error']}")
-                return None
-            
-            return result
-            
-        except requests.exceptions.RequestException as e:
-            logger.error(f"CryptAPI request failed: {e}")
-            return None
-        except Exception as e:
-            logger.error(f"Unexpected CryptAPI error: {e}")
-            return None
-    
-    def create_payment(self, payment_data: dict) -> ProviderResponse:
-        """Create payment address via CryptAPI."""
-        try:
-            amount = Decimal(str(payment_data['amount']))
-            currency = payment_data['currency'].lower()
-            order_id = payment_data.get('order_id', f'payment_{int(amount * 100)}')
-            
-            # Generate secure nonce for replay attack protection
-            security_nonce = self._generate_nonce()
-            
-            # Build callback URL with parameters including nonce
-            callback_params = {
-                'order_id': order_id,
-                'amount': str(amount),
-                'nonce': security_nonce
-            }
-            
-            # Create payment address
-            params = {
-                'address': self.own_address,
-                'callback': self.callback_url,
-                'convert': 1 if self.convert_payments else 0,
-                'multi_token': 1 if self.multi_token else 0,
-                'priority': self.priority,
-                **callback_params
-            }
-            
-            response = self._make_request(currency, 'create', params)
-            
-            if response and 'address_in' in response:
-                return ProviderResponse(
-                    success=True,
-                    provider_payment_id=response['address_in'],  # Use address as payment ID
-                    payment_url=None,  # CryptAPI doesn't provide payment URLs
-                    pay_address=response['address_in'],
-                    amount=amount,
-                    currency=currency.upper(),
-                    status='pending'
-                )
-            else:
-                return ProviderResponse(
-                    success=False,
-                    error_message='Failed to create payment address'
-                )
-                
-        except Exception as e:
-            logger.error(f"CryptAPI create_payment error: {e}")
-            return ProviderResponse(
-                success=False,
-                error_message=str(e)
-            )
-    
-    def check_payment_status(self, payment_id: str) -> ProviderResponse:
-        """Check payment status via CryptAPI."""
-        try:
-            # For CryptAPI, payment_id is the address
-            # We need to check logs to see if payment was received
-            # This is a limitation of CryptAPI - no direct status check by address
-            
-            # Return pending status as CryptAPI uses callbacks for status updates
-            return ProviderResponse(
-                success=True,
-                provider_payment_id=payment_id,
-                status='pending',
-                pay_address=payment_id,
-                amount=Decimal('0'),  # Unknown without logs
-                currency='unknown'
-            )
-            
-        except Exception as e:
-            logger.error(f"CryptAPI check_payment_status error: {e}")
-            return ProviderResponse(
-                success=False,
-                error_message=str(e)
-            )
-    
-    def process_webhook(self, payload: dict) -> WebhookData:
-        """Process CryptAPI webhook/callback."""
-        try:
-            # CryptAPI sends callbacks with these parameters:
-            # - address_in: payment address
-            # - address_out: your address  
-            # - txid_in: transaction ID
-            # - txid_out: forwarding transaction ID (if applicable)
-            # - confirmations: number of confirmations
-            # - value: amount received
-            # - value_coin: amount in coin
-            # - value_forwarded: amount forwarded
-            # - coin: cryptocurrency
-            # - pending: 0 or 1
-            
-            confirmations = int(payload.get('confirmations', 0))
-            pending = int(payload.get('pending', 1))
-            
-            # Determine status based on confirmations and pending flag
-            if pending == 1:
-                status = 'pending'
-            elif confirmations >= 1:
-                status = 'completed'
-            else:
-                status = 'processing'
-            
-            return WebhookData(
-                provider_payment_id=payload.get('address_in', ''),
-                status=status,
-                pay_amount=Decimal(str(payload.get('value_coin', 0))),
-                actually_paid=Decimal(str(payload.get('value_coin', 0))),
-                order_id=payload.get('order_id'),  # Custom parameter we sent
-                signature=payload.get('txid_in')  # Use transaction ID as signature
-            )
-            
-        except Exception as e:
-            logger.error(f"CryptAPI webhook processing error: {e}")
-            raise
-    
-    def get_supported_currencies(self) -> List[str]:
-        """Get list of supported currencies."""
-        try:
-            response = self._make_request('', 'info')
-            
-            if response and isinstance(response, dict):
-                # CryptAPI returns a dict with coin info
-                return list(response.keys())
-            else:
-                # Fallback currencies
-                return ['BTC', 'ETH', 'LTC', 'BCH', 'XMR', 'TRX']
-                
-        except Exception as e:
-            logger.error(f"Error getting supported currencies: {e}")
-            return ['BTC', 'ETH', 'LTC']  # Minimal fallback
-    
-    def get_minimum_payment_amount(self, currency_from: str, currency_to: str = 'usd') -> Optional[Decimal]:
-        """Get minimum payment amount for currency."""
-        try:
-            response = self._make_request(currency_from.lower(), 'info')
-            
-            if response and 'minimum_transaction' in response:
-                return Decimal(str(response['minimum_transaction']))
-            
-            return None
-            
-        except Exception as e:
-            logger.error(f"Error getting minimum amount: {e}")
-            return None
-    
-    def estimate_payment_amount(self, amount: Decimal, currency_code: str) -> Optional[dict]:
-        """Estimate payment amount - CryptAPI doesn't provide this."""
-        # CryptAPI doesn't have a direct estimation API
-        # Would need to use external price APIs
-        return None
-    
-    def validate_webhook(self, payload: dict, headers: Optional[dict] = None) -> bool:
-        """Validate CryptAPI webhook."""
-        try:
-            # CryptAPI doesn't use HMAC signatures
-            # Validation is done by checking if the callback came from their servers
-            # and contains expected parameters
-            
-            required_fields = ['address_in', 'address_out', 'txid_in', 'value_coin', 'coin', 'confirmations']
-            
-            for field in required_fields:
-                if field not in payload:
-                    logger.warning(f"Missing required field in CryptAPI webhook: {field}")
-                    return False
-            
-            # Basic validation passed
-            return True
-            
-        except Exception as e:
-            logger.error(f"CryptAPI webhook validation error: {e}")
-            return False
-    
-    def check_api_status(self) -> bool:
-        """Check if CryptAPI is available."""
-        try:
-            response = self._make_request('', 'info')
-            return response is not None
-        except:
-            return False
-    
-    def get_logs(self, callback_url: str) -> Optional[dict]:
-        """Get payment logs for a callback URL."""
-        try:
-            params = {'callback': callback_url}
-            # Note: This would need a specific coin, but we don't know which one
-            # This is a limitation of the current implementation
-            return None
-        except Exception as e:
-            logger.error(f"Error getting logs: {e}")
-            return None
-    
-    def _generate_nonce(self, length: int = 32) -> str:
-        """Generate cryptographically secure nonce for replay attack protection."""
-        sequence = string.ascii_letters + string.digits
-        return ''.join([secrets.choice(sequence) for _ in range(length)])