@netlify/build 28.0.0-beta → 28.0.0

package/src/time/aggregate.js

@@ -1,146 +0,0 @@
-import { createTimer, TOP_PARENT_TAG } from './main.js'
-
-// Some timers are computed based on others:
-//   - `others` is `total` minus the other timers
-//   - `run_plugins` is the sum of all plugins
-//   - `run_netlify_build_per_type` aggregates timers but per system/plugin/user
-//   - each plugin timer is the sum of its event handlers
-export const addAggregatedTimers = function (timers) {
-  const timersA = addRunPluginsTimer(timers)
-  const timersB = addPluginTimers(timersA)
-  const timersC = addOthersTimers(timersB)
-  const timersD = addTypeTimers(timersC)
-  return timersD
-}
-
-// Having a `total` timer is redundant since the buildbot already measures this.
-// The buildbot measurement is better since it includes the time to load Node.
-// Instead, we only use `total` to measure what did not get `measureDuration()`.
-const addOthersTimers = function (timers) {
-  const totalTimer = timers.find(isTotalTimer)
-  const timersA = timers.filter((timer) => !isTotalTimer(timer))
-  const topTimers = timersA.filter(isTopTimer)
-  const othersTimer = createOthersTimer(topTimers, totalTimer)
-  return [...timersA, othersTimer]
-}
-
-const isTotalTimer = function ({ stageTag, parentTag }) {
-  return stageTag === 'total' && parentTag === 'build_site'
-}
-
-const createOthersTimer = function (topTimers, { durationNs: totalTimerDurationNs }) {
-  const topTimersDurationNs = computeTimersDuration(topTimers)
-  const otherTimersDurationNs = Math.max(0, totalTimerDurationNs - topTimersDurationNs)
-  const othersTimer = createTimer(OTHERS_STAGE_TAG, otherTimersDurationNs)
-  return othersTimer
-}
-
-const OTHERS_STAGE_TAG = 'others'
-
-// Measure the total time running plugins
-const addRunPluginsTimer = function (timers) {
-  const pluginsTimers = timers.filter(isPluginTimer)
-  return pluginsTimers.length === 0 ? timers : [...timers, createSumTimer(pluginsTimers, RUN_PLUGINS_STAGE_TAG)]
-}
-
-const RUN_PLUGINS_STAGE_TAG = 'run_plugins'
-
-// Retrieve one timer for each plugin, summing all its individual timers
-// (one per event handler)
-const addPluginTimers = function (timers) {
-  const timersA = timers.filter((timer) => !isCommunityPluginTimer(timer))
-  const pluginsTimers = timersA.filter(isPluginTimer)
-  if (pluginsTimers.length === 0) {
-    return timersA
-  }
-
-  const pluginPackages = getPluginPackages(pluginsTimers)
-  const wholePluginsTimers = pluginPackages.map((pluginPackage) => getWholePluginTimer(pluginPackage, pluginsTimers))
-  return [...timersA, ...wholePluginsTimers]
-}
-
-// We only measure plugins maintained by us, not community
-const isCommunityPluginTimer = function (timer) {
-  return isPluginTimer(timer) && !isNetlifyMaintainedPlugin(getPluginTimerPackage(timer))
-}
-
-const isNetlifyMaintainedPlugin = function (pluginPackage) {
-  return NETLIFY_MAINTAINED_PLUGINS.has(pluginPackage)
-}
-
-const NETLIFY_MAINTAINED_PLUGINS = new Set([
-  'netlify_plugin_gatsby_cache',
-  'netlify_plugin_sitemap',
-  'netlify_plugin_debug_cache',
-  'netlify_plugin_is_website_vulnerable',
-  'netlify_plugin_lighthouse',
-  'netlify_plugin_nextjs',
-  'netlify_plugin_gatsby',
-])
-
-const getPluginPackages = function (pluginsTimers) {
-  const pluginPackages = pluginsTimers.map(getPluginTimerPackage)
-  return [...new Set(pluginPackages)]
-}
-
-const getWholePluginTimer = function (pluginPackage, pluginsTimers) {
-  const pluginTimers = pluginsTimers.filter((pluginTimer) => getPluginTimerPackage(pluginTimer) === pluginPackage)
-  const wholePluginsTimer = createSumTimer(pluginTimers, pluginPackage, RUN_PLUGINS_STAGE_TAG)
-  return wholePluginsTimer
-}
-
-const getPluginTimerPackage = function ({ parentTag }) {
-  return parentTag
-}
-
-// Check if a timer relates to a Build plugin
-const isPluginTimer = function ({ category }) {
-  return category === 'pluginEvent'
-}
-
-// Reports total time depending on whether it was system, plugin or user
-const addTypeTimers = function (timers) {
-  const topTimers = timers.filter(isTopTimer)
-  const typeTimers = TYPE_TIMERS.map(({ name, stages }) => getTypeTimer(name, stages, topTimers)).filter(Boolean)
-  return [...timers, ...typeTimers]
-}
-
-const TYPE_TIMERS = [
-  { name: 'system', stages: ['resolve_config', 'get_plugins_options', 'start_plugins', 'others'] },
-  { name: 'plugin', stages: ['load_plugins', 'run_plugins'] },
-  { name: 'user', stages: ['build_command', 'functions_bundling', 'deploy_site'] },
-]
-
-const getTypeTimer = function (name, stages, topTimers) {
-  const topTimersA = topTimers.filter(({ stageTag }) => stages.includes(stageTag))
-
-  if (topTimersA.length === 0) {
-    return
-  }
-
-  const typeTimer = createSumTimer(topTimersA, name, 'run_netlify_build_per_type')
-  return typeTimer
-}
-
-const isTopTimer = function ({ parentTag }) {
-  return parentTag === TOP_PARENT_TAG
-}
-
-// Creates a timer that sums up the duration of several others
-const createSumTimer = function (timers, stageTag, parentTag) {
-  const durationNs = computeTimersDuration(timers)
-  const timer = createTimer(stageTag, durationNs, { parentTag })
-  return timer
-}
-
-const computeTimersDuration = function (timers) {
-  return timers.map(getTimerDuration).reduce(reduceSum, 0)
-}
-
-const getTimerDuration = function ({ durationNs }) {
-  return durationNs
-}
-
-const reduceSum = function (sum, number) {
-  return sum + number
-}

