@depup/elastic-apm-node 4.15.0-depup.0

package/lib/cloud-metadata/aws.js

@@ -0,0 +1,175 @@
+/*
+ * Copyright Elasticsearch B.V. and other contributors where applicable.
+ * Licensed under the BSD 2-Clause License; you may not use this file except in
+ * compliance with the BSD 2-Clause License.
+ */
+
+'use strict';
+const URL = require('url').URL;
+const { httpRequest } = require('../http-request');
+const DEFAULT_BASE_URL = new URL('/', 'http://169.254.169.254:80');
+
+function sanitizeHttpHeaderValue(value) {
+  // no newlines, carriage returns, or ascii characters outside of 32 (\x20) - 127 (\x7F)
+  const newValue = value.replace(/[\r\n]/g, '').replace(/[^\x20-\x7F]/g, '');
+  return newValue;
+}
+
+/**
+ * Logic for making request to /latest/dynamic/instance-identity/document
+ *
+ * The headers parameter allow us to, if needed, set the IMDSv2 token
+ */
+function getMetadataAwsWithHeaders(
+  baseUrl,
+  headers,
+  connectTimeoutMs,
+  resTimeoutMs,
+  logger,
+  cb,
+) {
+  const options = {
+    method: 'GET',
+    timeout: resTimeoutMs,
+    connectTimeout: connectTimeoutMs,
+  };
+  if (headers) {
+    options.headers = headers;
+  }
+  const url = baseUrl + 'latest/dynamic/instance-identity/document';
+  const req = httpRequest(url, options, function (res) {
+    const finalData = [];
+    res.on('data', function (data) {
+      finalData.push(data);
+    });
+
+    res.on('end', function (data) {
+      let result;
+      try {
+        result = formatMetadataStringIntoObject(finalData.join(''));
+      } catch (err) {
+        logger.trace(
+          'aws metadata server responded, but there was an ' +
+            'error parsing the result: %o',
+          err,
+        );
+        cb(err);
+        return;
+      }
+      cb(null, result);
+    });
+  });
+
+  req.on('timeout', function () {
+    req.destroy(new Error('request to metadata server timed out'));
+  });
+
+  req.on('connectTimeout', function () {
+    req.destroy(new Error('could not ping metadata server'));
+  });
+
+  req.on('error', function (err) {
+    cb(err);
+  });
+
+  req.end();
+}
+
+/**
+ * Fetches metadata from either an IMDSv2 or IMDSv1 endpoint
+ *
+ * Attempts to fetch a token for an IMDSv2 service call.  If this call
+ * is a success, then we call the instance endpoint with the token.  If
+ * this call fails, then we call the instance endpoint without the token.
+ *
+ * A "success" to the token endpoint means an HTTP status code of 200
+ * and a non-zero-length return value for the token.
+ *
+ * https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-identity-documents.html
+ */
+function getMetadataAws(
+  connectTimeoutMs,
+  resTimeoutMs,
+  logger,
+  baseUrlOverride,
+  cb,
+) {
+  const baseUrl = baseUrlOverride || DEFAULT_BASE_URL;
+  const url = baseUrl + 'latest/api/token';
+  const options = {
+    method: 'PUT',
+    headers: {
+      'X-aws-ec2-metadata-token-ttl-seconds': 300,
+    },
+    timeout: resTimeoutMs,
+    connectTimeout: connectTimeoutMs,
+  };
+  const req = httpRequest(url, options, function (res) {
+    const finalData = [];
+    res.on('data', function (data) {
+      finalData.push(data);
+    });
+
+    res.on('end', function () {
+      const token = sanitizeHttpHeaderValue(finalData.join(''));
+      const headers = {};
+      if (token && res.statusCode === 200) {
+        // uses return value from call to latest/api/token as token,
+        // and takes extra steps to ensure characters are valid
+        headers['X-aws-ec2-metadata-token'] = token;
+      }
+
+      getMetadataAwsWithHeaders(
+        baseUrl,
+        headers,
+        connectTimeoutMs,
+        resTimeoutMs,
+        logger,
+        cb,
+      );
+    });
+  });
+  req.on('timeout', function () {
+    req.destroy(new Error('request for metadata token timed out'));
+  });
+
+  req.on('connectTimeout', function () {
+    req.destroy(
+      new Error('socket connection to metadata token server timed out'),
+    );
+  });
+
+  req.on('error', function (err) {
+    cb(err);
+  });
+
+  req.end();
+}
+
+/**
+ * Builds metadata object
+ *
+ * Takes the response from a /latest/dynamic/instance-identity/document
+ * service request and formats it into the cloud metadata object
+ */
+function formatMetadataStringIntoObject(string) {
+  const data = JSON.parse(string);
+  const metadata = {
+    account: {
+      id: String(data.accountId),
+    },
+    instance: {
+      id: String(data.instanceId),
+    },
+    availability_zone: String(data.availabilityZone),
+    machine: {
+      type: String(data.instanceType),
+    },
+    provider: 'aws',
+    region: String(data.region),
+  };
+
+  return metadata;
+}
+
+module.exports = { getMetadataAws };

