StreamEdge — Real-Time Video CDN & Streaming Platform

import ws from 'k6/ws';
import { check } from 'k6';
import { Trend, Rate, Counter } from 'k6/metrics';

const wsConnectTime = new Trend('ws_connect_time');
const wsErrors = new Rate('ws_errors');
const rebufferCount = new Counter('rebuffer_events');
const streamBitrate = new Trend('stream_bitrate_kbps');

export const options = {
  stages: [
    { duration: '1m', target: 1000 },   // Ramp to 1K
    { duration: '1m', target: 5000 },   // Ramp to 5K
    { duration: '2m', target: 10000 },  // Peak: 10K
    { duration: '1m', target: 5000 },   // Ramp down
    { duration: '1m', target: 0 },      // Close all
  ],
  thresholds: {
    'ws_connect_time': ['p(95)<500', 'p(99)<1200'], // p95 < 500ms, p99 < 1.2s
    'ws_errors': ['rate<0.01'], // Error rate < 1%
    'rebuffer_events': ['rate<0.02'], // Rebuffer rate < 2%
  },
};

export default function() {
  const streamId = 'LIVE-STREAM-2025';
  const viewerId = `viewer-${__VU}-${__ITER}`;
  const connectStart = new Date();

  const wsUrl = `wss://${__ENV.WS_HOST}/api/v1/streams/${streamId}/watch?viewer_id=${viewerId}`;

  const res = ws.connect(wsUrl, { tags: { name: 'StreamConnection' } }, function(socket) {
    const connectTime = new Date() - connectStart;
    wsConnectTime.add(connectTime);

    // Receive initial stream metadata
    socket.on('open', function() {
      console.log(`VU ${__VU}: Connected in ${connectTime}ms`);
      
      // Subscribe to stream
      socket.send(JSON.stringify({
        type: 'subscribe',
        stream_id: streamId,
        viewer_id: viewerId,
        initial_bitrate: 5000 // 5 Mbps
      }));
    });

    socket.on('message', function(message) {
      const data = JSON.parse(message);

      if (data.type === 'stream_chunk') {
        // Track bitrate adaptation
        streamBitrate.add(data.bitrate_kbps);
      } else if (data.type === 'quality_change') {
        console.log(`VU ${__VU}: Quality adjusted to ${data.bitrate_kbps} kbps`);
      } else if (data.type === 'rebuffer_start') {
        rebufferCount.add(1);
        console.warn(`VU ${__VU}: Rebuffer event detected`);
      } else if (data.type === 'error') {
        wsErrors.add(1);
        console.error(`VU ${__VU}: ${data.message}`);
      }
    });

    socket.on('close', function() {
      console.log(`VU ${__VU}: Connection closed`);
    });

    socket.on('error', function(error) {
      wsErrors.add(1);
      console.error(`VU ${__VU}: WebSocket error - ${error}`);
    });

    // Keep connection open for 5 minutes
    socket.setTimeout(function() {
      socket.close();
    }, 5 * 60 * 1000);
  });

  check(res, {
    'ws status code is 101': (r) => r && r.status === 101,
  });
}

import ws from 'k6/ws';
import http from 'k6/http';
import { check, sleep } from 'k6';
import { Trend, Counter } from 'k6/metrics';

const failoverRecoveryTime = new Trend('failover_recovery_ms');
const successfulFailovers = new Counter('successful_failovers');
const bitrateAdaptations = new Counter('bitrate_adaptations');

export const options = {
  vus: 100,
  duration: '5m',
};

export default function() {
  const streamId = 'LIVE-STREAM-2025';
  const viewerId = `viewer-${__VU}`;
  const wsUrl = `wss://${__ENV.WS_HOST}/api/v1/streams/${streamId}/watch?viewer_id=${viewerId}`;

  ws.connect(wsUrl, { tags: { name: 'BitrateAdaptation' } }, function(socket) {
    socket.on('open', function() {
      socket.send(JSON.stringify({
        type: 'subscribe',
        stream_id: streamId,
        viewer_id: viewerId
      }));
    });

    let messageCount = 0;
    let lastBitrate = 5000;
    let failoverDetected = false;
    const failoverStartTime = new Date();

    socket.on('message', function(message) {
      const data = JSON.parse(message);
      messageCount++;

      // Simulate bandwidth constraint every 10 messages
      if (messageCount % 10 === 0) {
        const bandwidth = Math.random() > 0.5 ? 2000 : 5000; // Vary between 2-5 Mbps
        socket.send(JSON.stringify({
          type: 'report_bandwidth',
          available_bandwidth_kbps: bandwidth
        }));
      }

      // Track bitrate adaptation
      if (data.type === 'quality_change') {
        const newBitrate = data.bitrate_kbps;
        if (newBitrate !== lastBitrate) {
          bitrateAdaptations.add(1);
          lastBitrate = newBitrate;
          console.log(`VU ${__VU}: Bitrate ${lastBitrate} → ${newBitrate} kbps`);
        }
      }

      // Detect and recover from failover
      if (data.type === 'edge_node_failure') {
        failoverDetected = true;
        console.warn(`VU ${__VU}: CDN failover triggered`);
      }

      if (failoverDetected && data.type === 'stream_resumed') {
        const recoveryTime = new Date() - failoverStartTime;
        failoverRecoveryTime.add(recoveryTime);
        successfulFailovers.add(1);
        failoverDetected = false;
        
        check(recoveryTime < 3000, {
          'failover recovery < 3 seconds': (ok) => ok,
        });
      }
    });

    socket.setTimeout(function() {
      socket.close();
    }, 5 * 60 * 1000);
  });
}

export function handleSummary(data) {
  const summary = {
    'Bitrate Adaptations': data.metrics.bitrate_adaptations.value,
    'Successful Failovers': data.metrics.successful_failovers.value,
    'Avg Failover Recovery (ms)': Math.round(data.metrics.failover_recovery_ms.values.avg),
  };
  console.log('\n=== Adaptive Bitrate & Failover Summary ===');
  Object.entries(summary).forEach(([key, value]) => {
    console.log(`${key}: ${value}`);
  });
}