Qa Observability

// k6 Load Testing Template
//
// Use this template for performance testing and capacity planning.
// Run: k6 run load-testing-k6.js

import http from 'k6/http';
import { check, sleep, group } from 'k6';
import { Rate, Trend, Counter, Gauge } from 'k6/metrics';
import { randomIntBetween, randomItem } from 'https://jslib.k6.io/k6-utils/1.2.0/index.js';

// ====================
// Configuration
// ====================

// Test configuration
export const options = {
  // Scenario 1: Load Test (ramp up to target load)
  scenarios: {
    load_test: {
      executor: 'ramping-vus',
      startVUs: 0,
      stages: [
        { duration: '2m', target: 50 },   // Ramp up to 50 users
        { duration: '5m', target: 50 },   // Stay at 50 users
        { duration: '2m', target: 100 },  // Ramp up to 100 users
        { duration: '5m', target: 100 },  // Stay at 100 users
        { duration: '2m', target: 200 },  // Ramp up to 200 users
        { duration: '5m', target: 200 },  // Stay at 200 users
        { duration: '2m', target: 0 },    // Ramp down
      ],
      gracefulRampDown: '30s',
    },

    // Scenario 2: Spike Test (sudden traffic spike)
    // spike_test: {
    //   executor: 'ramping-vus',
    //   startTime: '25m',
    //   stages: [
    //     { duration: '10s', target: 500 },  // Spike to 500 users
    //     { duration: '1m', target: 500 },   // Hold spike
    //     { duration: '10s', target: 0 },    // Drop to 0
    //   ],
    // },

    // Scenario 3: Soak Test (sustained load)
    // soak_test: {
    //   executor: 'constant-vus',
    //   vus: 100,
    //   duration: '1h',
    // },
  },

  // Performance thresholds (test fails if violated)
  thresholds: {
    // HTTP request duration
    'http_req_duration': [
      'p(95)<500',  // 95% of requests < 500ms
      'p(99)<1000', // 99% of requests < 1s
    ],

    // HTTP request failed rate
    'http_req_failed': [
      'rate<0.01',  // Error rate < 1%
    ],

    // Custom metrics
    'order_duration': ['p(95)<1000'],
    'errors': ['rate<0.05'],
  },

  // HTTP configuration
  httpDebug: 'full', // Change to 'full' for debugging

  // Discard response bodies to save memory
  discardResponseBodies: false, // Set to true for high-load tests
};

// ====================
// Custom Metrics
// ====================

const orderDuration = new Trend('order_duration');
const checkoutDuration = new Trend('checkout_duration');
const errorRate = new Rate('errors');
const orderCount = new Counter('orders_created');
const activeOrders = new Gauge('active_orders');

// ====================
// Configuration
// ====================

const BASE_URL = __ENV.BASE_URL || 'https://api.example.com';
const AUTH_TOKEN = __ENV.AUTH_TOKEN || 'your-test-token';

// Test data
const PRODUCT_IDS = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
const USER_IDS = Array.from({ length: 100 }, (_, i) => i + 1);

// ====================
// Setup (runs once)
// ====================

export function setup() {
  console.log('Starting load test');
  console.log(`Base URL: ${BASE_URL}`);

  // Health check
  const res = http.get(`${BASE_URL}/health`);
  check(res, {
    'health check passed': (r) => r.status === 200,
  });

  return {
    startTime: Date.now(),
  };
}

// ====================
// Main Test Scenario
// ====================

export default function (data) {
  const userId = randomItem(USER_IDS);

  // Request headers
  const headers = {
    'Content-Type': 'application/json',
    'Authorization': `Bearer ${AUTH_TOKEN}`,
    'X-User-ID': userId.toString(),
  };

  // Scenario: Create Order Flow
  group('Create Order Flow', function () {
    // Step 1: Get products
    group('Get Products', function () {
      const res = http.get(`${BASE_URL}/api/products`, { headers });

      check(res, {
        'products: status 200': (r) => r.status === 200,
        'products: has data': (r) => JSON.parse(r.body).data.length > 0,
      }) || errorRate.add(1);
    });

    // Step 2: Create order
    group('Create Order', function () {
      const orderStart = Date.now();

      const payload = JSON.stringify({
        user_id: userId,
        items: [
          {
            product_id: randomItem(PRODUCT_IDS),
            quantity: randomIntBetween(1, 5),
          },
        ],
      });

      const res = http.post(`${BASE_URL}/api/orders`, payload, { headers });

      const duration = Date.now() - orderStart;
      orderDuration.add(duration);

      const success = check(res, {
        'order: status 201': (r) => r.status === 201,
        'order: has order_id': (r) => JSON.parse(r.body).order_id !== undefined,
        'order: response time < 1s': (r) => r.timings.duration < 1000,
      });

      if (success) {
        orderCount.add(1);
        const order = JSON.parse(res.body);
        activeOrders.add(1);

        // Step 3: Process payment
        group('Process Payment', function () {
          const paymentPayload = JSON.stringify({
            order_id: order.order_id,
            payment_method: 'card',
            amount: order.total,
          });

          const paymentRes = http.post(`${BASE_URL}/api/payments`, paymentPayload, { headers });

          check(paymentRes, {
            'payment: status 200': (r) => r.status === 200,
            'payment: success': (r) => JSON.parse(r.body).status === 'success',
          }) || errorRate.add(1);

          sleep(0.5); // User waits for payment confirmation
        });

      } else {
        errorRate.add(1);
      }
    });
  });

  // Scenario: Browse Products (80% of users)
  if (Math.random() < 0.8) {
    group('Browse Products', function () {
      const res = http.get(`${BASE_URL}/api/products?page=1&limit=20`, { headers });

      check(res, {
        'browse: status 200': (r) => r.status === 200,
        'browse: response time < 500ms': (r) => r.timings.duration < 500,
      }) || errorRate.add(1);
    });
  }

  // Scenario: View Order History (20% of users)
  if (Math.random() < 0.2) {
    group('View Order History', function () {
      const res = http.get(`${BASE_URL}/api/orders?user_id=${userId}`, { headers });

      check(res, {
        'history: status 200': (r) => r.status === 200,
      }) || errorRate.add(1);
    });
  }

  // Think time (simulate user reading, clicking)
  sleep(randomIntBetween(1, 3));
}

// ====================
// Teardown (runs once)
// ====================

export function teardown(data) {
  const duration = (Date.now() - data.startTime) / 1000 / 60;
  console.log(`Load test completed in ${duration.toFixed(2)} minutes`);
}

// ====================
// Advanced: Custom Summary
// ====================

export function handleSummary(data) {
  // Print summary to stdout
  console.log('=======================================');
  console.log('Load Test Summary');
  console.log('=======================================');
  console.log(`Total Requests: ${data.metrics.http_reqs.values.count}`);
  console.log(`Request Rate: ${data.metrics.http_reqs.values.rate.toFixed(2)} req/s`);
  console.log(`Failed Requests: ${(data.metrics.http_req_failed.values.rate * 100).toFixed(2)}%`);
  console.log(`P95 Latency: ${data.metrics.http_req_duration.values['p(95)'].toFixed(2)}ms`);
  console.log(`P99 Latency: ${data.metrics.http_req_duration.values['p(99)'].toFixed(2)}ms`);
  console.log('=======================================');

  // Return JSON summary for CI/CD
  return {
    'summary.json': JSON.stringify(data, null, 2),
    'stdout': textSummary(data, { indent: ' ', enableColors: true }),
  };
}

