Updates lambda functions with more robust err handling

server/lambda/check-ports.js

@@ -9,7 +9,7 @@ const PORTS = [
 ];
 
 async function checkPort(port, domain) {
-    return new Promise(resolve => {
+    return new Promise((resolve, reject) => {
         const socket = new net.Socket();
 
         socket.setTimeout(1500); // you may want to adjust the timeout
@@ -21,22 +21,23 @@ async function checkPort(port, domain) {
 
         socket.once('timeout', () => {
           socket.destroy();
+          reject(new Error(`Timeout at port: ${port}`));
         });
 
         socket.once('error', (e) => {
             socket.destroy();
+            reject(e);
         });
+        
         socket.connect(port, domain);
     });
 }
 
 exports.handler = async (event, context) => {
   const domain = event.queryStringParameters.url;
+  
   if (!domain) {
-    return {
+    return errorResponse('Missing domain parameter.');
-      statusCode: 400,
-      body: JSON.stringify({ message: "Missing 'domain' parameter" }),
-    };
   }
 
   const delay = ms => new Promise(res => setTimeout(res, ms));
@@ -71,11 +72,19 @@ exports.handler = async (event, context) => {
     }
   }
 
+  if(timeoutReached){
+    return errorResponse('The function timed out before completing.');
+  }
+
   return {
     statusCode: 200,
-    body: JSON.stringify({ timeout: timeoutReached, openPorts, failedPorts }),
+    body: JSON.stringify({ openPorts, failedPorts }),
   };
 };
 
-
+const errorResponse = (message, statusCode = 444) => {
-
+  return {
+    statusCode: statusCode,
+    body: JSON.stringify({ error: message }),
+  };
+};

server/lambda/dns-sec.js

@@ -1,14 +1,10 @@
 const https = require('https');
-const urlModule = require('url');
 
 exports.handler = async function(event, context) {
   let { url } = event.queryStringParameters;
 
   if (!url) {
-    return {
+    return errorResponse('URL query parameter is required.');
-      statusCode: 400,
-      body: JSON.stringify({ error: 'url query parameter is required' }),
-    };
   }
 
   // Extract hostname from URL
@@ -40,11 +36,11 @@ exports.handler = async function(event, context) {
           res.on('end', () => {
             resolve(JSON.parse(data));
           });
-        });
 
-        req.on('error', error => {
+          res.on('error', error => {
             reject(error);
           });
+        });
 
         req.end();
       });
@@ -55,10 +51,7 @@ exports.handler = async function(event, context) {
         records[type] = { isFound: false, answer: null, response: dnsResponse};
       }
     } catch (error) {
-      return {
+      return errorResponse(`Error fetching ${type} record: ${error.message}`);
-        statusCode: 500,
-        body: JSON.stringify({ error: `Error fetching ${type} record: ${error.message}` }),
-      };
     }
   }
 
@@ -67,3 +60,10 @@ exports.handler = async function(event, context) {
     body: JSON.stringify(records),
   };
 };
+
+const errorResponse = (message, statusCode = 444) => {
+  return {
+    statusCode: statusCode,
+    body: JSON.stringify({ error: message }),
+  };
+};

server/lambda/find-url-ip.js

@@ -2,21 +2,32 @@ const dns = require('dns');
 
 /* Lambda function to fetch the IP address of a given URL */
 exports.handler = function (event, context, callback) {
-  const addressParam = event.queryStringParameters.address;
+  const addressParam = event.queryStringParameters.url;
+  
+  if (!addressParam) {
+    callback(null, errorResponse('Address parameter is missing.'));
+    return;
+  }
+
   const address = decodeURIComponent(addressParam)
     .replaceAll('https://', '')
     .replaceAll('http://', '');
+
   dns.lookup(address, (err, ip, family) => {
     if (err) {
-      callback(null, {
+      callback(null, errorResponse(err.message));
-        statusCode: 405,
-        body: JSON.stringify(err),
-      })
     } else {
-      callback(err, {
+      callback(null, {
         statusCode: 200,
         body: JSON.stringify({ ip, family }),
       });
     }
   });
 };
+
+const errorResponse = (message, statusCode = 444) => {
+  return {
+    statusCode: statusCode,
+    body: JSON.stringify({ error: message }),
+  };
+};

server/lambda/follow-redirects.js

@@ -23,9 +23,13 @@ exports.handler = async (event) => {
       }),
     };
   } catch (error) {
-    return {
+    return errorResponse(`Error: ${error.message}`);
-      statusCode: 500,
-      body: `Error: ${error.message}`,
-    };
   }
 };
