Benchmark: Apollo Server 4.10 vs. GraphQL Yoga 5.0: Request Throughput 2026

// benchmark-harness.mjs
// ESM benchmark harness comparing Apollo Server 4.10 and GraphQL Yoga 5.0
// Requirements: autocannon@8.0.0, @apollo/server@4.10.0, graphql-yoga@5.0.0
// Hardware: AMD EPYC 9654 (16 vCPUs), 64GB RAM, Node.js v22.9.0

import { spawn } from 'child_process';
import autocannon from 'autocannon';
import http from 'http';
import { promisify } from 'util';

const sleep = promisify(setTimeout);

// Configuration
const BENCHMARK_DURATION = 30; // seconds
const CONCURRENT_CONNECTIONS = 10000;
const SERVER_START_TIMEOUT = 5000; // ms
const APOLLO_PORT = 4000;
const YOGA_PORT = 4001;
const QUERY = JSON.stringify({
  query: `query GetUser {
    user(id: "bench-user-123") {
      id
      name
      email
      posts(limit: 5) {
        id
        title
      }
    }
  }`
});

// Start Apollo Server 4.10
function startApolloServer() {
  return new Promise((resolve, reject) => {
    const apollo = spawn('node', ['apollo-server.mjs'], {
      env: { ...process.env, PORT: APOLLO_PORT },
      stdio: 'pipe'
    });

    apollo.stdout.on('data', (data) => {
      if (data.toString().includes('Apollo Server 4.10 ready')) {
        resolve(apollo);
      }
    });

    apollo.stderr.on('data', (data) => {
      reject(new Error(`Apollo Server failed to start: ${data}`));
    });

    setTimeout(() => reject(new Error('Apollo Server start timeout')), SERVER_START_TIMEOUT);
  });
}

// Start GraphQL Yoga 5.0
function startYogaServer() {
  return new Promise((resolve, reject) => {
    const yoga = spawn('node', ['yoga-server.mjs'], {
      env: { ...process.env, PORT: YOGA_PORT },
      stdio: 'pipe'
    });

    yoga.stdout.on('data', (data) => {
      if (data.toString().includes('GraphQL Yoga 5.0 ready')) {
        resolve(yoga);
      }
    });

    yoga.stderr.on('data', (data) => {
      reject(new Error(`Yoga Server failed to start: ${data}`));
    });

    setTimeout(() => reject(new Error('Yoga Server start timeout')), SERVER_START_TIMEOUT);
  });
}

// Run benchmark for a single server
async function runBenchmark(port, serverName) {
  console.log(`Starting benchmark for ${serverName}...`);
  const result = await autocannon({
    url: `http://localhost:${port}/graphql`,
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: QUERY,
    connections: CONCURRENT_CONNECTIONS,
    duration: BENCHMARK_DURATION,
    pipelining: 1,
    requests: [{ method: 'POST', path: '/graphql', body: QUERY, headers: { 'Content-Type': 'application/json' } }]
  });

  console.log(`${serverName} Results:`);
  console.log(`  Throughput: ${result.requests.mean} req/s`);
  console.log(`  p99 Latency: ${result.latency.p99}ms`);
  console.log(`  Errors: ${result.errors}`);
  return result;
}