package/src/time/main.js

@@ -1,48 +0,0 @@
-import slugify from '@sindresorhus/slugify'
-import keepFuncProps from 'keep-func-props'
-
-import { startTimer, endTimer } from './measure.js'
-
-// Initialize the `timers` array
-export const initTimers = function () {
-  return []
-}
-
-// Wrap an async function to measure how long it takes.
-// The function must:
-//   - take a plain object as first argument. This must contain a `timers`.
-//   - return a plain object. This may or may not contain a modified `timers`.
-// The `durationNs` will be returned by the function. A new `timers` with the
-// additional duration timer will be returned as well.
-const kMeasureDuration = function (func, stageTag, { parentTag, category } = {}) {
-  return async function measuredFunc({ timers, ...opts }, ...args) {
-    const timerNs = startTimer()
-    const { timers: timersA = timers, ...returnObject } = await func({ timers, ...opts }, ...args)
-    const { tags = {} } = returnObject
-    const durationNs = endTimer(timerNs)
-    const timer = createTimer(stageTag, durationNs, { parentTag, category, tags })
-    const timersB = [...timersA, timer]
-    return { ...returnObject, timers: timersB, durationNs }
-  }
-}
-
-// Ensure the wrapped function `name` is not `anonymous` in stack traces
-export const measureDuration = keepFuncProps(kMeasureDuration)
-
-// Create a new object representing a completed timer
-export const createTimer = function (
-  stageTag,
-  durationNs,
-  { metricName = DEFAULT_METRIC_NAME, parentTag = TOP_PARENT_TAG, category, tags } = {},
-) {
-  return { metricName, stageTag, parentTag, durationNs, category, tags }
-}
-
-const DEFAULT_METRIC_NAME = 'buildbot.build.stage.duration'
-export const TOP_PARENT_TAG = 'run_netlify_build'
-
-// Make sure the timer name does not include special characters.
-// For example, the `packageName` of local plugins includes dots.
-export const normalizeTimerName = function (name) {
-  return slugify(name, { separator: '_' })
-}

package/src/time/measure.js

