Comprehensive comparison for technology in applications

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

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

class OrderProcessingQueue:
    """Production-ready SQS implementation for order processing system."""
    
    def __init__(self, queue_url: str, region: str = 'us-east-1'):
        self.sqs_client = boto3.client('sqs', region_name=region)
        self.queue_url = queue_url
        
    def send_order(self, order_data: Dict) -> Optional[str]:
        """Send order to SQS queue with error handling and message attributes."""
        try:
            order_data['timestamp'] = datetime.utcnow().isoformat()
            
            response = self.sqs_client.send_message(
                QueueUrl=self.queue_url,
                MessageBody=json.dumps(order_data),
                MessageAttributes={
                    'OrderType': {
                        'StringValue': order_data.get('type', 'standard'),
                        'DataType': 'String'
                    },
                    'Priority': {
                        'StringValue': str(order_data.get('priority', 5)),
                        'DataType': 'Number'
                    }
                },
                MessageDeduplicationId=order_data.get('order_id'),
                MessageGroupId=order_data.get('customer_id')
            )
            
            logger.info(f"Order {order_data['order_id']} sent. MessageId: {response['MessageId']}")
            return response['MessageId']
            
        except ClientError as e:
            logger.error(f"Failed to send order: {e.response['Error']['Message']}")
            return None
            
    def process_orders(self, max_messages: int = 10) -> List[Dict]:
        """Poll and process orders from queue with visibility timeout."""
        processed_orders = []
        
        try:
            response = self.sqs_client.receive_message(
                QueueUrl=self.queue_url,
                MaxNumberOfMessages=max_messages,
                WaitTimeSeconds=20,
                VisibilityTimeout=300,
                MessageAttributeNames=['All']
            )
            
            messages = response.get('Messages', [])
            logger.info(f"Received {len(messages)} messages from queue")
            
            for message in messages:
                try:
                    order_data = json.loads(message['Body'])
                    receipt_handle = message['ReceiptHandle']
                    
                    if self._process_single_order(order_data):
                        self.sqs_client.delete_message(
                            QueueUrl=self.queue_url,
                            ReceiptHandle=receipt_handle
                        )
                        processed_orders.append(order_data)
                        logger.info(f"Successfully processed order {order_data['order_id']}")
                    else:
                        logger.warning(f"Order processing failed: {order_data['order_id']}")
                        
                except json.JSONDecodeError as e:
                    logger.error(f"Invalid message format: {e}")
                except Exception as e:
                    logger.error(f"Error processing message: {e}")
                    
        except ClientError as e:
            logger.error(f"Failed to receive messages: {e.response['Error']['Message']}")
            
        return processed_orders
        
    def _process_single_order(self, order_data: Dict) -> bool:
        """Simulate order processing logic."""
        required_fields = ['order_id', 'customer_id', 'items', 'total']
        return all(field in order_data for field in required_fields)