Worker Mode

// Worker mode is enabled by default
const beacon = new AgentShieldBeacon({
  apiKey: 'your-api-key',
  useWorker: true, // Default: true
});

// The beacon automatically:
// 1. Creates a worker instance
// 2. Establishes communication channel
// 3. Falls back if workers unavailable

const beacon = new AgentShieldBeacon({
  apiKey: 'your-api-key',
  useWorker: true,
  workerUrl: '/static/beacon-worker.js', // Custom location
});

// For CSP-restricted environments
const workerCode = `
  self.addEventListener('message', (event) => {
    // Worker logic
  });
`;

const blob = new Blob([workerCode], { type: 'application/javascript' });
const workerUrl = URL.createObjectURL(blob);

const beacon = new AgentShieldBeacon({
  apiKey: 'your-api-key',
  useWorker: true,
  workerUrl: workerUrl,
});

const beacon = new AgentShieldBeacon({
  apiKey: 'your-api-key',
  useWorker: true,
  workerConfig: {
    // Health check configuration
    heartbeatInterval: 5000, // Check every 5 seconds
    maxUnhealthyCount: 3, // Restart after 3 failures
    healthCheckTimeout: 1000, // Health check timeout

    // Auto-restart configuration
    maxRestartAttempts: 3, // Maximum restart attempts
    restartDelay: 2000, // Delay between restarts
    restartBackoff: true, // Exponential backoff
  },
});

const beacon = new AgentShieldBeacon({
  apiKey: 'your-api-key',
  useWorker: true,
  workerConfig: {
    enableCompression: true, // Enable compression
    compressionThreshold: 1024, // Compress if > 1KB
    compressionLevel: 6, // 1-9 (speed vs size)
  },
});

const beacon = new AgentShieldBeacon({
  apiKey: 'your-api-key',
  useWorker: true,
  workerConfig: {
    maxMemoryUsage: 10485760, // 10MB limit
    gcInterval: 30000, // Garbage collection interval
    maxQueueSize: 1000, // Maximum queued events
    queueStrategy: 'drop-oldest', // What to do when full
  },
});

// Monitor worker initialization
const beacon = new AgentShieldBeacon({
  apiKey: 'your-api-key',
  useWorker: true,
  onWorkerInit: (worker) => {
    console.log('Worker initialized:', worker);
  },
  onWorkerError: (error) => {
    console.error('Worker error:', error);
    // Automatically falls back to direct mode
  },
});

// Check worker state
if (beacon.isWorkerActive()) {
  console.log('Worker is running');
}

// Get worker statistics
const stats = await beacon.getWorkerStats();
console.log('Worker stats:', {
  eventsProcessed: stats.eventsProcessed,
  memoryUsage: stats.memoryUsage,
  uptime: stats.uptime,
  errors: stats.errors,
});

// Graceful shutdown
beacon.destroy(); // Automatically terminates worker

// Force terminate worker
beacon.terminateWorker();

// Restart worker
beacon.restartWorker();

// Worker receives these message types
const messageTypes = {
  INIT: 'init', // Initialize worker
  EVENT: 'event', // Track event
  BATCH: 'batch', // Send batch
  FLUSH: 'flush', // Force flush
  CONFIG: 'config', // Update config
  PING: 'ping', // Health check
  TERMINATE: 'terminate', // Shutdown
};

// Worker sends these message types
const responseTypes = {
  READY: 'ready', // Worker ready
  SUCCESS: 'success', // Operation successful
  ERROR: 'error', // Operation failed
  STATS: 'stats', // Statistics update
  PONG: 'pong', // Health response
};

// beacon-worker.js
let config = {};
let eventQueue = [];
let flushTimer = null;

self.addEventListener('message', async (event) => {
  const { type, data } = event.data;

  switch (type) {
    case 'init':
      config = data;
      self.postMessage({ type: 'ready' });
      break;

    case 'event':
      eventQueue.push(data);
      if (eventQueue.length >= config.batchSize) {
        await flush();
      } else {
        scheduleFlush();
      }
      break;

    case 'flush':
      await flush();
      break;

    case 'ping':
      self.postMessage({ type: 'pong', timestamp: Date.now() });
      break;
  }
});

