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

package/lib/load-source-map.js

@@ -0,0 +1,100 @@
+/*
+ * 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';
+
+// This is a copy of load-source-map@2.0.0. It is inlined in elastic-apm-node
+// solely to update its `source-map` dependency to fix
+//   https://github.com/elastic/apm-agent-nodejs/issues/2589
+// If/when there is a new release of load-source-map with
+//   https://github.com/rexxars/load-source-map/pull/6
+// then we could move back to using load-source-map as a dependency.
+
+var fs = require('fs');
+var path = require('path');
+var SourceMapConsumer = require('source-map').SourceMapConsumer;
+
+var INLINE_SOURCEMAP_REGEX = /^data:application\/json[^,]+base64,/;
+var SOURCEMAP_REGEX =
+  /(?:\/\/[@#][ \t]+sourceMappingURL=([^\s'"]+?)[ \t]*$)|(?:\/\*[@#][ \t]+sourceMappingURL=([^*]+?)[ \t]*(?:\*\/)[ \t]*$)/;
+var READ_FILE_OPTS = { encoding: 'utf8' };
+
+module.exports = function readSourceMap(filename, cb) {
+  fs.readFile(filename, READ_FILE_OPTS, function (err, sourceFile) {
+    if (err) {
+      return cb(err);
+    }
+
+    // Look for a sourcemap URL
+    var sourceMapUrl = resolveSourceMapUrl(sourceFile, path.dirname(filename));
+    if (!sourceMapUrl) {
+      return cb();
+    }
+
+    // If it's an inline map, decode it and pass it through the same consumer factory
+    if (isInlineMap(sourceMapUrl)) {
+      return onMapRead(null, decodeInlineMap(sourceMapUrl));
+    }
+
+    // Load actual source map from given path
+    fs.readFile(sourceMapUrl, READ_FILE_OPTS, onMapRead);
+
+    function onMapRead(readErr, sourceMap) {
+      if (readErr) {
+        readErr.message =
+          'Error reading sourcemap for file "' +
+          filename +
+          '":\n' +
+          readErr.message;
+        return cb(readErr);
+      }
+
+      try {
+        new SourceMapConsumer(sourceMap).then(function onConsumerReady(
+          consumer,
+        ) {
+          return cb(null, consumer);
+        }, onConsumerError);
+      } catch (parseErr) {
+        onConsumerError(parseErr);
+      }
+    }
+
+    function onConsumerError(parseErr) {
+      parseErr.message =
+        'Error parsing sourcemap for file "' +
+        filename +
+        '":\n' +
+        parseErr.message;
+      return cb(parseErr);
+    }
+  });
+};
+
+function resolveSourceMapUrl(sourceFile, sourcePath) {
+  var lines = sourceFile.split(/\r?\n/);
+  var sourceMapUrl = null;
+  for (var i = lines.length - 1; i >= 0 && !sourceMapUrl; i--) {
+    sourceMapUrl = lines[i].match(SOURCEMAP_REGEX);
+  }
+
+  if (!sourceMapUrl) {
+    return null;
+  }
+
+  return isInlineMap(sourceMapUrl[1])
+    ? sourceMapUrl[1]
+    : path.resolve(sourcePath, sourceMapUrl[1]);
+}
+
+function isInlineMap(url) {
+  return INLINE_SOURCEMAP_REGEX.test(url);
+}
+
+function decodeInlineMap(data) {
+  var rawData = data.slice(data.indexOf(',') + 1);
+  return Buffer.from(rawData, 'base64').toString();
+}

package/lib/logging.js

@@ -0,0 +1,212 @@
+/*
+ * 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';
+
+/**
+ * @typedef {Object} Logger
+ * @property {function(Record<string, any> | string, ...any): undefined} fatal
+ * @property {function(Record<string, any> | string, ...any): undefined} error
+ * @property {function(Record<string, any> | string, ...any): undefined} warn
+ * @property {function(Record<string, any> | string, ...any): undefined} info
+ * @property {function(Record<string, any> | string, ...any): undefined} debug
+ * @property {function(Record<string, any> | string, ...any): undefined} trace
+ */
+
+// Internal logging for the Elastic APM Node.js Agent.
+//
+// Promised interface:
+// - The amount of logging can be controlled via the `logLevel` config var,
+//   and via the `log_level` central config var.
+// - A custom logger can be provided via the `logging` config var.
+//
+// Nothing else about this package's logging (e.g. structure or the particular
+// message text) is promised/stable.
+//
+// Per https://github.com/elastic/apm/blob/main/specs/agents/logging.md
+// the valid log levels are:
+//  - trace
+//  - debug
+//  - info (default)
+//  - warning
+//  - error
+//  - critical
+//  - off
+//
+// Before this spec, the supported levels were:
+//  - trace
+//  - debug
+//  - info (default)
+//  - warn - both "warn" and "warning" will be supported for backward compat
+//  - error
+//  - fatal - mapped to "critical" for backward compat
+
+const { ecsFormat } = require('@elastic/ecs-pino-format');
+var pino = require('pino');
+var semver = require('semver');
+
+const DEFAULT_LOG_LEVEL = 'info';
+
+// Used to mark loggers created here, for use by `isLoggerCustom()`.
+const LOGGER_IS_OURS_SYM = Symbol('ElasticAPMLoggerIsOurs');
+
+const PINO_LEVEL_FROM_LEVEL_NAME = {
+  trace: 'trace',
+  debug: 'debug',
+  info: 'info',
+  warning: 'warn',
+  warn: 'warn', // Supported for backwards compat
+  error: 'error',
+  critical: 'fatal',
+  fatal: 'fatal', // Supported for backwards compat
+  off: 'silent',
+};
+
+// SafePinoDestWrapper provides a pino destination that will pass logging calls
+// to a given `customLogger`. The custom logger must have the following API:
+//
+// - `.trace(string)`
+// - `.debug(string)`
+// - `.info(string)`
+// - `.warn(string)`
+// - `.error(string)`
+// - `.fatal(string)`
+//
+// The limitation of this wrapping is that structured data fields are *not*
+// passed on to the custom logger. I.e. this is a fallback mechanism.
+class SafePinoDestWrapper {
+  constructor(customLogger) {
+    this.customLogger = customLogger;
+    this.logFnNameFromLastLevel = pino.levels.labels;
+    this[Symbol.for('pino.metadata')] = true;
+  }
+
+  write(s) {
+    const { lastMsg, lastLevel } = this;
+    const logFnName = this.logFnNameFromLastLevel[lastLevel];
+    this.customLogger[logFnName](lastMsg);
+  }
+}
+
+/**
+ * Creates a pino logger for the agent.
+ *
+ * By default `createLogger()` will return a pino logger that logs to stdout
+ * in ecs-logging format, set to the "info" level.
+ *
+ * @param {String} levelName - Optional, default "info". It is meant to be one
+ *    of the log levels specified in the top of file comment. For backward
+ *    compatibility it falls back to "trace".
+ * @param {Object} customLogger - Optional. A custom logger object to which
+ *    log messages will be passed. It must provide
+ *    trace/debug/info/warn/error/fatal methods that take a string argument.
+ *
+ *    Internally the agent uses structured logging using the pino API
+ *    (https://getpino.io/#/docs/api?id=logger). However, with a custom logger,
+ *    log record fields other than the *message* are dropped, to avoid issues
+ *    with incompatible logger APIs.
+ *
+ *    As a special case, if the provided logger is a *pino logger instance*,
+ *    then it will be used directly.
+ *
+ * @param {string} [levelName=info] log level we want for the created logger
+ * @param {Logger} [customLogger] custom logger object provided by the user
+ * @returns {Logger}
+ */
+function createLogger(levelName, customLogger) {
+  let dest;
+  const serializers = {
+    err: pino.stdSerializers.err,
+    req: pino.stdSerializers.req,
+    res: pino.stdSerializers.res,
+  };
+
+  if (!levelName) {
+    levelName = DEFAULT_LOG_LEVEL;
+  }
+  let pinoLevel = PINO_LEVEL_FROM_LEVEL_NAME[levelName];
+  if (!pinoLevel) {
+    // For backwards compat, support an earlier bug where an unknown log level
+    // was accepted.
+    // TODO: Consider being more strict on this for v4.0.0.
+    pinoLevel = 'trace';
+  }
+
+  if (customLogger) {
+    // Is this a pino logger? If so, it supports the API the agent requires and
+    // can be used directly. We must add our custom serializers.
+    if (Symbol.for('pino.serializers') in customLogger) {
+      // Pino added `options` second arg to `logger.child` in 6.12.0.
+      if (semver.gte(customLogger.version, '6.12.0')) {
+        return customLogger.child({}, { serializers });
+      }
+
+      return customLogger.child({
+        serializers,
+      });
+    }
+
+    // Otherwise, we fallback to wrapping the provided logger such that the
+    // agent can use the pino logger API without breaking. The limitation is
+    // that only the log *message* is logged. Extra structured fields are
+    // dropped.
+    dest = new SafePinoDestWrapper(customLogger);
+    // Our wrapping logger level should be 'trace', to pass through all
+    // messages to the wrapped logger.
+    pinoLevel = 'trace';
+  } else {
+    // Log to stdout, the same default as pino itself.
+    dest = pino.destination(1);
+  }
+
+  const logger = pino(
+    {
+      name: 'elastic-apm-node',
+      base: {}, // Don't want pid and hostname fields.
+      level: pinoLevel,
+      serializers,
+      ...ecsFormat({ apmIntegration: false }),
+    },
+    dest,
+  );
+
+  if (!customLogger) {
+    logger[LOGGER_IS_OURS_SYM] = true; // used for isLoggerCustom()
+  }
+  return logger;
+}
+
+/**
+ * Returns true if the logger is not ours
+ *
+ * @param {Logger} logger
+ * @returns {boolean}
+ */
+function isLoggerCustom(logger) {
+  return !logger[LOGGER_IS_OURS_SYM];
+}
+
+/**
+ * Adjust the level on the given logger.
+ *
+ * @param {Logger} logger
+ * @param {string} levelName
+ */
+function setLogLevel(logger, levelName) {
+  const pinoLevel = PINO_LEVEL_FROM_LEVEL_NAME[levelName];
+  if (!pinoLevel) {
+    logger.warn('unknown log levelName "%s": cannot setLogLevel', levelName);
+  } else {
+    logger.level = pinoLevel;
+  }
+}
+
+module.exports = {
+  DEFAULT_LOG_LEVEL,
+  createLogger,
+  isLoggerCustom,
+  setLogLevel,
+};

