refactor

Author: mtrezza

benchmark/db-proxy.js

@@ -3,6 +3,8 @@
  * This helps make benchmark measurements more stable by simulating network conditions
  */
 
+/* eslint-disable no-console */
+
 const net = require('net');
 
 const PROXY_PORT = parseInt(process.env.PROXY_PORT || '27018', 10);
@@ -52,8 +54,7 @@ const server = net.createServer((clientSocket) => {
 });
 
 server.listen(PROXY_PORT, () => {
-  console.log(`MongoDB proxy listening on port ${PROXY_PORT}`);
-  console.log(`Forwarding to ${TARGET_HOST}:${TARGET_PORT} with ${LATENCY_MS}ms latency`);
+  console.log(`MongoDB proxy listening on port ${PROXY_PORT} forwarding to ${TARGET_PORT} with ${LATENCY_MS}ms latency`);
 });
 
 process.on('SIGTERM', () => {

benchmark/performance.js

@@ -24,6 +24,35 @@ const ITERATIONS = parseInt(process.env.BENCHMARK_ITERATIONS || '10000', 10);
 // Parse Server instance
 let parseServer;
 let mongoClient;
+let proxyProcess;
+let proxyServerCleanup;
+
+/**
+ * Start MongoDB proxy with artificial latency
+ */
+async function startProxy() {
+  const { spawn } = require('child_process');
+
+  proxyProcess = spawn('node', ['benchmark/db-proxy.js'], {
+    env: { ...process.env, PROXY_PORT: '27018', TARGET_PORT: '27017', LATENCY_MS: '10000' },
+    stdio: 'inherit',
+  });
+
+  // Wait for proxy to start
+  await new Promise(resolve => setTimeout(resolve, 2000));
+  console.log('MongoDB proxy started on port 27018 with 10ms latency');
+}
+
+/**
+ * Stop MongoDB proxy
+ */
+async function stopProxy() {
+  if (proxyProcess) {
+    proxyProcess.kill();
+    await new Promise(resolve => setTimeout(resolve, 500));
+    console.log('MongoDB proxy stopped');
+  }
+}
 
 /**
  * Initialize Parse Server for benchmarking
@@ -86,6 +115,66 @@ async function cleanupDatabase() {
   }
 }
 
+/**
+ * Reset Parse SDK to use the default server
+ */
+function resetParseServer() {
+  Parse.serverURL = SERVER_URL;
+}
+
+/**
+ * Start a Parse Server instance using the DB proxy for latency simulation
+ * Stores cleanup function globally for later use
+ */
+async function useProxyServer() {
+  const express = require('express');
+  const { default: ParseServer } = require('../lib/index.js');
+
+  // Create a new Parse Server instance using the proxy
+  const app = express();
+  const proxyParseServer = new ParseServer({
+    databaseURI: 'mongodb://localhost:27018/parse_benchmark_test',
+    appId: APP_ID,
+    masterKey: MASTER_KEY,
+    serverURL: 'http://localhost:1338/parse',
+    silent: true,
+    allowClientClassCreation: true,
+    logLevel: 'error',
+    verbose: false,
+  });
+
+  app.use('/parse', proxyParseServer.app);
+
+  const server = await new Promise((resolve, reject) => {
+    const s = app.listen(1338, (err) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve(s);
+      }
+    });
+  });
+
+  // Configure Parse SDK to use the proxy server
+  Parse.serverURL = 'http://localhost:1338/parse';
+
+  // Store cleanup function globally
+  proxyServerCleanup = async () => {
+    server.close();
+    await new Promise(resolve => setTimeout(resolve, 500));
+    proxyServerCleanup = null;
+  };
+}
+
+/**
+ * Clean up proxy server if it's running
+ */
+async function cleanupProxyServer() {
+  if (proxyServerCleanup) {
+    await proxyServerCleanup();
+  }
+}
+
 /**
  * Measure average time for an async operation over multiple iterations
  * Uses warmup iterations, median metric, and outlier filtering for robustness
@@ -295,8 +384,12 @@ async function benchmarkUserLogin() {
 
 /**
  * Benchmark: Query with Include (Parallel Include Pointers)
+ * This test uses the TCP proxy (port 27018) to simulate 10ms database latency for more realistic measurements
  */
 async function benchmarkQueryWithInclude() {
+  // Start proxy server
+  await useProxyServer();
+
   // Setup: Create nested object hierarchy
   const Level2Class = Parse.Object.extend('Level2');
   const Level1Class = Parse.Object.extend('Level1');
@@ -332,11 +425,13 @@ async function benchmarkQueryWithInclude() {
   }
   await Parse.Object.saveAll(rootObjects);
 
-  return measureOperation('Query with Include (2 levels)', async () => {
+  const result = await measureOperation('Query with Include (2 levels)', async () => {
     const query = new Parse.Query('Root');
     query.include('level1.level2');
     await query.find();
-  }, Math.floor(ITERATIONS / 10)); // Fewer iterations for complex queries
+  });
+
+  return result;
 }
 
 /**
@@ -349,6 +444,9 @@ async function runBenchmarks() {
   let server;
 
   try {
+    // Start MongoDB proxy
+    await startProxy();
+
     // Initialize Parse Server
     console.log('Initializing Parse Server...');
     server = await initializeParseServer();
@@ -358,38 +456,26 @@ async function runBenchmarks() {
 
     const results = [];
 
-    // Run each benchmark with database cleanup
-    console.log('Running Object Create benchmark...');
-    await cleanupDatabase();
-    results.push(await benchmarkObjectCreate());
-
-    console.log('Running Object Read benchmark...');
-    await cleanupDatabase();
-    results.push(await benchmarkObjectRead());
+    // Define all benchmarks to run
+    const benchmarks = [
+      { name: 'Object Create', fn: benchmarkObjectCreate },
+      { name: 'Object Read', fn: benchmarkObjectRead },
+      { name: 'Object Update', fn: benchmarkObjectUpdate },
+      { name: 'Simple Query', fn: benchmarkSimpleQuery },
+      { name: 'Batch Save', fn: benchmarkBatchSave },
+      { name: 'User Signup', fn: benchmarkUserSignup },
+      { name: 'User Login', fn: benchmarkUserLogin },
+      { name: 'Query with Include', fn: benchmarkQueryWithInclude },
+    ];
 
-    console.log('Running Object Update benchmark...');
-    await cleanupDatabase();
-    results.push(await benchmarkObjectUpdate());
-
-    console.log('Running Simple Query benchmark...');
-    await cleanupDatabase();
-    results.push(await benchmarkSimpleQuery());
-
-    console.log('Running Batch Save benchmark...');
-    await cleanupDatabase();
-    results.push(await benchmarkBatchSave());
-
-    console.log('Running User Signup benchmark...');
-    await cleanupDatabase();
-    results.push(await benchmarkUserSignup());
-
-    console.log('Running User Login benchmark...');
-    await cleanupDatabase();
-    results.push(await benchmarkUserLogin());
-
-    console.log('Running Query with Include benchmark...');
-    await cleanupDatabase();
-    results.push(await benchmarkQueryWithInclude());
+    // Run each benchmark with database cleanup
+    for (const benchmark of benchmarks) {
+      console.log(`Running ${benchmark.name} benchmark...`);
+      resetParseServer();
+      await cleanupDatabase();
+      results.push(await benchmark.fn());
+      await cleanupProxyServer();
+    }
 
     // Output results in github-action-benchmark format (stdout)
     console.log(JSON.stringify(results, null, 2));
@@ -412,8 +498,9 @@ async function runBenchmarks() {
     if (server) {
       server.close();
     }
+    await stopProxy();
     // Give some time for cleanup
-    setTimeout(() => process.exit(0), 10000);
+    setTimeout(() => process.exit(0), 1000);
   }
 }