Merge branch 'alpha' into append-metadata

Author: mtrezza

.github/workflows/ci-performance.yml

@@ -70,7 +70,7 @@ jobs:
         env:
           NODE_ENV: production
         run: |
-          echo "Running baseline benchmarks with CPU affinity (using PR's benchmark script)..."
+          echo "Running baseline benchmarks..."
           if [ ! -f "benchmark/performance.js" ]; then
             echo "⚠️ Benchmark script not found - this is expected for new features"
             echo "Skipping baseline benchmark"
@@ -135,7 +135,7 @@ jobs:
         env:
           NODE_ENV: production
         run: |
-          echo "Running PR benchmarks with CPU affinity..."
+          echo "Running PR benchmarks..."
           taskset -c 0 npm run benchmark > pr-output.txt 2>&1 || npm run benchmark > pr-output.txt 2>&1 || true
           echo "Benchmark command completed with exit code: $?"
           echo "Output file size: $(wc -c < pr-output.txt) bytes"

benchmark/MongoLatencyWrapper.js

@@ -0,0 +1,137 @@
+/**
+ * MongoDB Latency Wrapper
+ *
+ * Utility to inject artificial latency into MongoDB operations for performance testing.
+ * This wrapper temporarily wraps MongoDB Collection methods to add delays before
+ * database operations execute.
+ *
+ * Usage:
+ *   const { wrapMongoDBWithLatency } = require('./MongoLatencyWrapper');
+ *
+ *   // Before initializing Parse Server
+ *   const unwrap = wrapMongoDBWithLatency(10); // 10ms delay
+ *
+ *   // ... run benchmarks ...
+ *
+ *   // Cleanup when done
+ *   unwrap();
+ */
+
+const { Collection } = require('mongodb');
+
+// Store original methods for restoration
+const originalMethods = new Map();
+
+/**
+ * Wrap a Collection method to add artificial latency
+ * @param {string} methodName - Name of the method to wrap
+ * @param {number} latencyMs - Delay in milliseconds
+ */
+function wrapMethod(methodName, latencyMs) {
+  if (!originalMethods.has(methodName)) {
+    originalMethods.set(methodName, Collection.prototype[methodName]);
+  }
+
+  const originalMethod = originalMethods.get(methodName);
+
+  Collection.prototype[methodName] = function (...args) {
+    // For methods that return cursors (like find, aggregate), we need to delay the execution
+    // but still return a cursor-like object
+    const result = originalMethod.apply(this, args);
+
+    // Check if result has cursor methods (toArray, forEach, etc.)
+    if (result && typeof result.toArray === 'function') {
+      // Wrap cursor methods that actually execute the query
+      const originalToArray = result.toArray.bind(result);
+      result.toArray = function() {
+        // Wait for the original promise to settle, then delay the result
+        return originalToArray().then(
+          value => new Promise(resolve => setTimeout(() => resolve(value), latencyMs)),
+          error => new Promise((_, reject) => setTimeout(() => reject(error), latencyMs))
+        );
+      };
+      return result;
+    }
+
+    // For promise-returning methods, wrap the promise with delay
+    if (result && typeof result.then === 'function') {
+      // Wait for the original promise to settle, then delay the result
+      return result.then(
+        value => new Promise(resolve => setTimeout(() => resolve(value), latencyMs)),
+        error => new Promise((_, reject) => setTimeout(() => reject(error), latencyMs))
+      );
+    }
+
+    // For synchronous methods, just add delay
+    return new Promise((resolve) => {
+      setTimeout(() => {
+        resolve(result);
+      }, latencyMs);
+    });
+  };
+}
+
+/**
+ * Wrap MongoDB Collection methods with artificial latency
+ * @param {number} latencyMs - Delay in milliseconds to inject before each operation
+ * @returns {Function} unwrap - Function to restore original methods
+ */
+function wrapMongoDBWithLatency(latencyMs) {
+  if (typeof latencyMs !== 'number' || latencyMs < 0) {
+    throw new Error('latencyMs must be a non-negative number');
+  }
+
+  if (latencyMs === 0) {
+    // eslint-disable-next-line no-console
+    console.log('Latency is 0ms, skipping MongoDB wrapping');
+    return () => {}; // No-op unwrap function
+  }
+
+  // eslint-disable-next-line no-console
+  console.log(`Wrapping MongoDB operations with ${latencyMs}ms artificial latency`);
+
+  // List of MongoDB Collection methods to wrap
+  const methodsToWrap = [
+    'find',
+    'findOne',
+    'countDocuments',
+    'estimatedDocumentCount',
+    'distinct',
+    'aggregate',
+    'insertOne',
+    'insertMany',
+    'updateOne',
+    'updateMany',
+    'replaceOne',
+    'deleteOne',
+    'deleteMany',
+    'findOneAndUpdate',
+    'findOneAndReplace',
+    'findOneAndDelete',
+    'createIndex',
+    'createIndexes',
+    'dropIndex',
+    'dropIndexes',
+    'drop',
+  ];
+
+  methodsToWrap.forEach(methodName => {
+    wrapMethod(methodName, latencyMs);
+  });
+
+  // Return unwrap function to restore original methods
+  return function unwrap() {
+    // eslint-disable-next-line no-console
+    console.log('Removing MongoDB latency wrapper, restoring original methods');
+
+    originalMethods.forEach((originalMethod, methodName) => {
+      Collection.prototype[methodName] = originalMethod;
+    });
+
+    originalMethods.clear();
+  };
+}
+
+module.exports = {
+  wrapMongoDBWithLatency,
+};