Comprehensive comparison for DevOps technology in Software Development applications

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

// Initialize DogStatsD client for custom metrics
const dogstatsd = new StatsD({
  host: process.env.DD_AGENT_HOST || 'localhost',
  port: 8125,
  prefix: 'payment.service.',
  globalTags: {
    env: process.env.NODE_ENV || 'production',
    service: 'payment-api',
    version: process.env.APP_VERSION || '1.0.0'
  }
});

app.use(express.json());

// Payment processing endpoint with comprehensive Datadog instrumentation
app.post('/api/v1/payments', async (req, res) => {
  const span = tracer.scope().active();
  const startTime = Date.now();
  
  // Add custom tags to the trace
  span.setTag('payment.method', req.body.paymentMethod);
  span.setTag('payment.amount', req.body.amount);
  span.setTag('user.id', req.body.userId);
  
  // Increment request counter
  dogstatsd.increment('requests.total', 1, {
    payment_method: req.body.paymentMethod
  });
  
  try {
    // Validate payment request
    if (!req.body.amount || req.body.amount <= 0) {
      throw new Error('Invalid payment amount');
    }
    
    if (!req.body.paymentMethod || !req.body.userId) {
      throw new Error('Missing required fields');
    }
    
    // Create child span for payment validation
    const validationSpan = tracer.startSpan('payment.validation', {
      childOf: span
    });
    
    const isValid = await validatePaymentMethod(req.body.paymentMethod, req.body.userId);
    validationSpan.finish();
    
    if (!isValid) {
      dogstatsd.increment('payments.validation.failed');
      return res.status(400).json({ error: 'Invalid payment method' });
    }
    
    // Process payment with custom span
    const processingSpan = tracer.startSpan('payment.processing', {
      childOf: span
    });
    
    const paymentResult = await processPayment({
      userId: req.body.userId,
      amount: req.body.amount,
      paymentMethod: req.body.paymentMethod,
      currency: req.body.currency || 'USD'
    });
    
    processingSpan.finish();
    
    // Track successful payment metrics
    dogstatsd.increment('payments.success');
    dogstatsd.histogram('payments.amount', req.body.amount);
    dogstatsd.timing('payments.duration', Date.now() - startTime);
    
    // Add success event
    span.setTag('payment.status', 'success');
    span.setTag('payment.transaction_id', paymentResult.transactionId);
    
    res.status(200).json({
      success: true,
      transactionId: paymentResult.transactionId,
      amount: req.body.amount,
      currency: req.body.currency || 'USD'
    });
    
  } catch (error) {
    // Track error metrics
    dogstatsd.increment('payments.error', 1, {
      error_type: error.name,
      payment_method: req.body.paymentMethod
    });
    
    // Add error information to trace
    span.setTag('error', true);
    span.setTag('error.message', error.message);
    span.setTag('error.type', error.name);
    span.setTag('payment.status', 'failed');
    
    // Log error with trace correlation
    console.error('Payment processing failed:', {
      error: error.message,
      userId: req.body.userId,
      amount: req.body.amount,
      dd: {
        trace_id: span.context().toTraceId(),
        span_id: span.context().toSpanId()
      }
    });
    
    res.status(500).json({
      success: false,
      error: 'Payment processing failed',
      message: error.message
    });
  }
});

// Mock payment validation function
async function validatePaymentMethod(paymentMethod, userId) {
  return new Promise((resolve) => {
    setTimeout(() => resolve(true), 50);
  });
}

// Mock payment processing function
async function processPayment(paymentData) {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      if (Math.random() > 0.05) {
        resolve({
          transactionId: `txn_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
          status: 'completed'
        });
      } else {
        reject(new Error('Payment gateway timeout'));
      }
    }, 100);
  });
}

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

module.exports = app;