How to fix Error: FST_ERR_HOOK_TIMEOUT: Hook has exceeded the timeout limit in Node.js

fastify.addHook('onRequest', async (request, reply) => {
  // This is an 'onRequest' hook
});

fastify.addHook('preHandler', async (request, reply) => {
  // This is a 'preHandler' hook
});

fastify.addHook('onRequest', async (request, reply) => {
  console.log('onRequest hook starting');
  // your code
  console.log('onRequest hook completed');
});

// BAD: Synchronous file operations in a hook
fastify.addHook('preHandler', (request, reply, done) => {
  const data = fs.readFileSync('./large-file.txt', 'utf-8');
  done();
});

// GOOD: Use async file operations
fastify.addHook('preHandler', async (request, reply) => {
  const data = await fs.promises.readFile('./large-file.txt', 'utf-8');
});

// BAD: Infinite loop possibility
fastify.addHook('preHandler', async (request, reply) => {
  while (true) { // Never exits!
    await someOperation();
  }
});

// BAD: Waiting for a condition that never happens
fastify.addHook('preHandler', async (request, reply) => {
  while (!request.user) {
    await new Promise(resolve => setTimeout(resolve, 100));
  }
});

// GOOD: Use timeouts with Promise.race()
fastify.addHook('preHandler', async (request, reply) => {
  const timeout = new Promise((_, reject) =>
    setTimeout(() => reject(new Error('Hook timeout')), 5000)
  );
  await Promise.race([yourAsyncOperation(), timeout]);
});

// BAD: No timeout on external call
fastify.addHook('preHandler', async (request, reply) => {
  const user = await db.query('SELECT * FROM users');
});

// GOOD: Add timeout and connection pooling
fastify.addHook('preHandler', async (request, reply) => {
  const controller = new AbortController();
  const timeout = setTimeout(() => controller.abort(), 3000); // 3s timeout
  
  try {
    const user = await fetch('https://api.example.com/user', {
      signal: controller.signal
    });
  } finally {
    clearTimeout(timeout);
  }
});

// For databases, ensure connection pooling is configured
const db = knex({
  client: 'pg',
  connection: {
    pool: { min: 2, max: 10 }
  }
});

const fastify = require('fastify')({
  requestIdHeader: 'x-request-id',
  requestIdLogLabel: 'requestId',
  disableRequestLogging: false,
  requestTimeout: 30000, // 30 seconds for entire request
});

// For specific hooks, you can't directly configure timeout,
// but you can ensure your operations complete within Fastify's timeout
// Default request timeout is 30 seconds

// BAD: Heavy processing in a hook blocks the request
fastify.addHook('preHandler', async (request, reply) => {
  request.userId = await expensiveUserVerification();
});

// GOOD: Cache the result or defer the work
const userCache = new Map();

fastify.addHook('preHandler', async (request, reply) => {
  const cached = userCache.get(request.headers.authorization);
  if (cached) {
    request.userId = cached;
    return;
  }
  request.userId = 'unknown';
});

// Verify user in background, update cache
setInterval(() => {
  updateUserCache();
}, 60000); // Every minute

fastify.addHook('preHandler', async (request, reply) => {
  try {
    // your hook code
  } catch (error) {
    // Don't let unhandled errors cause timeouts
    fastify.log.error(error);
    reply.code(500).send({ error: 'Internal server error' });
  }
});

// Or throw and let Fastify's error handler deal with it
fastify.addHook('preHandler', async (request, reply) => {
  if (!request.user) {
    throw new Error('Unauthorized');
  }
});

fastify.setErrorHandler((error, request, reply) => {
  fastify.log.error(error);
  reply.code(500).send({ error: error.message });
});

fastify.addHook('preHandler', async (request, reply) => {
  const start = performance.now();
  
  try {
    // your hook code
  } finally {
    const duration = performance.now() - start;
    if (duration > 1000) { // Log if over 1 second
      fastify.log.warn({ duration }, 'Slow preHandler hook');
    }
  }
});

// Run your test suite with load testing
npm test

// Use tools like autocannon to load test
npx autocannon -c 10 -d 30 http://localhost:3000