@platformatic/metrics 3.54.0 → 3.56.0

package/index.js

@@ -1,4 +1,5 @@
 import collectHttpMetrics from '@platformatic/http-metrics'
+import { subscribe, unsubscribe } from 'node:diagnostics_channel'
 import os from 'node:os'
 import { performance } from 'node:perf_hooks'
 import client from '@platformatic/prom-client'
@@ -21,9 +22,17 @@ import gc from '@platformatic/prom-client/lib/metrics/gc.js'
 export * as client from '@platformatic/prom-client'
 
 const { eventLoopUtilization } = performance
-const { Registry, Gauge, Counter, collectDefaultMetrics } = client
+const { Registry, Gauge, Counter, Histogram, collectDefaultMetrics } = client
 
 export const kMetricsGroups = Symbol('plt.metrics.MetricsGroups')
+const kMetricsCleanups = Symbol('plt.metrics.MetricsCleanups')
+const kHttpClientRequestStart = Symbol('plt.metrics.HttpClientRequestStart')
+const kHttpClientRequestStatusCode = Symbol('plt.metrics.HttpClientRequestStatusCode')
+
+function getRegistrySet (registry, key) {
+  registry[key] ??= new Set()
+  return registry[key]
+}
 
 // Process-level metrics (same across all workers, collect once in main thread)
 export const PROCESS_LEVEL_METRICS = [
@@ -69,8 +78,7 @@ export const THREAD_LEVEL_METRICS = [
 ]
 
 export function registerMetricsGroup (registry, group) {
-  registry[kMetricsGroups] ??= new Set()
-  registry[kMetricsGroups].add(group)
+  getRegistrySet(registry, kMetricsGroups).add(group)
 }
 
 export function hasMetricsGroup (registry, group) {
@@ -80,23 +88,141 @@ export function hasMetricsGroup (registry, group) {
 // Use this method when dealing with metrics registration in async functions.
 // This will ensure that the group is registered only once.
 export function ensureMetricsGroup (registry, group) {
-  registry[kMetricsGroups] ??= new Set()
+  const groups = getRegistrySet(registry, kMetricsGroups)
 
-  if (registry[kMetricsGroups]?.has(group)) {
+  if (groups.has(group)) {
     return true
   }
 
-  registry[kMetricsGroups].add(group)
+  groups.add(group)
   return false
 }
 
+export function registerMetricsCleanup (registry, cleanup) {
+  getRegistrySet(registry, kMetricsCleanups).add(cleanup)
+}
+
 export function clearRegistry (registry) {
+  if (registry[kMetricsCleanups]) {
+    for (const cleanup of registry[kMetricsCleanups]) {
+      cleanup()
+    }
+    registry[kMetricsCleanups].clear()
+  }
+
   registry.clear()
   if (registry[kMetricsGroups]) {
     registry[kMetricsGroups].clear()
   }
 }
 
+function getHttpClientRequestOrigin (request) {
+  return typeof request.origin === 'string' && request.origin.length > 0 ? request.origin : 'unknown'
+}
+
+function getHttpClientErrorType (error) {
+  return error ? String(error.code ?? error.name ?? 'unknown') : ''
+}
+
+function isHttpClientMetricsEnabled (metricsConfig) {
+  return metricsConfig.httpClientMetrics === true || metricsConfig.httpClientMetrics === 'true'
+}
+
+export function collectHttpClientMetrics (registry) {
+  if (ensureMetricsGroup(registry, 'http-client')) {
+    return
+  }
+
+  const requestDurationMetric = new Histogram({
+    name: 'http_client_request_duration_seconds',
+    help: 'outgoing HTTP client request duration in seconds',
+    labelNames: ['method', 'status_code', 'dispatcher_stats_url', 'error_type'],
+    collect: function () {
+      process.nextTick(() => this.reset())
+    },
+    registers: [registry]
+  })
+
+  const onRequestCreate = ({ request }) => {
+    if (request && typeof request === 'object') {
+      request[kHttpClientRequestStart] = performance.now()
+    }
+  }
+
+  const onRequestHeaders = ({ request, response }) => {
+    if (request && typeof request === 'object') {
+      request[kHttpClientRequestStatusCode] = response?.statusCode ?? ''
+    }
+  }
+
+  const observeRequest = ({ request, response, error }) => {
+    if (!request || typeof request !== 'object') {
+      return
+    }
+
+    const start = request[kHttpClientRequestStart]
+    if (start === undefined) {
+      return
+    }
+
+    const duration = (performance.now() - start) / 1000
+    const method = request.method ?? 'unknown'
+    const statusCode = response?.statusCode ?? request[kHttpClientRequestStatusCode] ?? ''
+    const dispatcherStatsUrl = getHttpClientRequestOrigin(request)
+    const errorType = getHttpClientErrorType(error)
+
+    delete request[kHttpClientRequestStart]
+    delete request[kHttpClientRequestStatusCode]
+
+    requestDurationMetric.observe({
+      method,
+      status_code: statusCode,
+      dispatcher_stats_url: dispatcherStatsUrl,
+      error_type: errorType
+    }, duration)
+  }
+
+  subscribe('undici:request:create', onRequestCreate)
+  subscribe('undici:request:headers', onRequestHeaders)
+  subscribe('undici:request:trailers', observeRequest)
+  subscribe('undici:request:error', observeRequest)
+
+  registerMetricsCleanup(registry, () => {
+    unsubscribe('undici:request:create', onRequestCreate)
+    unsubscribe('undici:request:headers', onRequestHeaders)
+    unsubscribe('undici:request:trailers', observeRequest)
+    unsubscribe('undici:request:error', observeRequest)
+  })
+}
+
+function collectHttpServerMetrics (registry, metricsConfig) {
+  if (ensureMetricsGroup(registry, 'http')) {
+    return
+  }
+
+  // Build custom labels configuration
+  const { customLabels, getCustomLabels } = buildCustomLabelsConfig(metricsConfig.httpCustomLabels)
+
+  collectHttpMetrics(registry, {
+    customLabels,
+    getCustomLabels,
+    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())
+      }
+    }
+  })
+}
+
 export async function collectThreadCpuMetrics (registry) {
   if (ensureMetricsGroup(registry, 'threadCpuUsage')) {
     return
@@ -283,28 +409,11 @@ export async function collectThreadMetrics (applicationId, workerId, metricsConf
     await collectThreadCpuMetrics(registry)
   }
 
-  if (metricsConfig.httpMetrics && !ensureMetricsGroup(registry, 'http')) {
-    // Build custom labels configuration
-    const { customLabels, getCustomLabels } = buildCustomLabelsConfig(metricsConfig.httpCustomLabels)
-
-    collectHttpMetrics(registry, {
-      customLabels,
-      getCustomLabels,
-      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())
-        }
-      }
-    })
+  if (metricsConfig.httpMetrics) {
+    collectHttpServerMetrics(registry, metricsConfig)
+    if (isHttpClientMetricsEnabled(metricsConfig)) {
+      collectHttpClientMetrics(registry)
+    }
   }
 
   return {
@@ -365,28 +474,11 @@ export async function collectMetrics (applicationId, workerId, metricsConfig = {
     await collectThreadCpuMetrics(registry)
   }
 
-  if (metricsConfig.httpMetrics && !ensureMetricsGroup(registry, 'http')) {
-    // Build custom labels configuration
-    const { customLabels, getCustomLabels } = buildCustomLabelsConfig(metricsConfig.httpCustomLabels)
-
-    collectHttpMetrics(registry, {
-      customLabels,
-      getCustomLabels,
-      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())
-        }
-      }
-    })
+  if (metricsConfig.httpMetrics) {
+    collectHttpServerMetrics(registry, metricsConfig)
+    if (isHttpClientMetricsEnabled(metricsConfig)) {
+      collectHttpClientMetrics(registry)
+    }
   }
 
   return {

package/package.json

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

package/test/helper.js

@@ -123,7 +123,8 @@ export const expectedMetrics = [
   },
   {
     name: 'http_request_all_duration_seconds',
-    type: 'histogram'
+    type: 'histogram',
+    buckets: ['0.005', '0.01', '0.025', '0.05', '0.1', '0.25', '0.5', '1', '2.5', '5', '10']
   }
 ]
 
@@ -141,19 +142,24 @@ function assertSummary (metrics, metric) {
 }
 
 function assertHistogram (metrics, metric) {
-  ok(metrics.includes('http_request_all_duration_seconds_bucket{le="0.005"'))
-  ok(metrics.includes('http_request_all_duration_seconds_bucket{le="0.01"'))
-  ok(metrics.includes('http_request_all_duration_seconds_bucket{le="0.025"'))
-  ok(metrics.includes('http_request_all_duration_seconds_bucket{le="0.05"'))
-  ok(metrics.includes('http_request_all_duration_seconds_bucket{le="0.1"'))
-  ok(metrics.includes('http_request_all_duration_seconds_bucket{le="0.25"'))
-  ok(metrics.includes('http_request_all_duration_seconds_bucket{le="0.5"'))
-  ok(metrics.includes('http_request_all_duration_seconds_bucket{le="1"'))
-  ok(metrics.includes('http_request_all_duration_seconds_bucket{le="2.5"'))
-  ok(metrics.includes('http_request_all_duration_seconds_bucket{le="5"'))
-  ok(metrics.includes('http_request_all_duration_seconds_bucket{le="10"'))
-  ok(metrics.includes('http_request_all_duration_seconds_sum{'))
-  ok(metrics.includes('http_request_all_duration_seconds_count{'))
+  const lines = metrics.split('\n')
+  const bucketLines = lines.filter(line => line.startsWith(`${metric.name}_bucket{`))
+
+  if (!metric.buckets) {
+    return
+  }
+
+  ok(bucketLines.length > 0, `Metric ${metric.name} buckets not found`)
+
+  for (const bucket of metric.buckets ?? []) {
+    ok(
+      bucketLines.some(line => line.includes(`le="${bucket}"`)),
+      `Metric ${metric.name} bucket ${bucket} not found`
+    )
+  }
+
+  ok(lines.some(line => line.startsWith(`${metric.name}_sum{`)), `Metric ${metric.name} sum not found`)
+  ok(lines.some(line => line.startsWith(`${metric.name}_count{`)), `Metric ${metric.name} count not found`)
 }
 
 export function assertMetric (metrics, metric) {

package/test/index.test.js

@@ -1,6 +1,7 @@
 import assert from 'node:assert'
+import { channel } from 'node:diagnostics_channel'
 import { test } from 'node:test'
-import { buildCustomLabelsConfig, client, collectMetrics } from '../index.js'
+import { buildCustomLabelsConfig, clearRegistry, client, collectMetrics } from '../index.js'
 
 const nextTick = () => new Promise(resolve => process.nextTick(resolve))
 
@@ -58,21 +59,88 @@ test('workerId is NOT included in labels when negative', async () => {
   assert.strictEqual(values[0].labels.workerId, undefined)
 })
 
-test('httpMetrics creates histogram and summary with collect functions', async () => {
+test('httpMetrics creates histogram and summary with collect functions', async t => {
   const result = await collectMetrics('test-service', 1, { httpMetrics: true })
+  t.after(() => clearRegistry(result.registry))
   const metrics = await result.registry.getMetricsAsJSON()
 
   const histogram = metrics.find(m => m.name === 'http_request_all_duration_seconds')
   const summary = metrics.find(m => m.name === 'http_request_all_summary_seconds')
+  const clientHistogram = metrics.find(m => m.name === 'http_client_request_duration_seconds')
 
   assert.ok(histogram, 'histogram metric should exist')
   assert.ok(summary, 'summary metric should exist')
+  assert.strictEqual(clientHistogram, undefined, 'client histogram metric should not exist by default')
   assert.strictEqual(histogram.help, 'request duration in seconds summary for all requests')
   assert.strictEqual(summary.help, 'request duration in seconds histogram for all requests')
 })
 
-test('httpMetrics histogram resets after metric collection', async () => {
+test('httpMetrics creates HTTP client histogram when enabled', async t => {
+  const result = await collectMetrics('test-service', 1, { httpMetrics: true, httpClientMetrics: true })
+  t.after(() => clearRegistry(result.registry))
+  const metrics = await result.registry.getMetricsAsJSON()
+
+  const clientHistogram = metrics.find(m => m.name === 'http_client_request_duration_seconds')
+
+  assert.ok(clientHistogram, 'client histogram metric should exist')
+  assert.strictEqual(clientHistogram.help, 'outgoing HTTP client request duration in seconds')
+})
+
+test('httpMetrics observes outgoing HTTP client request durations', async t => {
+  const result = await collectMetrics('test-service', 2, { httpMetrics: true, httpClientMetrics: true })
+  t.after(() => clearRegistry(result.registry))
+
+  const request = {
+    method: 'POST',
+    origin: 'https://api.example.com:8443',
+    path: '/v1/resources'
+  }
+
+  channel('undici:request:create').publish({ request })
+  channel('undici:request:headers').publish({ request, response: { statusCode: 201 } })
+  channel('undici:request:trailers').publish({ request })
+
+  const metrics = await result.registry.getMetricsAsJSON()
+  const histogram = metrics.find(m => m.name === 'http_client_request_duration_seconds')
+  const count = histogram.values.find(v => v.metricName === 'http_client_request_duration_seconds_count')
+
+  assert.strictEqual(count.value, 1)
+  assert.strictEqual(count.labels.applicationId, 'test-service')
+  assert.strictEqual(count.labels.workerId, 2)
+  assert.strictEqual(count.labels.method, 'POST')
+  assert.strictEqual(count.labels.status_code, 201)
+  assert.strictEqual(count.labels.dispatcher_stats_url, 'https://api.example.com:8443')
+  assert.strictEqual(count.labels.error_type, '')
+})
+
+test('httpMetrics observes outgoing HTTP client request errors', async t => {
+  const result = await collectMetrics('test-service', 3, { httpMetrics: true, httpClientMetrics: true })
+  t.after(() => clearRegistry(result.registry))
+
+  const request = {
+    method: 'GET',
+    origin: 'http://dependency.internal',
+    path: '/health'
+  }
+  const error = Object.assign(new Error('socket closed'), { code: 'UND_ERR_SOCKET' })
+
+  channel('undici:request:create').publish({ request })
+  channel('undici:request:error').publish({ request, error })
+
+  const metrics = await result.registry.getMetricsAsJSON()
+  const histogram = metrics.find(m => m.name === 'http_client_request_duration_seconds')
+  const count = histogram.values.find(v => v.metricName === 'http_client_request_duration_seconds_count')
+
+  assert.strictEqual(count.value, 1)
+  assert.strictEqual(count.labels.method, 'GET')
+  assert.strictEqual(count.labels.status_code, '')
+  assert.strictEqual(count.labels.dispatcher_stats_url, 'http://dependency.internal')
+  assert.strictEqual(count.labels.error_type, 'UND_ERR_SOCKET')
+})
+
+test('httpMetrics histogram resets after metric collection', async t => {
   const result = await collectMetrics('test-service', 1, { httpMetrics: true })
+  t.after(() => clearRegistry(result.registry))
 
   // Get the histogram metric using the public API
   const histogramMetric = result.registry.getSingleMetric('http_request_all_duration_seconds')
@@ -99,8 +167,9 @@ test('httpMetrics histogram resets after metric collection', async () => {
   assert.strictEqual(count?.value || 0, 0, 'histogram count should be reset to 0')
 })
 
-test('httpMetrics summary resets after metric collection', async () => {
+test('httpMetrics summary resets after metric collection', async t => {
   const result = await collectMetrics('test-service', 1, { httpMetrics: true })
+  t.after(() => clearRegistry(result.registry))
 
   // Get the summary metric using the public API
   const summaryMetric = result.registry.getSingleMetric('http_request_all_summary_seconds')
@@ -203,7 +272,7 @@ test('buildCustomLabelsConfig handles case-insensitive header names', () => {
   assert.deepStrictEqual(labels, { domain: 'example.com' })
 })
 
-test('httpMetrics with custom labels configuration', async () => {
+test('httpMetrics with custom labels configuration', async t => {
   const httpCustomLabels = [
     { name: 'domain', header: 'x-forwarded-host', default: 'localhost' }
   ]
@@ -212,6 +281,7 @@ test('httpMetrics with custom labels configuration', async () => {
     httpMetrics: true,
     httpCustomLabels
   })
+  t.after(() => clearRegistry(result.registry))
 
   const metrics = await result.registry.getMetricsAsJSON()
   const histogram = metrics.find(m => m.name === 'http_request_all_duration_seconds')
@@ -230,8 +300,9 @@ test('httpMetrics with custom labels configuration', async () => {
   assert.ok(hasCustomLabel, 'custom domain label should be present in histogram values')
 })
 
-test('httpMetrics does not include telemetry_id label by default', async () => {
+test('httpMetrics does not include telemetry_id label by default', async t => {
   const result = await collectMetrics('test-service', 1, { httpMetrics: true })
+  t.after(() => clearRegistry(result.registry))
 
   const histogramMetric = result.registry.getSingleMetric('http_request_all_duration_seconds')
   assert.ok(histogramMetric, 'histogram metric should exist')