@percy/monitoring 1.30.7-beta.3

package/dist/cpu.js

@@ -0,0 +1,173 @@
+import os from 'os';
+import si from 'systeminformation';
+import { promises as fs } from 'fs';
+import logger from '@percy/logger';
+import { pathsExist } from './utils.js';
+const CGROUP_CPU_STATS = '/sys/fs/cgroup/cpu.stat';
+const CGROUP_CPU_MAX = '/sys/fs/cgroup/cpu.max';
+const CGROUP_FILES = [CGROUP_CPU_MAX, CGROUP_CPU_STATS];
+const log = logger('monitoring:cpu');
+
+/**
+ * Retrieves CPU information.
+ * @param {*} os - The OS module (if needed, otherwise remove this parameter).
+ * @param {*} param1 - An object containing CPU details.
+ * @returns {{ currentUsagePercent: number, cores: number, cgroupExists: boolean }} CPU information.
+ */
+async function getCPUUsageInfo(os) {
+  try {
+    if (os.includes('linux') && (await pathsExist(CGROUP_FILES))) {
+      return await getLinuxCPUUsage();
+    } else {
+      return await getCPUUsage();
+    }
+  } catch (error) {
+    // Don't raise this error to avoid user build failure
+    // show error in debug mode only
+    log.debug(`Error: ${error}`);
+    return {};
+  }
+}
+
+/**
+ * reading cpu stats from cgroup files
+ */
+async function readCpuStatFromCgroup() {
+  const content = await fs.readFile(CGROUP_CPU_STATS, 'utf8');
+  const stats = {};
+
+  // Parse the cpu.stat file
+  content.split('\n').forEach(line => {
+    const [key, value] = line.trim().split(' ');
+    if (key && value) {
+      stats[key] = parseInt(value);
+    }
+  });
+  return stats;
+}
+async function getTotalCores() {
+  let availableCPUs = (await si.cpu()).cores;
+  try {
+    // Read cpu.max for quota and period
+    const cpuMaxContent = await fs.readFile(CGROUP_CPU_MAX, 'utf8');
+    const [quotaStr, periodStr] = cpuMaxContent.trim().split(' ');
+    let quota, period;
+    if (quotaStr !== 'max') {
+      // Parse quota and period values
+      quota = parseInt(quotaStr);
+      period = parseInt(periodStr);
+      availableCPUs = quota / period;
+    }
+  } catch (error) {
+    // supressing this err, as we will use fallback system
+    // level cpu details
+  }
+  return availableCPUs;
+}
+async function getClientCPUDetails() {
+  const cores = await getTotalCores();
+  return {
+    arch: os.arch(),
+    cores
+  };
+}
+
+/**
+ * linux cpu load is calculated is same for
+ * containerLevel and machineLevel
+ * @returns {{ currentUsagePercent: number, cores: number }} CPU information.
+ */
+async function getLinuxCPUUsage() {
+  try {
+    const availableCPUs = await getTotalCores();
+
+    // Get first CPU usage reading
+    const startStats = await readCpuStatFromCgroup();
+
+    // Wait for 1 second, ie 10^6 microsecod
+    await new Promise(resolve => setTimeout(resolve, 1000));
+
+    // Get second CPU usage reading
+    const endStats = await readCpuStatFromCgroup();
+
+    // Calculate CPU usage
+    const usageDelta = endStats.usage_usec - startStats.usage_usec;
+
+    // Calculate percentage (similar to previous implementation)
+    // usageDelta is in microseconds, we measured over 1 second (1_000_000 microseconds)
+    // NOTE: cpuPercentage can be > 100% as something process can use
+    // more than allocated cpu range
+    const cpuPercent = usageDelta / (1_000_000 * availableCPUs) * 100;
+    return {
+      cores: availableCPUs,
+      currentUsagePercent: cpuPercent,
+      cgroupExists: true
+    };
+  } catch (error) {
+    // TODO: Log error here
+    log.debug('Linux c_group cpu usage error:', error);
+    // using fallback method to get details
+    return await getCPUUsage();
+  }
+}
+
+/**
+ * Each cpu.times has following 4 details
+ * {
+    user: time spent running user code
+    nice: time spent running user code at low priority
+    sys: time spent running system/kernel code
+    idle: time CPU was idle
+    irq: time spent handling interrupts
+  }
+ */
+async function computeCpuUsageStats() {
+  let totalTickTime = 0;
+  let totalIdleTime = 0;
+  os.cpus().forEach(cpu => {
+    for (let type in cpu.times) {
+      totalTickTime += cpu.times[type];
+    }
+    totalIdleTime += cpu.times.idle;
+  });
+  return {
+    totalTickTime,
+    totalIdleTime
+  };
+}
+;
+
+/**
+ * this is a fallback method, if
+ * 1. For LINUX, we can't find cgroup details
+ * 2. For Win/OSX operating system
+ * @returns {{ currentUsagePercent: number, cores: number, cgroupExists: boolean }}
+ */
+async function getCPUUsage() {
+  const initialCpuUsage = await computeCpuUsageStats();
+  // wait for 1 second, to connect cpu load for 10^6 micro-second
+  // ie. 1 second
+  await new Promise(res => setTimeout(res, 1000));
+  const finalCpuUsage = await computeCpuUsageStats();
+
+  // Calculate differences
+  const deltaTick = finalCpuUsage.totalTickTime - initialCpuUsage.totalTickTime;
+  const deltaIdle = finalCpuUsage.totalIdleTime - initialCpuUsage.totalIdleTime;
+
+  // Calculate % usage
+  let cpuUsagePercent = null;
+
+  // Case: If no cpu usage is done from 1 sec, then delta will be 0
+  // raising error zero division error
+  // ideally it shouldn't happen
+  if (deltaTick > 0) {
+    cpuUsagePercent = (1 - deltaIdle / deltaTick) * 100;
+  } else cpuUsagePercent = 0;
+  let cores = await getTotalCores();
+  return {
+    cores,
+    currentUsagePercent: cpuUsagePercent,
+    cgroupExists: false
+  };
+}
+export { getCPUUsageInfo, getClientCPUDetails };

