Comprehensive comparison for DevOps technology in Software Development applications

const express = require('express');
const StatsD = require('hot-shots');
const tracer = require('dd-trace').init({
  logInjection: true,
  analytics: true
});

const app = express();
app.use(express.json());

const dogstatsd = new StatsD({
  host: process.env.DD_AGENT_HOST || 'localhost',
  port: 8125,
  prefix: 'payment.service.',
  globalTags: {
    env: process.env.NODE_ENV || 'development',
    service: 'payment-api',
    version: process.env.APP_VERSION || '1.0.0'
  }
});

class PaymentService {
  async processPayment(userId, amount, currency) {
    const span = tracer.startSpan('payment.process');
    span.setTag('user.id', userId);
    span.setTag('payment.amount', amount);
    span.setTag('payment.currency', currency);
    
    const startTime = Date.now();
    
    try {
      if (amount <= 0) {
        throw new Error('Invalid payment amount');
      }
      
      if (!['USD', 'EUR', 'GBP'].includes(currency)) {
        throw new Error('Unsupported currency');
      }
      
      await this.validateUser(userId);
      await this.chargeCard(userId, amount, currency);
      await this.recordTransaction(userId, amount, currency);
      
      const duration = Date.now() - startTime;
      dogstatsd.timing('payment.process.duration', duration);
      dogstatsd.increment('payment.process.success', 1, {
        currency: currency
      });
      
      span.setTag('payment.status', 'success');
      span.finish();
      
      return {
        success: true,
        transactionId: `txn_${Date.now()}_${userId}`,
        amount,
        currency
      };
      
    } catch (error) {
      const duration = Date.now() - startTime;
      dogstatsd.timing('payment.process.duration', duration);
      dogstatsd.increment('payment.process.error', 1, {
        error_type: error.message
      });
      
      span.setTag('error', true);
      span.setTag('error.message', error.message);
      span.setTag('payment.status', 'failed');
      span.finish();
      
      throw error;
    }
  }
  
  async validateUser(userId) {
    const span = tracer.startSpan('payment.validate_user', {
      childOf: tracer.scope().active()
    });
    
    try {
      await new Promise(resolve => setTimeout(resolve, 50));
      span.finish();
      return true;
    } catch (error) {
      span.setTag('error', true);
      span.finish();
      throw error;
    }
  }
  
  async chargeCard(userId, amount, currency) {
    const span = tracer.startSpan('payment.charge_card', {
      childOf: tracer.scope().active()
    });
    
    try {
      await new Promise(resolve => setTimeout(resolve, 200));
      
      if (Math.random() < 0.05) {
        throw new Error('Card declined');
      }
      
      span.finish();
    } catch (error) {
      span.setTag('error', true);
      span.finish();
      throw error;
    }
  }
  
  async recordTransaction(userId, amount, currency) {
    const span = tracer.startSpan('payment.record_transaction', {
      childOf: tracer.scope().active()
    });
    
    try {
      await new Promise(resolve => setTimeout(resolve, 30));
      span.finish();
    } catch (error) {
      span.setTag('error', true);
      span.finish();
      throw error;
    }
  }
}

const paymentService = new PaymentService();

app.post('/api/v1/payments', async (req, res) => {
  const { userId, amount, currency } = req.body;
  
  dogstatsd.increment('api.payment.request', 1);
  
  if (!userId || !amount || !currency) {
    dogstatsd.increment('api.payment.validation_error', 1);
    return res.status(400).json({
      error: 'Missing required fields: userId, amount, currency'
    });
  }
  
  try {
    const result = await paymentService.processPayment(
      userId,
      amount,
      currency
    );
    
    dogstatsd.increment('api.payment.response.success', 1);
    res.status(200).json(result);
    
  } catch (error) {
    dogstatsd.increment('api.payment.response.error', 1, {
      error_type: error.message
    });
    
    res.status(500).json({
      error: 'Payment processing failed',
      message: error.message
    });
  }
});

app.get('/health', (req, res) => {
  dogstatsd.increment('api.health.check', 1);
  res.status(200).json({ status: 'healthy' });
});

const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
  console.log(`Payment service listening on port ${PORT}`);
});

process.on('SIGTERM', () => {
  dogstatsd.close();
  process.exit(0);
});