Contrarian Take: Go 1.24 Is Overrated for Microservices, Use Node.js 22 and Fastify 5.0 Instead

// fastify-microservice.js - Production-ready REST API with Node.js 22 + Fastify 5.0
// Requires: npm install fastify@5.0.0 @fastify/autoload @fastify/helmet @fastify/cors @opentelemetry/api @opentelemetry/sdk-node @opentelemetry/exporter-prometheus
import Fastify from 'fastify';
import autoload from '@fastify/autoload';
import helmet from '@fastify/helmet';
import cors from '@fastify/cors';
import { NodeSDK } from '@opentelemetry/sdk-node';
import { PrometheusExporter } from '@opentelemetry/exporter-prometheus';
import path from 'path';
import { fileURLToPath } from 'url';

// Initialize OpenTelemetry for tracing and metrics
const sdk = new NodeSDK({
  metricExporter: new PrometheusExporter({ port: 9464 }),
  serviceName: 'order-service',
});
sdk.start();

// Get current file directory for autoloading routes
const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);

// Initialize Fastify instance with logging and error handling
const fastify = Fastify({
  logger: {
    level: 'info',
    transport: process.env.NODE_ENV === 'development' ? { target: 'pino-pretty' } : undefined,
  },
  ajv: { customOptions: { removeAdditional: 'all', coerceTypes: true } },
});

// Register security plugins
await fastify.register(helmet, { contentSecurityPolicy: false });
await fastify.register(cors, { origin: process.env.ALLOWED_ORIGINS?.split(',') || [] });

// Autoload routes from ./routes directory
await fastify.register(autoload, {
  dir: path.join(__dirname, 'routes'),
  options: { prefix: '/api/v1' },
});

// Health check endpoint for orchestration
fastify.get('/health', async (request, reply) => {
  try {
    // Check downstream dependencies (e.g., database, Redis)
    const dbHealthy = await checkDatabaseHealth();
    const redisHealthy = await checkRedisHealth();
    if (!dbHealthy || !redisHealthy) {
      reply.code(503).send({ status: 'unhealthy', details: { db: dbHealthy, redis: redisHealthy } });
      return;
    }
    reply.send({ status: 'healthy', timestamp: new Date().toISOString() });
  } catch (err) {
    fastify.log.error(err, 'Health check failed');
    reply.code(500).send({ status: 'error', message: 'Health check failed' });
  }
});

// Global error handler
fastify.setErrorHandler((error, request, reply) => {
  fastify.log.error(error, 'Unhandled request error');
  const statusCode = error.statusCode || 500;
  reply.code(statusCode).send({
    error: error.name || 'InternalServerError',
    message: statusCode === 500 ? 'Something went wrong' : error.message,
    requestId: request.id,
  });
});

// Start server
try {
  const port = process.env.PORT || 3000;
  const host = process.env.HOST || '0.0.0.0';
  await fastify.listen({ port, host });
  fastify.log.info(`Server running on ${host}:${port}`);
} catch (err) {
  fastify.log.error(err);
  process.exit(1);
}

// Mock health check functions (replace with real implementations)
async function checkDatabaseHealth() {
  return Math.random() > 0.05; // 95% uptime simulation
}
async function checkRedisHealth() {
  return Math.random() > 0.03; // 97% uptime simulation
}

// main.go - Equivalent Go 1.24 microservice for comparison
// Requires: go 1.24, github.com/go-chi/chi/v5, go.opentelemetry.io/otel, go.opentelemetry.io/otel/exporters/prometheus
package main

import (
    \"context\"
    \"encoding/json\"
    \"fmt\"
    \"log\"
    \"net/http\"
    \"os\"
    \"os/signal\"
    \"syscall\"
    \"time\"

    \"github.com/go-chi/chi/v5\"
    \"github.com/go-chi/chi/v5/middleware\"
    \"go.opentelemetry.io/otel\"
    \"go.opentelemetry.io/otel/exporters/prometheus\"
    \"go.opentelemetry.io/otel/metric\"
    \"go.opentelemetry.io/otel/propagation\"
    \"go.opentelemetry.io/otel/sdk/metric\"
    \"go.opentelemetry.io/otel/trace\"
)