package/dist/index.js

@@ -0,0 +1,114 @@
+import os from 'os';
+import fs from 'fs';
+import logger from '@percy/logger';
+import { getCPUUsageInfo, getClientCPUDetails } from './cpu.js';
+import { getMemoryUsageInfo, getClientMemoryDetails } from './memory.js';
+export default class Monitoring {
+  constructor() {
+    this.os = this.getOS();
+    this.monitoringId = null;
+    this.running = false;
+    this.isContainer = this.isContainerLevel();
+    this.isPod = this.isPodLevel();
+    this.isMachine = this.isMachineLevel();
+    this.lastExecutedAt = null;
+    this.pod = this.isPodLevel();
+    this.cpuInfo = {};
+    this.memoryUsageInfo = {};
+    this.log = logger('monitoring');
+  }
+  getOS() {
+    return os.platform();
+  }
+  getPercyEnv() {
+    const percyKeys = Object.keys(process.env).filter(env => env.toLowerCase().includes('percy') && !env.toLowerCase().includes('token'));
+    let envs = {};
+    percyKeys.forEach(env => {
+      envs[env] = process.env[env];
+    });
+    return envs;
+  }
+  isContainerLevel() {
+    return fs.existsSync('/.dockerenv');
+  }
+  isPodLevel() {
+    return fs.existsSync('/var/run/secrets/kubernetes.io');
+  }
+  isMachineLevel() {
+    return !this.isContainerLevel();
+  }
+  async logSystemInfo() {
+    try {
+      const cpu = await getClientCPUDetails();
+      const mem = await getClientMemoryDetails();
+      const percyEnvs = this.getPercyEnv();
+      this.log.debug(`[Operating System] Platform: ${this.os}, Type: ${os.type()}, Release: ${os.release()}`);
+      this.log.debug(`[CPU] Arch: ${cpu.arch}, cores: ${cpu.cores}`);
+      this.log.debug(`[Memory] Total: ${mem.total / 1024 ** 3} gb, Swap Space: ${mem.swaptotal / 1024 ** 3} gb`);
+      this.log.debug(`Container Level: ${this.isContainer}, Pod Level: ${this.isPod}, Machine Level: ${this.isMachine}`);
+      this.log.debug(`Percy Envs: ${JSON.stringify(percyEnvs)}`);
+    } catch (error) {
+      // suppress error
+      this.log.debug(`Error logging system info: ${error}`);
+    }
+  }
+
+  /**
+   * It will start monitoring at certain interval
+   * by default every 5 seconds
+   */
+  async startMonitoring(options = {}) {
+    const {
+      interval = 5000
+    } = options;
+    // early return if already monitoring
+    if (this.monitoringId) return;
+    await this.executeMonitoring();
+    this.monitoringId = setInterval(() => {
+      this.executeMonitoring();
+    }, interval);
+    this.log.debug('Started monitoring sytem metrics');
+  }
+  async executeMonitoring() {
+    this.running = true;
+    await this.monitoringCPUUsage();
+    await this.monitorMemoryUsage();
+    this.lastExecutedAt = Date.now();
+  }
+  stopMonitoring() {
+    if (this.monitoringId) {
+      clearInterval(this.monitoringId);
+      this.monitoringId = null;
+      this.cpuInfo = {};
+      this.memoryUsageInfo = {};
+      this.running = false;
+      this.lastExecutedAt = null;
+      this.log.debug('Stopped monitoring sytem metrics');
+    }
+  }
+  async monitoringCPUUsage() {
+    const cpuInfo = await getCPUUsageInfo(this.os, {
+      containerLevel: this.isContainer,
+      machineLevel: this.isMachine
+    });
+    this.cpuInfo = cpuInfo;
+    this.log.debug(`cpuInfo: ${JSON.stringify(cpuInfo)}`);
+  }
+  async monitorMemoryUsage() {
+    const memoryInfo = await getMemoryUsageInfo(this.os, {
+      containerLevel: this.isContainer,
+      machineLevel: this.isMachine
+    });
+    this.memoryUsageInfo = memoryInfo;
+    this.log.debug(`memoryInfo: ${JSON.stringify(memoryInfo)}`);
+  }
+
+  // Whenever, this will get called to get
+  // cpu and memory usage info
+  getMonitoringInfo() {
+    return {
+      cpuInfo: this.cpuInfo,
+      memoryUsageInfo: this.memoryUsageInfo
+    };
+  }
+}