package/lib/cloud-metadata/azure.js

@@ -0,0 +1,123 @@
+/*
+ * Copyright Elasticsearch B.V. and other contributors where applicable.
+ * Licensed under the BSD 2-Clause License; you may not use this file except in
+ * compliance with the BSD 2-Clause License.
+ */
+
+'use strict';
+const URL = require('url').URL;
+const { httpRequest } = require('../http-request');
+
+const DEFAULT_BASE_URL = new URL('/', 'http://169.254.169.254:80');
+
+/**
+ * Checks for metadata server then fetches data
+ *
+ * The getMetadataAzure method will fetch cloud metadata information
+ * from Amazon's IMDSv1 endpoint and return (via callback)
+ * the formatted metadata.
+ *
+ * Before fetching data, the server will be "pinged" by attempting
+ * to connect via TCP with a short timeout (`connectTimeoutMs`).
+ *
+ * https://docs.microsoft.com/en-us/azure/virtual-machines/windows/instance-metadata-service?tabs=windows
+ */
+function getMetadataAzure(
+  connectTimeoutMs,
+  resTimeoutMs,
+  logger,
+  baseUrlOverride,
+  cb,
+) {
+  const baseUrl = baseUrlOverride || DEFAULT_BASE_URL;
+  const options = {
+    method: 'GET',
+    timeout: resTimeoutMs,
+    connectTimeout: connectTimeoutMs,
+    headers: {
+      Metadata: 'true',
+    },
+  };
+
+  const url = baseUrl.toString() + 'metadata/instance?api-version=2020-09-01';
+
+  const req = httpRequest(url, options, function (res) {
+    const finalData = [];
+    res.on('data', function (data) {
+      finalData.push(data);
+    });
+
+    res.on('end', function (data) {
+      let result;
+      try {
+        result = formatMetadataStringIntoObject(finalData.join(''));
+      } catch (err) {
+        logger.trace(
+          'azure metadata server responded, but there was an ' +
+            'error parsing the result: %o',
+          err,
+        );
+        cb(err);
+        return;
+      }
+      cb(null, result);
+    });
+  });
+
+  req.on('timeout', function () {
+    req.destroy(new Error('request to azure metadata server timed out'));
+  });
+
+  req.on('connectTimeout', function () {
+    req.destroy(new Error('could not ping azure metadata server'));
+  });
+
+  req.on('error', function (err) {
+    cb(err);
+  });
+
+  req.end();
+}
+
+/**
+ * Builds metadata object
+ *
+ * Takes the response from /metadata/instance?api-version=2020-09-01
+ * service request and formats it into the cloud metadata object
+ */
+function formatMetadataStringIntoObject(string) {
+  const metadata = {
+    account: {
+      id: null,
+    },
+    instance: {
+      id: null,
+      name: null,
+    },
+    project: {
+      name: null,
+    },
+    availability_zone: null,
+    machine: {
+      type: null,
+    },
+    provider: 'azure',
+    region: null,
+  };
+  const parsed = JSON.parse(string);
+  if (!parsed.compute) {
+    return metadata;
+  }
+  const data = parsed.compute;
+  metadata.account.id = String(data.subscriptionId);
+  metadata.instance.id = String(data.vmId);
+  metadata.instance.name = String(data.name);
+  metadata.project.name = String(data.resourceGroupName);
+  metadata.availability_zone = String(data.zone);
+  metadata.machine.type = String(data.vmSize);
+  metadata.region = String(data.location);
+
+  return metadata;
+}
+
+module.exports = { getMetadataAzure };

package/lib/cloud-metadata/callback-coordination.js