// Initialize OpenTelemetry
func initOtel() *metric.MeterProvider {
    exporter, err := prometheus.New()
    if err != nil {
        log.Fatalf(\"Failed to create Prometheus exporter: %v\", err)
    }
    provider := metric.NewMeterProvider(metric.WithReader(exporter))
    otel.SetMeterProvider(provider)
    otel.SetTextMapPropagator(propagation.NewCompositeTextMapPropagator(propagation.TraceContext{}, propagation.Baggage{}))
    return provider
}

// Health check handler
func healthHandler(w http.ResponseWriter, r *http.Request) {
    ctx := r.Context()
    span := trace.SpanFromContext(ctx)
    defer span.End()

    // Mock dependency checks
    dbHealthy := checkDatabaseHealth()
    redisHealthy := checkRedisHealth()

    w.Header().Set(\"Content-Type\", \"application/json\")
    if !dbHealthy || !redisHealthy {
        w.WriteHeader(http.StatusServiceUnavailable)
        json.NewEncoder(w).Encode(map[string]interface{}{
            \"status\":  \"unhealthy\",
            \"details\": map[string]bool{\"db\": dbHealthy, \"redis\": redisHealthy},
        })
        return
    }
    json.NewEncoder(w).Encode(map[string]string{
        \"status\":    \"healthy\",
        \"timestamp\": time.Now().UTC().Format(time.RFC3339),
    })
}

// Mock health check functions
func checkDatabaseHealth() bool {
    return true // Simplified for example
}
func checkRedisHealth() bool {
    return true
}

// Order handler (simplified)
func createOrderHandler(w http.ResponseWriter, r *http.Request) {
    ctx := r.Context()
    span := trace.SpanFromContext(ctx)
    defer span.End()

    if r.Method != http.MethodPost {
        http.Error(w, \"Method not allowed\", http.StatusMethodNotAllowed)
        return
    }

    var order struct {
        CustomerID string  `json:\"customer_id\"`
        Amount     float64 `json:\"amount\"`
    }
    if err := json.NewDecoder(r.Body).Decode(&order); err != nil {
        http.Error(w, \"Invalid request body\", http.StatusBadRequest)
        return
    }

    // Validate order
    if order.CustomerID == \"\" || order.Amount <= 0 {
        http.Error(w, \"Invalid order data\", http.StatusBadRequest)
        return
    }

    w.Header().Set(\"Content-Type\", \"application/json\")
    json.NewEncoder(w).Encode(map[string]string{\"status\": \"created\", \"order_id\": \"ord_12345\"})
}

func main() {
    // Initialize OpenTelemetry
    provider := initOtel()
    defer provider.Shutdown(context.Background())

    // Create chi router
    r := chi.NewRouter()
    r.Use(middleware.RequestID)
    r.Use(middleware.RealIP)
    r.Use(middleware.Logger)
    r.Use(middleware.Recoverer)
    r.Use(middleware.Timeout(60 * time.Second))

    // Register routes
    r.Get(\"/health\", healthHandler)
    r.Post(\"/api/v1/orders\", createOrderHandler)

    // Start server
    port := os.Getenv(\"PORT\")
    if port == \"\" {
        port = \"3000\"
    }
    host := os.Getenv(\"HOST\")
    if host == \"\" {
        host = \"0.0.0.0\"
    }
    addr := fmt.Sprintf(\"%s:%s\", host, port)

    srv := &http.Server{
        Addr:         addr,
        Handler:      r,
        ReadTimeout:  10 * time.Second,
        WriteTimeout: 30 * time.Second,
        IdleTimeout:  120 * time.Second,
    }

    // Graceful shutdown
    quit := make(chan os.Signal, 1)
    signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)

    go func() {
        log.Printf(\"Server running on %s\", addr)
        if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
            log.Fatalf(\"Server failed: %v\", err)
        }
    }()

    <-quit
    log.Println(\"Shutting down server...\")
    ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
    defer cancel()
    if err := srv.Shutdown(ctx); err != nil {
        log.Fatalf(\"Server forced to shutdown: %v\", err)
    }
    log.Println(\"Server exited\")
}

// benchmark.js - Comparative benchmark for Node.js 22 + Fastify 5.0 vs Go 1.24
// Requires: npm install autocannon chalk
import autocannon from 'autocannon';
import chalk from 'chalk';
import { exec } from 'child_process';
import { promisify } from 'util';
import fs from 'fs/promises';

const execAsync = promisify(exec);

// Benchmark configuration
const BENCHMARK_DURATION = 30; // seconds
const BENCHMARK_CONNECTIONS = 100;
const BENCHMARK_PIPELINING = 1;
const ENDPOINT = '/api/v1/orders';
const METHOD = 'POST';
const BODY = JSON.stringify({ customer_id: 'cust_123', amount: 99.99 });

// Results storage
const results = {
  node: null,
  go: null,
};

async function startNodeService() {
  console.log(chalk.blue('Starting Node.js 22 + Fastify 5.0 service...'));
  const proc = exec('node fastify-microservice.js', { env: { ...process.env, PORT: '3001' } });
  proc.stderr.on('data', (data) => console.error(chalk.red(`Node error: ${data}`)));
  // Wait for service to start
  await new Promise(resolve => setTimeout(resolve, 2000));
  return proc;
}

async function startGoService() {
  console.log(chalk.blue('Starting Go 1.24 service...'));
  const proc = exec('go run main.go', { env: { ...process.env, PORT: '3002' } });
  proc.stderr.on('data', (data) => console.error(chalk.red(`Go error: ${data}`)));
  // Wait for service to start
  await new Promise(resolve => setTimeout(resolve, 2000));
  return proc;
}

async function runBenchmark(url, name) {
  console.log(chalk.yellow(`Running benchmark for ${name} at ${url}...`));
  try {
    const result = await autocannon({
      url: `${url}${ENDPOINT}`,
      method: METHOD,
      body: BODY,
      headers: { 'Content-Type': 'application/json' },
      duration: BENCHMARK_DURATION,
      connections: BENCHMARK_CONNECTIONS,
      pipelining: BENCHMARK_PIPELINING,
      json: true,
    });
    return {
      name,
      reqPerSec: result.requests.average,
      latencyP99: result.latency.p99,
      bytesPerSec: result.throughput.average,
      errors: result.errors,
      timeouts: result.timeouts,
    };
  } catch (err) {
    console.error(chalk.red(`Benchmark failed for ${name}: ${err.message}`));
    return null;
  }
}

async function saveResults() {
  await fs.writeFile('benchmark-results.json', JSON.stringify(results, null, 2));
  console.log(chalk.green('Results saved to benchmark-results.json'));
}

async function main() {
  let nodeProc, goProc;
  try {
    // Start services
    nodeProc = await startNodeService();
    goProc = await startGoService();

    // Run benchmarks
    results.node = await runBenchmark('http://localhost:3001', 'Node.js 22 + Fastify 5.0');
    results.go = await runBenchmark('http://localhost:3002', 'Go 1.24');

    // Print comparison
    console.log(chalk.bold('\n=== Benchmark Results ==='));
    if (results.node && results.go) {
      console.log(chalk.cyan(`Node.js 22 + Fastify 5.0:`));
      console.log(`  Requests/sec: ${results.node.reqPerSec.toFixed(2)}`);
      console.log(`  P99 Latency: ${results.node.latencyP99.toFixed(2)} ms`);
      console.log(`  Errors: ${results.node.errors}`);

      console.log(chalk.cyan(`\nGo 1.24:`));
      console.log(`  Requests/sec: ${results.go.reqPerSec.toFixed(2)}`);
      console.log(`  P99 Latency: ${results.go.latencyP99.toFixed(2)} ms`);
      console.log(`  Errors: ${results.go.errors}`);

      const latencyDiff = ((results.node.latencyP99 - results.go.latencyP99) / results.go.latencyP99) * 100;
      const throughputDiff = ((results.node.reqPerSec - results.go.reqPerSec) / results.go.reqPerSec) * 100;
      console.log(chalk.bold(`\nDifference (Node vs Go):`));
      console.log(`  P99 Latency: ${latencyDiff.toFixed(2)}% ${latencyDiff < 0 ? 'lower' : 'higher'}`);
      console.log(`  Throughput: ${throughputDiff.toFixed(2)}% ${throughputDiff > 0 ? 'higher' : 'lower'}`);
    }

    await saveResults();
  } catch (err) {
    console.error(chalk.red(`Main error: ${err.message}`));
  } finally {
    // Cleanup
    nodeProc?.kill();
    goProc?.kill();
  }
}

main();

// Route with full schema validation in Fastify 5.0
fastify.post('/api/v1/orders', {
  schema: {
    body: {
      type: 'object',
      required: ['customer_id', 'amount'],
      properties: {
        customer_id: { type: 'string', minLength: 5 },
        amount: { type: 'number', minimum: 0.01 },
        items: { type: 'array', items: { type: 'string' } },
      },
      additionalProperties: false,
    },
    response: {
      200: {
        type: 'object',
        properties: {
          order_id: { type: 'string' },
          status: { type: 'string' },
        },
      },
    },
  },
}, async (request, reply) => {
  const { customer_id, amount } = request.body;
  // Business logic here
  return { order_id: 'ord_67890', status: 'created' };
});

// Node.js 22 native test for Fastify route
import { test, mock } from 'node:test';
import assert from 'node:assert/strict';
import Fastify from 'fastify';
import { createOrderHandler } from './routes/orders.js';

test('POST /api/v1/orders returns 200 for valid input', async (t) => {
  const fastify = Fastify({ logger: false });
  fastify.post('/api/v1/orders', createOrderHandler);

  const response = await fastify.inject({
    method: 'POST',
    url: '/api/v1/orders',
    payload: { customer_id: 'cust_123', amount: 99.99 },
  });

  assert.equal(response.statusCode, 200);
  const body = JSON.parse(response.payload);
  assert.match(body.order_id, /^ord_/);
  await fastify.close();
});

// Cluster setup for Node.js 22 + Fastify 5.0
import cluster from 'node:cluster';
import os from 'node:os';
import Fastify from 'fastify';

if (cluster.isPrimary) {
  const numCPUs = os.cpus().length;
  console.log(`Primary ${process.pid} is running, forking ${numCPUs} workers`);

  for (let i = 0; i < numCPUs; i++) {
    cluster.fork();
  }

  cluster.on('exit', (worker, code, signal) => {
    console.log(`Worker ${worker.process.pid} died, restarting...`);
    cluster.fork();
  });
} else {
  const fastify = Fastify({ logger: true });
  // Register autoload for routes
  fastify.register(import('@fastify/autoload'), {
    dir: './routes',
    options: { prefix: '/api/v1' },
  });

  fastify.listen({ port: 3000, host: '0.0.0.0' });
  console.log(`Worker ${process.pid} started`);
}