// Main execution
async function main() {
  let apolloProcess, yogaProcess;
  try {
    // Start servers
    console.log('Starting Apollo Server 4.10...');
    apolloProcess = await startApolloServer();
    await sleep(1000); // Warmup

    console.log('Starting GraphQL Yoga 5.0...');
    yogaProcess = await startYogaServer();
    await sleep(1000); // Warmup

    // Run benchmarks
    const apolloResults = await runBenchmark(APOLLO_PORT, 'Apollo Server 4.10');
    const yogaResults = await runBenchmark(YOGA_PORT, 'GraphQL Yoga 5.0');

    // Output comparison
    console.log('
=== Benchmark Comparison ===');
    console.log(`Throughput Difference: ${((yogaResults.requests.mean - apolloResults.requests.mean) / apolloResults.requests.mean * 100).toFixed(2)}%`);
    console.log(`Latency Difference: ${((apolloResults.latency.p99 - yogaResults.latency.p99) / yogaResults.latency.p99 * 100).toFixed(2)}%`);

  } catch (err) {
    console.error('Benchmark failed:', err.message);
    process.exit(1);
  } finally {
    // Cleanup
    apolloProcess?.kill();
    yogaProcess?.kill();
  }
}

// Handle uncaught errors
process.on('uncaughtException', (err) => {
  console.error('Uncaught exception:', err);
  process.exit(1);
});

main();

// apollo-server.mjs
// Apollo Server 4.10 implementation for benchmarking
// Imports: @apollo/server@4.10.0, graphql@16.8.1

import { ApolloServer } from '@apollo/server';
import { expressMiddleware } from '@apollo/server/express4';
import express from 'express';
import http from 'http';
import { makeExecutableSchema } from '@graphql-tools/schema';
import { readFileSync } from 'fs';
import { resolve } from 'path';

// Error handling for uncaught exceptions
process.on('uncaughtException', (err) => {
  console.error('Apollo Server uncaught exception:', err);
  process.exit(1);
});

// Mock data store (simulates real-world data access)
const users = new Map();
const posts = new Map();

// Seed benchmark data
function seedData() {
  for (let i = 0; i < 10000; i++) {
    const userId = `bench-user-${i}`;
    users.set(userId, {
      id: userId,
      name: `User ${i}`,
      email: `user${i}@bench.example.com`
    });
    for (let j = 0; j < 10; j++) {
      const postId = `post-${i}-${j}`;
      posts.set(postId, {
        id: postId,
        title: `Post ${j} for User ${i}`,
        authorId: userId
      });
    }
  }
}

// GraphQL Schema (matches benchmark query)
const typeDefs = readFileSync(resolve('./schema.graphql'), 'utf-8');

// Resolvers with error handling and simulated latency
const resolvers = {
  Query: {
    user: async (_, { id }) => {
      try {
        const user = users.get(id);
        if (!user) throw new Error(`User ${id} not found`);
        return user;
      } catch (err) {
        console.error('User resolver error:', err);
        throw new Error('Failed to fetch user');
      }
    }
  },
  User: {
    posts: async (user, { limit = 5 }) => {
      try {
        return Array.from(posts.values())
          .filter(post => post.authorId === user.id)
          .slice(0, limit);
      } catch (err) {
        console.error('Posts resolver error:', err);
        return [];
      }
    }
  }
};

// Create executable schema
const schema = makeExecutableSchema({ typeDefs, resolvers });

// Initialize Apollo Server
const server = new ApolloServer({
  schema,
  formatError: (err) => {
    console.error('Apollo Server error:', err);
    return { message: err.message, locations: err.locations, path: err.path };
  }
});

// Start server
async function startServer() {
  try {
    // Seed data before starting
    seedData();
    console.log('Seeded 10,000 users and 100,000 posts');

    // Start Apollo Server
    await server.start();
    const app = express();
    const httpServer = http.createServer(app);

    // Apply middleware
    app.use('/graphql', express.json(), expressMiddleware(server));

    // Start listening
    const port = process.env.PORT || 4000;
    await new Promise((resolve) => {
      httpServer.listen(port, () => {
        console.log(`Apollo Server 4.10 ready on port ${port}`);
        resolve();
      });
    });

    // Handle graceful shutdown
    process.on('SIGTERM', () => {
      console.log('SIGTERM received, shutting down Apollo Server...');
      httpServer.close(() => {
        console.log('Apollo Server closed');
        process.exit(0);
      });
    });

  } catch (err) {
    console.error('Failed to start Apollo Server:', err);
    process.exit(1);
  }
}

startServer();

// yoga-server.mjs
// GraphQL Yoga 5.0 implementation for benchmarking
// Imports: graphql-yoga@5.0.0, graphql@16.8.1

import { createYoga } from 'graphql-yoga';
import { createServer } from 'http';
import { makeExecutableSchema } from '@graphql-tools/schema';
import { readFileSync } from 'fs';
import { resolve } from 'path';

// Error handling for uncaught exceptions
process.on('uncaughtException', (err) => {
  console.error('Yoga Server uncaught exception:', err);
  process.exit(1);
});

// Mock data store (identical to Apollo Server for fair comparison)
const users = new Map();
const posts = new Map();

// Seed benchmark data (same as Apollo Server)
function seedData() {
  for (let i = 0; i < 10000; i++) {
    const userId = `bench-user-${i}`;
    users.set(userId, {
      id: userId,
      name: `User ${i}`,
      email: `user${i}@bench.example.com`
    });
    for (let j = 0; j < 10; j++) {
      const postId = `post-${i}-${j}`;
      posts.set(postId, {
        id: postId,
        title: `Post ${j} for User ${i}`,
        authorId: userId
      });
    }
  }
}

// GraphQL Schema (identical to Apollo Server)
const typeDefs = readFileSync(resolve('./schema.graphql'), 'utf-8');

// Resolvers (identical logic to Apollo Server for fair comparison)
const resolvers = {
  Query: {
    user: async (_, { id }) => {
      try {
        const user = users.get(id);
        if (!user) throw new Error(`User ${id} not found`);
        return user;
      } catch (err) {
        console.error('User resolver error:', err);
        throw new Error('Failed to fetch user');
      }
    }
  },
  User: {
    posts: async (user, { limit = 5 }) => {
      try {
        return Array.from(posts.values())
          .filter(post => post.authorId === user.id)
          .slice(0, limit);
      } catch (err) {
        console.error('Posts resolver error:', err);
        return [];
      }
    }
  }
};

// Create executable schema
const schema = makeExecutableSchema({ typeDefs, resolvers });

// Initialize Yoga Server
const yoga = createYoga({
  schema,
  logging: {
    debug: (...args) => console.debug(...args),
    info: (...args) => console.info(...args),
    warn: (...args) => console.warn(...args),
    error: (...args) => console.error(...args)
  },
  maskedErrors: false // Disable error masking for benchmarking
});

// Create HTTP server
const server = createServer(yoga);

// Start server
function startServer() {
  try {
    // Seed data before starting
    seedData();
    console.log('Seeded 10,000 users and 100,000 posts');

    // Start listening
    const port = process.env.PORT || 4001;
    server.listen(port, () => {
      console.log(`GraphQL Yoga 5.0 ready on port ${port}`);
    });

    // Handle graceful shutdown
    process.on('SIGTERM', () => {
      console.log('SIGTERM received, shutting down Yoga Server...');
      server.close(() => {
        console.log('Yoga Server closed');
        process.exit(0);
      });
    });

    // Handle server errors
    server.on('error', (err) => {
      console.error('Yoga Server HTTP error:', err);
      process.exit(1);
    });

  } catch (err) {
    console.error('Failed to start Yoga Server:', err);
    process.exit(1);
  }
}

startServer();

// dataloader.mjs
import DataLoader from 'dataloader';

// Batch function for user lookups (works with both Apollo and Yoga)
async function batchUsers(ids) {
  try {
    // Simulate database batch query (replace with actual DB call)
    const users = Array.from(ids).map(id => {
      const user = users.get(id);
      return user || new Error(`User ${id} not found`);
    });
    return users;
  } catch (err) {
    console.error('Batch user lookup failed:', err);
    return ids.map(() => new Error('Failed to fetch user'));
  }
}

// Create DataLoader instance (reuse across requests for hot paths)
export const userLoader = new DataLoader(batchUsers, {
  maxBatchSize: 100,
  cache: true,
  cacheKeyFn: (id) => id
});

// yoga-lambda.mjs
import { createYoga } from 'graphql-yoga';
import { makeExecutableSchema } from '@graphql-tools/schema';

const schema = makeExecutableSchema({ typeDefs, resolvers });
const yoga = createYoga({ schema });

export const handler = async (event) => {
  const response = await yoga.fetch(
    new Request(`https://lambda-url/graphql`, {
      method: 'POST',
      headers: event.headers,
      body: event.body
    })
  );
  return {
    statusCode: response.status,
    headers: Object.fromEntries(response.headers),
    body: await response.text()
  };
};

// apollo-metrics.mjs
import { ApolloServerPluginUsageReporting } from '@apollo/server/plugin/usageReporting';
import { PrometheusExporter } from '@opentelemetry/exporter-prometheus';

const prometheusExporter = new PrometheusExporter({ port: 9464 });

const metricsPlugin = ApolloServerPluginUsageReporting({
  sendVariableValues: { all: true },
  sendHeaders: { all: true },
  fieldLevelInstrumentation: 1.0, // 100% sampling
  exporter: prometheusExporter
});

export default metricsPlugin;