// Helper for text summary
function textSummary(data, options) {
  return 'Load test completed';
}

// ====================
// Usage Examples
// ====================

/*
1. Basic load test:
   k6 run load-testing-k6.js

2. Custom target:
   k6 run --vus 100 --duration 10m load-testing-k6.js

3. Custom base URL:
   k6 run -e BASE_URL=https://staging.example.com load-testing-k6.js

4. Cloud execution:
   k6 cloud load-testing-k6.js

5. CI/CD integration:
   k6 run --out json=results.json load-testing-k6.js

6. Thresholds only (no summary):
   k6 run --quiet load-testing-k6.js

7. Different scenarios:
   k6 run --scenario spike_test load-testing-k6.js
*/

# Artillery Load Testing Template
#
# Alternative to k6 - YAML-based load testing
# Install: npm install -g artillery
# Run: artillery run load-test.yaml

config:
  target: "https://api.example.com"
  phases:
    # Warm-up phase
    - duration: 60
      arrivalRate: 5
      name: "Warm up"

    # Ramp up to target load
    - duration: 120
      arrivalRate: 5
      rampTo: 50
      name: "Ramp up to 50 users/sec"

    # Sustained load
    - duration: 300
      arrivalRate: 50
      name: "Sustained load (50 users/sec)"

    # Peak load
    - duration: 120
      arrivalRate: 50
      rampTo: 100
      name: "Ramp up to 100 users/sec"

    # Peak sustained
    - duration: 300
      arrivalRate: 100
      name: "Peak load (100 users/sec)"

    # Ramp down
    - duration: 60
      arrivalRate: 100
      rampTo: 0
      name: "Ramp down"

  # HTTP configuration
  http:
    timeout: 30
    pool: 50  # Connection pool size

  # Performance thresholds
  ensure:
    p95: 500  # P95 latency < 500ms
    p99: 1000 # P99 latency < 1s
    maxErrorRate: 1  # Error rate < 1%

  # Variables
  variables:
    user_ids:
      - "user-1"
      - "user-2"
      - "user-3"
      - "user-4"
      - "user-5"

    product_ids:
      - 101
      - 102
      - 103
      - 104
      - 105

  # Plugins
  plugins:
    metrics-by-endpoint:
      stripQueryString: true
    expect: {}

scenarios:
  # Scenario 1: Browse products (60% of users)
  - name: "Browse Products"
    weight: 60
    flow:
      - get:
          url: "/api/products"
          headers:
            Authorization: "Bearer {{ $processEnvironment.AUTH_TOKEN }}"
            X-User-ID: "{{ user_ids }}"
          capture:
            - json: "$.data[0].id"
              as: "product_id"
          expect:
            - statusCode: 200
            - contentType: json
            - hasProperty: data

      - think: 2  # User reads for 2 seconds

      - get:
          url: "/api/products/{{ product_id }}"
          headers:
            Authorization: "Bearer {{ $processEnvironment.AUTH_TOKEN }}"
          expect:
            - statusCode: 200

      - think: 3

  # Scenario 2: Create order (30% of users)
  - name: "Create Order"
    weight: 30
    flow:
      - post:
          url: "/api/orders"
          headers:
            Authorization: "Bearer {{ $processEnvironment.AUTH_TOKEN }}"
            Content-Type: "application/json"
            X-User-ID: "{{ user_ids }}"
          json:
            items:
              - product_id: "{{ product_ids }}"
                quantity: "{{ $randomNumber(1, 5) }}"
          capture:
            - json: "$.order_id"
              as: "order_id"
          expect:
            - statusCode: 201
            - hasProperty: order_id

      - think: 1

      - get:
          url: "/api/orders/{{ order_id }}"
          headers:
            Authorization: "Bearer {{ $processEnvironment.AUTH_TOKEN }}"
          expect:
            - statusCode: 200

  # Scenario 3: View order history (10% of users)
  - name: "View Order History"
    weight: 10
    flow:
      - get:
          url: "/api/orders?user_id={{ user_ids }}"
          headers:
            Authorization: "Bearer {{ $processEnvironment.AUTH_TOKEN }}"
          expect:
            - statusCode: 200
            - contentType: json

# Custom metrics
# after:
#   flow:
#     - log: "Test completed"

# Reporting
# artillery run load-test.yaml --output report.json
# artillery report report.json --output report.html