package/lib/metrics/index.js

@@ -0,0 +1,92 @@
+/*
+ * 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 assert = require('assert');
+
+const MetricsRegistry = require('./registry');
+const { createQueueMetrics } = require('./queue');
+
+const registrySymbol = Symbol('metrics-registry');
+const agentSymbol = Symbol('metrics-agent');
+
+class NoopLogger {
+  debug() {}
+  error() {}
+  fatal() {}
+  info() {}
+  trace() {}
+  warn() {}
+}
+
+class Metrics {
+  constructor(agent) {
+    this[agentSymbol] = agent;
+    this[registrySymbol] = null;
+  }
+
+  start(refTimers) {
+    const metricsInterval = this[agentSymbol]._conf.metricsInterval;
+    assert(
+      metricsInterval > 0,
+      'Metrics.start() should not be called if metricsInterval <= 0',
+    );
+    this[registrySymbol] = new MetricsRegistry(this[agentSymbol], {
+      reporterOptions: {
+        defaultReportingIntervalInSeconds: metricsInterval,
+        enabled: true,
+        unrefTimers: !refTimers,
+        logger: new NoopLogger(),
+      },
+    });
+  }
+
+  stop() {
+    if (this[registrySymbol]) {
+      this[registrySymbol].shutdown();
+      this[registrySymbol] = null;
+    }
+  }
+
+  getOrCreateCounter(...args) {
+    if (!this[registrySymbol]) {
+      return;
+    }
+    return this[registrySymbol].getOrCreateCounter(...args);
+  }
+
+  incrementCounter(name, dimensions, amount = 1) {
+    if (!this[registrySymbol]) {
+      return;
+    }
+
+    this.getOrCreateCounter(name, dimensions).inc(amount);
+  }
+
+  getOrCreateGauge(...args) {
+    if (!this[registrySymbol]) {
+      return;
+    }
+    return this[registrySymbol].getOrCreateGauge(...args);
+  }
+
+  // factory function for creating a queue metrics collector
+  //
+  // called from instrumentation, only when the agent receives a queue message
+  createQueueMetricsCollector(queueOrTopicName) {
+    if (!this[registrySymbol]) {
+      return;
+    }
+    const collector = createQueueMetrics(
+      queueOrTopicName,
+      this[registrySymbol],
+    );
+    return collector;
+  }
+}
+
+module.exports = Metrics;

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

@@ -0,0 +1,40 @@
+/*
+ * 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 Stats = require('./stats');
+
+module.exports = function createSystemMetrics(registry) {
+  // Base system metrics
+  registry.getOrCreateGauge(
+    'system.cpu.total.norm.pct',
+    require('./system-cpu'),
+  );
+  registry.getOrCreateGauge('system.memory.total', () => os.totalmem());
+  registry.getOrCreateGauge('system.memory.actual.free', () => os.freemem());
+
+  // Process metrics
+  const stats = new Stats();
+  registry.registerCollector(stats);
+
+  const metrics = [
+    'system.process.cpu.total.norm.pct',
+    'system.process.cpu.system.norm.pct',
+    'system.process.cpu.user.norm.pct',
+  ];
+
+  for (const metric of metrics) {
+    registry.getOrCreateGauge(metric, () => stats.toJSON()[metric]);
+  }
+
+  registry.getOrCreateGauge(
+    'system.process.memory.rss.bytes',
+    () => process.memoryUsage().rss,
+  );
+};

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

@@ -0,0 +1,22 @@
+/*
+ * 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 processTop = require('./process-top')();
+
+const cpus = os.cpus();
+
+module.exports = function processCPUUsage() {
+  const cpu = processTop.cpu();
+  return {
+    total: cpu.percent / cpus.length,
+    user: cpu.user / cpu.time / cpus.length,
+    system: cpu.system / cpu.time / cpus.length,
+  };
+};

package/lib/metrics/platforms/generic/process-top.js

@@ -0,0 +1,157 @@
+/*
+ * 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';
+
+/**
+ * This file is extracted from the 'process-top' project copyright by
+ * Mathias Buus. It has been modified slightly to be used in the current
+ * context and where possible changes have been contributed back to the
+ * original project.
+ *
+ * https://github.com/mafintosh/process-top
+ *
+ * Original file:
+ *
+ * https://github.com/mafintosh/process-top/blob/master/index.js
+ *
+ * License:
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2018 Mathias Buus
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ */
+
+// const os = require('os')
+// const p = require('prettier-bytes')
+// const eld = require('event-loop-delay')
+
+module.exports = top;
+
+// function top (opts) {
+function top() {
+  // NOTE: Replacing line above
+  // if (!opts) opts = {}
+
+  // const tick = opts.interval || 1000
+  // const started = Date.now()
+  // const interval = setInterval(perSecond, tick)
+  // const win = [{ time: process.hrtime(), cpu: process.cpuUsage(), delay: 0 }, null, null, null]
+  const win = [
+    { time: process.hrtime(), cpu: process.cpuUsage() },
+    null,
+    null,
+    null,
+  ]; // NOTE: Replacing line above
+  // const loopSampler = eld()
+
+  let sec = 1;
+
+  // interval.unref()
+
+  return {
+    // pid: process.pid,
+    // command: process.argv.join(' '),
+    // started,
+    // time () {
+    //   return Date.now() - started
+    // },
+    // delay () {
+    //   const btm = oldest()
+    //   const timeDelta = process.hrtime(win[btm].time)
+    //   const ms = timeDelta[0] * 1e3 + Math.floor(timeDelta[1] / 1e6)
+    //   return Math.floor((loopSampler.delay - win[btm].delay) / (ms / tick))
+    // },
+    cpu() {
+      const btm = oldest();
+      const cpuDelta = process.cpuUsage(win[btm].cpu);
+      const timeDelta = process.hrtime(win[btm].time);
+      const us = timeDelta[0] * 1e6 + timeDelta[1] / 1e3;
+      perSecond(); // NOTE: Added to skip timer and update at each check
+      return {
+        time: us,
+        percent: (cpuDelta.system + cpuDelta.user) / us,
+        system: cpuDelta.system,
+        user: cpuDelta.user,
+      };
+    },
+    // memory () {
+    //   const mem = process.memoryUsage()
+    //   const total = os.totalmem()
+    //   return {
+    //     percent: mem.rss / total,
+    //     rss: mem.rss,
+    //     total,
+    //     heapPercent: mem.heapUsed / mem.heapTotal,
+    //     heapUsed: mem.heapUsed,
+    //     heapTotal: mem.heapTotal,
+    //     external: mem.external
+    //   }
+    // },
+    // loadavg () {
+    //   return os.loadavg()
+    // },
+    // destroy () {
+    //   clearInterval(interval)
+    // },
+    // toString () {
+    //   const mem = this.memory()
+    //   return `cpu: ${pct(this.cpu().percent)} | rss: ${p(mem.rss)} (${pct(mem.percent)}) | heap: ${p(mem.heapUsed)} / ${p(mem.heapTotal)} (${pct(mem.heapPercent)}) | ext: ${p(mem.external)} | delay: ${this.delay()} ms | ${time(this.time())} | loadavg: ${os.loadavg().map(fixed2).join(', ')}`
+    // }
+  };
+
+  function oldest() {
+    let btm = (sec - 4) & 3;
+    while (!win[btm]) btm = (btm + 1) & 3;
+    return btm;
+  }
+
+  function perSecond() {
+    const ptr = sec++ & 3;
+    // win[ptr] = { time: process.hrtime(), cpu: process.cpuUsage(), delay: loopSampler.delay }
+    win[ptr] = { time: process.hrtime(), cpu: process.cpuUsage() }; // NOTE: Replacing line above
+  }
+}
+
+// function pct (n) {
+//   return (100 * n).toFixed(1) + '%'
+// }
+
+// function fixed2 (n) {
+//   return n.toFixed(2)
+// }
+
+// function time (n) {
+//   let secs = Math.floor(n / 1000)
+//   let hours = Math.floor(secs / 3600)
+//   secs -= hours * 3600
+//   let mins = Math.floor(secs / 60)
+//   secs -= mins * 60
+//   return pad(hours) + ':' + pad(mins) + ':' + pad(secs)
+// }
+
+// function pad (n) {
+//   return n < 10 ? '0' + n : '' + n
+// }

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

@@ -0,0 +1,34 @@
+/*
+ * 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 processCpu = require('./process-cpu');
+
+class Stats {
+  constructor() {
+    this.stats = {
+      'system.process.cpu.total.norm.pct': 0,
+      'system.process.cpu.system.norm.pct': 0,
+      'system.process.cpu.user.norm.pct': 0,
+    };
+  }
+
+  toJSON() {
+    return this.stats;
+  }
+
+  collect(cb) {
+    const cpu = processCpu();
+    this.stats['system.process.cpu.total.norm.pct'] = cpu.total;
+    this.stats['system.process.cpu.system.norm.pct'] = cpu.system;
+    this.stats['system.process.cpu.user.norm.pct'] = cpu.user;
+
+    if (cb) process.nextTick(cb);
+  }
+}
+
+module.exports = Stats;