package/dist/memory.js

@@ -0,0 +1,103 @@
+import { promises as fs } from 'fs';
+import si from 'systeminformation';
+import logger from '@percy/logger';
+import { pathsExist } from './utils.js';
+const CGROUP_MEMORY_CURRENT = '/sys/fs/cgroup/memory.current';
+const CGROUP_MEMORY_MAX = '/sys/fs/cgroup/memory.max';
+const CGROUP_FILES = [CGROUP_MEMORY_CURRENT, CGROUP_MEMORY_MAX];
+const log = logger('monitoring:memory');
+
+/**
+ * Retrieves CPU information.
+ * @param {*} os - The OS module (if needed, otherwise remove this parameter).
+ * @param {*} param1 - An object containing CPU details.
+ * @returns {{ currentUsagePercent: number, totalMemory: number }} Memory information.
+ */
+async function getMemoryUsageInfo(os) {
+  try {
+    if (os.includes('linux') && (await pathsExist(CGROUP_FILES))) {
+      return await getLinuxMemoryUsage();
+    } else {
+      return await getMemoryUsage();
+    }
+  } catch (error) {
+    log.debug(`Error: ${error}`);
+    return {};
+  }
+}
+
+/**
+ * @returns { swaptotal: number, total: number }
+ */
+async function getClientMemoryDetails() {
+  // values are in bytes
+  const {
+    swaptotal
+  } = await si.mem();
+  const total = await getTotalMemory();
+  return {
+    swaptotal,
+    total
+  };
+}
+async function getTotalMemory() {
+  let maxAllocatedMemory = (await si.mem()).total;
+  try {
+    let maxMemory = await fs.readFile(CGROUP_MEMORY_MAX);
+    // if memory_max == max ( take system max value )
+    // as there is no limit set, it's the max value
+    if (maxMemory !== 'max') {
+      maxAllocatedMemory = parseInt(maxMemory);
+    }
+  } catch (error) {
+    // supressing this err, as we will use system level metric
+    // as fallback
+  }
+
+  // in bytes
+  return maxAllocatedMemory;
+}
+
+/**
+ * get memory usage using linux c_group ( control group )
+ * @returns {{ currentUsagePercent: number, totalMemory: number }} Memory information.
+ */
+async function getLinuxMemoryUsage() {
+  try {
+    const maxAllocatedMemory = await getTotalMemory(); // in bytes
+    const currentMemoryUsage = parseInt(await fs.readFile(CGROUP_MEMORY_CURRENT)); // in bytes
+    const memoryUsagePercentage = currentMemoryUsage / maxAllocatedMemory * 100;
+    return {
+      totalMemory: maxAllocatedMemory,
+      currentUsagePercent: memoryUsagePercentage
+    };
+  } catch (error) {
+    log.debug('Linux c_group memory usage error:', error);
+
+    // Use the fallback method, to get memory usage details
+    return await getMemoryUsage();
+  }
+}
+
+/**
+ * Fallback method, for
+ * 1. LINUX, if cgroups files doesn't exists
+ * 2. MacOSX, Windows based OS
+ *
+ * @returns {{ currentUsagePercent: number, totalMemory: number }} Memory information.
+ */
+async function getMemoryUsage() {
+  // Get total and free memory
+  const memInfo = await si.mem();
+  const totalMemory = memInfo.total;
+  const freeMemory = memInfo.available;
+
+  // Calculate memory usage percentage
+  const usedMemory = totalMemory - freeMemory;
+  const memoryUsagePercentage = usedMemory / totalMemory * 100;
+  return {
+    currentUsagePercent: memoryUsagePercentage,
+    totalMemory
+  };
+}
+export { getMemoryUsageInfo, getClientMemoryDetails };

