libp2p 0.36.2 → 0.37.0

package/src/metrics/index.js

@@ -1,290 +0,0 @@
-// @ts-nocheck
-'use strict'
-
-const mergeOptions = require('merge-options')
-const { pipe } = require('it-pipe')
-const { tap } = require('streaming-iterables')
-const oldPeerLRU = require('./old-peers')
-const { METRICS: defaultOptions } = require('../constants')
-const Stats = require('./stats')
-
-const initialCounters = [
-  'dataReceived',
-  'dataSent'
-]
-
-const directionToEvent = {
-  in: 'dataReceived',
-  out: 'dataSent'
-}
-
-/**
- * @typedef {import('peer-id')} PeerId
- * @typedef {import('libp2p-interfaces/src/transport/types').MultiaddrConnection} MultiaddrConnection
- */
-
-/**
- * @typedef MetricsOptions
- * @property {number} [computeThrottleMaxQueueSize = defaultOptions.computeThrottleMaxQueueSize]
- * @property {number} [computeThrottleTimeout = defaultOptions.computeThrottleTimeout]
- * @property {number[]} [movingAverageIntervals = defaultOptions.movingAverageIntervals]
- * @property {number} [maxOldPeersRetention = defaultOptions.maxOldPeersRetention]
- */
-
-class Metrics {
-  /**
-   * @class
-   * @param {MetricsOptions} options
-   */
-  constructor (options) {
-    this._options = mergeOptions(defaultOptions, options)
-    this._globalStats = new Stats(initialCounters, this._options)
-    this._peerStats = new Map()
-    this._protocolStats = new Map()
-    this._oldPeers = oldPeerLRU(this._options.maxOldPeersRetention)
-    this._running = false
-    this._onMessage = this._onMessage.bind(this)
-    this._systems = new Map()
-  }
-
-  /**
-   * Must be called for stats to saved. Any data pushed for tracking
-   * will be ignored.
-   */
-  start () {
-    this._running = true
-  }
-
-  /**
-   * Stops all averages timers and prevents new data from being tracked.
-   * Once `stop` is called, `start` must be called to resume stats tracking.
-   */
-  stop () {
-    this._running = false
-    this._globalStats.stop()
-    for (const stats of this._peerStats.values()) {
-      stats.stop()
-    }
-    for (const stats of this._protocolStats.values()) {
-      stats.stop()
-    }
-  }
-
-  /**
-   * Gets the global `Stats` object
-   *
-   * @returns {Stats}
-   */
-  get global () {
-    return this._globalStats
-  }
-
-  /**
-   * Returns a list of `PeerId` strings currently being tracked
-   *
-   * @returns {string[]}
-   */
-  get peers () {
-    return Array.from(this._peerStats.keys())
-  }
-
-  /**
-   * @returns {Map<string, Map<string, Map<string, any>>>}
-   */
-  getComponentMetrics () {
-    return this._systems
-  }
-
-  updateComponentMetric ({ system = 'libp2p', component, metric, value }) {
-    if (!this._systems.has(system)) {
-      this._systems.set(system, new Map())
-    }
-
-    const systemMetrics = this._systems.get(system)
-
-    if (!systemMetrics.has(component)) {
-      systemMetrics.set(component, new Map())
-    }
-
-    const componentMetrics = systemMetrics.get(component)
-
-    componentMetrics.set(metric, value)
-  }
-
-  /**
-   * Returns the `Stats` object for the given `PeerId` whether it
-   * is a live peer, or in the disconnected peer LRU cache.
-   *
-   * @param {PeerId} peerId
-   * @returns {Stats}
-   */
-  forPeer (peerId) {
-    const idString = peerId.toB58String()
-    return this._peerStats.get(idString) || this._oldPeers.get(idString)
-  }
-
-  /**
-   * Returns a list of all protocol strings currently being tracked.
-   *
-   * @returns {string[]}
-   */
-  get protocols () {
-    return Array.from(this._protocolStats.keys())
-  }
-
-  /**
-   * Returns the `Stats` object for the given `protocol`.
-   *
-   * @param {string} protocol
-   * @returns {Stats}
-   */
-  forProtocol (protocol) {
-    return this._protocolStats.get(protocol)
-  }
-
-  /**
-   * Should be called when all connections to a given peer
-   * have closed. The `Stats` collection for the peer will
-   * be stopped and moved to an LRU for temporary retention.
-   *
-   * @param {PeerId} peerId
-   */
-  onPeerDisconnected (peerId) {
-    const idString = peerId.toB58String()
-    const peerStats = this._peerStats.get(idString)
-    if (peerStats) {
-      peerStats.stop()
-      this._peerStats.delete(idString)
-      this._oldPeers.set(idString, peerStats)
-    }
-  }
-
-  /**
-   * Takes the metadata for a message and tracks it in the
-   * appropriate categories. If the protocol is present, protocol
-   * stats will also be tracked.
-   *
-   * @private
-   * @param {object} params
-   * @param {PeerId} params.remotePeer - Remote peer
-   * @param {string} [params.protocol] - Protocol string the stream is running
-   * @param {string} params.direction - One of ['in','out']
-   * @param {number} params.dataLength - Size of the message
-   * @returns {void}
-   */
-  _onMessage ({ remotePeer, protocol, direction, dataLength }) {
-    if (!this._running) return
-
-    const key = directionToEvent[direction]
-
-    let peerStats = this.forPeer(remotePeer)
-    if (!peerStats) {
-      peerStats = new Stats(initialCounters, this._options)
-      this._peerStats.set(remotePeer.toB58String(), peerStats)
-    }
-
-    // Peer and global stats
-    peerStats.push(key, dataLength)
-    this._globalStats.push(key, dataLength)
-
-    // Protocol specific stats
-    if (protocol) {
-      let protocolStats = this.forProtocol(protocol)
-      if (!protocolStats) {
-        protocolStats = new Stats(initialCounters, this._options)
-        this._protocolStats.set(protocol, protocolStats)
-      }
-      protocolStats.push(key, dataLength)
-    }
-  }
-
-  /**
-   * Replaces the `PeerId` string with the given `peerId`.
-   * If stats are already being tracked for the given `peerId`, the
-   * placeholder stats will be merged with the existing stats.
-   *
-   * @param {PeerId} placeholder - A peerId string
-   * @param {PeerId} peerId
-   * @returns {void}
-   */
-  updatePlaceholder (placeholder, peerId) {
-    if (!this._running) return
-    const placeholderStats = this.forPeer(placeholder)
-    const peerIdString = peerId.toB58String()
-    const existingStats = this.forPeer(peerId)
-    let mergedStats = placeholderStats
-
-    // If we already have stats, merge the two
-    if (existingStats) {
-      // If existing, merge
-      mergedStats = Metrics.mergeStats(existingStats, mergedStats)
-      // Attempt to delete from the old peers list just in case it was tracked there
-      this._oldPeers.delete(peerIdString)
-    }
-
-    this._peerStats.delete(placeholder.toB58String())
-    this._peerStats.set(peerIdString, mergedStats)
-    mergedStats.start()
-  }
-
-  /**
-   * Tracks data running through a given Duplex Iterable `stream`. If
-   * the `peerId` is not provided, a placeholder string will be created and
-   * returned. This allows lazy tracking of a peer when the peer is not yet known.
-   * When the `PeerId` is known, `Metrics.updatePlaceholder` should be called
-   * with the placeholder string returned from here, and the known `PeerId`.
-   *
-   * @param {Object} options
-   * @param {MultiaddrConnection} options.stream - A duplex iterable stream
-   * @param {PeerId} [options.remotePeer] - The id of the remote peer that's connected
-   * @param {string} [options.protocol] - The protocol the stream is running
-   * @returns {MultiaddrConnection} The peerId string or placeholder string
-   */
-  trackStream ({ stream, remotePeer, protocol }) {
-    const metrics = this
-    const _source = stream.source
-    stream.source = tap(chunk => metrics._onMessage({
-      remotePeer,
-      protocol,
-      direction: 'in',
-      dataLength: chunk.length
-    }))(_source)
-
-    const _sink = stream.sink
-    stream.sink = source => {
-      return pipe(
-        source,
-        tap(chunk => metrics._onMessage({
-          remotePeer,
-          protocol,
-          direction: 'out',
-          dataLength: chunk.length
-        })),
-        _sink
-      )
-    }
-
-    return stream
-  }
-
-  /**
-   * Merges `other` into `target`. `target` will be modified
-   * and returned.
-   *
-   * @param {Stats} target
-   * @param {Stats} other
-   * @returns {Stats}
-   */
-  static mergeStats (target, other) {
-    target.stop()
-    other.stop()
-
-    // Merge queues
-    target._queue = [...target._queue, ...other._queue]
-
-    // TODO: how to merge moving averages?
-    return target
-  }
-}
-
-module.exports = Metrics

