PostgreSQL 17 and Playwright 1.50: real world latency test #2289

// pg-latency-benchmark.js
// Benchmark PostgreSQL 17 vs 16 read/write latency for test #2289
// Dependencies: pg@8.11.3, dotenv@16.3.1
require('dotenv').config();
const { Pool } = require('pg');
const { performance } = require('perf_hooks');

// Configuration for test #2289: 10k iterations, 1M row test table
const BENCH_CONFIG = {
  iterations: 10000,
  tableRows: 1000000,
  pg17ConnectionString: process.env.PG17_CONNECTION_STRING,
  pg16ConnectionString: process.env.PG16_CONNECTION_STRING,
  testQuery: 'SELECT id, created_at, payload FROM test_bench_data WHERE id = $1',
  writeQuery: 'INSERT INTO test_bench_data (payload) VALUES ($1) RETURNING id'
};

// Initialize connection pools for both PostgreSQL versions
let pg17Pool, pg16Pool;
try {
  pg17Pool = new Pool({ connectionString: BENCH_CONFIG.pg17ConnectionString, max: 20 });
  pg16Pool = new Pool({ connectionString: BENCH_CONFIG.pg16ConnectionString, max: 20 });
} catch (poolInitError) {
  console.error(`[FATAL] Failed to initialize connection pools: ${poolInitError.message}`);
  process.exit(1);
}

// Pre-warm pools to avoid cold start latency skew
async function warmPools() {
  const warmPromises = [];
  for (let i = 0; i < 5; i++) {
    warmPromises.push(pg17Pool.query('SELECT 1'));
    warmPromises.push(pg16Pool.query('SELECT 1'));
  }
  await Promise.all(warmPromises);
  console.log('[INFO] Connection pools warmed successfully');
}

// Run read latency benchmark for a target PostgreSQL version
async function runReadBenchmark(pool, versionLabel) {
  const latencies = [];
  let errorCount = 0;

  for (let i = 0; i < BENCH_CONFIG.iterations; i++) {
    const randomId = Math.floor(Math.random() * BENCH_CONFIG.tableRows) + 1;
    const start = performance.now();
    try {
      const result = await pool.query(BENCH_CONFIG.testQuery, [randomId]);
      if (result.rows.length === 0) {
        console.warn(`[WARN] No row found for id ${randomId} in ${versionLabel} read benchmark`);
      }
      const end = performance.now();
      latencies.push(end - start);
    } catch (queryError) {
      errorCount++;
      console.error(`[ERROR] Read query failed for ${versionLabel}: ${queryError.message}`);
    }
  }

  // Calculate p50, p95, p99 latencies
  latencies.sort((a, b) => a - b);
  const p50 = latencies[Math.floor(latencies.length * 0.5)];
  const p95 = latencies[Math.floor(latencies.length * 0.95)];
  const p99 = latencies[Math.floor(latencies.length * 0.99)];
  const avg = latencies.reduce((sum, val) => sum + val, 0) / latencies.length;

  return { versionLabel, p50, p95, p99, avg, errorCount, totalIterations: BENCH_CONFIG.iterations };
}

// Run write latency benchmark
async function runWriteBenchmark(pool, versionLabel) {
  const latencies = [];
  let errorCount = 0;

  for (let i = 0; i < BENCH_CONFIG.iterations; i++) {
    const testPayload = `test-payload-${Date.now()}-${i}`;
    const start = performance.now();
    try {
      const result = await pool.query(BENCH_CONFIG.writeQuery, [testPayload]);
      if (result.rows.length === 0) {
        console.warn(`[WARN] No row inserted for iteration ${i} in ${versionLabel} write benchmark`);
      }
      const end = performance.now();
      latencies.push(end - start);
    } catch (queryError) {
      errorCount++;
      console.error(`[ERROR] Write query failed for ${versionLabel}: ${queryError.message}`);
    }
  }

  latencies.sort((a, b) => a - b);
  const p50 = latencies[Math.floor(latencies.length * 0.5)];
  const p95 = latencies[Math.floor(latencies.length * 0.95)];
  const p99 = latencies[Math.floor(latencies.length * 0.99)];
  const avg = latencies.reduce((sum, val) => sum + val, 0) / latencies.length;

  return { versionLabel, p50, p95, p99, avg, errorCount, totalIterations: BENCH_CONFIG.iterations };
}

