Testing & Debugging

// Set up test webhook endpoint
app.post('/test-webhook', (req, res) => {
  const { event, data } = req.body;
  
  console.log('Webhook received:', { event, data });
  
  // Test different event types
  switch (event) {
    case 'message.sent':
      console.log('Message sent successfully');
      break;
    case 'message.delivered':
      console.log('Message delivered to:', data.to);
      break;
    case 'message.failed':
      console.log('Message failed:', data.error_reason);
      break;
    case 'message.received':
      console.log('Incoming message from:', data.from);
      break;
  }
  
  res.status(200).send('OK');
});

// Configure webhook for testing
const webhookConfig = {
  url: 'https://your-test-app.com/test-webhook',
  events: ['message.sent', 'message.delivered', 'message.failed'],
  secret: 'test-webhook-secret'
};

await client.webhooks.create(webhookConfig);

// Load testing with concurrent requests
const loadTest = async (concurrentRequests = 10, totalMessages = 1000) => {
  const results = {
    successful: 0,
    failed: 0,
    totalTime: 0
  };
  
  const startTime = Date.now();
  const batchSize = Math.ceil(totalMessages / concurrentRequests);
  
  const batches = [];
  for (let i = 0; i < concurrentRequests; i++) {
    const batch = [];
    
    for (let j = 0; j < batchSize && (i * batchSize + j) < totalMessages; j++) {
      batch.push(
        client.messages.send({
          to: '+1555000001',
          type: 'text',
          message: `Load test message ${i * batchSize + j + 1}`
        })
        .then(() => ({ success: true }))
        .catch(error => ({ success: false, error: error.message }))
      );
    }
    
    batches.push(Promise.all(batch));
  }
  
  const allResults = await Promise.all(batches);
  
  // Process results
  allResults.flat().forEach(result => {
    if (result.success) {
      results.successful++;
    } else {
      results.failed++;
    }
  });
  
  results.totalTime = Date.now() - startTime;
  results.messagesPerSecond = totalMessages / (results.totalTime / 1000);
  
  console.log('Load Test Results:', results);
  return results;
};

// Run load test
loadTest(20, 500).then(results => {
  console.log(`
Performance Metrics:`);
  console.log(`Success Rate: ${(results.successful / (results.successful + results.failed) * 100).toFixed(2)}%`);
  console.log(`Messages/Second: ${results.messagesPerSecond.toFixed(2)}`);
  console.log(`Total Time: ${results.totalTime}ms`);
});

// Performance monitoring wrapper
class Amanah AIMonitor {
  constructor(client) {
    this.client = client;
    this.metrics = {
      requests: 0,
      successes: 0,
      failures: 0,
      totalLatency: 0
    };
  }
  
  async sendMessage(messageData) {
    const startTime = Date.now();
    this.metrics.requests++;
    
    try {
      const result = await this.client.messages.send(messageData);
      
      this.metrics.successes++;
      const latency = Date.now() - startTime;
      this.metrics.totalLatency += latency;
      
      // Log success metrics
      if (latency > 5000) {
        console.warn(\`Slow API response: \${latency}ms\`);
        // Send alert
        this.sendAlert('HIGH_LATENCY', { latency, messageId: result.message_id });
      }
      
      return result;
      
    } catch (error) {
      this.metrics.failures++;
      
      // Log error metrics
      console.error('API request failed:', error.message);
      this.sendAlert('API_FAILURE', { error: error.message, messageData });
      
      throw error;
    }
  }
  
  getStats() {
    const avgLatency = this.metrics.totalLatency / this.metrics.successes;
    const successRate = (this.metrics.successes / this.metrics.requests) * 100;
    
    return {
      requests: this.metrics.requests,
      successRate: successRate.toFixed(2) + '%',
      averageLatency: avgLatency.toFixed(0) + 'ms',
      failures: this.metrics.failures
    };
  }
  
  sendAlert(type, data) {
    // Integrate with your monitoring service
    // e.g., Datadog, New Relic, or custom webhook
    console.log(\`ALERT [\${type}]:\`, data);
  }
  
  // Reset metrics (call periodically)
  resetMetrics() {
    this.metrics = {
      requests: 0,
      successes: 0,
      failures: 0,
      totalLatency: 0
    };
  }
}

// Usage
const monitoredClient = new Amanah AIMonitor(client);

// Send messages through monitored client
await monitoredClient.sendMessage({
  to: '+1234567890',
  type: 'text',
  message: 'Monitored message'
});

// Get performance stats
console.log('Performance Stats:', monitoredClient.getStats());