package/src/metrics/old-peers.js

@@ -1,16 +0,0 @@
-'use strict'
-
-const LRU = require('hashlru')
-
-/**
- * Creates and returns a Least Recently Used Cache
- *
- * @param {number} maxSize
- * @returns {any}
- */
-module.exports = (maxSize) => {
-  // @ts-ignore LRU expression is not callable
-  const patched = LRU(maxSize)
-  patched.delete = patched.remove
-  return patched
-}

package/src/metrics/stats.js

@@ -1,270 +0,0 @@
-// @ts-nocheck
-'use strict'
-
-const { EventEmitter } = require('events')
-const { BigNumber: Big } = require('bignumber.js')
-const MovingAverage = require('@vascosantos/moving-average')
-const retimer = require('retimer')
-
-/**
- * @typedef {import('@vascosantos/moving-average').IMovingAverage} IMovingAverage
- * @typedef {import('bignumber.js').BigNumber} Big
- */
-
-class Stats extends EventEmitter {
-  /**
-   * A queue based manager for stat processing
-   *
-   * @class
-   * @param {string[]} initialCounters
-   * @param {any} options
-   */
-  constructor (initialCounters, options) {
-    super()
-
-    this._options = options
-    this._queue = []
-
-    /** @type {{ dataReceived: Big, dataSent: Big }} */
-    this._stats = {
-      dataReceived: Big(0),
-      dataSent: Big(0)
-    }
-
-    this._frequencyLastTime = Date.now()
-    this._frequencyAccumulators = {}
-
-    /** @type {{ dataReceived: IMovingAverage[], dataSent: IMovingAverage[] }} */
-    this._movingAverages = {}
-
-    this._update = this._update.bind(this)
-
-    const intervals = this._options.movingAverageIntervals
-
-    for (let i = 0; i < initialCounters.length; i++) {
-      const key = initialCounters[i]
-      this._stats[key] = Big(0)
-      this._movingAverages[key] = {}
-      for (let k = 0; k < intervals.length; k++) {
-        const interval = intervals[k]
-        const ma = this._movingAverages[key][interval] = MovingAverage(interval)
-        ma.push(this._frequencyLastTime, 0)
-      }
-    }
-  }
-
-  /**
-   * Initializes the internal timer if there are items in the queue. This
-   * should only need to be called if `Stats.stop` was previously called, as
-   * `Stats.push` will also start the processing.
-   *
-   * @returns {void}
-   */
-  start () {
-    if (this._queue.length) {
-      this._resetComputeTimeout()
-    }
-  }
-
-  /**
-   * Stops processing and computing of stats by clearing the internal
-   * timer.
-   *
-   * @returns {void}
-   */
-  stop () {
-    if (this._timeout) {
-      this._timeout.clear()
-      this._timeout = null
-    }
-  }
-
-  /**
-   * Returns a clone of the current stats.
-   */
-  get snapshot () {
-    return Object.assign({}, this._stats)
-  }
-
-  /**
-   * Returns a clone of the internal movingAverages
-   */
-  get movingAverages () {
-    return Object.assign({}, this._movingAverages)
-  }
-
-  /**
-   * Returns a plain JSON object of the stats
-   *
-   * @returns {*}
-   */
-  toJSON () {
-    const snapshot = this.snapshot
-    const movingAverages = this.movingAverages
-    const data = {
-      dataReceived: snapshot.dataReceived.toString(),
-      dataSent: snapshot.dataSent.toString(),
-      movingAverages: {}
-    }
-
-    const counters = Object.keys(movingAverages)
-    for (const key of counters) {
-      data.movingAverages[key] = {}
-      for (const interval of Object.keys(movingAverages[key])) {
-        data.movingAverages[key][interval] = movingAverages[key][interval].movingAverage()
-      }
-    }
-
-    return data
-  }
-
-  /**
-   * Pushes the given operation data to the queue, along with the
-   * current Timestamp, then resets the update timer.
-   *
-   * @param {string} counter
-   * @param {number} inc
-   * @returns {void}
-   */
-  push (counter, inc) {
-    this._queue.push([counter, inc, Date.now()])
-    this._resetComputeTimeout()
-  }
-
-  /**
-   * Resets the timeout for triggering updates.
-   *
-   * @private
-   * @returns {void}
-   */
-  _resetComputeTimeout () {
-    this._timeout = retimer(this._update, this._nextTimeout())
-  }
-
-  /**
-   * Calculates and returns the timeout for the next update based on
-   * the urgency of the update.
-   *
-   * @private
-   * @returns {number}
-   */
-  _nextTimeout () {
-    // calculate the need for an update, depending on the queue length
-    const urgency = this._queue.length / this._options.computeThrottleMaxQueueSize
-    const timeout = Math.max(this._options.computeThrottleTimeout * (1 - urgency), 0)
-    return timeout
-  }
-
-  /**
-   * If there are items in the queue, they will will be processed and
-   * the frequency for all items will be updated based on the Timestamp
-   * of the last item in the queue. The `update` event will also be emitted
-   * with the latest stats.
-   *
-   * If there are no items in the queue, no action is taken.
-   *
-   * @private
-   * @returns {void}
-   */
-  _update () {
-    this._timeout = null
-    if (this._queue.length) {
-      let last
-      for (last of this._queue) {
-        this._applyOp(last)
-      }
-      this._queue = []
-
-      this._updateFrequency(last[2]) // contains timestamp of last op
-
-      this.emit('update', this._stats)
-    }
-  }
-
-  /**
-   * For each key in the stats, the frequency and moving averages
-   * will be updated via Stats._updateFrequencyFor based on the time
-   * difference between calls to this method.
-   *
-   * @private
-   * @param {Timestamp} latestTime
-   * @returns {void}
-   */
-  _updateFrequency (latestTime) {
-    const timeDiff = latestTime - this._frequencyLastTime
-
-    Object.keys(this._stats).forEach((key) => {
-      this._updateFrequencyFor(key, timeDiff, latestTime)
-    })
-
-    this._frequencyLastTime = latestTime
-  }
-
-  /**
-   * Updates the `movingAverages` for the given `key` and also
-   * resets the `frequencyAccumulator` for the `key`.
-   *
-   * @private
-   * @param {string} key
-   * @param {number} timeDiffMS - Time in milliseconds
-   * @param {Timestamp} latestTime - Time in ticks
-   * @returns {void}
-   */
-  _updateFrequencyFor (key, timeDiffMS, latestTime) {
-    const count = this._frequencyAccumulators[key] || 0
-    this._frequencyAccumulators[key] = 0
-    // if `timeDiff` is zero, `hz` becomes Infinity, so we fallback to 1ms
-    const safeTimeDiff = timeDiffMS || 1
-    const hz = (count / safeTimeDiff) * 1000
-
-    let movingAverages = this._movingAverages[key]
-    if (!movingAverages) {
-      movingAverages = this._movingAverages[key] = {}
-    }
-
-    const intervals = this._options.movingAverageIntervals
-
-    for (let i = 0; i < intervals.length; i++) {
-      const movingAverageInterval = intervals[i]
-      let movingAverage = movingAverages[movingAverageInterval]
-      if (!movingAverage) {
-        movingAverage = movingAverages[movingAverageInterval] = MovingAverage(movingAverageInterval)
-      }
-      movingAverage.push(latestTime, hz)
-    }
-  }
-
-  /**
-   * For the given operation, `op`, the stats and `frequencyAccumulator`
-   * will be updated or initialized if they don't already exist.
-   *
-   * @private
-   * @param {{string, number}[]} op
-   * @throws {InvalidNumber}
-   * @returns {void}
-   */
-  _applyOp (op) {
-    const key = op[0]
-    const inc = op[1]
-
-    if (typeof inc !== 'number') {
-      throw new Error(`invalid increment number: ${inc}`)
-    }
-
-    let n
-
-    if (!Object.prototype.hasOwnProperty.call(this._stats, key)) {
-      n = this._stats[key] = Big(0)
-    } else {
-      n = this._stats[key]
-    }
-    this._stats[key] = n.plus(inc)
-
-    if (!this._frequencyAccumulators[key]) {
-      this._frequencyAccumulators[key] = 0
-    }
-    this._frequencyAccumulators[key] += inc
-  }
-}
-
-module.exports = Stats