{
  "dashboard": {
    "title": "Service SLO Dashboard",
    "tags": ["slo", "observability", "production"],
    "timezone": "browser",
    "refresh": "1m",
    "time": {
      "from": "now-30d",
      "to": "now"
    },
    "panels": [
      {
        "id": 1,
        "title": "Availability SLI (30d Rolling)",
        "type": "gauge",
        "gridPos": { "x": 0, "y": 0, "w": 6, "h": 6 },
        "targets": [
          {
            "expr": "sum(rate(http_requests_total{service=\"$service\",status!~\"5..\"}[30d])) / sum(rate(http_requests_total{service=\"$service\"}[30d]))",
            "legendFormat": "Availability"
          }
        ],
        "options": {
          "orientation": "auto",
          "showThresholdLabels": true,
          "showThresholdMarkers": true
        },
        "fieldConfig": {
          "defaults": {
            "unit": "percentunit",
            "min": 0.99,
            "max": 1,
            "thresholds": {
              "mode": "absolute",
              "steps": [
                { "value": 0.99, "color": "red" },
                { "value": 0.995, "color": "yellow" },
                { "value": 0.999, "color": "green" }
              ]
            }
          }
        }
      },
      {
        "id": 2,
        "title": "Error Budget Remaining",
        "type": "gauge",
        "gridPos": { "x": 6, "y": 0, "w": 6, "h": 6 },
        "targets": [
          {
            "expr": "((0.999 - (1 - (sum(rate(http_requests_total{service=\"$service\",status!~\"5..\"}[30d])) / sum(rate(http_requests_total{service=\"$service\"}[30d]))))) / 0.001) * 100",
            "legendFormat": "Budget Remaining"
          }
        ],
        "options": {
          "orientation": "auto",
          "showThresholdLabels": true,
          "showThresholdMarkers": true
        },
        "fieldConfig": {
          "defaults": {
            "unit": "percent",
            "min": 0,
            "max": 100,
            "thresholds": {
              "mode": "absolute",
              "steps": [
                { "value": 0, "color": "red" },
                { "value": 10, "color": "orange" },
                { "value": 25, "color": "yellow" },
                { "value": 50, "color": "green" }
              ]
            }
          }
        }
      },
      {
        "id": 3,
        "title": "P99 Latency (Target: 500ms)",
        "type": "gauge",
        "gridPos": { "x": 12, "y": 0, "w": 6, "h": 6 },
        "targets": [
          {
            "expr": "histogram_quantile(0.99, rate(http_request_duration_seconds_bucket{service=\"$service\"}[5m]))",
            "legendFormat": "P99 Latency"
          }
        ],
        "options": {
          "orientation": "auto",
          "showThresholdLabels": true,
          "showThresholdMarkers": true
        },
        "fieldConfig": {
          "defaults": {
            "unit": "s",
            "min": 0,
            "max": 2,
            "thresholds": {
              "mode": "absolute",
              "steps": [
                { "value": 0, "color": "green" },
                { "value": 0.5, "color": "yellow" },
                { "value": 1.0, "color": "red" }
              ]
            }
          }
        }
      },
      {
        "id": 4,
        "title": "Request Rate (req/s)",
        "type": "stat",
        "gridPos": { "x": 18, "y": 0, "w": 6, "h": 6 },
        "targets": [
          {
            "expr": "sum(rate(http_requests_total{service=\"$service\"}[5m]))",
            "legendFormat": "Requests/s"
          }
        ],
        "options": {
          "colorMode": "value",
          "graphMode": "area",
          "justifyMode": "auto",
          "orientation": "auto"
        },
        "fieldConfig": {
          "defaults": {
            "unit": "reqps",
            "decimals": 2
          }
        }
      },
      {
        "id": 5,
        "title": "SLI History (30 days)",
        "type": "graph",
        "gridPos": { "x": 0, "y": 6, "w": 12, "h": 8 },
        "targets": [
          {
            "expr": "0.999",
            "legendFormat": "Target (99.9%)"
          },
          {
            "expr": "sum(rate(http_requests_total{service=\"$service\",status!~\"5..\"}[1h])) / sum(rate(http_requests_total{service=\"$service\"}[1h]))",
            "legendFormat": "Actual SLI"
          }
        ],
        "yaxes": [
          {
            "format": "percentunit",
            "min": 0.99,
            "max": 1
          }
        ],
        "seriesOverrides": [
          {
            "alias": "Target (99.9%)",
            "color": "#73BF69",
            "dashes": true,
            "fill": 0,
            "linewidth": 2
          },
          {
            "alias": "Actual SLI",
            "color": "#5794F2",
            "fill": 1,
            "fillGradient": 5
          }
        ]
      },
      {
        "id": 6,
        "title": "Error Budget Burn Rate (1h window)",
        "type": "graph",
        "gridPos": { "x": 12, "y": 6, "w": 12, "h": 8 },
        "targets": [
          {
            "expr": "(1 - (sum(rate(http_requests_total{service=\"$service\",status!~\"5..\"}[1h])) / sum(rate(http_requests_total{service=\"$service\"}[1h])))) / (1 - 0.999)",
            "legendFormat": "Burn Rate"
          },
          {
            "expr": "14.4",
            "legendFormat": "Critical Threshold (14.4x)"
          },
          {
            "expr": "6",
            "legendFormat": "Warning Threshold (6x)"
          }
        ],
        "yaxes": [
          {
            "format": "short",
            "min": 0,
            "max": 20
          }
        ],
        "seriesOverrides": [
          {
            "alias": "Critical Threshold (14.4x)",
            "color": "#F2495C",
            "dashes": true,
            "fill": 0
          },
          {
            "alias": "Warning Threshold (6x)",
            "color": "#FF9830",
            "dashes": true,
            "fill": 0
          }
        ]
      },
      {
        "id": 7,
        "title": "Latency Distribution (P50, P95, P99)",
        "type": "graph",
        "gridPos": { "x": 0, "y": 14, "w": 12, "h": 8 },
        "targets": [
          {
            "expr": "histogram_quantile(0.50, rate(http_request_duration_seconds_bucket{service=\"$service\"}[5m]))",
            "legendFormat": "P50"
          },
          {
            "expr": "histogram_quantile(0.95, rate(http_request_duration_seconds_bucket{service=\"$service\"}[5m]))",
            "legendFormat": "P95"
          },
          {
            "expr": "histogram_quantile(0.99, rate(http_request_duration_seconds_bucket{service=\"$service\"}[5m]))",
            "legendFormat": "P99"
          },
          {
            "expr": "0.5",
            "legendFormat": "SLO Target (500ms)"
          }
        ],
        "yaxes": [
          {
            "format": "s",
            "min": 0
          }
        ],
        "seriesOverrides": [
          {
            "alias": "SLO Target (500ms)",
            "color": "#73BF69",
            "dashes": true,
            "fill": 0
          }
        ]
      },
      {
        "id": 8,
        "title": "Error Rate by Status Code",
        "type": "graph",
        "gridPos": { "x": 12, "y": 14, "w": 12, "h": 8 },
        "targets": [
          {
            "expr": "sum by (status) (rate(http_requests_total{service=\"$service\",status=~\"5..\"}[5m]))",
            "legendFormat": "{{status}}"
          }
        ],
        "yaxes": [
          {
            "format": "reqps",
            "min": 0
          }
        ],
        "stack": true
      },
      {
        "id": 9,
        "title": "Active Alerts",
        "type": "table",
        "gridPos": { "x": 0, "y": 22, "w": 24, "h": 6 },
        "targets": [
          {
            "expr": "ALERTS{service=\"$service\",alertstate=\"firing\"}",
            "format": "table",
            "instant": true
          }
        ],
        "transformations": [
          {
            "id": "organize",
            "options": {
              "excludeByName": {
                "Time": true,
                "Value": true,
                "__name__": true
              },
              "indexByName": {
                "alertname": 0,
                "severity": 1,
                "alertstate": 2,
                "summary": 3
              }
            }
          }
        ]
      }
    ],
    "templating": {
      "list": [
        {
          "name": "service",
          "type": "query",
          "datasource": "Prometheus",
          "query": "label_values(http_requests_total, service)",
          "multi": false,
          "includeAll": false,
          "current": {
            "value": "order-api",
            "text": "order-api"
          }
        }
      ]
    },
    "annotations": {
      "list": [
        {
          "name": "Deployments",
          "datasource": "Prometheus",
          "expr": "changes(deployment_info{service=\"$service\"}[5m]) > 0",
          "iconColor": "blue",
          "enable": true
        },
        {
          "name": "Incidents",
          "datasource": "Prometheus",
          "expr": "ALERTS{service=\"$service\",alertstate=\"firing\",severity=\"critical\"}",
          "iconColor": "red",
          "enable": true
        }
      ]
    }
  }
}