async function main() {
  try {
    await warmPools();

    console.log('[INFO] Starting read benchmark for PostgreSQL 17...');
    const pg17ReadResults = await runReadBenchmark(pg17Pool, 'PostgreSQL 17');
    console.log('[INFO] Starting read benchmark for PostgreSQL 16...');
    const pg16ReadResults = await runReadBenchmark(pg16Pool, 'PostgreSQL 16');

    console.log('\n=== Test #2289 Read Latency Results ===');
    console.log(`PostgreSQL 17: p50=${pg17ReadResults.p50.toFixed(2)}ms, p99=${pg17ReadResults.p99.toFixed(2)}ms, errors=${pg17ReadResults.errorCount}`);
    console.log(`PostgreSQL 16: p50=${pg16ReadResults.p50.toFixed(2)}ms, p99=${pg16ReadResults.p99.toFixed(2)}ms, errors=${pg16ReadResults.errorCount}`);
    console.log(`p99 Improvement: ${((pg16ReadResults.p99 - pg17ReadResults.p99)/pg16ReadResults.p99 * 100).toFixed(1)}%`);

    console.log('\n[INFO] Starting write benchmark for PostgreSQL 17...');
    const pg17WriteResults = await runWriteBenchmark(pg17Pool, 'PostgreSQL 17');
    console.log('[INFO] Starting write benchmark for PostgreSQL 16...');
    const pg16WriteResults = await runWriteBenchmark(pg16Pool, 'PostgreSQL 16');

    console.log('\n=== Test #2289 Write Latency Results ===');
    console.log(`PostgreSQL 17: p50=${pg17WriteResults.p50.toFixed(2)}ms, p99=${pg17WriteResults.p99.toFixed(2)}ms, errors=${pg17WriteResults.errorCount}`);
    console.log(`PostgreSQL 16: p50=${pg16WriteResults.p50.toFixed(2)}ms, p99=${pg16WriteResults.p99.toFixed(2)}ms, errors=${pg16WriteResults.errorCount}`);
    console.log(`p99 Improvement: ${((pg16WriteResults.p99 - pg17WriteResults.p99)/pg16WriteResults.p99 * 100).toFixed(1)}%`);
  } catch (mainError) {
    console.error(`[FATAL] Benchmark failed: ${mainError.message}`);
  } finally {
    await pg17Pool.end();
    await pg16Pool.end();
  }
}

// Run benchmark if executed directly
if (require.main === module) {
  main();
}

// Full test #2289 dataset and raw results: https://github.com/enterprisedb/pg-latency-benchmarks

// playwright-latency-test.js
// Playwright 1.50 UI latency benchmark for test #2289
// Dependencies: playwright@1.50.0, @playwright/test@1.50.0
const { test, expect } = require('@playwright/test');
const { performance } = require('perf_hooks');

// Test configuration for #2289: 500 iterations, 3 browser engines
const PLAYWRIGHT_CONFIG = {
  iterations: 500,
  targetUrl: 'https://pg17-bench-app.example.com/dashboard',
  loginCredentials: {
    username: process.env.BENCH_USERNAME,
    password: process.env.BENCH_PASSWORD
  },
  targetElementSelector: '[data-testid="user-dashboard-loaded"]',
  browsers: ['chromium', 'firefox', 'webkit']
};

// Store latency results per browser
const latencyResults = {};