package/src/metrics/tracked-map.js

@@ -1,94 +0,0 @@
-'use strict'
-
-/**
- * @template K
- * @template V
- */
-class TrackedMap extends Map {
-  /**
-   * @param {object} options
-   * @param {string} options.system
-   * @param {string} options.component
-   * @param {string} options.metric
-   * @param {import('.')} options.metrics
-   */
-  constructor (options) {
-    super()
-
-    const { system, component, metric, metrics } = options
-    this._system = system
-    this._component = component
-    this._metric = metric
-    this._metrics = metrics
-
-    this._metrics.updateComponentMetric({
-      system: this._system,
-      component: this._component,
-      metric: this._metric,
-      value: this.size
-    })
-  }
-
-  /**
-   * @param {K} key
-   * @param {V} value
-   */
-  set (key, value) {
-    super.set(key, value)
-    this._metrics.updateComponentMetric({
-      system: this._system,
-      component: this._component,
-      metric: this._metric,
-      value: this.size
-    })
-    return this
-  }
-
-  /**
-   * @param {K} key
-   */
-  delete (key) {
-    const deleted = super.delete(key)
-    this._metrics.updateComponentMetric({
-      system: this._system,
-      component: this._component,
-      metric: this._metric,
-      value: this.size
-    })
-    return deleted
-  }
-
-  clear () {
-    super.clear()
-
-    this._metrics.updateComponentMetric({
-      system: this._system,
-      component: this._component,
-      metric: this._metric,
-      value: this.size
-    })
-  }
-}
-
-/**
- * @template K
- * @template V
- * @param {object} options
- * @param {string} [options.system]
- * @param {string} options.component
- * @param {string} options.metric
- * @param {import('.')} [options.metrics]
- * @returns {Map<K, V>}
- */
-module.exports = ({ system = 'libp2p', component, metric, metrics }) => {
-  /** @type {Map<K, V>} */
-  let map
-
-  if (metrics) {
-    map = new TrackedMap({ system, component, metric, metrics })
-  } else {
-    map = new Map()
-  }
-
-  return map
-}