@platformatic/metrics 3.30.0 → 3.31.0

package/index.js

@@ -3,6 +3,21 @@ import os from 'node:os'
 import { performance } from 'node:perf_hooks'
 import client from '@platformatic/prom-client'
 
+// Import individual metric collectors from prom-client
+import processCpuTotal from '@platformatic/prom-client/lib/metrics/processCpuTotal.js'
+import processStartTime from '@platformatic/prom-client/lib/metrics/processStartTime.js'
+import osMemoryHeap from '@platformatic/prom-client/lib/metrics/osMemoryHeap.js'
+import processOpenFileDescriptors from '@platformatic/prom-client/lib/metrics/processOpenFileDescriptors.js'
+import processMaxFileDescriptors from '@platformatic/prom-client/lib/metrics/processMaxFileDescriptors.js'
+import eventLoopLag from '@platformatic/prom-client/lib/metrics/eventLoopLag.js'
+import processHandles from '@platformatic/prom-client/lib/metrics/processHandles.js'
+import processRequests from '@platformatic/prom-client/lib/metrics/processRequests.js'
+import processResources from '@platformatic/prom-client/lib/metrics/processResources.js'
+import heapSizeAndUsed from '@platformatic/prom-client/lib/metrics/heapSizeAndUsed.js'
+import heapSpacesSizeAndUsed from '@platformatic/prom-client/lib/metrics/heapSpacesSizeAndUsed.js'
+import version from '@platformatic/prom-client/lib/metrics/version.js'
+import gc from '@platformatic/prom-client/lib/metrics/gc.js'
+
 export * as client from '@platformatic/prom-client'
 
 const { eventLoopUtilization } = performance
@@ -10,6 +25,49 @@ const { Registry, Gauge, Counter, collectDefaultMetrics } = client
 
 export const kMetricsGroups = Symbol('plt.metrics.MetricsGroups')
 