{
  "dashboard": {
    "title": "Service Observability - Unified Dashboard",
    "description": "Unified observability dashboard combining logs, metrics, and traces",
    "tags": ["observability", "production", "unified"],
    "timezone": "browser",
    "refresh": "30s",
    "time": {
      "from": "now-1h",
      "to": "now"
    },
    "panels": [
      {
        "id": 1,
        "title": "Request Rate (req/s)",
        "type": "graph",
        "gridPos": { "x": 0, "y": 0, "w": 8, "h": 6 },
        "targets": [
          {
            "expr": "sum(rate(http_requests_total{service=\"$service\"}[5m])) by (status)",
            "legendFormat": "{{status}}"
          }
        ],
        "yaxes": [
          {
            "format": "reqps",
            "min": 0
          }
        ]
      },
      {
        "id": 2,
        "title": "Error Rate (%)",
        "type": "graph",
        "gridPos": { "x": 8, "y": 0, "w": 8, "h": 6 },
        "targets": [
          {
            "expr": "(sum(rate(http_requests_total{service=\"$service\",status=~\"5..\"}[5m])) / sum(rate(http_requests_total{service=\"$service\"}[5m]))) * 100",
            "legendFormat": "Error Rate"
          }
        ],
        "yaxes": [
          {
            "format": "percent",
            "min": 0,
            "max": 100
          }
        ],
        "alert": {
          "conditions": [
            {
              "evaluator": {
                "params": [5],
                "type": "gt"
              },
              "query": {
                "params": ["A", "5m", "now"]
              },
              "type": "query"
            }
          ],
          "frequency": "1m",
          "handler": 1,
          "message": "Error rate above 5%",
          "name": "High Error Rate"
        }
      },
      {
        "id": 3,
        "title": "Latency (P50, P95, P99)",
        "type": "graph",
        "gridPos": { "x": 16, "y": 0, "w": 8, "h": 6 },
        "targets": [
          {
            "expr": "histogram_quantile(0.50, rate(http_request_duration_seconds_bucket{service=\"$service\"}[5m]))",
            "legendFormat": "P50"
          },
          {
            "expr": "histogram_quantile(0.95, rate(http_request_duration_seconds_bucket{service=\"$service\"}[5m]))",
            "legendFormat": "P95"
          },
          {
            "expr": "histogram_quantile(0.99, rate(http_request_duration_seconds_bucket{service=\"$service\"}[5m]))",
            "legendFormat": "P99"
          }
        ],
        "yaxes": [
          {
            "format": "s",
            "min": 0
          }
        ]
      },
      {
        "id": 4,
        "title": "Active Traces (last 5m)",
        "type": "stat",
        "gridPos": { "x": 0, "y": 6, "w": 4, "h": 4 },
        "targets": [
          {
            "expr": "sum(increase(traces_total{service=\"$service\"}[5m]))",
            "legendFormat": "Traces"
          }
        ],
        "options": {
          "colorMode": "value",
          "graphMode": "area"
        }
      },
      {
        "id": 5,
        "title": "Error Logs (last 5m)",
        "type": "stat",
        "gridPos": { "x": 4, "y": 6, "w": 4, "h": 4 },
        "targets": [
          {
            "expr": "sum(increase(log_messages_total{service=\"$service\",level=\"error\"}[5m]))",
            "legendFormat": "Errors"
          }
        ],
        "options": {
          "colorMode": "value",
          "graphMode": "area"
        },
        "fieldConfig": {
          "defaults": {
            "thresholds": {
              "mode": "absolute",
              "steps": [
                { "value": 0, "color": "green" },
                { "value": 10, "color": "yellow" },
                { "value": 50, "color": "red" }
              ]
            }
          }
        }
      },
      {
        "id": 6,
        "title": "Active Alerts",
        "type": "stat",
        "gridPos": { "x": 8, "y": 6, "w": 4, "h": 4 },
        "targets": [
          {
            "expr": "count(ALERTS{service=\"$service\",alertstate=\"firing\"})",
            "legendFormat": "Firing"
          }
        ],
        "options": {
          "colorMode": "background"
        },
        "fieldConfig": {
          "defaults": {
            "thresholds": {
              "mode": "absolute",
              "steps": [
                { "value": 0, "color": "green" },
                { "value": 1, "color": "orange" },
                { "value": 3, "color": "red" }
              ]
            }
          }
        }
      },
      {
        "id": 7,
        "title": "CPU Usage (%)",
        "type": "gauge",
        "gridPos": { "x": 12, "y": 6, "w": 6, "h": 4 },
        "targets": [
          {
            "expr": "avg(rate(process_cpu_seconds_total{service=\"$service\"}[5m])) * 100",
            "legendFormat": "CPU"
          }
        ],
        "fieldConfig": {
          "defaults": {
            "unit": "percent",
            "min": 0,
            "max": 100,
            "thresholds": {
              "mode": "absolute",
              "steps": [
                { "value": 0, "color": "green" },
                { "value": 70, "color": "yellow" },
                { "value": 90, "color": "red" }
              ]
            }
          }
        }
      },
      {
        "id": 8,
        "title": "Memory Usage (MB)",
        "type": "gauge",
        "gridPos": { "x": 18, "y": 6, "w": 6, "h": 4 },
        "targets": [
          {
            "expr": "avg(process_resident_memory_bytes{service=\"$service\"}) / 1024 / 1024",
            "legendFormat": "Memory"
          }
        ],
        "fieldConfig": {
          "defaults": {
            "unit": "decmbytes",
            "thresholds": {
              "mode": "absolute",
              "steps": [
                { "value": 0, "color": "green" },
                { "value": 400, "color": "yellow" },
                { "value": 800, "color": "red" }
              ]
            }
          }
        }
      },
      {
        "id": 9,
        "title": "Recent Error Logs",
        "type": "logs",
        "gridPos": { "x": 0, "y": 10, "w": 12, "h": 8 },
        "targets": [
          {
            "expr": "{service=\"$service\", level=\"error\"}",
            "refId": "A"
          }
        ],
        "options": {
          "showTime": true,
          "showLabels": true,
          "sortOrder": "Descending",
          "wrapLogMessage": true
        }
      },
      {
        "id": 10,
        "title": "Slowest Traces (P99)",
        "type": "table",
        "gridPos": { "x": 12, "y": 10, "w": 12, "h": 8 },
        "targets": [
          {
            "expr": "topk(10, histogram_quantile(0.99, rate(http_request_duration_seconds_bucket{service=\"$service\"}[5m])) by (endpoint))",
            "format": "table",
            "instant": true
          }
        ],
        "transformations": [
          {
            "id": "organize",
            "options": {
              "excludeByName": {
                "Time": true
              },
              "renameByName": {
                "endpoint": "Endpoint",
                "Value": "P99 Latency (s)"
              }
            }
          }
        ]
      },
      {
        "id": 11,
        "title": "Trace Waterfall (Click to explore)",
        "type": "traces",
        "gridPos": { "x": 0, "y": 18, "w": 24, "h": 10 },
        "datasource": "Jaeger",
        "targets": [
          {
            "query": "service=\"$service\"",
            "refId": "A"
          }
        ],
        "options": {
          "showSpanDetails": true,
          "showServiceGraph": true
        }
      }
    ],
    "templating": {
      "list": [
        {
          "name": "service",
          "type": "query",
          "datasource": "Prometheus",
          "query": "label_values(http_requests_total, service)",
          "multi": false,
          "includeAll": false,
          "current": {
            "value": "order-api",
            "text": "order-api"
          }
        },
        {
          "name": "environment",
          "type": "query",
          "datasource": "Prometheus",
          "query": "label_values(http_requests_total{service=\"$service\"}, environment)",
          "multi": false,
          "includeAll": false
        }
      ]
    },
    "annotations": {
      "list": [
        {
          "name": "Deployments",
          "datasource": "Prometheus",
          "expr": "changes(deployment_info{service=\"$service\"}[5m]) > 0",
          "iconColor": "blue",
          "enable": true,
          "tagKeys": "version"
        },
        {
          "name": "Incidents",
          "datasource": "Prometheus",
          "expr": "ALERTS{service=\"$service\",alertstate=\"firing\",severity=\"critical\"}",
          "iconColor": "red",
          "enable": true
        },
        {
          "name": "Slow Requests",
          "datasource": "Jaeger",
          "query": "service=\"$service\" AND duration > 1s",
          "iconColor": "orange",
          "enable": true
        }
      ]
    },
    "links": [
      {
        "title": "Jaeger - Trace Explorer",
        "url": "http://jaeger:16686/search?service=$service",
        "type": "link",
        "icon": "external link"
      },
      {
        "title": "Prometheus - Service Metrics",
        "url": "http://prometheus:9090/graph?g0.expr=http_requests_total%7Bservice%3D%22$service%22%7D",
        "type": "link",
        "icon": "external link"
      },
      {
        "title": "Loki - Service Logs",
        "url": "http://loki:3100/loki/api/v1/query_range?query=%7Bservice%3D%22$service%22%7D",
        "type": "link",
        "icon": "external link"
      }
    ]
  }
}

