Security & Monitoring

// Example: Secure API Client with monitoring
class SecureAPIClient {
  constructor(config) {
    this.baseURL = config.baseURL;
    this.apiKey = this.getSecureApiKey();
    this.rateLimiter = new RateLimiter(config.rateLimit);
    this.logger = new SecurityLogger();
    this.metrics = new MetricsCollector();
  }

  getSecureApiKey() {
    const apiKey = process.env.API_KEY;
    if (!apiKey) {
      throw new Error('API key not found in environment variables');
    }
    return apiKey;
  }

  async makeRequest(endpoint, options = {}) {
    const requestId = this.generateRequestId();
    const startTime = Date.now();

    try {
      await this.rateLimiter.checkLimit();
      this.validateInput(endpoint, options);

      const secureOptions = {
        ...options,
        headers: {
          'Authorization': `Bearer ${this.apiKey}`,
          'X-Request-ID': requestId,
          'User-Agent': 'SecureAutomation/1.0',
          ...options.headers
        }
      };

      const response = await this.timeoutRequest(
        fetch(`${this.baseURL}${endpoint}`, secureOptions),
        10000
      );

      this.logger.logRequest({
        requestId,
        endpoint,
        statusCode: response.status,
        duration: Date.now() - startTime,
        success: true
      });

      this.metrics.recordAPICall(endpoint, response.status, Date.now() - startTime);

      if (!response.ok) {
        throw new APIError(`HTTP ${response.status}`, response.status);
      }

      return await response.json();
    } catch (error) {
      this.logger.logSecurityEvent({
        requestId,
        endpoint,
        error: error.message,
        severity: this.getErrorSeverity(error),
        timestamp: new Date().toISOString()
      });

      if (this.isSuspiciousError(error)) {
        this.alertSecurityTeam(error, requestId);
      }

      throw error;
    }
  }

  validateInput(endpoint, options) {
    if (endpoint.includes('..') || endpoint.includes('//')) {
      throw new SecurityError('Invalid endpoint path detected');
    }
    if (options.body && options.body.length > 1024 * 1024) {
      throw new SecurityError('Request body too large');
    }
  }

  isSuspiciousError(error) {
    return error.status === 401 || error.status === 403 ||
           error.message.includes('unauthorized');
  }
}

// Example: Comprehensive monitoring setup
class AutomationMonitor {
  constructor() {
    this.metrics = new Map();
    this.alerts = new AlertManager();
    this.logger = new StructuredLogger();
  }

  trackExecutionTime(operationName, duration) {
    this.metrics.set(`execution_time_${operationName}`, duration);

    if (duration > 5000) {
      this.alerts.send({
        severity: 'warning',
        message: `Slow operation detected: ${operationName} took ${duration}ms`,
        tags: ['performance', 'latency']
      });
    }
  }

  trackError(operationType, error) {
    const errorKey = `errors_${operationType}`;
    const currentCount = this.metrics.get(errorKey) || 0;
    this.metrics.set(errorKey, currentCount + 1);

    this.logger.error({
      operation: operationType,
      error_message: error.message,
      timestamp: new Date().toISOString()
    });

    if (currentCount > 10) {
      this.alerts.send({
        severity: 'critical',
        message: `High error rate in ${operationType}: ${currentCount} errors`,
        tags: ['errors', 'critical']
      });
    }
  }

  trackBusinessMetric(metricName, value, tags = {}) {
    this.logger.info({
      metric: metricName,
      value: value,
      tags: tags,
      timestamp: new Date().toISOString()
    });

    if (metricName === 'automation_success_rate' && value < 0.95) {
      this.alerts.send({
        severity: 'warning',
        message: `Automation success rate dropped to ${(value * 100).toFixed(1)}%`,
        tags: ['business', 'automation']
      });
    }
  }

  getHealthStatus() {
    return {
      status: 'healthy',
      timestamp: new Date().toISOString(),
      metrics: Object.fromEntries(this.metrics),
      uptime: process.uptime()
    };
  }
}