beddel 0.2.3 → 1.0.0

package/src/performance/benchmark.ts

@@ -1,644 +0,0 @@
-/**
- * Benchmark System - Comprehensive Performance Testing
- * Generates comparative benchmarks for isolated execution vs standard execution
- */
-import { performanceTargets } from "../config";
-import { PerformanceMonitor } from "./monitor";
-
-export interface BenchmarkResult {
-  name: string;
-  executionTime: number; // ms
-  memoryUsed: number; // MB
-  successCount: number;
-  failureCount: number;
-  securityScore: number;
-  timestamp: Date;
-}
-
-export interface BenchmarkSuite {
-  name: string;
-  description: string;
-  testCases: TestCase[];
-}
-
-export interface TestCase {
-  name: string;
-  code: string;
-  expectedResult?: any;
-  context?: Record<string, any>;
-  securityProfile?: string;
-  timeout?: number;
-  memoryLimit?: number;
-}
-
-export class BenchmarkSystem {
-  private baselineResults: BenchmarkResult[] = [];
-  private isolateResults: BenchmarkResult[] = [];
-  private currentSuite?: BenchmarkSuite;
-
-  constructor(
-    private performanceMonitor: PerformanceMonitor,
-    private readonly sampleSize = 100
-  ) {}
-
-  /**
-   * Create standard benchmark test cases
-   */
-  private createStandardTestSuite(): BenchmarkSuite {
-    return {
-      name: "standard-performance",
-      description: "Standard execution performance benchmark",
-      testCases: [
-        {
-          name: "simple-math",
-          code: "1 + 1",
-          expectedResult: 2,
-        },
-        {
-          name: "string-concatenation",
-          code: "'hello' + ' ' + 'world'",
-          expectedResult: "hello world",
-        },
-        {
-          name: "array-operations",
-          code: "[1,2,3,4,5].map(x => x * 2).reduce((a,b) => a + b, 0)",
-          expectedResult: 30,
-        },
-        {
-          name: "object-creation",
-          code: `({ name: "test", value: 42, items: [1,2,3] })`,
-          context: {},
-        },
-        {
-          name: "loop-processing",
-          code: `let sum = 0; for(let i = 0; i < 1000; i++) { sum += i; }; sum;`,
-          expectedResult: 499500,
-        },
-        {
-          name: "json-parsing",
-          code: `JSON.parse('{"a":1,"b":2,"c":3}')`,
-          expectedResult: { a: 1, b: 2, c: 3 },
-        },
-        {
-          name: "regex-matching",
-          code: `/test/.test("this is a test")`,
-          expectedResult: true,
-        },
-        {
-          name: "math-functions",
-          code: `Math.max(...[1,2,3,4,5]) + Math.min(...[1,2,3,4,5])`,
-          expectedResult: 6,
-        },
-        {
-          name: "string-methods",
-          code: `"hello world".toUpperCase().split(" ").join("-")`,
-          expectedResult: "HELLO-WORLD",
-        },
-        {
-          name: "conditional-logic",
-          code: `const x = 50; x > 100 ? "big" : x > 50 ? "medium" : "small"`,
-          expectedResult: "small",
-        },
-      ],
-    };
-  }
-
-  /**
-   * Create security-focused test cases
-   */
-  private createSecurityTestSuite(): BenchmarkSuite {
-    return {
-      name: "security-performance",
-      description: "Security-focused execution benchmark",
-      testCases: [
-        {
-          name: "ultra-secure-math",
-          code: "42 + 42",
-          securityProfile: "ultra-secure",
-        },
-        {
-          name: "high-security-string",
-          code: `'secure-${Date.now()}'`,
-          securityProfile: "high-security",
-        },
-        {
-          name: "tenant-isolated-computation",
-          code: `({ id: "tenant-001", score: 95.5 })`,
-          securityProfile: "tenant-isolated",
-        },
-        {
-          name: "secure-array-processing",
-          code: `[1,1,2,3,5,8].filter(x => x > 2).join("-")`,
-          securityProfile: "high-security",
-        },
-        {
-          name: "safe-object-manipulation",
-          code: `(({a,b,c}) => ({sum: a+b+c, avg: (a+b+c)/3}))({a:5,b:10,c:15})`,
-          securityProfile: "ultra-secure",
-        },
-        {
-          name: "limited-scope-eval",
-          code: `const items = []; for(let i=0; i<10; i++) items.push(i*i); items;`,
-          securityProfile: "ultra-secure",
-        },
-        {
-          name: "safe-string-format",
-          code: `"Score: ${Math.floor((Math.random() * 100) % 100)}"`,
-          securityProfile: "high-security",
-        },
-        {
-          name: "secure-timestamp-generate",
-          code: `new Date(Date.now()).toISOString()`,
-          securityProfile: "tenant-isolated",
-        },
-        {
-          name: "controlled-math-expr",
-          code: `Math.pow(2, 10) % 1000`,
-          securityProfile: "ultra-secure",
-        },
-        {
-          name: "safe-regex-validation",
-          code: `/(?=.*[a-z])(?=.*[A-Z])\d{6,}/.test("Abc123456")`,
-          securityProfile: "high-security",
-        },
-      ],
-    };
-  }
-
-  /**
-   * Create memory-intensive test cases
-   */
-  private createMemoryIntensiveSuite(): BenchmarkSuite {
-    return {
-      name: "memory-intensive",
-      description: "Memory-intensive execution benchmark",
-      testCases: [
-        {
-          name: "large-array-creation",
-          code: `Array.from({length: 1000}, (_, i) => ({ id: i, data: "x".repeat(100) }))`,
-          memoryLimit: 2,
-        },
-        {
-          name: "object-manipulation",
-          code: `const obj = {}; for(let i=0; i<500; i++) obj[i] = {value: i, doubled: i*2}; obj;`,
-          memoryLimit: 2,
-        },
-        {
-          name: "string-processing",
-          code: `"hello".repeat(1000).split("").join("-").toUpperCase()`,
-          memoryLimit: 2,
-        },
-        {
-          name: "nested-computation",
-          code: `const matrix = []; for(let i=0; i<10; i++) { matrix[i] = Array.from({length:50}, (_,j) => i+j*j); } matrix.flat();`,
-          memoryLimit: 2,
-        },
-        {
-          name: "recursive-function",
-          code: `(function fib(n) { return n <= 1 ? n : fib(n-1) + fib(n-2); })(10)`,
-          memoryLimit: 2,
-        },
-        {
-          name: "complex-object-build",
-          code: `({ items: Array.from({length: 50}, (_,i) => ({id: i, nested: {deep: {value: Math.random()}}}))})`,
-          memoryLimit: 2,
-        },
-        {
-          name: "map-reduce-heavy",
-          code: `Array.from({length:100}, (_,i) => i).map(x => x*x).filter(x => x%2===0).reduce((a,b) => a+b, 0)`,
-          memoryLimit: 2,
-        },
-        {
-          name: "circular-reference-test",
-          code: `const a = {}, b = {}; a.b = b; b.a = a; a.toString = () => "circular"; a.toString()`,
-          memoryLimit: 2,
-        },
-        {
-          name: "base64-encoding",
-          code: `btoa("x".repeat(2000))`,
-          memoryLimit: 4,
-        },
-        {
-          name: "json-round-trip",
-          code: `JSON.parse(JSON.stringify({data: Array.from({length:200}, (_,i) => ({i, v: i*i*i}))}))`,
-          memoryLimit: 3,
-        },
-      ],
-    };
-  }
-
-  /**
-   * Create performance targets test suite
-   */
-  private createTargetedSuite(): BenchmarkSuite {
-    return {
-      name: "performance-targets",
-      description: "Targeted performance benchmarks meeting 50ms target",
-      testCases: [
-        {
-          name: "math-calc-target",
-          code: `(((2 + 3) * 4) / 5) - 1`,
-          timeout: 50,
-          expectedResult: 3,
-        },
-        {
-          name: "string-concat-target",
-          code: `["a","b","c","d","e"].join("").concat("-test")`,
-          timeout: 50,
-          expectedResult: "abcde-test",
-        },
-        {
-          name: "array-sum-target",
-          code: `[1,2,3,4,5,6,7,8,9,10].reduce((a,b) => a+b, 0)`,
-          timeout: 50,
-          expectedResult: 55,
-        },
-        {
-          name: "object-access-target",
-          code: `({ x: 5, y: 10 }).x + ({ x: 15, y: 20 }).y`,
-          timeout: 50,
-          expectedResult: 25,
-        },
-        {
-          name: "boolean-logic-target",
-          code: `true && false || true && !false`,
-          timeout: 50,
-          expectedResult: true,
-        },
-        {
-          name: "template-string-target",
-          code: `"Result: ${200 + 50}"`,
-          timeout: 50,
-          expectedResult: "Result: 250",
-        },
-        {
-          name: "function-call-target",
-          code: `(x => x*x)(5) + (y => y+1)(10)`,
-          timeout: 50,
-          expectedResult: 35,
-        },
-        {
-          name: "condition-chain-target",
-          code: `const score = 75; score >= 90 ? "A" : score >= 80 ? "B" : score >= 70 ? "C" : "D"`,
-          timeout: 50,
-          expectedResult: "C",
-        },
-        {
-          name: "loop-simple-target",
-          code: `let total = 0; for(let i=1; i<=20; i++) total += i; total;`,
-          timeout: 50,
-          expectedResult: 210,
-        },
-        {
-          name: "date-parse-target",
-          code: `new Date("2024-01-01").getTime() > new Date("2023-12-31").getTime()`,
-          timeout: 50,
-          expectedResult: true,
-        },
-      ],
-    };
-  }
-
-  /**
-   * Run comprehensive benchmark suite
-   */
-  public async runComprehensiveBenchmark(): Promise<{
-    baseline: BenchmarkResult[];
-    isolated: BenchmarkResult[];
-    comparison: {
-      executionTimeRatio: number;
-      memoryRatio: number;
-      successRateRatio: number;
-      summary: string;
-    };
-  }> {
-    const suites = [
-      this.createStandardTestSuite(),
-      this.createSecurityTestSuite(),
-      this.createTargetedSuite(),
-      this.createMemoryIntensiveSuite(),
-    ];
-
-    const baselineResults: BenchmarkResult[] = [];
-    const isolatedResults: BenchmarkResult[] = [];
-
-    for (const suite of suites) {
-      this.currentSuite = suite;
-
-      // Run baseline tests (standard execution)
-      const baselineSuiteResults = await this.runSuiteBaseline(suite);
-      baselineResults.push(...baselineSuiteResults);
-
-      // Run isolated tests
-      const isolatedSuiteResults = await this.runSuiteIsolated(suite);
-      isolatedResults.push(...isolatedSuiteResults);
-    }
-
-    // Generate comparison analysis
-    const comparison = this.generateComparison(
-      baselineResults,
-      isolatedResults
-    );
-
-    return {
-      baseline: baselineResults,
-      isolated: isolatedResults,
-      comparison,
-    };
-  }
-
-  /**
-   * Run baseline execution (standard runtime)
-   */
-  private async runSuiteBaseline(
-    suite: BenchmarkSuite
-  ): Promise<BenchmarkResult[]> {
-    const results: BenchmarkResult[] = [];
-
-    for (const testCase of suite.testCases) {
-      const suiteResults = await this.runTestCaseBaseline(testCase);
-      results.push(suiteResults);
-    }
-
-    return results;
-  }
-
-  /**
-   * Run single baseline test case
-   */
-  private async runTestCaseBaseline(
-    testCase: TestCase
-  ): Promise<BenchmarkResult> {
-    const startTime = Date.now();
-    const startMemory = process.memoryUsage().heapUsed;
-    let successCount = 0;
-    let failureCount = 0;
-
-    // Run multiple iterations for accurate measurement
-    for (let i = 0; i < this.sampleSize; i++) {
-      try {
-        // Create new function from code and execute
-        const result = await this.executeBaselineCode(testCase.code);
-
-        // Verify result if expected result provided
-        if (testCase.expectedResult !== undefined) {
-          if (
-            JSON.stringify(result) === JSON.stringify(testCase.expectedResult)
-          ) {
-            successCount++;
-          } else {
-            failureCount++;
-          }
-        } else {
-          successCount++;
-        }
-      } catch (error) {
-        failureCount++;
-      }
-    }
-
-    const executionTime = Date.now() - startTime;
-    const memoryUsed =
-      (process.memoryUsage().heapUsed - startMemory) / (1024 * 1024);
-
-    return {
-      name: testCase.name,
-      executionTime: executionTime / this.sampleSize, // Average per execution
-      memoryUsed: memoryUsed / this.sampleSize,
-      successCount,
-      failureCount,
-      securityScore: 5.0, // Baseline security score (mid-range)
-      timestamp: new Date(),
-    };
-  }
-
-  /**
-   * Execute baseline code safely
-   */
-  private async executeBaselineCode(code: string): Promise<any> {
-    // Create a safe execution context using Function constructor
-    const func = new Function("return " + code + ";");
-    return func();
-  }
-
-  /**
-   * Run isolated execution benchmark
-   */
-  private async runSuiteIsolated(
-    suite: BenchmarkSuite
-  ): Promise<BenchmarkResult[]> {
-    const results: BenchmarkResult[] = [];
-
-    for (const testCase of suite.testCases) {
-      const suiteResults = await this.runTestCaseIsolated(testCase);
-      results.push(suiteResults);
-    }
-
-    return results;
-  }
-
-  /**
-   * Run single isolated test case
-   */
-  private async runTestCaseIsolated(
-    testCase: TestCase
-  ): Promise<BenchmarkResult> {
-    const {
-      IsolatedRuntimeManager,
-    } = require("../../src/runtime/isolatedRuntime");
-    const runtimeManager = new IsolatedRuntimeManager();
-
-    try {
-      const startTime = Date.now();
-      let successCount = 0;
-      let failureCount = 0;
-      let totalMemoryUsed = 0;
-
-      // Run multiple iterations for accurate measurement
-      for (let i = 0; i < this.sampleSize; i++) {
-        const result = await runtimeManager.execute({
-          code: testCase.code,
-          context: testCase.context || {},
-          securityProfile: testCase.securityProfile || "ultra-secure",
-          timeout: testCase.timeout || 5000,
-          memoryLimit: testCase.memoryLimit || 2,
-          scanForSecurity: false, // Skip security scanning for benchmarks
-        });
-
-        if (result.success) {
-          if (testCase.expectedResult !== undefined) {
-            if (
-              JSON.stringify(result.result) ===
-              JSON.stringify(testCase.expectedResult)
-            ) {
-              successCount++;
-            } else {
-              failureCount++;
-            }
-          } else {
-            successCount++;
-          }
-          totalMemoryUsed += result.memoryUsed;
-        } else {
-          failureCount++;
-        }
-
-        // Add slight delay to prevent overwhelming the system
-        await new Promise((resolve) => setTimeout(resolve, 1));
-      }
-
-      const executionTime = Date.now() - startTime;
-      const avgExecutionTime = executionTime / this.sampleSize;
-      const avgMemoryUsed = totalMemoryUsed / successCount || 0;
-
-      return {
-        name: testCase.name,
-        executionTime: avgExecutionTime,
-        memoryUsed: avgMemoryUsed,
-        successCount,
-        failureCount,
-        securityScore: 9.5, // High security score for isolated execution
-        timestamp: new Date(),
-      };
-    } finally {
-      await runtimeManager.dispose();
-    }
-  }
-
-  /**
-   * Generate comparison analysis
-   */
-  private generateComparison(
-    baseline: BenchmarkResult[],
-    isolated: BenchmarkResult[]
-  ): {
-    executionTimeRatio: number;
-    memoryRatio: number;
-    successRateRatio: number;
-    summary: string;
-  } {
-    // Calculate averages
-    const baselineAvgTime =
-      baseline.reduce((sum, r) => sum + r.executionTime, 0) / baseline.length;
-    const isolatedAvgTime =
-      isolated.reduce((sum, r) => sum + r.executionTime, 0) / isolated.length;
-
-    const baselineAvgMemory =
-      baseline.reduce((sum, r) => sum + r.memoryUsed, 0) / baseline.length;
-    const isolatedAvgMemory =
-      isolated.reduce((sum, r) => sum + r.memoryUsed, 0) / isolated.length;
-
-    const baselineSuccessRate =
-      baseline.reduce((sum, r) => sum + r.successCount, 0) /
-      baseline.reduce((sum, r) => sum + r.successCount + r.failureCount, 0);
-    const isolatedSuccessRate =
-      isolated.reduce((sum, r) => sum + r.successCount, 0) /
-      isolated.reduce((sum, r) => sum + r.successCount + r.failureCount, 0);
-
-    const executionTimeRatio = isolatedAvgTime / baselineAvgTime;
-    const memoryRatio = isolatedAvgMemory / baselineAvgMemory;
-    const successRateRatio = isolatedSuccessRate / baselineSuccessRate;
-
-    let summary = "Isolated Runtime Performance Summary:\n";
-    summary += `• Execution Time: ${executionTimeRatio.toFixed(
-      2
-    )}x baseline (average ${isolatedAvgTime.toFixed(
-      1
-    )}ms vs ${baselineAvgTime.toFixed(1)}ms)\n`;
-    summary += `• Memory Usage: ${memoryRatio.toFixed(
-      2
-    )}x baseline (average ${isolatedAvgMemory.toFixed(
-      1
-    )}MB vs ${baselineAvgMemory.toFixed(1)}MB)\n`;
-    summary += `• Success Rate: ${(successRateRatio * 100).toFixed(
-      1
-    )}% of baseline (${(isolatedSuccessRate * 100).toFixed(1)}% vs ${(
-      baselineSuccessRate * 100
-    ).toFixed(1)}%)\n`;
-
-    if (executionTimeRatio < 1.1 && memoryRatio < 10) {
-      summary +=
-        "✅ Performance within acceptable range for secure execution\n";
-    } else {
-      summary += "⚠️  Isolation overhead detected - consider optimization\n";
-    }
-
-    summary += `\nSecurity Benefits: 9.5/10 vs 5.0/10 security score with isolated execution`;
-
-    return {
-      executionTimeRatio,
-      memoryRatio,
-      successRateRatio,
-      summary,
-    };
-  }
-
-  /**
-   * Generate performance report
-   */
-  public generateReport(
-    baseline: BenchmarkResult[],
-    isolated: BenchmarkResult[]
-  ): string {
-    const comparison = this.generateComparison(baseline, isolated);
-
-    return `# Isolated Runtime Performance Report
-Generated: ${new Date().toISOString()}
-
-## Summary
-${comparison.summary}
-
-## Key Metrics
-- **Target Performance**: <50ms execution time
-- **Memory Budget**: <2MB per execution  
-- **Success Rate Target**: >99.9%
-- **Security Score**: 9.5/10 (vs 5.0 for standard execution)
-
-## Baseline vs Isolated Performance
-- Execution Time Ratio: ${comparison.executionTimeRatio.toFixed(2)}x
-- Memory Usage Ratio: ${comparison.memoryRatio.toFixed(2)}x
-- Success Rate Ratio: ${(comparison.successRateRatio * 100).toFixed(1)}%
-
-## Recommendations
-1. Monitor execution time during peak loads
-2. Adjust pool size based on benchmark results
-3. Consider warming up isolate pools for latency-sensitive operations
-4. Implement circuit breakers for excessive execution times
-`;
-  }
-
-  /**
-   * Quick performance check against targets
-   */
-  public quickHealthCheck(): {
-    isHealthy: boolean;
-    issues: string[];
-    metrics: {
-      avgExecutionTime: number;
-      avgMemoryUsage: number;
-      successRate: number;
-    };
-  } {
-    // This would integrate with the performance monitor
-    // For now, return placeholder data
-    return {
-      isHealthy: true,
-      issues: [],
-      metrics: {
-        avgExecutionTime: 48.5,
-        avgMemoryUsage: 1.8,
-        successRate: 99.9,
-      },
-    };
-  }
-}
-
-// Global benchmark instance
-export let benchmarkSystem: BenchmarkSystem | null = null;
-
-export function initializeBenchmarks(
-  performanceMonitor: PerformanceMonitor
-): BenchmarkSystem {
-  benchmarkSystem = new BenchmarkSystem(performanceMonitor);
-  return benchmarkSystem;
-}

package/src/performance/index.ts

@@ -1,34 +0,0 @@
-/**
- * Performance Module - Index
- * Exports all performance monitoring capabilities for the Beddel runtime
- */
-
-export * from "./monitor";
-export * from "./benchmark";
-export * from "./autoscaling";
-
-// Re-export key types for convenience
-export type {
-  PerformanceMonitor,
-  PerformanceMetric,
-  PerformanceSnapshot,
-  Violation,
-  Recommendation,
-} from "./monitor";
-
-export type { BenchmarkResult, BenchmarkSuite, TestCase } from "./benchmark";
-
-export type {
-  AutoscaleConfig,
-  AutoscaleDecision,
-  AutoscaleSystem,
-} from "./autoscaling";
-
-// Export individual instances
-export { performanceMonitor } from "./monitor";
-export { benchmarkSystem, initializeBenchmarks } from "./benchmark";
-export {
-  autoscaleSystem,
-  initializeAutoscaling,
-  getAutoscalingConfig,
-} from "./autoscaling";