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 PreparedStatement, ConsistencyLevel
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 code repository)
    """
    
    def __init__(self, contact_points=['127.0.0.1'], keyspace='dev_platform'):
        # Configure connection with best practices
        auth_provider = PlainTextAuthProvider(username='cassandra', password='cassandra')
        
        profile = ExecutionProfile(
            load_balancing_policy=TokenAwarePolicy(DCAwareRoundRobinPolicy()),
            consistency_level=ConsistencyLevel.LOCAL_QUORUM
        )
        
        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 data modeling"""
        try:
            self.session.execute(f"""
                CREATE KEYSPACE IF NOT EXISTS {self.keyspace}
                WITH replication = {{'class': 'NetworkTopologyStrategy', 'datacenter1': 3}}
                AND durable_writes = true
            """)
            
            self.session.set_keyspace(self.keyspace)
            
            # Table optimized for querying user activities by user_id and time
            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_name text,
                    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 compaction = {'class': 'TimeWindowCompactionStrategy'}
            """)
            
            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_activity_stmt = self.session.prepare("""
            INSERT INTO user_activities 
            (user_id, activity_date, activity_time, activity_id, activity_type, repository_name, details)
            VALUES (?, ?, ?, ?, ?, ?, ?)
        """)
        
        self.get_activities_stmt = self.session.prepare("""
            SELECT * FROM user_activities
            WHERE user_id = ? AND activity_date = ?
            LIMIT ?
        """)
    
    def log_activity(self, user_id, activity_type, repository_name, details=None):
        """Log a user activity with proper error handling"""
        try:
            activity_time = datetime.now()
            activity_id = uuid.uuid1()
            activity_date = activity_time.date()
            
            self.session.execute(
                self.insert_activity_stmt,
                (user_id, activity_date, activity_time, activity_id, 
                 activity_type, repository_name, details or {})
            )
            
            logger.info(f"Activity logged: {activity_type} for user {user_id}")
            return activity_id
        except Exception as e:
            logger.error(f"Failed to log activity: {e}")
            raise
    
    def get_user_activities(self, user_id, date, limit=50):
        """Retrieve user activities for a specific date"""
        try:
            rows = self.session.execute(
                self.get_activities_stmt,
                (user_id, date, limit)
            )
            
            activities = [{
                'activity_id': str(row.activity_id),
                'activity_time': row.activity_time.isoformat(),
                'activity_type': row.activity_type,
                'repository_name': row.repository_name,
                'details': row.details
            } for row in rows]
            
            return activities
        except Exception as e:
            logger.error(f"Failed to retrieve activities: {e}")
            return []
    
    def close(self):
        """Clean up resources"""
        self.cluster.shutdown()
        logger.info("Connection closed")

# Example usage
if __name__ == "__main__":
    tracker = UserActivityTracker()
    
    user_id = uuid.uuid4()
    
    # Log various activities
    tracker.log_activity(
        user_id, 
        'commit', 
        'my-awesome-project',
        {'commit_hash': 'abc123', 'message': 'Fixed critical bug'}
    )
    
    tracker.log_activity(
        user_id,
        'pull_request',
        'my-awesome-project',
        {'pr_number': '42', 'status': 'open'}
    )
    
    # Retrieve activities
    activities = tracker.get_user_activities(user_id, datetime.now().date())
    print(f"Found {len(activities)} activities")
    
    tracker.close()