apminsight/lib/communication/cloudchecker.js

monitor nodejs applications

var http = require("http");
var utils = require("./../util/utils");
var logger = require("./../util/logger");

var hostName = "169.254.169.254";

function doCloudCheck(cb) {
    var completedReqCount = 0;
    var cbInvoked = false;
    checkForAws(handleResponse);
    checkForAzure(handleResponse);
    checkForGCP(handleResponse);
    checkForAwsFargate(handleResponse);
    function handleResponse(instanceId, cloudName) {
        completedReqCount++;
        if (cloudName) {
            cb(instanceId, cloudName);
            logger.info("Application hosted in " + cloudName);
            cbInvoked = true;
            return;
        }
        if (completedReqCount == 4 && !cbInvoked) {
            cb();
        }
    }
}

function checkForAws(responseHandler) {
    //IMDSv1 check
    var options = {
        host: hostName,
        path: "/latest/meta-data/instance-id"
    };
    sendReq(options, function (instanceId) {
        if (!utils.isEmpty(instanceId) && typeof instanceId === "string") {
            responseHandler(instanceId, "AWS");
            return;
        } else {
            //IMDSv2 check
            var options = {
                host: hostName,
                path: "/latest/api/token",
                method: "PUT",
                headers: {
                    "X-aws-ec2-metadata-token-ttl-seconds": 21600
                }
            };
            sendReq(options, function (token) {
                if (token) {
                    var conOptions = {
                        host: hostName,
                        path: "/latest/meta-data/",
                        headers: {
                            "X-aws-ec2-metadata-token": token
                        }
                    };
                    sendReq(conOptions, function (instanceId) {
                        if (
                            !utils.isEmpty(instanceId) &&
                            typeof instanceId === "string"
                        )
                            responseHandler(instanceId, "AWS");
                    });
                } else {
                    responseHandler();
                    logger.info("Application not hosted in AWS.");
                }
            });
        }
    });
}

function checkForAzure(responseHandler) {
    var options = {
        host: hostName,
        path: "/metadata/v1/InstanceInfo",
        headers: {
            Metadata: true
        }
    };
    sendReq(options, function (responseData) {
        var azureInsId;
        try {
            if (responseData) {
                var responseJson = JSON.parse(responseData);
                azureInsId = responseJson.ID;
            }
        } catch (e) {
            logger.error("azure response parser error");
        }
        if (!utils.isEmpty(azureInsId) && typeof azureInsId === "string") {
            responseHandler(azureInsId, "AZURE");
        } else {
            responseHandler();
            logger.info("Application not hosted in Azure.");
        }
    });
}

function checkForGCP(responseHandler) {
    var options = {
        host: "metadata.google.internal",
        path: "/computeMetadata/v1/instance/id",
        headers: {
            "Metadata-Flavor": "Google"
        }
    };
    sendReq(options, function (responseData, responseCode) {
        if (responseCode == 200) {
            responseHandler("", "GCP");
        } else {
            responseHandler();
            logger.info("Application not hosted in GCP");
        }
    });
}

function checkForAwsFargate(responseHandler) {
    var uriFromEnv = process.env.ECS_CONTAINER_METADATA_URI;
    var options = {
        host: "169.254.170.2",
        path: "/v2/metadata"
    };
    var uri = uriFromEnv ? uriFromEnv : options;
    sendReq(uri, function (responseData, responseCode) {
        if (responseCode == 200) {
            responseHandler("", "AWS");
        } else {
            responseHandler();
            logger.info("Application not hosted in AWS_Fargate");
        }
    });
}

function sendReq(options, responseHandler) {
    var req = http.request(options, function (response) {
        if (response.statusCode < 200 || response.statusCode > 299) {
            responseHandler();
            return;
        }
        response.setEncoding("utf8");
        var rawData = "";
        response.on("data", function (chunk) {
            rawData += chunk;
        });

        response.on("end", function () {
            responseHandler(rawData, response.statusCode);
        });
    });

    req.on("socket", function (socket) {
        socket.setTimeout(500);
        socket.on("timeout", function () {
            req.abort();
        });
    });

    req.on("error", function () {
        responseHandler();
    });

    req.end();
}

module.exports = {
    doCloudCheck: doCloudCheck
};