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

package/lib/metrics/platforms/generic/system-cpu.js

@@ -0,0 +1,51 @@
+/*
+ * 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 os = require('os');
+
+function cpuAverage() {
+  const times = {
+    user: 0,
+    nice: 0,
+    sys: 0,
+    idle: 0,
+    irq: 0,
+    total: 0,
+  };
+
+  const cpus = os.cpus();
+  for (const cpu of cpus) {
+    for (const type of Object.keys(cpu.times)) {
+      times[type] += cpu.times[type];
+      times.total += cpu.times[type];
+    }
+  }
+
+  // Average over CPU count
+  const averages = {};
+  for (const type of Object.keys(times)) {
+    averages[type] = times[type] / cpus.length;
+  }
+
+  return averages;
+}
+
+function cpuPercent(last, next) {
+  const idle = next.idle - last.idle;
+  const total = next.total - last.total;
+  return 1 - idle / total || 0;
+}
+
+let last = cpuAverage();
+
+module.exports = function systemCPUUsage() {
+  const next = cpuAverage();
+  const result = cpuPercent(last, next);
+  last = next;
+  return result;
+};

package/lib/metrics/platforms/linux/index.js

@@ -0,0 +1,19 @@
+/*
+ * 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 Stats = require('./stats');
+
+module.exports = function createSystemMetrics(registry) {
+  const stats = new Stats();
+
+  registry.registerCollector(stats);
+
+  for (const metric of Object.keys(stats.toJSON())) {
+    registry.getOrCreateGauge(metric, () => stats.toJSON()[metric]);
+  }
+};

package/lib/metrics/platforms/linux/stats.js

@@ -0,0 +1,213 @@
+/*
+ * 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 fs = require('fs');
+
+const afterAll = require('after-all-results');
+
+const whitespace = /\s+/;
+
+class Stats {
+  constructor(opts) {
+    opts = opts || {};
+
+    this.files = {
+      processFile: opts.processFile || '/proc/self/stat',
+      memoryFile: opts.memoryFile || '/proc/meminfo',
+      cpuFile: opts.cpuFile || '/proc/stat',
+    };
+
+    this.previous = {
+      cpuTotal: 0,
+      cpuUsage: 0,
+      memTotal: 0,
+      memAvailable: 0,
+      utime: 0,
+      stime: 0,
+      vsize: 0,
+      rss: 0,
+    };
+
+    this.stats = {
+      'system.cpu.total.norm.pct': 0,
+      'system.memory.actual.free': 0,
+      'system.memory.total': 0,
+      'system.process.cpu.total.norm.pct': 0,
+      'system.process.cpu.system.norm.pct': 0,
+      'system.process.cpu.user.norm.pct': 0,
+      'system.process.memory.size': 0,
+      'system.process.memory.rss.bytes': 0,
+    };
+
+    this.inProgress = false;
+    this.timer = null;
+
+    // Do initial load
+    const files = [
+      this.files.processFile,
+      this.files.memoryFile,
+      this.files.cpuFile,
+    ];
+
+    try {
+      const datas = files.map(readFileSync);
+      this.previous = this.readStats(datas);
+      this.update(datas);
+    } catch (err) {}
+  }
+
+  toJSON() {
+    return this.stats;
+  }
+
+  collect(cb) {
+    if (this.inProgress) {
+      if (cb) process.nextTick(cb);
+      return;
+    }
+
+    this.inProgress = true;
+
+    const files = [
+      this.files.processFile,
+      this.files.memoryFile,
+      this.files.cpuFile,
+    ];
+
+    const next = afterAll((err, files) => {
+      if (!err) this.update(files);
+      if (cb) cb();
+    });
+
+    for (const file of files) {
+      fs.readFile(file, next());
+    }
+  }
+
+  readStats([processFile, memoryFile, cpuFile]) {
+    // CPU data
+    //
+    // Example of line we're trying to parse:
+    // cpu  13978 30 2511 9257 2248 0 102 0 0 0
+
+    const cpuLine = firstLineOfBufferAsString(cpuFile);
+    const cpuTimes = cpuLine.split(whitespace);
+
+    let cpuTotal = 0;
+    for (let i = 1; i < cpuTimes.length; i++) {
+      cpuTotal += Number(cpuTimes[i]);
+    }
+
+    // We're off-by-one in relation to the expected index, because we include
+    // the `cpu` label at the beginning of the line
+    const idle = Number(cpuTimes[4]);
+    const iowait = Number(cpuTimes[5]);
+    const cpuUsage = cpuTotal - idle - iowait;
+
+    // Memory data
+    let memAvailable = 0;
+    let memTotal = 0;
+
+    let matches = 0;
+    for (const line of memoryFile.toString().split('\n')) {
+      if (/^MemAvailable:/.test(line)) {
+        memAvailable = parseInt(line.split(whitespace)[1], 10) * 1024;
+        matches++;
+      } else if (/^MemTotal:/.test(line)) {
+        memTotal = parseInt(line.split(whitespace)[1], 10) * 1024;
+        matches++;
+      }
+      if (matches === 2) break;
+    }
+
+    // Process data
+    //
+    // Example of line we're trying to parse:
+    //
+    // 44 (node /app/node_) R 1 44 44 0 -1 4210688 7948 0 0 0 109 21 0 0 20 0 10 0 133652 954462208 12906 18446744073709551615 4194304 32940036 140735797366336 0 0 0 0 4096 16898 0 0 0 17 0 0 0 0 0 0 35037200 35143856 41115648 140735797369050 140735797369131 140735797369131 140735797370852 0
+    //
+    // We can't just split on whitespace as the 2nd field might contain
+    // whitespace. However, the parentheses will always be there, so we can
+    // ignore everything from before the `)` to get rid of the whitespace
+    // problem.
+    //
+    // For details about each field, see:
+    // http://man7.org/linux/man-pages/man5/proc.5.html
+
+    const processLine = firstLineOfBufferAsString(processFile);
+    const processData = processLine
+      .slice(processLine.lastIndexOf(')'))
+      .split(whitespace);
+
+    // all fields are referenced by their index, but are off by one because
+    // we're dropping the first field from the line due to the whitespace
+    // problem described above
+    const utime = parseInt(processData[12], 10); // position in file: 14
+    const stime = parseInt(processData[13], 10); // position in file: 15
+    const vsize = parseInt(processData[21], 10); // position in file: 23
+
+    return {
+      cpuUsage,
+      cpuTotal,
+      memTotal,
+      memAvailable,
+      utime,
+      stime,
+      vsize,
+      rss: process.memoryUsage().rss, // TODO: Calculate using field 24 (rss) * PAGE_SIZE
+    };
+  }
+
+  update(files) {
+    const prev = this.previous;
+    const next = this.readStats(files);
+    const stats = this.stats;
+
+    const cpuTotal = next.cpuTotal - prev.cpuTotal;
+    const cpuUsage = next.cpuUsage - prev.cpuUsage;
+    const utime = next.utime - prev.utime;
+    const stime = next.stime - prev.stime;
+
+    stats['system.cpu.total.norm.pct'] = cpuUsage / cpuTotal || 0;
+    stats['system.memory.actual.free'] = next.memAvailable;
+    stats['system.memory.total'] = next.memTotal;
+
+    // We use Math.min to guard against an edge case where /proc/self/stat
+    // reported more clock ticks than /proc/stat, in which case it looks like
+    // the process spent more CPU time than was used by the system. In that
+    // case we just assume it was a 100% CPU.
+    //
+    // This might happen because we don't read the process file at the same
+    // time as the system file. In between the two reads, the process will
+    // spend some time on the CPU and hence the two reads are not 100% synced
+    // up.
+    const cpuProcessPercent = Math.min((utime + stime) / cpuTotal || 0, 1);
+    const cpuProcessUserPercent = Math.min(utime / cpuTotal || 0, 1);
+    const cpuProcessSystemPercent = Math.min(stime / cpuTotal || 0, 1);
+
+    stats['system.process.cpu.total.norm.pct'] = cpuProcessPercent;
+    stats['system.process.cpu.user.norm.pct'] = cpuProcessUserPercent;
+    stats['system.process.cpu.system.norm.pct'] = cpuProcessSystemPercent;
+    stats['system.process.memory.size'] = next.vsize;
+    stats['system.process.memory.rss.bytes'] = next.rss;
+
+    this.previous = next;
+    this.inProgress = false;
+  }
+}
+
+function firstLineOfBufferAsString(buff) {
+  const newline = buff.indexOf('\n');
+  return buff.toString('utf8', 0, newline === -1 ? buff.length : newline);
+}
+
+function readFileSync(file) {
+  return fs.readFileSync(file);
+}
+
+module.exports = Stats;

package/lib/metrics/queue.js

@@ -0,0 +1,90 @@
+/*
+ * 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';
+class QueueMetricsCollector {
+  constructor() {
+    this.stats = {
+      'queue.latency.min.ms': 0,
+      'queue.latency.max.ms': 0,
+      'queue.latency.avg.ms': 0,
+    };
+
+    this.total = 0;
+    this.count = 0;
+    this.min = 0;
+    this.max = 0;
+  }
+
+  // Updates the data used to generate our stats
+  //
+  // Unlike the Stats and RuntimeCollector, this function
+  // also returns the instantiated collector.
+  //
+  // @param {number} time A javascript ms timestamp
+  updateStats(time) {
+    if (this.min === 0 || this.min > time) {
+      this.min = time;
+    }
+    if (this.max < time) {
+      this.max = time;
+    }
+
+    this.count++;
+    this.total += time;
+  }
+
+  // standard `collect` method for stats collectors
+  //
+  // called by the MetricReporter object prior to its sending data
+  //
+  // @param {function} cb callback function
+  collect(cb) {
+    // update average based on count and total
+    this.stats['queue.latency.avg.ms'] = 0;
+    if (this.count > 0) {
+      this.stats['queue.latency.avg.ms'] = this.total / this.count;
+    }
+
+    this.stats['queue.latency.max.ms'] = this.max;
+    this.stats['queue.latency.min.ms'] = this.min;
+
+    // reset for next run
+    this.total = 0;
+    this.count = 0;
+    this.max = 0;
+    this.min = 0;
+    if (cb) process.nextTick(cb);
+  }
+}
+
+// Creates and Registers a Metric Collector
+//
+// Unlike the Stats and RuntimeCollector, this function
+// also returns the instantiated collector.
+//
+// @param {string} queueOrTopicName
+// @param {MetricRegistry} registry
+// @returns QueueMetricsCollector
+function createQueueMetrics(queueOrTopicName, registry) {
+  const collector = new QueueMetricsCollector();
+  registry.registerCollector(collector);
+  for (const metric of Object.keys(collector.stats)) {
+    registry.getOrCreateGauge(
+      metric,
+      function returnCurrentValue() {
+        return collector.stats[metric];
+      },
+      { queue_name: queueOrTopicName },
+    );
+  }
+  return collector;
+}
+
+module.exports = {
+  createQueueMetrics,
+  QueueMetricsCollector,
+};

package/lib/metrics/registry.js

@@ -0,0 +1,52 @@
+/*
+ * 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 os = require('os');
+
+const { SelfReportingMetricsRegistry } = require('measured-reporting');
+const DimensionAwareMetricsRegistry = require('measured-reporting/lib/registries/DimensionAwareMetricsRegistry');
+
+const MetricsReporter = require('./reporter');
+const createRuntimeMetrics = require('./runtime');
+const createSystemMetrics =
+  process.platform === 'linux'
+    ? require('./platforms/linux')
+    : require('./platforms/generic');
+
+class MetricsRegistry extends SelfReportingMetricsRegistry {
+  constructor(agent, { reporterOptions, registryOptions = {} } = {}) {
+    const defaultReporterOptions = {
+      defaultDimensions: {
+        hostname: agent._conf.hostname || os.hostname(),
+        env: agent._conf.environment || '',
+      },
+    };
+
+    const options = Object.assign({}, defaultReporterOptions, reporterOptions);
+    const reporter = new MetricsReporter(agent, options);
+
+    registryOptions.registry = new DimensionAwareMetricsRegistry({
+      metricLimit: agent._conf.metricsLimit,
+    });
+
+    super(reporter, registryOptions);
+    this._agent = agent;
+
+    this._registry.collectors = [];
+    if (reporter.enabled) {
+      createSystemMetrics(this);
+      createRuntimeMetrics(this);
+    }
+  }
+
+  registerCollector(collector) {
+    this._registry.collectors.push(collector);
+  }
+}
+
+module.exports = MetricsRegistry;

package/lib/metrics/reporter.js

@@ -0,0 +1,119 @@
+/*
+ * 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 afterAll = require('after-all-results');
+const { Reporter } = require('measured-reporting');
+const ObjectIdentityMap = require('object-identity-map');
+
+class MetricsReporter extends Reporter {
+  constructor(agent, options = {}) {
+    super(options);
+    this.enabled = options.enabled;
+    this._agent = agent;
+
+    if (!this.enabled) {
+      this.shutdown();
+    }
+  }
+
+  _reportMetrics(metrics) {
+    if (!this.enabled) return;
+
+    const baseDimensions = {
+      timestamp: Date.now() * 1000,
+      tags: this._getDimensions(metrics),
+    };
+
+    const next = afterAll(() => {
+      const seen = new ObjectIdentityMap();
+
+      for (const metric of metrics) {
+        // Due to limitations in measured-reporting, metrics dropped
+        // due to `metricsLimit` leave empty slots in the list.
+        if (!metric) continue;
+        if (this._agent._isMetricNameDisabled(metric.name)) {
+          continue;
+        }
+
+        if (this.isStaleMetric(metric)) {
+          this.removeMetricFromRegistry(metric, this._registry);
+          continue;
+        }
+
+        const data = seen.ensure(metric.dimensions, () => {
+          const metricData = unflattenBreakdown(metric.dimensions);
+          const merged = Object.assign(
+            { samples: {} },
+            baseDimensions,
+            metricData,
+          );
+          Object.assign(merged.tags, baseDimensions.tags, metricData.tags);
+          return merged;
+        });
+
+        data.samples[metric.name] = {
+          value: metric.metricImpl.toJSON(),
+        };
+
+        if (metric.metricImpl.constructor.name === 'Counter') {
+          metric.metricImpl.reset();
+        }
+      }
+
+      if (this._agent._apmClient) {
+        for (const metric of seen.values()) {
+          this._agent._apmClient.sendMetricSet(metric);
+        }
+      }
+    });
+
+    for (const collector of this._registry.collectors) {
+      collector.collect(next());
+    }
+  }
+
+  isStaleMetric(metric) {
+    // if a metric is a counting metric and that count is
+    // zero, then the metric is considered stale
+    if (metric.metricImpl && metric.metricImpl._count === 0) {
+      return true;
+    }
+    return false;
+  }
+
+  removeMetricFromRegistry(metric) {
+    if (!this._registry || !this._registry._metrics) {
+      return;
+    }
+    const key = this._registry._generateStorageKey(
+      metric.name,
+      metric.dimensions,
+    );
+    return this._registry._metrics.delete(key);
+  }
+}
+
+module.exports = MetricsReporter;
+
+function unflattenBreakdown(source) {
+  const target = {
+    tags: {},
+  };
+
+  for (const [key, value] of Object.entries(source)) {
+    if (key.includes('::')) {
+      const [parent, child] = key.split('::');
+      if (!target[parent]) target[parent] = {};
+      target[parent][child] = value;
+    } else {
+      target.tags[key] = value;
+    }
+  }
+
+  return target;
+}

package/lib/metrics/runtime.js

@@ -0,0 +1,77 @@
+/*
+ * 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 eventLoopMonitor = require('monitor-event-loop-delay');
+
+const activeHandles =
+  typeof process._getActiveHandles === 'function'
+    ? process._getActiveHandles.bind(process)
+    : () => [];
+
+const activeRequests =
+  typeof process._getActiveRequests === 'function'
+    ? process._getActiveRequests.bind(process)
+    : () => [];
+
+const eventLoopMonitorResolution = 10;
+
+class RuntimeCollector {
+  constructor() {
+    this.stats = {
+      'nodejs.handles.active': 0,
+      'nodejs.requests.active': 0,
+      'nodejs.eventloop.delay.avg.ms': 0,
+      'nodejs.memory.heap.allocated.bytes': 0,
+      'nodejs.memory.heap.used.bytes': 0,
+      'nodejs.memory.external.bytes': 0,
+      'nodejs.memory.arrayBuffers.bytes': 0,
+    };
+
+    const monitor = eventLoopMonitor({
+      resolution: eventLoopMonitorResolution,
+    });
+    monitor.enable();
+
+    this.loopMonitor = monitor;
+    this.collect();
+  }
+
+  collect(cb) {
+    // Handles and Requests
+    this.stats['nodejs.handles.active'] = activeHandles().length;
+    this.stats['nodejs.requests.active'] = activeRequests().length;
+
+    // Event loop
+    const loopDelay = Math.max(
+      0,
+      (this.loopMonitor.mean || 0) / 1e6 - eventLoopMonitorResolution,
+    );
+    this.stats['nodejs.eventloop.delay.avg.ms'] = loopDelay;
+    this.loopMonitor.reset();
+
+    // Memory / Heap
+    const memoryUsage = process.memoryUsage();
+    this.stats['nodejs.memory.heap.allocated.bytes'] = memoryUsage.heapTotal;
+    this.stats['nodejs.memory.heap.used.bytes'] = memoryUsage.heapUsed;
+
+    this.stats['nodejs.memory.external.bytes'] = memoryUsage.external;
+    this.stats['nodejs.memory.arrayBuffers.bytes'] =
+      memoryUsage.arrayBuffers || 0; // Only available in NodeJS +13.0
+
+    if (cb) process.nextTick(cb);
+  }
+}
+
+module.exports = function createRuntimeMetrics(registry) {
+  const collector = new RuntimeCollector();
+  registry.registerCollector(collector);
+
+  for (const metric of Object.keys(collector.stats)) {
+    registry.getOrCreateGauge(metric, () => collector.stats[metric]);
+  }
+};

package/lib/middleware/connect.js

@@ -0,0 +1,16 @@
+/*
+ * 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';
+
+module.exports = function connectMiddleware() {
+  var agent = this;
+  return function (err, req, res, next) {
+    agent.captureError(err, { request: req }, function elasticAPMMiddleware() {
+      next(err);
+    });
+  };
+};