test.describe('Playwright 1.50 Latency Test #2289', () => {
  // Pre-authenticate to avoid auth flow latency skew
  test.beforeAll(async ({ browser }) => {
    const context = await browser.newContext();
    const page = await context.newPage();
    try {
      await page.goto('https://pg17-bench-app.example.com/login');
      await page.fill('[data-testid="username"]', PLAYWRIGHT_CONFIG.loginCredentials.username);
      await page.fill('[data-testid="password"]', PLAYWRIGHT_CONFIG.loginCredentials.password);
      await page.click('[data-testid="login-submit"]');
      await page.waitForSelector(PLAYWRIGHT_CONFIG.targetElementSelector, { timeout: 10000 });
      console.log('[INFO] Pre-authentication successful');
    } catch (authError) {
      console.error(`[FATAL] Pre-auth failed: ${authError.message}`);
      throw authError;
    } finally {
      await context.close();
    }
  });

  // Run latency test for each browser engine
  for (const browserName of PLAYWRIGHT_CONFIG.browsers) {
    test.describe(`${browserName} latency benchmark`, () => {
      const browserResults = {
        latencies: [],
        errors: 0,
        timeouts: 0
      };
      latencyResults[browserName] = browserResults;

      test(`Run ${PLAYWRIGHT_CONFIG.iterations} iterations on ${browserName}`, async ({ browser }) => {
        const context = await browser.newContext({ ignoreHTTPSErrors: true });
        const page = await context.newPage();

        for (let i = 0; i < PLAYWRIGHT_CONFIG.iterations; i++) {
          const start = performance.now();
          try {
            // Navigate to dashboard, which fetches PostgreSQL 17 data via API
            await page.goto(PLAYWRIGHT_CONFIG.targetUrl, { waitUntil: 'networkidle' });
            // Wait for dashboard to fully render with PostgreSQL data
            await page.waitForSelector(PLAYWRIGHT_CONFIG.targetElementSelector, { state: 'visible', timeout: 5000 });
            const end = performance.now();
            browserResults.latencies.push(end - start);
          } catch (testError) {
            if (testError.message.includes('timeout')) {
              browserResults.timeouts++;
            } else {
              browserResults.errors++;
            }
            console.error(`[ERROR] Iteration ${i} failed for ${browserName}: ${testError.message}`);
          }
        }

        await context.close();
      });
    });
  }

  // Generate summary report after all tests
  test.afterAll(() => {
    console.log('\n=== Playwright 1.50 Test #2289 Results ===');
    for (const [browser, results] of Object.entries(latencyResults)) {
      results.latencies.sort((a, b) => a - b);
      const p50 = results.latencies[Math.floor(results.latencies.length * 0.5)];
      const p99 = results.latencies[Math.floor(results.latencies.length * 0.99)];
      console.log(`${browser}: p50=${p50.toFixed(2)}ms, p99=${p99.toFixed(2)}ms, errors=${results.errors}, timeouts=${results.timeouts}`);
    }
  });
});

// Full Playwright test suite and CI config: https://github.com/microsoft/playwright/tree/main/tests/latency-benchmarks

// e2e-latency-pipeline.js
// Combined PostgreSQL 17 + Playwright 1.50 E2E latency test for CI pipelines
// Dependencies: pg@8.11.3, playwright@1.50.0, dotenv@16.3.1
require('dotenv').config();
const { Pool } = require('pg');
const { chromium } = require('playwright');
const { performance } = require('perf_hooks');

// Pipeline configuration for test #2289
const PIPELINE_CONFIG = {
  pgConnectionString: process.env.PG17_CONNECTION_STRING,
  appBaseUrl: 'https://pg17-bench-app.example.com',
  testUser: { username: 'bench_user', password: 'bench_pass_2289' },
  maxRetries: 3,
  latencyThresholdMs: 200 // Fail pipeline if p99 exceeds this
};

// Initialize PostgreSQL pool
const pgPool = new Pool({ connectionString: PIPELINE_CONFIG.pgConnectionString, max: 10 });

