Comprehensive comparison for Database technology in Software Development applications

from cassandra.cluster import Cluster, ExecutionProfile, EXEC_PROFILE_DEFAULT
from cassandra.policies import DCAwareRoundRobinPolicy, TokenAwarePolicy
from cassandra.query import ConsistencyLevel, PreparedStatement
from cassandra.auth import PlainTextAuthProvider
import uuid
from datetime import datetime
import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

class UserActivityTracker:
    """
    Production-ready Cassandra implementation for tracking user activities
    in a software development platform (e.g., GitHub-like service).
    Demonstrates time-series data modeling and best practices.
    """
    
    def __init__(self, contact_points=['127.0.0.1'], keyspace='dev_platform'):
        # Configure connection with production settings
        auth_provider = PlainTextAuthProvider(username='cassandra', password='cassandra')
        
        profile = ExecutionProfile(
            load_balancing_policy=TokenAwarePolicy(DCAwareRoundRobinPolicy()),
            consistency_level=ConsistencyLevel.LOCAL_QUORUM,
            request_timeout=15
        )
        
        self.cluster = Cluster(
            contact_points=contact_points,
            auth_provider=auth_provider,
            execution_profiles={EXEC_PROFILE_DEFAULT: profile}
        )
        
        self.session = self.cluster.connect()
        self.keyspace = keyspace
        self._initialize_schema()
        self._prepare_statements()
    
    def _initialize_schema(self):
        """Create keyspace and tables with proper replication strategy"""
        try:
            self.session.execute(f"""
                CREATE KEYSPACE IF NOT EXISTS {self.keyspace}
                WITH replication = {{
                    'class': 'NetworkTopologyStrategy',
                    'datacenter1': 3
                }}
            """)
            
            self.session.set_keyspace(self.keyspace)
            
            # Time-series table partitioned by user and date for efficient queries
            self.session.execute("""
                CREATE TABLE IF NOT EXISTS user_activities (
                    user_id uuid,
                    activity_date date,
                    activity_time timestamp,
                    activity_id timeuuid,
                    activity_type text,
                    repository_id uuid,
                    details map<text, text>,
                    PRIMARY KEY ((user_id, activity_date), activity_time, activity_id)
                ) WITH CLUSTERING ORDER BY (activity_time DESC, activity_id DESC)
                AND default_time_to_live = 7776000
            """)
            
            logger.info("Schema initialized successfully")
        except Exception as e:
            logger.error(f"Schema initialization failed: {e}")
            raise
    
    def _prepare_statements(self):
        """Prepare statements for better performance"""
        self.insert_stmt = self.session.prepare("""
            INSERT INTO user_activities 
            (user_id, activity_date, activity_time, activity_id, 
             activity_type, repository_id, details)
            VALUES (?, ?, ?, ?, ?, ?, ?)
            USING TTL ?
        """)
        
        self.query_stmt = self.session.prepare("""
            SELECT * FROM user_activities
            WHERE user_id = ? AND activity_date = ?
            LIMIT ?
        """)
    
    def track_activity(self, user_id, activity_type, repository_id, details, ttl=2592000):
        """Record a user activity with proper error handling"""
        try:
            activity_time = datetime.utcnow()
            activity_date = activity_time.date()
            activity_id = uuid.uuid1()
            
            self.session.execute(
                self.insert_stmt,
                (
                    uuid.UUID(user_id) if isinstance(user_id, str) else user_id,
                    activity_date,
                    activity_time,
                    activity_id,
                    activity_type,
                    uuid.UUID(repository_id) if isinstance(repository_id, str) else repository_id,
                    details,
                    ttl
                )
            )
            
            logger.info(f"Activity tracked: {activity_type} for user {user_id}")
            return str(activity_id)
            
        except Exception as e:
            logger.error(f"Failed to track activity: {e}")
            raise
    
    def get_user_activities(self, user_id, date, limit=100):
        """Retrieve user activities for a specific date"""
        try:
            rows = self.session.execute(
                self.query_stmt,
                (
                    uuid.UUID(user_id) if isinstance(user_id, str) else user_id,
                    date,
                    limit
                )
            )
            
            activities = []
            for row in rows:
                activities.append({
                    'activity_id': str(row.activity_id),
                    'activity_type': row.activity_type,
                    'activity_time': row.activity_time.isoformat(),
                    'repository_id': str(row.repository_id),
                    'details': row.details
                })
            
            return activities
            
        except Exception as e:
            logger.error(f"Failed to retrieve activities: {e}")
            return []
    
    def close(self):
        """Properly close connections"""
        self.cluster.shutdown()
        logger.info("Connection closed")

# Example usage
if __name__ == '__main__':
    tracker = UserActivityTracker()
    
    user_id = uuid.uuid4()
    repo_id = uuid.uuid4()
    
    # Track various activities
    tracker.track_activity(
        user_id=user_id,
        activity_type='COMMIT',
        repository_id=repo_id,
        details={'branch': 'main', 'files_changed': '5', 'message': 'Fixed bug #123'}
    )
    
    # Retrieve activities
    activities = tracker.get_user_activities(user_id, datetime.utcnow().date())
    print(f"Found {len(activities)} activities")
    
    tracker.close()