# Prometheus Alert Rules for SLO Monitoring
#
# This template provides production-ready alert rules based on Google SRE practices.
# Deploy to Prometheus via ConfigMap or rules file.

groups:
  # ============================================================
  # SLO Burn Rate Alerts (Multi-Window)
  # Based on Google SRE Workbook Chapter 5
  # ============================================================
  - name: slo-burn-rate-alerts
    interval: 30s
    rules:
      # Fast Burn - Critical (2% budget in 1 hour)
      - alert: ErrorBudgetBurnRateCritical1h
        expr: |
          (
            1 - (
              sum(rate(http_requests_total{service="$SERVICE",status!~"5.."}[1h]))
              /
              sum(rate(http_requests_total{service="$SERVICE"}[1h]))
            )
          ) > (14.4 * (1 - $SLO_TARGET))
        for: 2m
        labels:
          severity: critical
          slo: availability
          burn_rate: fast
        annotations:
          summary: "Critical error budget burn rate for {{ $labels.service }}"
          description: |
            Service {{ $labels.service }} is consuming 2% of 30-day error budget in 1 hour.
            Current error rate: {{ $value | humanizePercentage }}
            At this rate, entire error budget will be exhausted in 50 hours.
          runbook_url: "https://wiki.example.com/runbooks/high-error-rate"
          dashboard_url: "https://grafana.example.com/d/slo/{{ $labels.service }}"

      # Fast Burn - Warning (5% budget in 6 hours)
      - alert: ErrorBudgetBurnRateWarning6h
        expr: |
          (
            1 - (
              sum(rate(http_requests_total{service="$SERVICE",status!~"5.."}[6h]))
              /
              sum(rate(http_requests_total{service="$SERVICE"}[6h]))
            )
          ) > (6 * (1 - $SLO_TARGET))
        for: 15m
        labels:
          severity: warning
          slo: availability
          burn_rate: fast
        annotations:
          summary: "Warning error budget burn rate for {{ $labels.service }}"
          description: |
            Service {{ $labels.service }} is consuming 5% of 30-day error budget in 6 hours.
            Current error rate: {{ $value | humanizePercentage }}
            At this rate, entire error budget will be exhausted in 5 days.
          runbook_url: "https://wiki.example.com/runbooks/elevated-error-rate"

      # Slow Burn - Warning (10% budget in 1 day)
      - alert: ErrorBudgetBurnRateWarning1d
        expr: |
          (
            1 - (
              sum(rate(http_requests_total{service="$SERVICE",status!~"5.."}[1d]))
              /
              sum(rate(http_requests_total{service="$SERVICE"}[1d]))
            )
          ) > (3 * (1 - $SLO_TARGET))
        for: 1h
        labels:
          severity: warning
          slo: availability
          burn_rate: slow
        annotations:
          summary: "Slow error budget burn for {{ $labels.service }}"
          description: |
            Service {{ $labels.service }} is consuming 10% of 30-day error budget in 1 day.
            Current error rate: {{ $value | humanizePercentage }}
            At this rate, entire error budget will be exhausted in 10 days.

      # Slow Burn - Info (10% budget in 3 days)
      - alert: ErrorBudgetBurnRateInfo3d
        expr: |
          (
            1 - (
              sum(rate(http_requests_total{service="$SERVICE",status!~"5.."}[3d]))
              /
              sum(rate(http_requests_total{service="$SERVICE"}[3d]))
            )
          ) > (1 * (1 - $SLO_TARGET))
        for: 6h
        labels:
          severity: info
          slo: availability
          burn_rate: slow
        annotations:
          summary: "Error budget consumption for {{ $labels.service }}"
          description: |
            Service {{ $labels.service }} is on track to consume entire error budget by end of window.
            Current error rate: {{ $value | humanizePercentage }}

  # ============================================================
  # Latency SLO Alerts
  # ============================================================
  - name: latency-slo-alerts
    interval: 30s
    rules:
      - alert: LatencyP99Degradation
        expr: |
          histogram_quantile(0.99,
            rate(http_request_duration_seconds_bucket{service="$SERVICE"}[5m])
          ) > $LATENCY_TARGET_SECONDS
        for: 10m
        labels:
          severity: warning
          slo: latency
        annotations:
          summary: "P99 latency above target for {{ $labels.service }}"
          description: |
            P99 latency is {{ $value | humanizeDuration }}, target is {{ $LATENCY_TARGET_SECONDS }}s
            Service: {{ $labels.service }}
            Endpoint: {{ $labels.endpoint }}
          runbook_url: "https://wiki.example.com/runbooks/high-latency"

      - alert: LatencyP99Critical
        expr: |
          histogram_quantile(0.99,
            rate(http_request_duration_seconds_bucket{service="$SERVICE"}[5m])
          ) > ($LATENCY_TARGET_SECONDS * 2)
        for: 5m
        labels:
          severity: critical
          slo: latency
        annotations:
          summary: "P99 latency critically high for {{ $labels.service }}"
          description: |
            P99 latency is {{ $value | humanizeDuration }}, 2x the target of {{ $LATENCY_TARGET_SECONDS }}s
            Immediate investigation required.

  # ============================================================
  # Error Budget Exhaustion Alerts
  # ============================================================
  - name: error-budget-alerts
    interval: 5m
    rules:
      - alert: ErrorBudgetNearlyExhausted
        expr: |
          (
            (($SLO_TARGET) - (
              1 - (
                sum(rate(http_requests_total{service="$SERVICE",status!~"5.."}[30d]))
                /
                sum(rate(http_requests_total{service="$SERVICE"}[30d]))
              )
            )) / (1 - $SLO_TARGET)
          ) * 100 < 10
        for: 30m
        labels:
          severity: warning
        annotations:
          summary: "Error budget nearly exhausted for {{ $labels.service }}"
          description: |
            Only {{ $value | humanize }}% of error budget remaining for {{ $labels.service }}.
            Consider feature freeze to preserve reliability.

      - alert: ErrorBudgetExhausted
        expr: |
          (
            (($SLO_TARGET) - (
              1 - (
                sum(rate(http_requests_total{service="$SERVICE",status!~"5.."}[30d]))
                /
                sum(rate(http_requests_total{service="$SERVICE"}[30d]))
              )
            )) / (1 - $SLO_TARGET)
          ) * 100 <= 0
        for: 15m
        labels:
          severity: critical
        annotations:
          summary: "Error budget exhausted for {{ $labels.service }}"
          description: |
            Error budget is EXHAUSTED for {{ $labels.service }}.
            Immediate action required:
            - Stop all feature releases
            - Focus on reliability improvements
            - Incident response mode

  # ============================================================
  # Traffic Anomaly Detection
  # ============================================================
  - name: traffic-anomalies
    interval: 1m
    rules:
      - alert: TrafficDropSignificant
        expr: |
          (
            sum(rate(http_requests_total{service="$SERVICE"}[5m]))
            /
            sum(rate(http_requests_total{service="$SERVICE"}[5m] offset 1h))
          ) < 0.5
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "Traffic dropped significantly for {{ $labels.service }}"
          description: |
            Current traffic is 50% below traffic 1 hour ago.
            This may indicate an outage or upstream issue.
            Current: {{ $value | humanize }} req/s

      - alert: TrafficSpikeUnexpected
        expr: |
          (
            sum(rate(http_requests_total{service="$SERVICE"}[5m]))
            /
            sum(rate(http_requests_total{service="$SERVICE"}[5m] offset 1h))
          ) > 3
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "Unexpected traffic spike for {{ $labels.service }}"
          description: |
            Current traffic is 3x higher than 1 hour ago.
            Current: {{ $value | humanize }} req/s
            Check for DDoS, viral event, or misconfiguration.

  # ============================================================
  # Availability Alerts (Blackbox Monitoring)
  # ============================================================
  - name: availability-blackbox
    interval: 30s
    rules:
      - alert: ServiceDown
        expr: up{job="$SERVICE"} == 0
        for: 1m
        labels:
          severity: critical
        annotations:
          summary: "Service {{ $labels.service }} is down"
          description: |
            Service {{ $labels.instance }} has been down for more than 1 minute.
            Target: {{ $labels.instance }}

      - alert: HealthCheckFailing
        expr: probe_success{job="$SERVICE-health"} == 0
        for: 2m
        labels:
          severity: critical
        annotations:
          summary: "Health check failing for {{ $labels.service }}"
          description: |
            Health check for {{ $labels.instance }} has been failing for 2 minutes.
            Check application logs and resource usage.

