Comprehensive comparison for technology in applications

import boto3
import json
import time
import uuid
from datetime import datetime
from typing import Dict, List, Optional
from botocore.exceptions import ClientError

class ClickstreamProcessor:
    """
    Production-ready Kinesis producer for processing clickstream events.
    Implements batching, error handling, and retry logic.
    """
    
    def __init__(self, stream_name: str, region: str = 'us-east-1'):
        self.stream_name = stream_name
        self.kinesis_client = boto3.client('kinesis', region_name=region)
        self.batch_size = 500
        self.max_retries = 3
        
    def put_clickstream_event(self, user_id: str, event_type: str, 
                              page_url: str, metadata: Optional[Dict] = None) -> bool:
        """
        Send a single clickstream event to Kinesis with retry logic.
        """
        event = {
            'event_id': str(uuid.uuid4()),
            'user_id': user_id,
            'event_type': event_type,
            'page_url': page_url,
            'timestamp': datetime.utcnow().isoformat(),
            'metadata': metadata or {}
        }
        
        for attempt in range(self.max_retries):
            try:
                response = self.kinesis_client.put_record(
                    StreamName=self.stream_name,
                    Data=json.dumps(event),
                    PartitionKey=user_id
                )
                
                print(f"Event sent successfully. Shard: {response['ShardId']}, "
                      f"Sequence: {response['SequenceNumber']}")
                return True
                
            except ClientError as e:
                error_code = e.response['Error']['Code']
                
                if error_code == 'ProvisionedThroughputExceededException':
                    wait_time = (2 ** attempt) * 0.1
                    print(f"Throughput exceeded. Retrying in {wait_time}s...")
                    time.sleep(wait_time)
                else:
                    print(f"Error sending event: {e}")
                    return False
                    
            except Exception as e:
                print(f"Unexpected error: {e}")
                return False
                
        print(f"Failed to send event after {self.max_retries} attempts")
        return False
    
    def put_batch_events(self, events: List[Dict]) -> Dict[str, int]:
        """
        Send multiple events in batches for improved throughput.
        """
        records = []
        for event in events:
            records.append({
                'Data': json.dumps(event),
                'PartitionKey': event.get('user_id', str(uuid.uuid4()))
            })
        
        success_count = 0
        failed_count = 0
        
        for i in range(0, len(records), self.batch_size):
            batch = records[i:i + self.batch_size]
            
            try:
                response = self.kinesis_client.put_records(
                    StreamName=self.stream_name,
                    Records=batch
                )
                
                success_count += len(batch) - response['FailedRecordCount']
                failed_count += response['FailedRecordCount']
                
                if response['FailedRecordCount'] > 0:
                    print(f"Batch had {response['FailedRecordCount']} failures")
                    
            except ClientError as e:
                print(f"Batch send error: {e}")
                failed_count += len(batch)
        
        return {'success': success_count, 'failed': failed_count}