Deployment

// utils/monitoring.ts
class ProductionMonitoring {
  private metricsEndpoint: string;
  private apiKey: string;

  constructor(config: { metricsEndpoint: string; apiKey: string }) {
    this.metricsEndpoint = config.metricsEndpoint;
    this.apiKey = config.apiKey;
  }

  // Application performance monitoring
  trackPageLoad(pageName: string, loadTime: number): void {
    this.sendMetric({
      type: 'performance',
      name: 'page_load',
      value: loadTime,
      tags: { page: pageName },
      timestamp: Date.now()
    });
  }

  trackQlikOperation(operation: string, duration: number, success: boolean): void {
    this.sendMetric({
      type: 'qlik_operation',
      name: operation,
      value: duration,
      tags: { success: success.toString() },
      timestamp: Date.now()
    });
  }

  trackError(error: Error, context: string): void {
    this.sendMetric({
      type: 'error',
      name: 'application_error',
      value: 1,
      tags: {
        error_type: error.name,
        context: context,
        message: error.message.substring(0, 100)
      },
      timestamp: Date.now()
    });
  }

  trackUserAction(action: string, metadata?: Record<string, any>): void {
    this.sendMetric({
      type: 'user_action',
      name: action,
      value: 1,
      tags: metadata || {},
      timestamp: Date.now()
    });
  }

  private async sendMetric(metric: any): Promise<void> {
    try {
      await fetch(this.metricsEndpoint, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
          'Authorization': `Bearer ${this.apiKey}`
        },
        body: JSON.stringify(metric)
      });
    } catch (error) {
      console.error('Failed to send metric:', error);
    }
  }
}

// Health check endpoint
// pages/api/health.ts
import { NextApiRequest, NextApiResponse } from 'next';

export default async function handler(req: NextApiRequest, res: NextApiResponse) {
  try {
    // Check database connectivity (if applicable)
    // Check external service connectivity (Qlik)
    const qlikHealthy = await checkQlikConnectivity();
    
    const health = {
      status: 'healthy',
      timestamp: new Date().toISOString(),
      version: process.env.npm_package_version || '1.0.0',
      environment: process.env.NODE_ENV,
      uptime: process.uptime(),
      memory: process.memoryUsage(),
      services: {
        qlik: qlikHealthy ? 'healthy' : 'unhealthy'
      }
    };

    const statusCode = qlikHealthy ? 200 : 503;
    res.status(statusCode).json(health);

  } catch (error) {
    res.status(503).json({
      status: 'unhealthy',
      error: error.message,
      timestamp: new Date().toISOString()
    });
  }
}

async function checkQlikConnectivity(): Promise<boolean> {
  try {
    // Basic connectivity check to Qlik
    const response = await fetch(`https://${process.env.QLIK_HOST}/api/v1/users/me`, {
      method: 'HEAD',
      timeout: 5000
    });
    return response.ok;
  } catch {
    return false;
  }
}