@@ -0,0 +1,159 @@
+/*
+ * Copyright Elasticsearch B.V. and other contributors where applicable.
+ * Licensed under the BSD 2-Clause License; you may not use this file except in
+ * compliance with the BSD 2-Clause License.
+ */
+
+'use strict';
+const { EventEmitter } = require('events');
+
+/**
+ * Coordinates fetching of metadata from multiple providers
+ *
+ * Implements event based coordination for fetching metadata
+ * from multiple providers.  The first provider to return
+ * a non-error result "wins".  When this happens the CallbackCoordination
+ * object will emit a `result` event.
+ *
+ * If all the metadata providers fail to return a result, then the
+ * object will emit an error event indicating failure to collect metadata
+ * from any event.
+ *
+ * Since a scheduled callback may (accidently) fail to call its own
+ * callback function, the CallbackCoordination object includes its
+ * own timeout timer to avoid deadlock situation.
+ */
+class CallbackCoordination extends EventEmitter {
+  constructor(maxWaitMS = -1, logger) {
+    super();
+
+    this.logger = logger;
+    // how many results have we seen
+    this.resultCount = 0;
+    this.expectedResults = 0;
+    this.errors = [];
+    this.scheduled = [];
+    this.done = false;
+    this.started = false;
+    this.timeout = null;
+    if (maxWaitMS !== -1) {
+      this.timeout = setTimeout(() => {
+        if (!this.done) {
+          this.complete();
+          this.logger.warn(
+            'cloud metadata requests timed out, using default values instead',
+          );
+          const error = new CallbackCoordinationError(
+            'callback coordination reached timeout',
+            this.errors,
+          );
+          this.emit('error', error);
+        }
+      }, maxWaitMS);
+    }
+  }
+
+  /**
+   * Finishes coordination
+   *
+   * Marks as `done`, cleans up timeout (if necessary)
+   */
+  complete() {
+    this.done = true;
+    if (this.timeout) {
+      clearTimeout(this.timeout);
+    }
+  }
+
+  /**
+   * Accepts and schedules a callback function
+   *
+   * Callback will be in the form
+   *     function(fetcher) {
+   *         //... work to fetch data ...
+   *
+   *         // this callback calls the recordResult method
+   *         // method of the fetcher
+   *         fetcher.recordResult(error, result)
+   *     }
+   *
+   * Method also increments expectedResults counter to keep track
+   * of how many callbacks we've scheduled
+   */
+  schedule(fetcherCallback) {
+    if (this.started) {
+      this.logger.error('Can not schedule callback, already started');
+      return;
+    }
+
+    this.expectedResults++;
+    this.scheduled.push(fetcherCallback);
+  }
+
+  /**
+   * Starts processing of the callbacks scheduled by the `schedule` method
+   */
+  start() {
+    this.started = true;
+    // if called with nothing, send an error through so we don't hang
+    if (this.scheduled.length === 0) {
+      const error = new CallbackCoordinationError('no callbacks to run');
+      this.recordResult(error);
+    }
+
+    for (const cb of this.scheduled) {
+      process.nextTick(cb.bind(null, this));
+    }
+  }
+
+  /**
+   * Receives calls from scheduled callbacks.
+   *
+   * If called with a non-error, the method will emit a `result` event
+   * and include the results as an argument.  Only a single result
+   * is emitted -- if other callbacks respond with a result this method
+   * will ignore them.
+   *
+   * If called by _all_ scheduled callbacks without a non-error, this method
+   * will issue the error event.
+   */
+  recordResult(error, result) {
+    // console.log('.')
+    this.resultCount++;
+    if (error) {
+      this.errors.push(error);
+      if (this.resultCount >= this.expectedResults && !this.done) {
+        this.complete();
+        // we've made every request without success, signal an error
+        const error = new CallbackCoordinationError(
+          'no response from any callback, no cloud metadata will be set (normal outside of cloud env.)',
+          this.errors,
+        );
+        this.logger.debug('no cloud metadata servers responded');
+        this.emit('error', error);
+      }
+    }
+
+    if (!error && result && !this.done) {
+      this.complete();
+      this.emit('result', result);
+    }
+  }
+}
+
+/**
+ * Error for CallbackCoordination class
+ *
+ * Includes the individual errors from each callback
+ * of the CallbackCoordination object
+ */
+class CallbackCoordinationError extends Error {
+  constructor(message, allErrors = []) {
+    super(message);
+    this.allErrors = allErrors;
+  }
+}
+
+module.exports = {
+  CallbackCoordination,
+};

