Comprehensive comparison for DevOps technology in Software Development applications

import boto3
import json
import os
import logging
from datetime import datetime
from botocore.exceptions import ClientError

# Configure logging
logger = logging.getLogger()
logger.setLevel(logging.INFO)

# Initialize AWS clients
dynamodb = boto3.resource('dynamodb')
sns = boto3.client('sns')
ssm = boto3.client('ssm')

# Environment variables
TABLE_NAME = os.environ.get('ORDERS_TABLE', 'orders')
SNS_TOPIC_ARN = os.environ.get('SNS_TOPIC_ARN')
MAX_RETRY_ATTEMPTS = 3

def lambda_handler(event, context):
    """
    Production-grade Lambda handler for processing e-commerce orders.
    Implements error handling, retries, and notifications.
    """
    try:
        # Parse incoming order request
        body = json.loads(event.get('body', '{}'))
        order_id = body.get('order_id')
        user_id = body.get('user_id')
        items = body.get('items', [])
        total_amount = body.get('total_amount', 0)
        
        # Input validation
        if not all([order_id, user_id, items, total_amount]):
            return create_response(400, {'error': 'Missing required fields'})
        
        if total_amount <= 0:
            return create_response(400, {'error': 'Invalid order amount'})
        
        # Get payment processing configuration from Parameter Store
        payment_config = get_parameter('/app/payment/config')
        
        # Store order in DynamoDB with conditional write
        table = dynamodb.Table(TABLE_NAME)
        order_data = {
            'order_id': order_id,
            'user_id': user_id,
            'items': items,
            'total_amount': total_amount,
            'status': 'pending',
            'created_at': datetime.utcnow().isoformat(),
            'ttl': int(datetime.utcnow().timestamp()) + 2592000  # 30 days TTL
        }
        
        table.put_item(
            Item=order_data,
            ConditionExpression='attribute_not_exists(order_id)'
        )
        
        logger.info(f"Order {order_id} created successfully for user {user_id}")
        
        # Send notification to SNS topic for downstream processing
        notification_message = {
            'event_type': 'order_created',
            'order_id': order_id,
            'user_id': user_id,
            'total_amount': total_amount,
            'timestamp': datetime.utcnow().isoformat()
        }
        
        publish_to_sns(notification_message)
        
        return create_response(201, {
            'message': 'Order created successfully',
            'order_id': order_id,
            'status': 'pending'
        })
        
    except ClientError as e:
        error_code = e.response['Error']['Code']
        
        if error_code == 'ConditionalCheckFailedException':
            logger.warning(f"Duplicate order attempt: {order_id}")
            return create_response(409, {'error': 'Order already exists'})
        
        logger.error(f"AWS Client Error: {str(e)}")
        return create_response(500, {'error': 'Service temporarily unavailable'})
        
    except json.JSONDecodeError:
        logger.error("Invalid JSON in request body")
        return create_response(400, {'error': 'Invalid JSON format'})
        
    except Exception as e:
        logger.error(f"Unexpected error: {str(e)}", exc_info=True)
        return create_response(500, {'error': 'Internal server error'})

def get_parameter(parameter_name):
    """Retrieve configuration from SSM Parameter Store with caching."""
    try:
        response = ssm.get_parameter(Name=parameter_name, WithDecryption=True)
        return json.loads(response['Parameter']['Value'])
    except ClientError as e:
        logger.error(f"Failed to retrieve parameter {parameter_name}: {str(e)}")
        return {}

def publish_to_sns(message):
    """Publish message to SNS with retry logic."""
    for attempt in range(MAX_RETRY_ATTEMPTS):
        try:
            sns.publish(
                TopicArn=SNS_TOPIC_ARN,
                Message=json.dumps(message),
                MessageAttributes={
                    'event_type': {'DataType': 'String', 'StringValue': message['event_type']}
                }
            )
            logger.info(f"Published message to SNS: {message['order_id']}")
            return True
        except ClientError as e:
            logger.warning(f"SNS publish attempt {attempt + 1} failed: {str(e)}")
            if attempt == MAX_RETRY_ATTEMPTS - 1:
                logger.error(f"Failed to publish to SNS after {MAX_RETRY_ATTEMPTS} attempts")
    return False

def create_response(status_code, body):
    """Create standardized API Gateway response."""
    return {
        'statusCode': status_code,
        'headers': {
            'Content-Type': 'application/json',
            'Access-Control-Allow-Origin': '*',
            'X-Request-ID': context.request_id if 'context' in globals() else 'unknown'
        },
        'body': json.dumps(body)
    }