function scheduleFlush() {
  if (flushTimer) return;

  flushTimer = setTimeout(async () => {
    await flush();
    flushTimer = null;
  }, config.flushInterval);
}

async function flush() {
  if (eventQueue.length === 0) return;

  const batch = eventQueue.splice(0, config.batchSize);

  try {
    const response = await fetch(config.endpoint, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'X-API-Key': config.apiKey,
      },
      body: JSON.stringify({ events: batch }),
    });

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

    self.postMessage({
      type: 'success',
      count: batch.length,
    });
  } catch (error) {
    self.postMessage({
      type: 'error',
      error: error.message,
    });

    // Re-queue events for retry
    eventQueue.unshift(...batch);
  }
}

const beacon = new AgentShieldBeacon({
  apiKey: 'your-api-key',
  useWorker: true,
  fallbackMode: 'auto', // Automatic fallback
  onFallback: (reason) => {
    console.log('Falling back to direct mode:', reason);
    // Reasons: 'not-supported', 'error', 'timeout'
  },
});

// Check worker support
if (!('Worker' in window)) {
  console.log('Workers not supported');
  beacon.updateConfig({ useWorker: false });
}

// Force fallback on error
beacon.on('worker:error', (error) => {
  if (error.critical) {
    beacon.disableWorker();
  }
});

function createBeacon() {
  const hasWorkerSupport = 'Worker' in window;
  const isModernBrowser = 'requestIdleCallback' in window;

  return new AgentShieldBeacon({
    apiKey: 'your-api-key',
    useWorker: hasWorkerSupport,
    fallbackMode: isModernBrowser ? 'idle' : 'direct',
  });
}

// Optimize for high-traffic
const highTrafficConfig = {
  apiKey: 'your-api-key',
  useWorker: true,
  batchSize: 100,
  flushInterval: 10000,
  workerConfig: {
    enableCompression: true,
    maxQueueSize: 5000,
  },
};

// Optimize for real-time
const realTimeConfig = {
  apiKey: 'your-api-key',
  useWorker: true,
  batchSize: 1,
  flushInterval: 1000,
  workerConfig: {
    enableCompression: false, // Reduce latency
  },
};

// Monitor and control memory usage
const beacon = new AgentShieldBeacon({
  apiKey: 'your-api-key',
  useWorker: true,
  workerConfig: {
    maxMemoryUsage: 5242880, // 5MB
    onMemoryWarning: (usage) => {
      console.warn(`Worker memory high: ${usage} bytes`);
      beacon.flush(); // Force flush to free memory
    },
  },
});

// Throttle processing in worker
const beacon = new AgentShieldBeacon({
  apiKey: 'your-api-key',
  useWorker: true,
  workerConfig: {
    processingDelay: 100, // Delay between batches
    maxConcurrent: 2, // Max concurrent requests
    priorityQueue: true, // Process high-priority first
  },
});

const beacon = new AgentShieldBeacon({
  apiKey: 'your-api-key',
  useWorker: true,
  debug: true,
  logLevel: 'debug',
  workerConfig: {
    debug: true, // Enable worker debug logs
  },
});

// In worker file
console.log('[Worker]', 'Processing event', event);

// Messages appear in main console with [Worker] prefix

// Profile worker performance
const beacon = new AgentShieldBeacon({
  apiKey: 'your-api-key',
  useWorker: true,
  onWorkerStats: (stats) => {
    console.log('Worker performance:', {
      eventsPerSecond: stats.throughput,
      avgProcessingTime: stats.avgTime,
      memoryUsage: stats.memory,
      queueLength: stats.queueSize,
    });
  },
});

Content-Security-Policy:
  worker-src 'self' blob:;
  script-src 'self';

// Workers are sandboxed by default
// No access to:
// - DOM
// - localStorage
// - sessionStorage
// - document/window objects

// Workers have access to:
// - fetch API
// - IndexedDB
// - WebSockets
// - Crypto API