# ============================================================
# Usage Examples
# ============================================================

# 1. Deploy to Kubernetes via ConfigMap:
#
# kubectl create configmap prometheus-rules \
#   --from-file=slo-alerts.yaml \
#   --namespace=monitoring
#
# 2. Set variables in prometheus.yaml:
#
# global:
#   external_labels:
#     SERVICE: "order-api"
#     SLO_TARGET: "0.999"
#     LATENCY_TARGET_SECONDS: "0.5"
#
# 3. Test alerts:
#
# promtool test rules slo-alerts.yaml
#
# 4. Validate in Prometheus UI:
#
# http://prometheus:9090/alerts

# ============================================================
# Common SLO Targets
# ============================================================

# Service Type              | Availability SLO | Latency SLO (P99)
# --------------------------|------------------|-------------------
# User-facing API           | 99.9% (0.999)   | 500ms (0.5s)
# Internal API              | 99.5% (0.995)   | 1s
# Batch processing          | 99% (0.99)      | N/A
# Critical payment service  | 99.99% (0.9999) | 200ms (0.2s)

# SLO Definition Template
#
# Use this template to define Service Level Objectives (SLOs) for your services.
# Based on Google SRE best practices.

---
# Service: Order API
service:
  name: order-api
  description: Core API for order processing
  team: platform-team
  oncall: platform-oncall@company.com

# SLOs
slos:
  # Availability SLO
  - name: order-api-availability
    objective: "99.9% of order API requests succeed over 30 days"
    sli:
      type: availability
      measurement: |
        sum(rate(http_requests_total{service="order-api",status!~"5.."}[30d]))
        /
        sum(rate(http_requests_total{service="order-api"}[30d]))
      datasource: prometheus
    target: 0.999  # 99.9%
    window: 30d
    error_budget:
      allowed_failure_rate: 0.1%  # 0.001
      allowed_downtime_minutes: 43.2  # per 30 days
      burn_rate_alerts:
        - name: critical-burn-1h
          window: 1h
          burn_rate: 14.4
          budget_consumed: 2%
          severity: critical
          notification: pagerduty
        - name: critical-burn-6h
          window: 6h
          burn_rate: 6
          budget_consumed: 5%
          severity: critical
          notification: slack
        - name: warning-burn-1d
          window: 1d
          burn_rate: 3
          budget_consumed: 10%
          severity: warning
          notification: slack
    error_budget_policy:
      - threshold: 50%
        action: full_velocity
        description: "Ship all features, run experiments"
      - threshold: 25%
        action: reduced_velocity
        description: "Critical features only, increase test coverage"
      - threshold: 10%
        action: feature_freeze
        description: "Stop feature releases, focus on reliability"
      - threshold: 0%
        action: incident_mode
        description: "Emergency response, stop all releases"

  # Latency SLO
  - name: order-api-latency-p99
    objective: "99% of order API requests complete in < 500ms over 30 days"
    sli:
      type: latency
      measurement: |
        histogram_quantile(0.99,
          rate(http_request_duration_seconds_bucket{service="order-api"}[30d])
        )
      datasource: prometheus
    target: 0.5  # 500ms
    window: 30d
    error_budget:
      allowed_slow_requests: 1%
      burn_rate_alerts:
        - name: latency-degradation
          window: 1h
          threshold: 1000  # P99 > 1s for 1 hour
          severity: warning
          notification: slack

  # User Journey SLO (Checkout Flow)
  - name: checkout-success-rate
    objective: "95% of checkout flows complete successfully over 7 days"
    sli:
      type: success_rate
      measurement: |
        sum(rate(checkout_completed_total{service="order-api"}[7d]))
        /
        sum(rate(checkout_started_total{service="order-api"}[7d]))
      datasource: prometheus
    target: 0.95  # 95%
    window: 7d
    error_budget:
      allowed_failure_rate: 5%
      burn_rate_alerts:
        - name: checkout-failure-spike
          window: 1h
          burn_rate: 10
          severity: critical
          notification: pagerduty

