lightweight-browser-load-tester/dist/types/index.d.ts

A lightweight load testing tool using real browsers for streaming applications with DRM support

/**
 * Core type definitions for the lightweight browser load tester
 */
/**
 * Configuration for DRM systems
 */
export interface DRMConfiguration {
    type: 'widevine' | 'playready' | 'fairplay';
    licenseUrl: string;
    certificateUrl?: string;
    customHeaders?: Record<string, string>;
}
/**
 * Template for parameterizing API requests
 */
export interface ParameterTemplate {
    target: 'header' | 'query' | 'body';
    name: string;
    valueTemplate: string;
    scope: 'global' | 'per-session';
    urlPattern?: string;
    method?: string;
}
/**
 * Resource limits for browser instances
 */
export interface ResourceLimits {
    maxMemoryPerInstance: number;
    maxCpuPercentage: number;
    maxConcurrentInstances: number;
}
/**
 * Prometheus RemoteWrite configuration
 */
export interface PrometheusConfiguration {
    enabled: boolean;
    remoteWriteUrl: string;
    username?: string;
    password?: string;
    headers?: Record<string, string>;
    batchSize?: number;
    flushInterval?: number;
    timeout?: number;
    retryAttempts?: number;
    retryDelay?: number;
}
/**
 * OpenTelemetry OTLP configuration
 */
export interface OpenTelemetryConfiguration {
    enabled: boolean;
    endpoint: string;
    protocol: 'http/protobuf' | 'http/json' | 'grpc';
    headers?: Record<string, string>;
    serviceName?: string;
    serviceVersion?: string;
    timeout?: number;
    compression?: 'gzip' | 'none';
    batchTimeout?: number;
    maxExportBatchSize?: number;
    maxQueueSize?: number;
    exportTimeout?: number;
}
/**
 * Browser options configuration
 */
export interface BrowserOptions {
    headless?: boolean;
    args?: string[];
    browserType?: 'chromium' | 'chrome';
}
/**
 * Main test configuration interface
 */
export interface TestConfiguration {
    concurrentUsers: number;
    testDuration: number;
    rampUpTime: number;
    streamingUrl: string;
    streamingOnly?: boolean;
    allowedUrls?: string[];
    blockedUrls?: string[];
    drmConfig?: DRMConfiguration;
    requestParameters: ParameterTemplate[];
    resourceLimits: ResourceLimits;
    localStorage?: LocalStorageEntry[];
    browserOptions?: BrowserOptions;
    prometheus?: PrometheusConfiguration;
    opentelemetry?: OpenTelemetryConfiguration;
}
/**
 * Summary of test execution results
 */
export interface TestSummary {
    totalRequests: number;
    successfulRequests: number;
    failedRequests: number;
    averageResponseTime: number;
    peakConcurrentUsers: number;
    testDuration: number;
}
/**
 * Metrics for individual browser instances
 */
export interface BrowserMetrics {
    instanceId: string;
    memoryUsage: number;
    cpuUsage: number;
    requestCount: number;
    errorCount: number;
    uptime: number;
}
/**
 * DRM-specific error information
 */
export interface DRMError {
    timestamp: Date;
    errorCode: string;
    errorMessage: string;
    licenseUrl: string;
    drmType: string;
}
/**
 * DRM performance metrics
 */
export interface DRMMetrics {
    licenseRequestCount: number;
    averageLicenseTime: number;
    licenseSuccessRate: number;
    drmType: string;
    errors: DRMError[];
}
/**
 * Network request performance metrics
 */
export interface NetworkMetrics {
    url: string;
    method: string;
    responseTime: number;
    statusCode: number;
    timestamp: Date;
    requestSize: number;
    responseSize: number;
    isStreamingRelated?: boolean;
    streamingType?: 'manifest' | 'segment' | 'license' | 'api' | 'other';
}
/**
 * Streaming-specific request metrics
 */
export interface StreamingMetrics {
    manifestRequests: number;
    segmentRequests: number;
    licenseRequests: number;
    apiRequests: number;
    totalStreamingRequests: number;
    averageManifestTime: number;
    averageSegmentTime: number;
    averageLicenseTime: number;
    streamingSuccessRate: number;
    bandwidthUsage: number;
    errors: StreamingError[];
}
/**
 * Streaming-specific error information
 */
export interface StreamingError {
    timestamp: Date;
    errorType: 'manifest' | 'segment' | 'license' | 'playback' | 'network';
    errorCode?: string;
    errorMessage: string;
    url?: string;
    context?: Record<string, any>;
}
/**
 * Error log entry
 */
export interface ErrorLog {
    timestamp: Date;
    level: 'error' | 'warning' | 'info';
    message: string;
    stack?: string;
    context?: Record<string, any>;
}
/**
 * Complete test results structure
 */
export interface TestResults {
    summary: TestSummary;
    browserMetrics: BrowserMetrics[];
    drmMetrics: DRMMetrics[];
    networkMetrics: NetworkMetrics[];
    errors: ErrorLog[];
}
/**
 * Local storage entry for a specific domain
 */
export interface LocalStorageEntry {
    domain: string;
    data: Record<string, string>;
}
/**
 * Browser pool configuration options
 */
export interface BrowserPoolConfig {
    maxInstances: number;
    minInstances: number;
    resourceLimits: ResourceLimits;
    browserOptions?: BrowserOptions;
    localStorage?: LocalStorageEntry[];
    drmConfig?: DRMConfiguration;
}
/**
 * Managed browser instance with resource tracking
 */
export interface ManagedBrowserInstance {
    id: string;
    browser: any;
    context: any;
    page: any;
    createdAt: Date;
    lastUsed: Date;
    isActive: boolean;
    metrics: BrowserMetrics;
}
//# sourceMappingURL=index.d.ts.map