package/lib/cloud-metadata/gcp.js

@@ -0,0 +1,133 @@
+/*
+ * Copyright Elasticsearch B.V. and other contributors where applicable.
+ * Licensed under the BSD 2-Clause License; you may not use this file except in
+ * compliance with the BSD 2-Clause License.
+ */
+
+'use strict';
+
+const URL = require('url').URL;
+const JSONBigInt = require('json-bigint');
+const { httpRequest } = require('../http-request');
+
+const DEFAULT_BASE_URL = new URL('/', 'http://metadata.google.internal:80');
+
+/**
+ * Checks for metadata server then fetches data
+ *
+ * The getMetadataGcp function will fetch cloud metadata information
+ * from Amazon's IMDSv1 endpoint and return (via callback)
+ * the formatted metadata.
+ *
+ * Before fetching data, the server will be "pinged" by attempting
+ * to connect via TCP with a short timeout. (`connectTimeoutMs`)
+ *
+ * https://cloud.google.com/compute/docs/storing-retrieving-metadata
+ */
+function getMetadataGcp(
+  connectTimeoutMs,
+  resTimeoutMs,
+  logger,
+  baseUrlOverride,
+  cb,
+) {
+  const baseUrl = baseUrlOverride || DEFAULT_BASE_URL;
+  const options = {
+    method: 'GET',
+    timeout: resTimeoutMs,
+    connectTimeout: connectTimeoutMs,
+    headers: {
+      'Metadata-Flavor': 'Google',
+    },
+  };
+  const url = baseUrl + 'computeMetadata/v1/?recursive=true';
+  const req = httpRequest(url, options, function (res) {
+    const finalData = [];
+    res.on('data', function (data) {
+      finalData.push(data);
+    });
+
+    res.on('end', function (data) {
+      if (res.statusCode !== 200) {
+        logger.debug('gcp metadata: unexpected statusCode: %s', res.statusCode);
+        cb(
+          new Error(
+            'error fetching gcp metadata: unexpected statusCode: ' +
+              res.statusCode,
+          ),
+        );
+        return;
+      }
+      // Note: We could also guard on the response having the
+      // 'Metadata-Flavor: Google' header as done by:
+      // https://github.com/googleapis/gcp-metadata/blob/v6.0.0/src/index.ts#L109-L112
+
+      let result;
+      try {
+        result = formatMetadataStringIntoObject(finalData.join(''));
+      } catch (err) {
+        logger.debug(
+          'gcp metadata server responded, but there was an ' +
+            'error parsing the result: %o',
+          err,
+        );
+        cb(err);
+        return;
+      }
+      cb(null, result);
+    });
+  });
+
+  req.on('timeout', function () {
+    req.destroy(new Error('request to metadata server timed out'));
+  });
+
+  req.on('connectTimeout', function () {
+    req.destroy(new Error('could not ping metadata server'));
+  });
+
+  req.on('error', function (err) {
+    cb(err);
+  });
+
+  req.end();
+}
+
+/**
+ * Builds metadata object
+ *
+ * Convert a GCP Cloud Engine VM metadata response
+ * (https://cloud.google.com/compute/docs/metadata/default-metadata-values)
+ * to the APM intake cloud metadata object
+ * (https://github.com/elastic/apm/blob/main/specs/agents/metadata.md#gcp-metadata).
+ *
+ * See discussion about big int values here:
+ * https://github.com/googleapis/gcp-metadata#take-care-with-large-number-valued-properties
+ * This implementation is using the same 'json-bigint' library as 'gcp-metadata'.
+ */
+function formatMetadataStringIntoObject(string) {
+  const data = JSONBigInt.parse(string);
+
+  // E.g., 'projects/513326162531/zones/us-west1-b' -> 'us-west1-b'
+  const az = data.instance.zone.split('/').pop();
+
+  const metadata = {
+    provider: 'gcp',
+    instance: {
+      id: data.instance.id.toString(), // We expect this to be a BigInt.
+      name: data.instance.name,
+    },
+    project: {
+      id: data.project.projectId,
+    },
+    availability_zone: az,
+    region: az.slice(0, az.lastIndexOf('-')), // 'us-west1-b' -> 'us-west1'
+    machine: {
+      type: data.instance.machineType.split('/').pop(),
+    },
+  };
+
+  return metadata;
+}
+
+module.exports = { getMetadataGcp };