@@ -1,22 +0,0 @@
-import { hrtime } from 'process'
-
-// Starts a timer
-export const startTimer = function () {
-  return hrtime()
-}
-
-// Stops a timer
-export const endTimer = function ([startSecs, startNsecs]) {
-  const [endSecs, endNsecs] = hrtime()
-  const durationNs = (endSecs - startSecs) * NANOSECS_TO_SECS + endNsecs - startNsecs
-  return durationNs
-}
-
-// statsd expects milliseconds integers.
-// To prevent double rounding errors, rounding should only be applied once.
-export const roundTimerToMillisecs = function (durationNs) {
-  return Math.round(durationNs / NANOSECS_TO_MSECS)
-}
-
-const NANOSECS_TO_SECS = 1e9
-const NANOSECS_TO_MSECS = 1e6

package/src/time/report.js

@@ -1,59 +0,0 @@
-import { promisify } from 'util'
-
-import StatsdClient from 'statsd-client'
-
-import { addAggregatedTimers } from './aggregate.js'
-import { roundTimerToMillisecs } from './measure.js'
-
-// TODO: replace with `timers/promises` after dropping Node < 15.0.0
-const pSetTimeout = promisify(setTimeout)
-
-// Record the duration of a build phase, for monitoring.
-// Sends to statsd daemon.
-export const reportTimers = async function ({ timers, statsdOpts: { host, port }, framework }) {
-  if (host === undefined) {
-    return
-  }
-
-  const timersA = addAggregatedTimers(timers)
-  await sendTimers({ timers: timersA, host, port, framework })
-}
-
-const sendTimers = async function ({ timers, host, port, framework }) {
-  const client = await startClient(host, port)
-  timers.forEach((timer) => {
-    sendTimer({ timer, client, framework })
-  })
-  await closeClient(client)
-}
-
-// The socket creation is delayed until the first packet is sent. In our
-// case, this happens just before `client.close()` is called, which is too
-// late and make it not send anything. We need to manually create it using
-// the internal API.
-const startClient = async function (host, port) {
-  const client = new StatsdClient({ host, port, socketTimeout: 0 })
-  // eslint-disable-next-line no-underscore-dangle
-  await promisify(client._socket._createSocket.bind(client._socket))()
-  return client
-}
-
-const sendTimer = function ({ timer: { metricName, stageTag, parentTag, durationNs, tags }, client, framework }) {
-  const durationMs = roundTimerToMillisecs(durationNs)
-  const frameworkTag = framework === undefined ? {} : { framework }
-  client.distribution(metricName, durationMs, { stage: stageTag, parent: parentTag, ...tags, ...frameworkTag })
-}
-
-// UDP packets are buffered and flushed at regular intervals by statsd-client.
-// Closing force flushing all of them.
-const closeClient = async function (client) {
-  client.close()
-
-  // statsd-clent does not provide with a way of knowing when the socket is done
-  // closing, so we need to use the following hack.
-  await pSetTimeout(CLOSE_TIMEOUT)
-  await pSetTimeout(CLOSE_TIMEOUT)
-}
-
-// See https://github.com/msiebuhr/node-statsd-client/blob/45a93ee4c94ca72f244a40b06cb542d4bd7c3766/lib/EphemeralSocket.js#L81
-const CLOSE_TIMEOUT = 11

package/src/utils/errors.js

@@ -1,12 +0,0 @@
-// Wrap an async function so it prepends an error message on exceptions.
-// This helps locate errors.
-export const addAsyncErrorMessage = function (asyncFunc, message) {
-  return async (...args) => {
-    try {
-      return await asyncFunc(...args)
-    } catch (error) {
-      error.stack = `${message}: ${error.stack}`
-      throw error
-    }
-  }
-}

package/src/utils/json.js

@@ -1,19 +0,0 @@
-import { promises as fs, readFileSync } from 'fs'
-import { fileURLToPath } from 'url'
-
-const ROOT_PACKAGE_JSON_PATH = fileURLToPath(new URL('../../package.json', import.meta.url))
-
-// TODO: Replace with dynamic `import()` once it is supported without
-// experimental flags
-export const importJsonFile = async function (filePath) {
-  const fileContents = await fs.readFile(filePath)
-  return JSON.parse(fileContents)
-}
-
-const importJsonFileSync = function (filePath) {
-  // Use sync I/O so it is easier to migrate to `import()` later on
-  const fileContents = readFileSync(filePath, 'utf8')
-  return JSON.parse(fileContents)
-}
-
-export const ROOT_PACKAGE_JSON = importJsonFileSync(ROOT_PACKAGE_JSON_PATH)

