Node.js中并行异步调用时一个请求拖慢另一个的问题排查

Hey there, let's dig into this tricky intermittent issue you've been dealing with over the past year+—it's the kind of head-scratcher that makes you double-check every line of code, so I feel your pain.

First, let's restate the problem clearly to make sure we're on the same page:

We’ve observed a peculiar phenomenon that pops up occasionally (not constantly) and repeats over time. We haven’t been able to track down its root cause, and suspect it might be tied to our implementation, runtime environment (Node 8.x & Koa), or external factors. Our setup uses the request-promise module to make two parallel asynchronous calls to dependent services.

Simplified Parallel Call Implementation (common pattern matching your description) #

const rp = require('request-promise');
const Koa = require('koa');
const app = new Koa();

app.use(async ctx => {
  // Parallel calls to two dependent services
  try {
    const [service1Response, service2Response] = await Promise.all([
      rp('https://dependent-service-1.com/api/data'),
      rp('https://dependent-service-2.com/api/data')
    ]);
    
    ctx.body = { 
      service1: service1Response, 
      service2: service2Response 
    };
  } catch (err) {
    ctx.status = 500;
    ctx.body = { error: 'Failed to fetch dependent data' };
  }
});

app.listen(3000);

You mentioned noticing odd patterns in your response time graphs—even without full details, here are some actionable troubleshooting angles based on the stack you're using:

Potential Root Causes & Fixes #

• Node 8.x EOL Limitations: Node 8.x reached end-of-life back in 2019, and it has known quirks with event loop handling, promise microtask scheduling, and connection pooling that could cause intermittent delays. If possible, upgrading to a supported LTS version (even Node 14.x would be a huge improvement) might resolve hidden runtime bugs.
• Connection Pool Bottlenecks: request-promise wraps the request library, which uses a default connection pool limit (usually 5 sockets per host). If your parallel calls hit this limit, subsequent requests will queue, causing unexpected latency spikes. Adjust the pool size explicitly:

  const rp = require('request-promise').defaults({
    pool: { maxSockets: 15 } // Tune this based on your traffic needs
  });
  

• Dependent Service Instability: The issue might not be on your end. Add logging to track individual response times for each service call—this will let you see if one service is consistently slow during the anomalous periods. Check if the dependent services have rate limiting, intermittent downtime, or latency spikes that align with your graphs.
• Koa Middleware Interference: If you have additional middleware (like logging, auth, or request validation) in your Koa app, check if any of it is blocking the event loop with synchronous code or introducing async delays that only surface under parallel load. Use Node 8's --trace-event-categories v8,node.async_hooks flag to profile event loop blocking.
• Hidden Error Handling Gaps: request-promise might be swallowing errors or retrying silently depending on your configuration. Expand your error logging to capture specific details about failed calls (status codes, timeout errors, etc.):

  catch (err) {
    console.error(`Parallel call failed at ${new Date()}:`, {
      service: err.options.uri,
      errorCode: err.statusCode,
      errorMessage: err.message
    });
    ctx.status = err.statusCode || 500;
    ctx.body = { error: `Failed to fetch from ${err.options.uri}` };
  }
  

内容的提问来源于stack exchange，提问作者Rob Graham