How to handle error using nodejs http module

I have two servers. An addUser api in Server1 calls getId api in Server2 using nodejs http module. Below is my code, but I always receive error when addUser tries to parse the data(I don't know if it is error so it has error parsing data) from getId api. If getId api in Server2 returns a normal res.json(), parsing data has no issue. I wonder why getId throw error, the addUser api still goes into on.(data, ...)? What is the right way to handle error in this case?

Server1

app.get('/api/addUser/:userName', (req, res) => {
        const options = {
          host: 'localhost',
          port: 3090,
          path: '/api/getId',
          method: 'GET',
          headers: {
              accept: 'application/json'
          }
        };
        try {
            const x = http.request(options, function(res){
              let ret;
              res.on('data', function(data){
                console.log(data);
                if (!data) {
                  return;
                }
                const userId = JSON.parse(data); // throw error this line
                const user = {
                  userName: req.params.userName,
                  userId
                };
                ret = user;
                users.push(user);
            });
            }).on("error", err => { console.log(err); }).end();
        } catch (err) {
          errorCounter.add(1);
        }

Server2

app.get('/api/getId', (req, res) => {
   throw new Error('getId api error');
});

When you throw at the top level of your Express request handler (not inside an asynchronous callback), Express will catch that exception and, by default (if you don't have an Express error handler), will turn it into a 500 response status and will send back text/html with a summary of the error. Your attempt to JSON.parse() that HTML fails.

Your http.request() code needs to check the http status. At the low level that http.request() works, the only way you get an error from http.request() is if the actual http request encounters a parameter error or a network failure error.

When the request reaches the server and the server returns ANY kind of response, that is NOT considered an error. Getting a 404 status or a 500 status back is considered a successful http request from that standpoint of http.request(). If you want 4xx and 5xx status to be considered an error, then you will either have to manually code that or use a higher level library that does that for you.

As such, you have to check the http status that comes back from the response and only try to parse the response IF you get a 2xx response.

In addition, the data event is a chunk of data from the response stream. For small responses on a fast network, it might be the whole response, but it also might be just a chunk of the response. To do this reliably, you have to accumulate all data from the data events and then when the end event comes, you now know you have the whole response and you can parse it.

Here's an example:

const options = {
    host: 'localhost',
    port: 3090,
    path: '/api/getId',
    method: 'GET',
    headers: {
        accept: 'application/json'
    }
};

http.request(options, function (res) {
    let result = "";
    if (res.statusCode < 300) {
        res.on('data', function (data) {
            // accumulate data from the response stream
            result += data.toString();
        }).on('end', () => {
            try {
                const userId = JSON.parse(result);
                // do something with userId here
            } catch (e) {
                // do something with error e here - error parsing JSON
            }
        });
    } else {
        // do something because of a non-2xx status code here
    }
}).on("error", err => { 
    console.log(err); 
    // do something with err here
}).end();

Note, you have 3 different places, you need error handling here and 1 place where you have the final response.

As I said in the comments, this is a whole lot simpler with a higher level http library such as got() or node-fetch().

Here's how this code looks for got():

import got from 'got';

const options = {
    headers: { accept: 'application/json' }
};

got("http://localhost:3090/api/getId", options).json().then(result => {
    // this is your parsed JSON here
    console.log(result);
}).catch(err => {
    // got an error here
    console.log(err);
});

As you can see, the got() library does a lot for you. It checks the http status. It parses the JSON. It combines all the error paths into one error return (a rejected promise). It takes a URL instead of an options object and the same library call works for https or http URLs. And, it returns a promise.