Merge branch 'main' into jessitron/update-example

packages/opentelemetry-host-metrics/src/BaseMetrics.ts

@@ -46,7 +46,7 @@ export abstract class BaseMetrics {
   constructor(config: MetricsCollectorConfig) {
     this._name = config.name || DEFAULT_NAME;
     const meterProvider =
-      config.meterProvider! || api.metrics.getMeterProvider();
+      config.meterProvider || api.metrics.getMeterProvider();
     if (!config.meterProvider) {
       this._logger.warn('No meter provider, using default');
     }

packages/opentelemetry-host-metrics/src/enum.ts

@@ -27,9 +27,16 @@ export enum METRIC_NAMES {
   PROCESS_MEMORY_USAGE = 'process.memory.usage',
 }
 
-export enum METRIC_ATTRIBUTES {
+export enum ATTRIBUTE_NAMES {
   SYSTEM_CPU_LOGICAL_NUMBER = 'system.cpu.logical_number',
   SYSTEM_CPU_STATE = 'system.cpu.state',
+  SYSTEM_MEMORY_STATE = 'system.memory.state',
+  SYSTEM_DEVICE = 'system.device',
+  SYSTEM_NETWORK_DIRECTION = 'system.network.direction',
+  SYSTEM_NETWORK_STATE = 'system.network.state',
+  // TODO: change value if semconv changes
+  // https://github.com/open-telemetry/opentelemetry-specification/issues/3776
+  PROCESS_CPU_STATE = 'state',
 }
 
 export enum CPU_LABELS {
@@ -41,7 +48,6 @@ export enum CPU_LABELS {
 }
 
 export enum NETWORK_LABELS {
-  DEVICE = 'device',
   RECEIVE = 'receive',
   TRANSMIT = 'transmit',
 }

packages/opentelemetry-host-metrics/src/metric.ts

@@ -40,8 +40,8 @@ export class HostMetrics extends BaseMetrics {
     observableResult: api.BatchObservableResult,
     cpuUsages: CpuUsageData[]
   ): void {
-    const stateAttr = enums.METRIC_ATTRIBUTES.SYSTEM_CPU_STATE;
-    const cpuAttr = enums.METRIC_ATTRIBUTES.SYSTEM_CPU_LOGICAL_NUMBER;
+    const stateAttr = enums.ATTRIBUTE_NAMES.SYSTEM_CPU_STATE;
+    const cpuAttr = enums.ATTRIBUTE_NAMES.SYSTEM_CPU_LOGICAL_NUMBER;
 
     for (let i = 0, j = cpuUsages.length; i < j; i++) {
       const cpuUsage = cpuUsages[i];
@@ -93,25 +93,27 @@ export class HostMetrics extends BaseMetrics {
     observableResult: api.BatchObservableResult,
     processCpuUsage: ProcessCpuUsageData
   ): void {
+    const stateAttr = enums.ATTRIBUTE_NAMES.PROCESS_CPU_STATE;
+
     observableResult.observe(this._processCpuTime, processCpuUsage.user, {
-      state: enums.CPU_LABELS.USER,
+      [stateAttr]: enums.CPU_LABELS.USER,
     });
     observableResult.observe(this._processCpuTime, processCpuUsage.system, {
-      state: enums.CPU_LABELS.SYSTEM,
+      [stateAttr]: enums.CPU_LABELS.SYSTEM,
     });
 
     observableResult.observe(
       this._processCpuUtilization,
       processCpuUsage.userP,
       {
-        state: enums.CPU_LABELS.USER,
+        [stateAttr]: enums.CPU_LABELS.USER,
       }
     );
     observableResult.observe(
       this._processCpuUtilization,
       processCpuUsage.systemP,
       {
-        state: enums.CPU_LABELS.SYSTEM,
+        [stateAttr]: enums.CPU_LABELS.SYSTEM,
       }
     );
   }
@@ -120,18 +122,20 @@ export class HostMetrics extends BaseMetrics {
     observableResult: api.BatchObservableResult,
     memUsage: MemoryData
   ): void {
+    const stateAttr = enums.ATTRIBUTE_NAMES.SYSTEM_MEMORY_STATE;
+
     observableResult.observe(this._memoryUsage, memUsage.used, {
-      state: enums.MEMORY_LABELS.USED,
+      [stateAttr]: enums.MEMORY_LABELS.USED,
     });
     observableResult.observe(this._memoryUsage, memUsage.free, {
-      state: enums.MEMORY_LABELS.FREE,
+      [stateAttr]: enums.MEMORY_LABELS.FREE,
     });
 
     observableResult.observe(this._memoryUtilization, memUsage.usedP, {
-      state: enums.MEMORY_LABELS.USED,
+      [stateAttr]: enums.MEMORY_LABELS.USED,
     });
     observableResult.observe(this._memoryUtilization, memUsage.freeP, {
-      state: enums.MEMORY_LABELS.FREE,
+      [stateAttr]: enums.MEMORY_LABELS.FREE,
     });
   }
 
@@ -146,33 +150,36 @@ export class HostMetrics extends BaseMetrics {
     observableResult: api.BatchObservableResult,
     networkUsages: NetworkData[]
   ): void {
+    const deviceAttr = enums.ATTRIBUTE_NAMES.SYSTEM_DEVICE;
+    const directionAttr = enums.ATTRIBUTE_NAMES.SYSTEM_NETWORK_DIRECTION;
+
     for (let i = 0, j = networkUsages.length; i < j; i++) {
       const networkUsage = networkUsages[i];
       observableResult.observe(this._networkDropped, networkUsage.rx_dropped, {
-        [enums.NETWORK_LABELS.DEVICE]: networkUsage.iface,
-        direction: enums.NETWORK_LABELS.RECEIVE,
+        [deviceAttr]: networkUsage.iface,
+        [directionAttr]: enums.NETWORK_LABELS.RECEIVE,
       });
       observableResult.observe(this._networkDropped, networkUsage.tx_dropped, {
-        device: networkUsage.iface,
-        direction: enums.NETWORK_LABELS.TRANSMIT,
+        [deviceAttr]: networkUsage.iface,
+        [directionAttr]: enums.NETWORK_LABELS.TRANSMIT,
       });
 
       observableResult.observe(this._networkErrors, networkUsage.rx_errors, {
-        device: networkUsage.iface,
-        direction: enums.NETWORK_LABELS.RECEIVE,
+        [deviceAttr]: networkUsage.iface,
+        [directionAttr]: enums.NETWORK_LABELS.RECEIVE,
       });
       observableResult.observe(this._networkErrors, networkUsage.tx_errors, {
-        device: networkUsage.iface,
-        direction: enums.NETWORK_LABELS.TRANSMIT,
+        [deviceAttr]: networkUsage.iface,
+        [directionAttr]: enums.NETWORK_LABELS.TRANSMIT,
       });
 
       observableResult.observe(this._networkIo, networkUsage.rx_bytes, {
-        device: networkUsage.iface,
-        direction: enums.NETWORK_LABELS.RECEIVE,
+        [deviceAttr]: networkUsage.iface,
+        [directionAttr]: enums.NETWORK_LABELS.RECEIVE,
       });
       observableResult.observe(this._networkIo, networkUsage.tx_bytes, {
-        device: networkUsage.iface,
-        direction: enums.NETWORK_LABELS.TRANSMIT,
+        [deviceAttr]: networkUsage.iface,
+        [directionAttr]: enums.NETWORK_LABELS.TRANSMIT,
       });
     }
   }

packages/opentelemetry-host-metrics/src/stats/common.ts

@@ -19,7 +19,7 @@ import * as os from 'os';
 import { CpuUsageData, MemoryData, ProcessCpuUsageData } from '../types';
 
 const MILLISECOND = 1 / 1e3;
-let cpuUsageTime: number | undefined = undefined;
+const MICROSECOND = 1 / 1e6;
 
 /**
  * We get data as soon as we load the module so the 1st collect
@@ -77,19 +77,38 @@ export function getCpuUsageData(): CpuUsageData[] {
 }
 
 /**
- * It returns process cpu load delta from last time - to be used with SumObservers.
- * When called first time it will return 0 and then delta will be calculated
+ * We get data as soon as we load the module so the 1st collect
+ * of the metric already has valuable data to be sent.
+ */
+let prevProcData: { time: number; usage: NodeJS.CpuUsage } = {
+  time: Date.now(),
+  usage: process.cpuUsage(),
+};
+
+/**
+ * Gets the process CPU usage and returns
+ * - the time spent in `user` state
+ * - the time spent in `system` state
+ * - the % of time in `user` state since last measurement
+ * - the % of time in `system` state since last measurement
  */
 export function getProcessCpuUsageData(): ProcessCpuUsageData {
-  if (typeof cpuUsageTime !== 'number') {
-    cpuUsageTime = new Date().getTime() - process.uptime() * 1000;
-  }
-  const timeElapsed = (new Date().getTime() - cpuUsageTime) / 1000;
-  const cpuUsage: NodeJS.CpuUsage = process.cpuUsage();
-  const user = cpuUsage.user * MILLISECOND;
-  const system = cpuUsage.system * MILLISECOND;
-  const userP = user / timeElapsed;
-  const systemP = system / timeElapsed;
+  const currentTime = Date.now();
+  const currentUsage = process.cpuUsage();
+  const prevUsage = prevProcData.usage;
+  // According to semantic conventions we need to divide by
+  // - time elapsed (in microseconds to match `process.cpuUsage()` units)
+  // - number of CPUs
+  const timeElapsed = (currentTime - prevProcData.time) * 1000;
+  const cpusTimeElapsed = timeElapsed * prevOsData.cpus.length;
+
+  const user = currentUsage.user * MICROSECOND;
+  const system = currentUsage.system * MICROSECOND;
+  const userP = (currentUsage.user - prevUsage.user) / cpusTimeElapsed;
+  const systemP = (currentUsage.system - prevUsage.system) / cpusTimeElapsed;
+
+  prevProcData = { time: currentTime, usage: currentUsage };
+
   return {
     user,
     system,