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):
    """
    Lambda handler for processing e-commerce orders.
    Demonstrates AWS best practices: DynamoDB transactions, SNS notifications,
    SSM Parameter Store, error handling, and idempotency.
    """
    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')
        
        # Validate required fields
        if not all([order_id, user_id, items, total_amount]):
            return create_response(400, {'error': 'Missing required fields'})
        
        # Get configuration from SSM Parameter Store
        tax_rate = get_parameter('/config/tax_rate', default=0.08)
        
        # Calculate final amount with tax
        final_amount = total_amount * (1 + tax_rate)
        
        # Prepare order record
        table = dynamodb.Table(TABLE_NAME)
        order_record = {
            'order_id': order_id,
            'user_id': user_id,
            'items': items,
            'total_amount': str(total_amount),
            'final_amount': str(final_amount),
            'status': 'PENDING',
            'created_at': datetime.utcnow().isoformat(),
            'updated_at': datetime.utcnow().isoformat()
        }
        
        # Use DynamoDB conditional write for idempotency
        try:
            table.put_item(
                Item=order_record,
                ConditionExpression='attribute_not_exists(order_id)'
            )
            logger.info(f'Order {order_id} created successfully')
        except ClientError as e:
            if e.response['Error']['Code'] == 'ConditionalCheckFailedException':
                logger.warning(f'Order {order_id} already exists')
                return create_response(409, {'error': 'Order already exists'})
            raise
        
        # Send SNS notification for order processing
        notification_sent = send_order_notification(order_record)
        
        if not notification_sent:
            logger.error(f'Failed to send notification for order {order_id}')
        
        # Return success response
        return create_response(201, {
            'message': 'Order created successfully',
            'order_id': order_id,
            'final_amount': final_amount,
            'notification_sent': notification_sent
        })
        
    except json.JSONDecodeError:
        logger.error('Invalid JSON in request body')
        return create_response(400, {'error': 'Invalid JSON'})
    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(name, default=None):
    """Retrieve parameter from SSM Parameter Store with caching."""
    try:
        response = ssm.get_parameter(Name=name, WithDecryption=True)
        return float(response['Parameter']['Value'])
    except ClientError as e:
        logger.warning(f'Failed to get parameter {name}: {str(e)}')
        return default

def send_order_notification(order_record):
    """Send SNS notification for order processing."""
    if not SNS_TOPIC_ARN:
        logger.warning('SNS_TOPIC_ARN not configured')
        return False
    
    try:
        message = {
            'order_id': order_record['order_id'],
            'user_id': order_record['user_id'],
            'amount': order_record['final_amount'],
            'status': order_record['status']
        }
        
        sns.publish(
            TopicArn=SNS_TOPIC_ARN,
            Message=json.dumps(message),
            Subject=f"New Order: {order_record['order_id']}",
            MessageAttributes={
                'order_type': {'DataType': 'String', 'StringValue': 'ecommerce'}
            }
        )
        return True
    except ClientError as e:
        logger.error(f'SNS publish failed: {str(e)}')
        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': '*'
        },
        'body': json.dumps(body)
    }