package/src/utils/package.js

@@ -1,23 +0,0 @@
-import { dirname } from 'path'
-
-import { readPackageUp } from 'read-pkg-up'
-
-// Retrieve `package.json` from a specific directory
-export const getPackageJson = async function (cwd, { normalize } = {}) {
-  const packageObj = await getPackageObj({ cwd, normalize })
-  if (packageObj === undefined) {
-    return { packageJson: {} }
-  }
-
-  const { path, packageJson } = packageObj
-  const packageDir = dirname(path)
-  return { packageDir, packageJson }
-}
-
-const getPackageObj = async function ({ cwd, normalize = true }) {
-  try {
-    return await readPackageUp({ cwd, normalize })
-    // If the `package.json` is invalid and `normalize` is `true`, an error is
-    // thrown. We return `undefined` then.
-  } catch {}
-}

package/src/utils/remove_falsy.js

@@ -1,10 +0,0 @@
-import filterObj from 'filter-obj'
-
-// Remove falsy values from object
-export const removeFalsy = function (obj) {
-  return filterObj(obj, isDefined)
-}
-
-const isDefined = function (key, value) {
-  return value !== undefined && value !== ''
-}

package/src/utils/resolve.js

@@ -1,46 +0,0 @@
-import { createRequire } from 'module'
-
-import { async as resolveLib } from 'resolve'
-
-// TODO: use `import.resolve()` once it is available without any experimental
-// flags
-const require = createRequire(import.meta.url)
-
-// Like `resolvePath()` but does not throw
-export const tryResolvePath = async function (path, basedir) {
-  try {
-    const resolvedPath = await resolvePath(path, basedir)
-    return { path: resolvedPath }
-  } catch (error) {
-    return { error }
-  }
-}
-
-// This throws if the package cannot be found
-export const resolvePath = async function (path, basedir) {
-  try {
-    return await resolvePathWithBasedir(path, basedir)
-    // Fallback.
-    // `resolve` sometimes gives unhelpful error messages.
-    // https://github.com/browserify/resolve/issues/223
-  } catch {
-    return require.resolve(path, { paths: [basedir] })
-  }
-}
-
-// Like `require.resolve()` but as an external library.
-// We need to use `new Promise()` due to a bug with `utils.promisify()` on
-// `resolve`:
-//   https://github.com/browserify/resolve/issues/151#issuecomment-368210310
-const resolvePathWithBasedir = function (path, basedir) {
-  return new Promise((resolve, reject) => {
-    // eslint-disable-next-line promise/prefer-await-to-callbacks
-    resolveLib(path, { basedir }, (error, resolvedPath) => {
-      if (error) {
-        return reject(error)
-      }
-
-      resolve(resolvedPath)
-    })
-  })
-}

package/src/utils/semver.js

@@ -1,34 +0,0 @@
-import semver from 'semver'
-
-// Compare two versions by their major versions.
-// Takes into account the special rules for `0.*.*` and `0.0.*` versions.
-export const isPreviousMajor = function (versionA, versionB) {
-  return semver.lt(getMajor(versionA), getMajor(versionB))
-}
-
-// Remove minor/patch numbers
-const getMajor = function (version) {
-  return semver.minVersion(getMajorVersion(version)).version
-}
-
-// According to semver, the second number is the major release number for
-// `0.*.*` versions and the third for `0.0.*`. This is how `^` behaves with the
-// `semver` module which is used by `npm`.
-export const getMajorVersion = function (version) {
-  if (!version || semver.clean(version) === null) {
-    return
-  }
-
-  const majorVersion = semver.major(version)
-  if (majorVersion !== 0) {
-    return `${majorVersion}`
-  }
-
-  const minorVersion = semver.minor(version)
-  if (minorVersion !== 0) {
-    return `${majorVersion}.${minorVersion}`
-  }
-
-  const patchVersion = semver.patch(version)
-  return `${majorVersion}.${minorVersion}.${patchVersion}`
-}