# Prometheus Alert Rules
prometheus_alerts:
  groups:
    - name: slo-burn-rate-order-api
      interval: 30s
      rules:
        # Fast burn (1 hour window)
        - alert: OrderAPIErrorBudgetBurnRateCritical1h
          expr: |
            (
              1 - (
                sum(rate(http_requests_total{service="order-api",status!~"5.."}[1h]))
                /
                sum(rate(http_requests_total{service="order-api"}[1h]))
              )
            ) > (14.4 * (1 - 0.999))
          for: 2m
          labels:
            severity: critical
            service: order-api
            slo: availability
          annotations:
            summary: "Critical error budget burn rate for Order API (1h window)"
            description: "Consuming 2% of 30-day error budget in 1 hour. Current error rate {{ $value | humanizePercentage }}"
            runbook_url: "https://wiki.company.com/runbooks/order-api-high-error-rate"

        # Slow burn (6 hour window)
        - alert: OrderAPIErrorBudgetBurnRateWarning6h
          expr: |
            (
              1 - (
                sum(rate(http_requests_total{service="order-api",status!~"5.."}[6h]))
                /
                sum(rate(http_requests_total{service="order-api"}[6h]))
              )
            ) > (6 * (1 - 0.999))
          for: 15m
          labels:
            severity: warning
            service: order-api
            slo: availability
          annotations:
            summary: "Warning error budget burn rate for Order API (6h window)"
            description: "Consuming 5% of 30-day error budget in 6 hours. Current error rate {{ $value | humanizePercentage }}"
            runbook_url: "https://wiki.company.com/runbooks/order-api-high-error-rate"

        # Latency SLO
        - alert: OrderAPILatencyDegradation
          expr: |
            histogram_quantile(0.99,
              rate(http_request_duration_seconds_bucket{service="order-api"}[1h])
            ) > 1.0
          for: 5m
          labels:
            severity: warning
            service: order-api
            slo: latency
          annotations:
            summary: "Order API P99 latency above 1s"
            description: "P99 latency is {{ $value | humanizeDuration }}, target is 500ms"
            runbook_url: "https://wiki.company.com/runbooks/order-api-slow-requests"

# Dashboard Configuration
grafana_dashboard:
  title: "Order API - SLO Dashboard"
  panels:
    - title: "Availability SLI (30d)"
      type: gauge
      query: |
        sum(rate(http_requests_total{service="order-api",status!~"5.."}[30d]))
        /
        sum(rate(http_requests_total{service="order-api"}[30d]))
      thresholds:
        - value: 0.999
          color: green
        - value: 0.995
          color: yellow
        - value: 0.99
          color: red

    - title: "Error Budget Remaining"
      type: gauge
      query: |
        (
          (0.999 - (
            1 - (
              sum(rate(http_requests_total{service="order-api",status!~"5.."}[30d]))
              /
              sum(rate(http_requests_total{service="order-api"}[30d]))
            )
          )) / 0.001
        ) * 100
      thresholds:
        - value: 50
          color: green
        - value: 25
          color: yellow
        - value: 10
          color: red

    - title: "Error Budget Burn Rate (1h)"
      type: graph
      query: |
        (
          1 - (
            sum(rate(http_requests_total{service="order-api",status!~"5.."}[1h]))
            /
            sum(rate(http_requests_total{service="order-api"}[1h]))
          )
        ) / (1 - 0.999)

    - title: "P99 Latency (30d)"
      type: graph
      query: |
        histogram_quantile(0.99,
          rate(http_request_duration_seconds_bucket{service="order-api"}[5m])
        )
      thresholds:
        - value: 0.5
          color: green
        - value: 1.0
          color: red

    - title: "SLI History (30d)"
      type: graph
      queries:
        - name: "Target (99.9%)"
          query: "0.999"
          color: green
        - name: "Actual SLI"
          query: |
            sum(rate(http_requests_total{service="order-api",status!~"5.."}[1h]))
            /
            sum(rate(http_requests_total{service="order-api"}[1h]))
          color: blue

# Review Schedule
review:
  frequency: weekly
  participants:
    - platform-team
    - product-team
  agenda:
    - Review current SLI status
    - Analyze error budget consumption
    - Discuss incidents and postmortems
    - Adjust SLO targets if needed

---
# Additional Examples

# Example: Payment Service SLO
# service:
#   name: payment-service
# slos:
#   - name: payment-success-rate
#     objective: "99.95% of payment attempts succeed"
#     sli:
#       type: success_rate
#       measurement: |
#         sum(rate(payment_success_total[30d]))
#         /
#         sum(rate(payment_attempts_total[30d]))
#     target: 0.9995
#     window: 30d

# Example: Batch Job SLO
# service:
#   name: data-pipeline
# slos:
#   - name: batch-job-success-rate
#     objective: "99% of daily batch jobs complete successfully"
#     sli:
#       type: success_rate
#       measurement: |
#         sum(rate(batch_job_success_total[7d]))
#         /
#         sum(rate(batch_job_total[7d]))
#     target: 0.99
#     window: 7d

# Example: Multi-region SLO
# service:
#   name: global-api
# slos:
#   - name: global-availability
#     objective: "99.99% availability across all regions"
#     sli:
#       type: availability
#       measurement: |
#         sum(rate(http_requests_total{status!~"5.."}[30d])) by (region)
#         /
#         sum(rate(http_requests_total[30d])) by (region)
#     target: 0.9999
#     window: 30d

// Node.js Performance Profiling Configuration Template
//
// Use with clinic.js for comprehensive profiling
// Install: npm install -g clinic

module.exports = {
  // ============================================================
  // Clinic.js Configuration
  // ============================================================

  clinic: {
    // CPU profiling (flame graph)
    flame: {
      command: 'node app.js',
      sampleInterval: 10, // ms
      detectPort: true,
      debug: false
    },

    // Event loop delay profiling
    doctor: {
      command: 'node app.js',
      sampleInterval: 10,
      detectPort: true,
      debug: false
    },

    // Async operations profiling
    bubbleprof: {
      command: 'node app.js',
      detectPort: true,
      debug: false
    }
  },

  // ============================================================
  // V8 Profiler Configuration
  // ============================================================

  v8: {
    // CPU profiling
    cpuProfile: {
      enabled: process.env.NODE_ENV !== 'production',
      interval: 1000, // Sampling interval in microseconds
      outputPath: './profiles/cpu-profile-${Date.now()}.cpuprofile'
    },

    // Heap snapshot
    heapSnapshot: {
      enabled: true,
      interval: 60 * 60 * 1000, // Every hour
      outputPath: './profiles/heap-${Date.now()}.heapsnapshot',
      maxSnapshots: 5 // Keep last 5 snapshots
    },

    // Heap statistics
    heapStats: {
      enabled: true,
      interval: 10000, // Every 10 seconds
      thresholds: {
        heapUsedMB: 800,      // Alert if heap usage > 800MB
        externalMB: 100,       // Alert if external memory > 100MB
        arrayBuffersMB: 50     // Alert if array buffers > 50MB
      }
    }
  },

  // ============================================================
  // Performance Monitoring
  // ============================================================

  monitoring: {
    // Event loop lag monitoring
    eventLoop: {
      enabled: true,
      warningThreshold: 50, // ms
      criticalThreshold: 100 // ms
    },

    // GC monitoring
    gc: {
      enabled: true,
      logSlowGC: true,
      slowGCThreshold: 100 // ms
    },

    // Memory leak detection
    memoryLeak: {
      enabled: true,
      checkInterval: 60000, // 1 minute
      growthThreshold: 10, // Alert if heap grows for 10 consecutive checks
      action: 'snapshot' // 'snapshot' | 'alert' | 'restart'
    }
  },

  // ============================================================
  // APM Integration (Example: Datadog)
  // ============================================================

  apm: {
    enabled: process.env.NODE_ENV === 'production',
    provider: 'datadog', // 'datadog' | 'newrelic' | 'elastic'
    config: {
      service: process.env.SERVICE_NAME || 'my-service',
      env: process.env.NODE_ENV || 'development',
      version: process.env.SERVICE_VERSION || '1.0.0',

      // Profiling
      profiling: true,
      runtimeMetrics: true,

      // Sampling
      sampleRate: process.env.NODE_ENV === 'production' ? 0.1 : 1.0
    }
  }
};