async function runE2ELatencyCheck() {
  const pipelineStart = performance.now();
  let pgLatencies = [];
  let uiLatencies = [];
  let pipelinePass = true;
  let errorMessage = '';

  // Step 1: Verify PostgreSQL 17 is responsive with read query
  console.log('[PIPELINE] Step 1: PostgreSQL 17 readiness check');
  try {
    const pgStart = performance.now();
    const pgResult = await pgPool.query('SELECT version() FROM version()');
    const pgEnd = performance.now();
    pgLatencies.push(pgEnd - pgStart);
    if (!pgResult.rows[0].version.includes('PostgreSQL 17')) {
      throw new Error(`Unexpected PostgreSQL version: ${pgResult.rows[0].version}`);
    }
    console.log(`[PIPELINE] PostgreSQL 17 ready in ${(pgEnd - pgStart).toFixed(2)}ms`);
  } catch (pgError) {
    pipelinePass = false;
    errorMessage = `PostgreSQL readiness failed: ${pgError.message}`;
    console.error(`[PIPELINE ERROR] ${errorMessage}`);
    return { pipelinePass, errorMessage };
  }

  // Step 2: Run Playwright UI latency test against PostgreSQL-backed app
  console.log('[PIPELINE] Step 2: Playwright 1.50 UI latency check');
  const browser = await chromium.launch({ headless: true });
  const context = await browser.newContext();
  const page = await context.newPage();

  try {
    // Login to app
    await page.goto(`${PIPELINE_CONFIG.appBaseUrl}/login`);
    await page.fill('[data-testid="username"]', PIPELINE_CONFIG.testUser.username);
    await page.fill('[data-testid="password"]', PIPELINE_CONFIG.testUser.password);
    await page.click('[data-testid="login-submit"]');
    await page.waitForSelector('[data-testid="dashboard-header"]', { timeout: 10000 });

    // Run 100 UI latency iterations
    for (let i = 0; i < 100; i++) {
      const uiStart = performance.now();
      await page.goto(`${PIPELINE_CONFIG.appBaseUrl}/dashboard`, { waitUntil: 'networkidle' });
      await page.waitForSelector('[data-testid="user-data-table"]', { state: 'visible', timeout: 5000 });
      const uiEnd = performance.now();
      uiLatencies.push(uiEnd - uiStart);
    }

    // Calculate p99 UI latency
    uiLatencies.sort((a, b) => a - b);
    const uiP99 = uiLatencies[Math.floor(uiLatencies.length * 0.99)];
    console.log(`[PIPELINE] UI p99 latency: ${uiP99.toFixed(2)}ms`);

    if (uiP99 > PIPELINE_CONFIG.latencyThresholdMs) {
      pipelinePass = false;
      errorMessage = `UI p99 latency ${uiP99.toFixed(2)}ms exceeds threshold ${PIPELINE_CONFIG.latencyThresholdMs}ms`;
    }
  } catch (uiError) {
    pipelinePass = false;
    errorMessage = `Playwright test failed: ${uiError.message}`;
    console.error(`[PIPELINE ERROR] ${errorMessage}`);
  } finally {
    await browser.close();
    await pgPool.end();
  }

  const pipelineEnd = performance.now();
  console.log(`[PIPELINE] Total pipeline time: ${(pipelineEnd - pipelineStart).toFixed(2)}ms`);
  return { pipelinePass, errorMessage, pgLatencies, uiLatencies };
}

// Run pipeline if executed directly
if (require.main === module) {
  runE2ELatencyCheck().then(result => {
    if (result.pipelinePass) {
      console.log('[PIPELINE] All latency checks passed');
      process.exit(0);
    } else {
      console.error(`[PIPELINE] Failed: ${result.errorMessage}`);
      process.exit(1);
    }
  }).catch(err => {
    console.error(`[PIPELINE FATAL] ${err.message}`);
    process.exit(1);
  });
}

// CI pipeline integration examples: https://github.com/actions/playwright-pg-latency-action

-- PostgreSQL 17 config snippet to enable parallel sequential scan
-- Add to postgresql.conf or RDS parameter group
max_parallel_workers_per_gather = 4
parallel_leader_participation = on
max_parallel_workers = 16  -- Match total vCPUs for RDS instance

-- Check if a query uses parallel scan
EXPLAIN (ANALYZE, VERBOSE) 
SELECT COUNT(*) FROM test_bench_data WHERE created_at > '2024-01-01';
-- Look for "Parallel Seq Scan" in the output

// playwright.config.js snippet for Playwright 1.50
module.exports = {
  projects: [
    { name: 'chromium', use: { browserName: 'chromium' } },
    { name: 'firefox', use: { browserName: 'firefox' } },
    { name: 'webkit', use: { browserName: 'webkit' } } // Now stable in 1.50
  ],
  timeout: 30000 // Reduce global timeout to fail fast on latency spikes
};

// Wait for PostgreSQL API response before asserting UI state
await page.waitForResponse(resp => 
  resp.url().includes('/api/dashboard-data') && resp.status() === 200
);

# GitHub Actions workflow snippet for latency-gated releases
name: Latency Gate
on: [pull_request]
jobs:
  latency-check:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with: { node-version: '20' }
      - run: npm install
      - uses: actions/playwright-pg-latency-action@v1
        with:
          pg-connection-string: ${{ secrets.PG17_STAGING_CONNECTION }}
          latency-threshold-ms: 200
          playwright-version: '1.50.0'