+
+const errorResponse = (message, statusCode = 444) => {
+  return {
+    statusCode: statusCode,
+    body: JSON.stringify({ error: message }),
+  };
+};

server/lambda/get-carbon.js

@@ -6,7 +6,7 @@ exports.handler = async (event, context) => {
   if (!url) {
     return {
       statusCode: 400,
-      body: JSON.stringify({ message: 'url query parameter is required' }),
+      body: JSON.stringify({ error: 'url query parameter is required' }),
     };
   }
 
@@ -49,7 +49,7 @@ exports.handler = async (event, context) => {
   } catch (error) {
     return {
       statusCode: 500,
-      body: JSON.stringify({ message: `Error: ${error.message}` }),
+      body: JSON.stringify({ error: `Error: ${error.message}` }),
     };
   }
 };

server/lambda/get-cookies.js

@@ -21,7 +21,7 @@ exports.handler = async function(event, context) {
   } catch (error) {
     return {
       statusCode: 500,
-      body: JSON.stringify({ message: error.message }),
+      body: JSON.stringify({ error: error.message }),
     };
   }
 };

server/lambda/get-headers.js

@@ -6,7 +6,7 @@ exports.handler = async function(event, context) {
   if (!url) {
     return {
       statusCode: 400,
-      body: JSON.stringify({ message: 'url query string parameter is required' }),
+      body: JSON.stringify({ error: 'url query string parameter is required' }),
     };
   }
 
@@ -21,7 +21,7 @@ exports.handler = async function(event, context) {
   } catch (error) {
     return {
       statusCode: 500,
-      body: JSON.stringify({ message: error.message }),
+      body: JSON.stringify({ error: error.message }),
     };
   }
 };

server/lambda/get-txt.js

@@ -24,7 +24,7 @@ exports.handler = async (event) => {
     console.error('Error:', error);
     return {
       statusCode: 500,
-      body: JSON.stringify({ message: error.message }),
+      body: JSON.stringify({ error: error.message }),
     };
   }
 };

server/lambda/read-robots-txt.js

@@ -6,11 +6,20 @@ exports.handler = async function(event, context) {
   if (!siteURL) {
     return {
       statusCode: 400,
-      body: 'Missing URL parameter',
+      body: JSON.stringify({ error: 'Missing url query parameter' }),
+    };
+  }
+
+  let parsedURL;
+  try {
+    parsedURL = new URL(siteURL);
+  } catch (error) {
+    return {
+      statusCode: 400,
+      body: JSON.stringify({ error: 'Invalid url query parameter' }),
     };
   }
 
-  const parsedURL = new URL(siteURL);
   const robotsURL = `${parsedURL.protocol}//${parsedURL.hostname}/robots.txt`;
 
   try {
@@ -25,13 +34,13 @@ exports.handler = async function(event, context) {
     } else {
       return {
         statusCode: response.status,
-        body: `Failed to fetch robots.txt`,
+        body: JSON.stringify({ error: 'Failed to fetch robots.txt', statusCode: response.status }),
       };
     }
   } catch (error) {
     return {
       statusCode: 500,
-      body: `Error fetching robots.txt: ${error.toString()}`,
+      body: JSON.stringify({ error: `Error fetching robots.txt: ${error.message}` }),
     };
   }
 };

server/lambda/server-status.js