+// Process-level metrics (same across all workers, collect once in main thread)
+export const PROCESS_LEVEL_METRICS = [
+  'process_cpu_user_seconds_total',
+  'process_cpu_system_seconds_total',
+  'process_cpu_seconds_total',
+  'process_start_time_seconds',
+  'process_resident_memory_bytes',
+  'process_open_fds',
+  'process_max_fds',
+  'nodejs_version_info',
+  'process_cpu_percent_usage'
+]
+
+// Thread/isolate-specific metrics (different per worker)
+export const THREAD_LEVEL_METRICS = [
+  'nodejs_heap_size_total_bytes',
+  'nodejs_heap_size_used_bytes',
+  'nodejs_external_memory_bytes',
+  'nodejs_heap_space_size_total_bytes',
+  'nodejs_heap_space_size_used_bytes',
+  'nodejs_heap_space_size_available_bytes',
+  'nodejs_eventloop_lag_seconds',
+  'nodejs_eventloop_lag_min_seconds',
+  'nodejs_eventloop_lag_max_seconds',
+  'nodejs_eventloop_lag_mean_seconds',
+  'nodejs_eventloop_lag_stddev_seconds',
+  'nodejs_eventloop_lag_p50_seconds',
+  'nodejs_eventloop_lag_p90_seconds',
+  'nodejs_eventloop_lag_p99_seconds',
+  'nodejs_eventloop_utilization',
+  'nodejs_gc_duration_seconds',
+  'nodejs_active_handles',
+  'nodejs_active_handles_total',
+  'nodejs_active_requests',
+  'nodejs_active_requests_total',
+  'nodejs_active_resources',
+  'nodejs_active_resources_total',
+  'thread_cpu_user_system_seconds_total',
+  'thread_cpu_system_seconds_total',
+  'thread_cpu_seconds_total',
+  'thread_cpu_percent_usage'
+]
+
 export function registerMetricsGroup (registry, group) {
   registry[kMetricsGroups] ??= new Set()
   registry[kMetricsGroups].add(group)
@@ -93,25 +151,12 @@ export async function collectThreadCpuMetrics (registry) {
   registry.registerMetric(threadCpuPercentUsageGaugeMetric)
 }
 
-export function collectEluMetric (registry) {
-  if (ensureMetricsGroup(registry, 'elu')) {
+// Collect system CPU usage metric (based on os.cpus(), process-level)
+export function collectSystemCpuMetric (registry) {
+  if (ensureMetricsGroup(registry, 'systemCpu')) {
     return
   }
 
-  let startELU = eventLoopUtilization()
-  const eluMetric = new Gauge({
-    name: 'nodejs_eventloop_utilization',
-    help: 'The event loop utilization as a fraction of the loop time. 1 is fully utilized, 0 is fully idle.',
-    collect: () => {
-      const endELU = eventLoopUtilization()
-      const result = eventLoopUtilization(endELU, startELU).utilization
-      eluMetric.set(result)
-      startELU = endELU
-    },
-    registers: [registry]
-  })
-  registry.registerMetric(eluMetric)
-
   let previousIdleTime = 0
   let previousTotalTime = 0
   const cpuMetric = new Gauge({
@@ -122,14 +167,16 @@ export function collectEluMetric (registry) {
       let idleTime = 0
       let totalTime = 0
 
-      cpus.forEach(cpu => {
-        for (const type in cpu.times) {
-          totalTime += cpu.times[type]
+      for (let i = 0; i < cpus.length; i++) {
+        const cpu = cpus[i]
+        const times = cpu.times
+        for (const type in times) {
+          totalTime += times[type]
           if (type === 'idle') {
-            idleTime += cpu.times[type]
+            idleTime += times[type]
           }
         }
-      })
+      }
 
       const idleDiff = idleTime - previousIdleTime
       const totalDiff = totalTime - previousTotalTime
@@ -146,6 +193,127 @@ export function collectEluMetric (registry) {
   registry.registerMetric(cpuMetric)
 }
 
+// Collect only the ELU metric (thread-specific)
+export function collectEluMetric (registry) {
+  if (ensureMetricsGroup(registry, 'elu')) {
+    return
+  }
+
+  let startELU = eventLoopUtilization()
+  const eluMetric = new Gauge({
+    name: 'nodejs_eventloop_utilization',
+    help: 'The event loop utilization as a fraction of the loop time. 1 is fully utilized, 0 is fully idle.',
+    collect: () => {
+      const endELU = eventLoopUtilization()
+      const result = eventLoopUtilization(endELU, startELU).utilization
+      eluMetric.set(result)
+      startELU = endELU
+    },
+    registers: [registry]
+  })
+  registry.registerMetric(eluMetric)
+}
+
+// Legacy function that collects both ELU and system CPU (for backward compatibility)
+export function collectEluAndSystemCpuMetrics (registry) {
+  collectEluMetric(registry)
+  collectSystemCpuMetric(registry)
+}
+
+// Collect process-level metrics (same across all workers, should run in main thread only)
+export function collectProcessMetrics (registry) {
+  if (ensureMetricsGroup(registry, 'process-level')) {
+    return
+  }
+
+  const config = {}
+
+  // Process CPU metrics
+  processCpuTotal(registry, config)
+  // Process start time
+  processStartTime(registry, config)
+  // Resident memory (RSS)
+  osMemoryHeap(registry, config)
+  // Open file descriptors (Linux)
+  processOpenFileDescriptors(registry, config)
+  // Max file descriptors (Linux)
+  processMaxFileDescriptors(registry, config)
+  // Node.js version info
+  version(registry, config)
+  // System CPU percent usage (os.cpus() based)
+  collectSystemCpuMetric(registry)
+}
+
+// Collect thread-specific metrics (different per worker)
+export async function collectThreadMetrics (applicationId, workerId, metricsConfig = {}, registry = undefined) {
+  if (!registry) {
+    registry = new Registry()
+  }
+
+  const labels = { ...metricsConfig.labels }
+
+  // Use the configured label name
+  const labelName = metricsConfig.idLabel || 'applicationId'
+  labels[labelName] = applicationId
+
+  if (workerId >= 0) {
+    labels.workerId = workerId
+  }
+  registry.setDefaultLabels(labels)
+
+  if (metricsConfig.defaultMetrics) {
+    if (!ensureMetricsGroup(registry, 'thread-level')) {
+      const config = { eventLoopMonitoringPrecision: 10 }
+
+      // Thread-specific metrics only
+      heapSizeAndUsed(registry, config)
+      heapSpacesSizeAndUsed(registry, config)
+      eventLoopLag(registry, config)
+      gc(registry, config)
+      processHandles(registry, config)
+      processRequests(registry, config)
+      if (typeof process.getActiveResourcesInfo === 'function') {
+        processResources(registry, config)
+      }
+    }
+
+    // Event loop utilization (thread-specific)
+    collectEluMetric(registry)
+    // Thread CPU metrics
+    await collectThreadCpuMetrics(registry)
+  }
+
+  if (metricsConfig.httpMetrics && !ensureMetricsGroup(registry, 'http')) {
+    collectHttpMetrics(registry, {
+      customLabels: ['telemetry_id'],
+      getCustomLabels: req => {
+        const telemetryId = req.headers?.['x-plt-telemetry-id'] ?? 'unknown'
+        return { telemetry_id: telemetryId }
+      },
+      histogram: {
+        name: 'http_request_all_duration_seconds',
+        help: 'request duration in seconds summary for all requests',
+        collect: function () {
+          process.nextTick(() => this.reset())
+        }
+      },
+      summary: {
+        name: 'http_request_all_summary_seconds',
+        help: 'request duration in seconds histogram for all requests',
+        collect: function () {
+          process.nextTick(() => this.reset())
+        }
+      }
+    })
+  }
+
+  return {
+    registry,
+    otlpBridge: null
+  }
+}
+
+// Original function for backward compatibility (collects all metrics)
 export async function collectMetrics (applicationId, workerId, metricsConfig = {}, registry = undefined) {
   if (!registry) {
     registry = new Registry()
@@ -168,6 +336,7 @@ export async function collectMetrics (applicationId, workerId, metricsConfig = {
     }
 
     collectEluMetric(registry)
+    collectSystemCpuMetric(registry)
     await collectThreadCpuMetrics(registry)
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/metrics",
-  "version": "3.30.0",
+  "version": "3.31.0",
   "description": "Platformatic Capability Metrics",
   "main": "index.js",
   "type": "module",