django-cfg 1.2.31__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.
-"""
-
-from django_cfg.modules.django_logger import get_logger
-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 = get_logger("provider_health")
-
-
-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/__init__.py

@@ -1,4 +0,0 @@
-from .provider import CryptAPIProvider
-from .models import CryptAPIConfig, CryptAPICurrency, CryptAPINetwork
-
-__all__ = ['CryptAPIProvider', 'CryptAPIConfig', 'CryptAPICurrency', 'CryptAPINetwork']

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

@@ -1,8 +0,0 @@
-
-
-PUBLIC_KEY = """-----BEGIN PUBLIC KEY-----
-MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQC3FT0Ym8b3myVxhQW7ESuuu6lo
-dGAsUJs4fq+Ey//jm27jQ7HHHDmP1YJO7XE7Jf/0DTEJgcw4EZhJFVwsk6d3+4fy
-Bsn0tKeyGMiaE6cVkX0cy6Y85o8zgc/CwZKc0uw6d5siAo++xl2zl+RGMXCELQVE
-ox7pp208zTvown577wIDAQAB
------END PUBLIC KEY-----"""

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

@@ -1,192 +0,0 @@
-from pydantic import BaseModel, Field, ConfigDict, field_validator
-from typing import Optional, List, Dict, Any
-from decimal import Decimal
-
-from ...internal_types import ProviderConfig
-from .config import PUBLIC_KEY
-
-class CryptAPIConfig(ProviderConfig):
-    """CryptAPI provider configuration with Pydantic v2."""
-    
-    own_address: str = Field(..., description="Your cryptocurrency address")
-    callback_url: Optional[str] = Field(default=None, 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")
-    verify_signatures: bool = Field(default=True, description="Enable webhook signature verification")
-    
-    # CryptAPI's official public key for signature verification
-    public_key: str = Field(
-        default=PUBLIC_KEY,
-        description="CryptAPI RSA public key for signature verification"
-    )
-
-
-class CryptAPICurrency(BaseModel):
-    """CryptAPI specific currency model."""
-    model_config = ConfigDict(validate_assignment=True, extra="forbid")
-    
-    currency_code: str = Field(..., description="Currency symbol (e.g., BTC, ETH)")
-    name: str = Field(..., description="Full currency name")
-    minimum_transaction: Optional[Decimal] = Field(None, description="Minimum transaction amount")
-    maximum_transaction: Optional[Decimal] = Field(None, description="Maximum transaction amount")
-    fee_percent: Optional[Decimal] = Field(None, description="Fee percentage")
-    logo: Optional[str] = Field(None, description="Currency logo URL")
-
-
-class CryptAPINetwork(BaseModel):
-    """CryptAPI specific network model."""
-    model_config = ConfigDict(validate_assignment=True, extra="forbid")
-    
-    currency: str = Field(..., description="Currency code this network belongs to")
-    network: str = Field(..., description="Network code (e.g., mainnet, testnet)")
-    name: str = Field(..., description="Network display name")
-    confirmations: int = Field(1, description="Required confirmations")
-    fee: Optional[Decimal] = Field(None, description="Network fee")
-
-
-class CryptAPIPaymentRequest(BaseModel):
-    """CryptAPI payment creation request."""
-    ticker: str = Field(..., description="Currency ticker")
-    callback: str = Field(..., description="Callback URL")
-    address: Optional[str] = Field(None, description="Destination address")
-    pending: bool = Field(False, description="Accept pending transactions")
-    confirmations: int = Field(1, description="Required confirmations")
-    email: Optional[str] = Field(None, description="Email for notifications")
-    post: int = Field(0, description="POST data format")
-    json: int = Field(1, description="JSON response format")
-    priority: Optional[str] = Field(None, description="Priority level")
-    multi_token: bool = Field(False, description="Multi-token support")
-    convert: int = Field(1, description="Convert amounts")
-
-
-class CryptAPIPaymentResponse(BaseModel):
-    """CryptAPI payment creation response."""
-    address_in: str = Field(..., description="Payment address")
-    address_out: Optional[str] = Field(None, description="Destination address")
-    callback_url: str = Field(..., description="Callback URL")
-    priority: Optional[str] = Field(None, description="Priority level")
-    minimum: Optional[Decimal] = Field(None, description="Minimum amount")
-
-
-class CryptAPICallback(BaseModel):
-    """CryptAPI webhook callback data according to official documentation."""
-    model_config = ConfigDict(validate_assignment=True, extra="allow")  # Allow extra fields for custom params
-    
-    # Required fields from documentation
-    uuid: Optional[str] = Field(None, description="Unique identifier for each payment transaction")
-    address_in: str = Field(..., description="CryptAPI-generated payment address")
-    address_out: str = Field(..., description="Your destination address(es)")
-    txid_in: str = Field(..., description="Transaction hash of customer's payment")
-    coin: str = Field(..., description="Cryptocurrency ticker")
-    price: Optional[Decimal] = Field(None, description="Cryptocurrency price in USD")
-    pending: Optional[int] = Field(0, description="1=pending webhook, 0=confirmed webhook")
-    
-    # Confirmed webhook only fields
-    txid_out: Optional[str] = Field(None, description="CryptAPI's forwarding transaction hash")
-    confirmations: Optional[int] = Field(None, description="Number of blockchain confirmations")
-    value_coin: Optional[Decimal] = Field(None, description="Payment amount before fees")
-    value_forwarded_coin: Optional[Decimal] = Field(None, description="Amount forwarded after fees")
-    fee_coin: Optional[Decimal] = Field(None, description="CryptAPI service fee")
-    
-    # Optional conversion fields (when convert=1)
-    value_coin_convert: Optional[str] = Field(None, description="JSON FIAT conversions of value_coin")
-    value_forwarded_coin_convert: Optional[str] = Field(None, description="JSON FIAT conversions of value_forwarded_coin")
-    
-    @field_validator('pending')
-    @classmethod
-    def validate_pending(cls, v):
-        """Validate pending field is 0 or 1."""
-        if v not in [0, 1]:
-            raise ValueError("pending must be 0 (confirmed) or 1 (pending)")
-        return v
-    
-
-
-class CryptAPIInfoResponse(BaseModel):
-    """CryptAPI info endpoint response."""
-    ticker: str = Field(..., description="Currency ticker")
-    minimum_transaction: Decimal = Field(..., description="Minimum transaction amount")
-    maximum_transaction: Optional[Decimal] = Field(None, description="Maximum transaction amount")
-    fee_percent: Decimal = Field(..., description="Fee percentage")
-    network_fee: Decimal = Field(..., description="Network fee")
-    prices: Dict[str, Decimal] = Field(..., description="Price conversions")
-
-
-class CryptAPIEstimateFeeResponse(BaseModel):
-    """CryptAPI fee estimation response."""
-    estimated_cost: Decimal = Field(..., description="Estimated cost")
-    estimated_cost_currency: Dict[str, Decimal] = Field(..., description="Cost in different currencies")
-
-
-class CryptAPIConvertResponse(BaseModel):
-    """CryptAPI currency conversion response."""
-    value_coin: Decimal = Field(..., description="Value in cryptocurrency")
-    exchange_rate: Decimal = Field(..., description="Exchange rate used")
-
-
-class CryptAPIQRCodeResponse(BaseModel):
-    """CryptAPI QR code response."""
-    qr_code: str = Field(..., description="Base64 encoded QR code image")
-    payment_uri: str = Field(..., description="Payment URI for QR code")
-
-
-class CryptAPILogsResponse(BaseModel):
-    """CryptAPI logs response."""
-    callbacks: List[Dict[str, Any]] = Field(default_factory=list, description="Callback logs")
-    payments: List[Dict[str, Any]] = Field(default_factory=list, description="Payment logs")
-
-
-class CryptAPISupportedCoinsResponse(BaseModel):
-    """CryptAPI supported coins response."""
-    model_config = ConfigDict(validate_assignment=True, extra="forbid")
-    
-    currencies: List[CryptAPICurrency] = Field(..., description="List of supported currencies")
-
-
-# =============================================================================
-# MONITORING & HEALTH CHECK MODELS
-# =============================================================================
-
-class CryptAPIInfoResponse(BaseModel):
-    """CryptAPI /btc/info/ response schema for health checks."""
-    model_config = ConfigDict(validate_assignment=True, extra="forbid")
-    
-    coin: str = Field(..., description="Cryptocurrency name")
-    logo: str = Field(..., description="Logo URL")
-    ticker: str = Field(..., description="Currency ticker")
-    minimum_transaction: int = Field(..., description="Minimum transaction in satoshis")
-    minimum_transaction_coin: str = Field(..., description="Minimum transaction in coin units")
-    minimum_fee: int = Field(..., description="Minimum fee in satoshis")
-    minimum_fee_coin: str = Field(..., description="Minimum fee in coin units")
-    fee_percent: str = Field(..., description="Fee percentage")
-    network_fee_estimation: str = Field(..., description="Network fee estimation")
-    status: str = Field(..., description="API status")
-    prices: Dict[str, str] = Field(..., description="Prices in various fiat currencies")
-    prices_updated: str = Field(..., description="Prices last updated timestamp")
-    
-    @field_validator('status')
-    @classmethod
-    def validate_status(cls, v):
-        """Validate that status is success."""
-        if v != 'success':
-            raise ValueError(f"Expected status 'success', got '{v}'")
-        return v
-    
-    @field_validator('prices')
-    @classmethod
-    def validate_prices_not_empty(cls, v):
-        """Validate that prices dict is not empty."""
-        if not v:
-            raise ValueError("Prices dictionary cannot be empty")
-        return v
-    
-    def get_usd_price(self) -> Optional[Decimal]:
-        """Get USD price as Decimal."""
-        usd_price = self.prices.get('USD')
-        if usd_price:
-            try:
-                return Decimal(usd_price)
-            except:
-                return None
-        return None