@@ -7,13 +7,13 @@ exports.handler = async function(event, context) {
   if (!url) {
     return {
       statusCode: 400,
-      body: JSON.stringify({ message: 'You must provide a URL query parameter!' }),
+      body: JSON.stringify({ error: 'You must provide a URL query parameter!' }),
     };
   }
 
   let dnsLookupTime;
   let responseCode;
-  let startTime = performance.now();
+  let startTime;
 
   const obs = new PerformanceObserver((items) => {
     dnsLookupTime = items.getEntries()[0].duration;
@@ -24,28 +24,46 @@ exports.handler = async function(event, context) {
 
   performance.mark('A');
 
-  return new Promise((resolve) => {
+  try {
-    https.get(url, (res) => {
+    startTime = performance.now();
+    const response = await new Promise((resolve, reject) => {
+      const req = https.get(url, res => {
         let data = '';
         responseCode = res.statusCode;
-      res.on('data', (chunk) => {
+        res.on('data', chunk => {
           data += chunk;
         });
         res.on('end', () => {
+          resolve(res);
+        });
+      });
+
+      req.on('error', reject);
+      req.end();
+    });
+
+    if (responseCode < 200 || responseCode >= 400) {
+      return {
+        statusCode: 200,
+        body: JSON.stringify({ error: `Received non-success response code: ${responseCode}` }),
+      };
+    }
+
     performance.mark('B');
     performance.measure('A to B', 'A', 'B');
     let responseTime = performance.now() - startTime;
     obs.disconnect();
-        resolve({
+
+    return {
       statusCode: 200,
       body: JSON.stringify({ isUp: true, dnsLookupTime, responseTime, responseCode }),
-        });
+    };
-      });
+
-    }).on('error', (e) => {
+  } catch (error) {
-      resolve({
+    obs.disconnect();
-        statusCode: 500,
+    return {
-        body: JSON.stringify({ isUp: false, error: e.message }),
+      statusCode: 200,
-      });
+      body: JSON.stringify({ error: `Error during operation: ${error.message}` }),
-    });
+    };
-  });
+  }
 };

server/lambda/site-features.js

@@ -4,7 +4,7 @@ exports.handler = async function (event, context) {
   const { url } = event.queryStringParameters;
   const apiKey = process.env.BUILT_WITH_API_KEY;
 
-  const errorResponse = (message, statusCode = 444) => {
+  const errorResponse = (message, statusCode = 500) => {
     return {
       statusCode: statusCode,
       body: JSON.stringify({ error: message }),
@@ -12,33 +12,45 @@ exports.handler = async function (event, context) {
   };
 
   if (!url) {
-    return errorResponse('url query parameter is required', 400);
+    return errorResponse('URL query parameter is required', 400);
+  }
+
+  if (!apiKey) {
+    return errorResponse('Missing BuiltWith API key in environment variables', 500);
   }
 
   const apiUrl = `https://api.builtwith.com/free1/api.json?KEY=${apiKey}&LOOKUP=${encodeURIComponent(url)}`;
 
-  return new Promise((resolve, reject) => {
+  try {
-    https.get(apiUrl, (res) => {
+    const response = await new Promise((resolve, reject) => {
+      const req = https.get(apiUrl, res => {
         let data = '';
 
-      // A chunk of data has been received.
+        res.on('data', chunk => {
-      res.on('data', (chunk) => {
           data += chunk;
         });
 
-      // The whole response has been received.
         res.on('end', () => {
-        if(res.statusCode !== 200){
+          if (res.statusCode >= 200 && res.statusCode <= 299) {
-          resolve(errorResponse(`Request failed with status code: ${res.statusCode}`));
+            resolve(data);
           } else {
-          resolve({
+            reject(new Error(`Request failed with status code: ${res.statusCode}`));
-            statusCode: 200,
-            body: data,
-          });
           }
         });
-    }).on('error', (err) => {
-      resolve(errorResponse(`Error making request: ${err.message}`, 500));
       });
+
+      req.on('error', error => {
+        reject(error);
       });
+
+      req.end();
+    });
+
+    return {
+      statusCode: 200,
+      body: response,
+    };
+  } catch (error) {
+    return errorResponse(`Error making request: ${error.message}`);
+  }
 };

server/lambda/ssl-check.js

@@ -3,7 +3,7 @@ const https = require('https');
 exports.handler = async function (event, context) {
   const { url } = event.queryStringParameters;
 
-  const errorResponse = (message, statusCode = 444) => {
+  const errorResponse = (message, statusCode = 500) => {
     return {
       statusCode: statusCode,
       body: JSON.stringify({ error: message }),
@@ -11,10 +11,11 @@ exports.handler = async function (event, context) {
   };
 
   if (!url) {
-    return errorResponse('url query parameter is required');
+    return errorResponse('URL query parameter is required', 400);
   }
 
-  return new Promise((resolve, reject) => {
+  try {
+    const response = await new Promise((resolve, reject) => {
       const req = https.request(url, res => {
 
         // Check if the SSL handshake was authorized
@@ -35,10 +36,15 @@ exports.handler = async function (event, context) {
         }
       });
 
-    req.on('error', (error) => {
+      req.on('error', error => {
-      resolve(errorResponse(`Error fetching site certificate: ${error.message}`, 500));
+        resolve(errorResponse(`Error fetching site certificate: ${error.message}`));
       });
 
       req.end();
     });
+
+    return response;
+  } catch (error) {
+    return errorResponse(`Unexpected error occurred: ${error.message}`);
+  }
 };

server/lambda/trace-route.js

@@ -3,19 +3,10 @@ const url = require('url');
 
 exports.handler = async function(event, context) {
   const urlString = event.queryStringParameters.url;
-  const startTime = Date.now();
 
   try {
     if (!urlString) {
-
+      throw new Error('URL parameter is missing!');
-      return {
-        statusCode: 400,
-        body: JSON.stringify({
-
-
-          error: 'URL parameter is missing!'
-        }),
-      };
     }
 
     // Parse the URL and get the hostname
@@ -23,66 +14,42 @@ exports.handler = async function(event, context) {
     const host = urlObject.hostname;
 
     if (!host) {
-
+      throw new Error('Invalid URL provided');
-      return {
-        statusCode: 400,
-        body: JSON.stringify({
-          error: 'Invalid URL provided'
-        }),
-      };
     }
 
     // Traceroute with callback
-    return await new Promise((resolve, reject) => {
+    const result = await new Promise((resolve, reject) => {
       traceroute.trace(host, (err, hops) => {
-        if (err) {
+        if (err || !hops) {
-          reject(err);
+          reject(err || new Error('No hops found'));
-        } else if (hops) {
+        } else {
           resolve(hops);
         }
       });
+
       // Check if remaining time is less than 8.8 seconds, then reject promise
       if (context.getRemainingTimeInMillis() < 8800) {
         reject(new Error('Lambda is about to timeout'));
       }
-    }).then((result) => {
+    });
-      const timeTaken = Date.now() - startTime;
 
     return {
       statusCode: 200,
       body: JSON.stringify({
         message: "Traceroute completed!",
         result,
-          timeTaken
       }),
     };
-    }).catch((err) => {
-      return {
-        statusCode: 500,
-        body: JSON.stringify({
-          error: err.message
-        }),
-      };
-    });
-
-
   } catch (err) {
-    if (err.code === 'ENOENT') {
+    const message = err.code === 'ENOENT'
-
+      ? 'Traceroute command is not installed on the host.'
-      return {
+      : err.message;
-        statusCode: 400,
-        body: JSON.stringify({
-          error: 'Traceroute command is not installed on the host.'
-        }),
-      };
-    } else {
 
     return {
       statusCode: 500,
       body: JSON.stringify({
-          error: err.message
+        error: message,
       }),
     };
   }
-  }
 };