package/dist/utils.js

@@ -0,0 +1,14 @@
+import { promises as fs } from 'fs';
+async function pathsExist(paths) {
+  let exists = true;
+  try {
+    for (const file of paths) {
+      // throws error if file is not accessible
+      await fs.access(file);
+    }
+  } catch (error) {
+    exists = false;
+  }
+  return exists;
+}
+export { pathsExist };

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@percy/monitoring",
+  "version": "1.30.7-beta.3",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/percy/cli",
+    "directory": "packages/monitoring"
+  },
+  "publishConfig": {
+    "access": "public",
+    "tag": "beta"
+  },
+  "engines": {
+    "node": ">=14"
+  },
+  "files": [
+    "dist"
+  ],
+  "main": "./dist/index.js",
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "node ../../scripts/build",
+    "lint": "eslint --ignore-path ../../.gitignore .",
+    "test": "node ../../scripts/test",
+    "test:coverage": "yarn test --coverage"
+  },
+  "dependencies": {
+    "@percy/config": "1.30.7-beta.3",
+    "@percy/logger": "1.30.7-beta.3",
+    "@percy/sdk-utils": "1.30.7-beta.3",
+    "systeminformation": "^5.25.11"
+  },
+  "gitHead": "06141a5d15278e9cb14550a96c745336acf8bafd"
+}