Comprehensive comparison for DevOps technology in Software Development applications

import time
import logging
from datadog import initialize, statsd
from datadog import api as datadog_api
from functools import wraps
from flask import Flask, request, jsonify
import os

# Initialize Datadog
options = {
    'api_key': os.getenv('DD_API_KEY'),
    'app_key': os.getenv('DD_APP_KEY'),
    'statsd_host': os.getenv('DD_AGENT_HOST', 'localhost'),
    'statsd_port': int(os.getenv('DD_AGENT_PORT', 8125))
}
initialize(**options)

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

def datadog_monitor(metric_prefix):
    """Decorator to monitor endpoint performance and errors"""
    def decorator(f):
        @wraps(f)
        def wrapper(*args, **kwargs):
            start_time = time.time()
            endpoint_name = f.__name__
            
            # Increment request counter
            statsd.increment(f'{metric_prefix}.requests.count',
                           tags=[f'endpoint:{endpoint_name}', f'env:{os.getenv("ENV", "dev")}'])
            
            try:
                result = f(*args, **kwargs)
                
                # Record success metrics
                statsd.increment(f'{metric_prefix}.requests.success',
                               tags=[f'endpoint:{endpoint_name}', 'status:success'])
                
                return result
                
            except Exception as e:
                # Record error metrics
                statsd.increment(f'{metric_prefix}.requests.error',
                               tags=[f'endpoint:{endpoint_name}', 
                                     f'error_type:{type(e).__name__}',
                                     'status:error'])
                logger.error(f'Error in {endpoint_name}: {str(e)}', 
                           extra={'endpoint': endpoint_name, 'error': str(e)})
                raise
                
            finally:
                # Record response time
                duration = time.time() - start_time
                statsd.histogram(f'{metric_prefix}.requests.duration',
                               duration,
                               tags=[f'endpoint:{endpoint_name}'])
                statsd.timing(f'{metric_prefix}.requests.timing',
                            duration * 1000,
                            tags=[f'endpoint:{endpoint_name}'])
        
        return wrapper
    return decorator

@app.route('/api/v1/payment/process', methods=['POST'])
@datadog_monitor('payment.api')
def process_payment():
    """Process payment with Datadog monitoring"""
    try:
        data = request.get_json()
        
        # Validate input
        if not data or 'amount' not in data or 'user_id' not in data:
            statsd.increment('payment.api.validation.error',
                           tags=['error_type:missing_fields'])
            return jsonify({'error': 'Missing required fields'}), 400
        
        amount = float(data['amount'])
        user_id = data['user_id']
        
        # Track payment amount distribution
        statsd.histogram('payment.api.amount.distribution', amount,
                        tags=[f'user_id:{user_id}'])
        
        # Simulate payment processing
        if amount <= 0:
            statsd.increment('payment.api.validation.error',
                           tags=['error_type:invalid_amount'])
            return jsonify({'error': 'Invalid amount'}), 400
        
        if amount > 10000:
            # Track high-value transactions
            statsd.increment('payment.api.high_value_transaction',
                           tags=[f'user_id:{user_id}', 'amount_range:over_10k'])
            statsd.event(
                title='High Value Transaction',
                text=f'Transaction of ${amount} for user {user_id}',
                tags=['payment', 'high_value', f'user_id:{user_id}']
            )
        
        # Simulate processing time based on amount
        processing_time = 0.1 + (amount / 100000)
        time.sleep(processing_time)
        
        # Record successful payment
        statsd.increment('payment.api.processed.success',
                        tags=[f'user_id:{user_id}'])
        statsd.gauge('payment.api.last_transaction_amount', amount,
                    tags=[f'user_id:{user_id}'])
        
        return jsonify({
            'status': 'success',
            'transaction_id': f'txn_{int(time.time())}_{user_id}',
            'amount': amount
        }), 200
        
    except ValueError as e:
        statsd.increment('payment.api.validation.error',
                        tags=['error_type:invalid_data_type'])
        return jsonify({'error': 'Invalid data format'}), 400
    except Exception as e:
        logger.error(f'Unexpected error in payment processing: {str(e)}')
        return jsonify({'error': 'Internal server error'}), 500

if __name__ == '__main__':
    # Send deployment event to Datadog
    statsd.event(
        title='Payment Service Deployed',
        text='Payment processing service started',
        tags=['deployment', 'payment-service', f'env:{os.getenv("ENV", "dev")}']
    )
    app.run(host='0.0.0.0', port=5000)