// ============================================================
// Profiling Setup Functions
// ============================================================

function setupCPUProfiling() {
  const v8 = require('v8');
  const fs = require('fs');
  const path = require('path');

  const config = module.exports.v8.cpuProfile;
  if (!config.enabled) return;

  // Create profiles directory
  const profilesDir = path.dirname(config.outputPath);
  if (!fs.existsSync(profilesDir)) {
    fs.mkdirSync(profilesDir, { recursive: true });
  }

  // Start profiling on SIGUSR1
  process.on('SIGUSR1', () => {
    const startTime = Date.now();
    const outputPath = config.outputPath.replace('${Date.now()}', startTime);

    console.log(`Starting CPU profile: ${outputPath}`);

    // Note: Requires --prof flag or inspector API
    // This is a simplified example
    console.log('Use: node --prof app.js');
    console.log('Then: node --prof-process isolate-*.log > profile.txt');
  });
}

function setupHeapSnapshots() {
  const v8 = require('v8');
  const fs = require('fs');
  const path = require('path');

  const config = module.exports.v8.heapSnapshot;
  if (!config.enabled) return;

  // Create profiles directory
  const profilesDir = path.dirname(config.outputPath);
  if (!fs.existsSync(profilesDir)) {
    fs.mkdirSync(profilesDir, { recursive: true });
  }

  function takeSnapshot() {
    const outputPath = config.outputPath.replace('${Date.now()}', Date.now());
    console.log(`Taking heap snapshot: ${outputPath}`);
    v8.writeHeapSnapshot(outputPath);

    // Cleanup old snapshots
    cleanupOldSnapshots(profilesDir, config.maxSnapshots);
  }

  // Take snapshot on SIGUSR2
  process.on('SIGUSR2', takeSnapshot);

  // Periodic snapshots
  if (config.interval) {
    setInterval(takeSnapshot, config.interval);
  }
}

function cleanupOldSnapshots(dir, maxSnapshots) {
  const fs = require('fs');
  const path = require('path');

  const files = fs.readdirSync(dir)
    .filter(f => f.endsWith('.heapsnapshot'))
    .map(f => ({
      name: f,
      path: path.join(dir, f),
      time: fs.statSync(path.join(dir, f)).mtime.getTime()
    }))
    .sort((a, b) => b.time - a.time);

  // Delete old files
  files.slice(maxSnapshots).forEach(file => {
    fs.unlinkSync(file.path);
    console.log(`Deleted old snapshot: ${file.name}`);
  });
}

function setupHeapMonitoring() {
  const config = module.exports.v8.heapStats;
  if (!config.enabled) return;

  setInterval(() => {
    const usage = process.memoryUsage();
    const heapUsedMB = Math.round(usage.heapUsed / 1024 / 1024);
    const externalMB = Math.round(usage.external / 1024 / 1024);
    const arrayBuffersMB = Math.round(usage.arrayBuffers / 1024 / 1024);

    console.log({
      heapUsedMB,
      heapTotalMB: Math.round(usage.heapTotal / 1024 / 1024),
      externalMB,
      arrayBuffersMB,
      rssMB: Math.round(usage.rss / 1024 / 1024)
    });

    // Alert on threshold breach
    if (heapUsedMB > config.thresholds.heapUsedMB) {
      console.error(`Heap usage above threshold: ${heapUsedMB}MB > ${config.thresholds.heapUsedMB}MB`);
    }
    if (externalMB > config.thresholds.externalMB) {
      console.error(`External memory above threshold: ${externalMB}MB > ${config.thresholds.externalMB}MB`);
    }
    if (arrayBuffersMB > config.thresholds.arrayBuffersMB) {
      console.error(`Array buffers above threshold: ${arrayBuffersMB}MB > ${config.thresholds.arrayBuffersMB}MB`);
    }
  }, config.interval);
}

function setupEventLoopMonitoring() {
  const config = module.exports.monitoring.eventLoop;
  if (!config.enabled) return;

  let lastCheck = Date.now();

  setInterval(() => {
    const now = Date.now();
    const lag = now - lastCheck - 100; // 100ms is the interval

    if (lag > config.criticalThreshold) {
      console.error(`Event loop lag CRITICAL: ${lag}ms`);
    } else if (lag > config.warningThreshold) {
      console.warn(`Event loop lag WARNING: ${lag}ms`);
    }

    lastCheck = now;
  }, 100);
}

function setupMemoryLeakDetection() {
  const config = module.exports.monitoring.memoryLeak;
  if (!config.enabled) return;

  let lastHeapUsed = 0;
  let growthCount = 0;

  setInterval(() => {
    const currentHeapUsed = process.memoryUsage().heapUsed;

    if (currentHeapUsed > lastHeapUsed) {
      growthCount++;
      if (growthCount >= config.growthThreshold) {
        console.error(`Possible memory leak detected (heap growing for ${growthCount} checks)`);

        if (config.action === 'snapshot') {
          const v8 = require('v8');
          const filename = `./profiles/leak-${Date.now()}.heapsnapshot`;
          v8.writeHeapSnapshot(filename);
          console.log(`Heap snapshot taken: ${filename}`);
        }

        growthCount = 0;
      }
    } else {
      growthCount = 0;
    }

    lastHeapUsed = currentHeapUsed;
  }, config.checkInterval);
}

// ============================================================
// Initialize Profiling
// ============================================================

function initializeProfiling() {
  console.log('Initializing performance profiling...');

  setupCPUProfiling();
  setupHeapSnapshots();
  setupHeapMonitoring();
  setupEventLoopMonitoring();
  setupMemoryLeakDetection();

  console.log('Profiling enabled. Send SIGUSR1 for CPU profile, SIGUSR2 for heap snapshot.');
}

// Auto-initialize if required directly
if (require.main === module) {
  initializeProfiling();
}

module.exports.initializeProfiling = initializeProfiling;

// ============================================================
// Usage Examples
// ============================================================

/*
1. Enable profiling in application:

   const profiling = require('./profiling-config');
   profiling.initializeProfiling();

2. Take heap snapshot:

   kill -SIGUSR2 $(pgrep -f "node app.js")

3. Run with clinic.js:

   clinic doctor -- node app.js
   clinic flame -- node app.js
   clinic bubbleprof -- node app.js

4. Built-in profiler:

   node --prof app.js
   node --prof-process isolate-*.log > profile.txt

5. Chrome DevTools:

   node --inspect app.js
   # Open chrome://inspect
*/