318 lines
8.6 KiB
JavaScript
318 lines
8.6 KiB
JavaScript
/**
|
|
* Opt-in Docker / container collector (Phase 3 spike).
|
|
*
|
|
* Enable: PEARDATA_DOCKER=1
|
|
* Discovers containers via cgroup v2 scopes (docker-*.scope / libpod-*.scope)
|
|
* and optionally Docker Engine API over a unix socket for names.
|
|
*
|
|
* Emits:
|
|
* docker.containers — running / total counts
|
|
* docker.cpu.<shortId> — % of one host CPU
|
|
* docker.mem.<shortId> — usage / limit MiB
|
|
*/
|
|
import fs from 'fs'
|
|
import path from 'path'
|
|
import http from 'http'
|
|
import os from 'os'
|
|
import { EventEmitter } from 'events'
|
|
import {
|
|
SAMPLE_INTERVAL_MS,
|
|
registerChart,
|
|
DOCKER_CONTAINERS_CHART,
|
|
makeDockerCpuChart,
|
|
makeDockerMemChart,
|
|
} from '../../../shared/metrics.js'
|
|
import logger from '../../utils/logger.js'
|
|
|
|
const log = logger.child('docker')
|
|
|
|
export function isDockerCollectorEnabled() {
|
|
const v = process.env.PEARDATA_DOCKER
|
|
return v === '1' || v === 'on' || v === 'true'
|
|
}
|
|
|
|
function readFile(p) {
|
|
try {
|
|
return fs.readFileSync(p, 'utf8')
|
|
} catch {
|
|
return null
|
|
}
|
|
}
|
|
|
|
function bytesToMiB(n) {
|
|
return n / (1024 * 1024)
|
|
}
|
|
|
|
function hostCpus() {
|
|
try {
|
|
return os.cpus().length || 1
|
|
} catch {
|
|
return 1
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @returns {Array<{ id: string, shortId: string, name: string, cgroupPath: string }>}
|
|
*/
|
|
export function discoverCgroupContainers() {
|
|
const roots = [
|
|
'/sys/fs/cgroup/system.slice',
|
|
'/sys/fs/cgroup/docker',
|
|
'/sys/fs/cgroup',
|
|
]
|
|
/** @type {Map<string, { id: string, shortId: string, name: string, cgroupPath: string }>} */
|
|
const found = new Map()
|
|
|
|
for (const root of roots) {
|
|
let entries
|
|
try {
|
|
entries = fs.readdirSync(root, { withFileTypes: true })
|
|
} catch {
|
|
continue
|
|
}
|
|
for (const ent of entries) {
|
|
if (!ent.isDirectory()) continue
|
|
const name = ent.name
|
|
let id = null
|
|
let label = name
|
|
const dockerScope = name.match(/^docker-([0-9a-f]{12,64})\.scope$/i)
|
|
const podmanScope = name.match(/^libpod-([0-9a-f]{12,64})\.scope$/i)
|
|
if (dockerScope) {
|
|
id = dockerScope[1].toLowerCase()
|
|
label = id.slice(0, 12)
|
|
} else if (podmanScope) {
|
|
id = podmanScope[1].toLowerCase()
|
|
label = id.slice(0, 12)
|
|
} else if (/^[0-9a-f]{64}$/i.test(name) && root.endsWith('/docker')) {
|
|
id = name.toLowerCase()
|
|
label = id.slice(0, 12)
|
|
}
|
|
if (!id || found.has(id)) continue
|
|
const cgroupPath = path.join(root, name)
|
|
if (
|
|
!readFile(path.join(cgroupPath, 'cpu.stat')) &&
|
|
!readFile(path.join(cgroupPath, 'cpuacct.usage'))
|
|
) {
|
|
continue
|
|
}
|
|
found.set(id, {
|
|
id,
|
|
shortId: id.slice(0, 12),
|
|
name: label,
|
|
cgroupPath,
|
|
})
|
|
}
|
|
}
|
|
return [...found.values()]
|
|
}
|
|
|
|
/**
|
|
* @param {string} cgroupPath
|
|
* @returns {{ usageNs: number }|null}
|
|
*/
|
|
export function readCgroupCpu(cgroupPath) {
|
|
const raw = readFile(path.join(cgroupPath, 'cpu.stat'))
|
|
if (raw) {
|
|
/** @type {Record<string, number>} */
|
|
const m = {}
|
|
for (const line of raw.split('\n')) {
|
|
const [k, v] = line.trim().split(/\s+/)
|
|
if (k && v != null) m[k] = Number(v)
|
|
}
|
|
if (m.usage_usec != null) {
|
|
return { usageNs: m.usage_usec * 1000 }
|
|
}
|
|
}
|
|
const acct = readFile(path.join(cgroupPath, 'cpuacct.usage'))
|
|
if (acct) {
|
|
const usageNs = Number(acct.trim())
|
|
if (Number.isFinite(usageNs)) return { usageNs }
|
|
}
|
|
return null
|
|
}
|
|
|
|
/**
|
|
* @param {string} cgroupPath
|
|
* @returns {{ usage: number, limit: number }|null} bytes
|
|
*/
|
|
export function readCgroupMemory(cgroupPath) {
|
|
const current = readFile(path.join(cgroupPath, 'memory.current'))
|
|
if (current) {
|
|
const usage = Number(current.trim())
|
|
let limit = Number(readFile(path.join(cgroupPath, 'memory.max'))?.trim())
|
|
if (!Number.isFinite(limit) || limit <= 0 || limit > 1e15) limit = 0
|
|
if (Number.isFinite(usage)) return { usage, limit }
|
|
}
|
|
const usageFile = readFile(path.join(cgroupPath, 'memory.usage_in_bytes'))
|
|
if (usageFile) {
|
|
const usage = Number(usageFile.trim())
|
|
const limitRaw = readFile(path.join(cgroupPath, 'memory.limit_in_bytes'))
|
|
let limit = limitRaw ? Number(limitRaw.trim()) : 0
|
|
if (limit > 1e15) limit = 0
|
|
if (Number.isFinite(usage)) return { usage, limit }
|
|
}
|
|
return null
|
|
}
|
|
|
|
/**
|
|
* @param {string} socketPath
|
|
* @returns {Promise<Map<string, string>>} id → name
|
|
*/
|
|
export function fetchDockerNames(socketPath) {
|
|
return new Promise((resolve) => {
|
|
const req = http.request(
|
|
{
|
|
socketPath,
|
|
path: '/containers/json?all=1',
|
|
method: 'GET',
|
|
timeout: 2000,
|
|
},
|
|
(res) => {
|
|
let body = ''
|
|
res.on('data', (c) => {
|
|
body += c
|
|
})
|
|
res.on('end', () => {
|
|
try {
|
|
const list = JSON.parse(body)
|
|
/** @type {Map<string, string>} */
|
|
const map = new Map()
|
|
for (const c of list) {
|
|
const id = String(c.Id || '').toLowerCase()
|
|
const name = String((c.Names && c.Names[0]) || id)
|
|
.replace(/^\//, '')
|
|
.slice(0, 64)
|
|
if (id) map.set(id, name)
|
|
if (id.length >= 12) map.set(id.slice(0, 12), name)
|
|
}
|
|
resolve(map)
|
|
} catch {
|
|
resolve(new Map())
|
|
}
|
|
})
|
|
}
|
|
)
|
|
req.on('error', () => resolve(new Map()))
|
|
req.on('timeout', () => {
|
|
req.destroy()
|
|
resolve(new Map())
|
|
})
|
|
req.end()
|
|
})
|
|
}
|
|
|
|
export class DockerCollector extends EventEmitter {
|
|
constructor(opts = {}) {
|
|
super()
|
|
this.intervalMs = opts.intervalMs || Number(process.env.PEARDATA_SAMPLE_MS) || SAMPLE_INTERVAL_MS
|
|
this.socketPath = opts.socketPath || process.env.PEARDATA_DOCKER_SOCKET || '/var/run/docker.sock'
|
|
this._timer = null
|
|
/** @type {Map<string, { usageNs: number, wallMs: number }>} */
|
|
this._prevCpu = new Map()
|
|
/** @type {Map<string, string>} */
|
|
this._names = new Map()
|
|
this._nameRefreshAt = 0
|
|
}
|
|
|
|
start() {
|
|
if (this._timer) return
|
|
registerChart(DOCKER_CONTAINERS_CHART)
|
|
log.info('Docker collector started', { socket: this.socketPath })
|
|
this._tick()
|
|
this._timer = setInterval(() => this._tick(), this.intervalMs)
|
|
if (typeof this._timer.unref === 'function') this._timer.unref()
|
|
}
|
|
|
|
stop() {
|
|
if (this._timer) {
|
|
clearInterval(this._timer)
|
|
this._timer = null
|
|
}
|
|
}
|
|
|
|
async _refreshNames() {
|
|
const now = Date.now()
|
|
if (now - this._nameRefreshAt < 30_000) return
|
|
this._nameRefreshAt = now
|
|
try {
|
|
if (fs.existsSync(this.socketPath)) {
|
|
this._names = await fetchDockerNames(this.socketPath)
|
|
}
|
|
} catch {
|
|
// ignore
|
|
}
|
|
}
|
|
|
|
async _tick() {
|
|
try {
|
|
await this._refreshNames()
|
|
const containers = discoverCgroupContainers()
|
|
const ts = Date.now()
|
|
const wallMs = ts
|
|
const ncpu = hostCpus()
|
|
/** @type {Array<{ chart: string, context: string, ts: number, values: Record<string, number|null> }>} */
|
|
const batch = [
|
|
{
|
|
chart: 'docker.containers',
|
|
context: 'docker.containers',
|
|
ts,
|
|
values: { running: containers.length, total: containers.length },
|
|
},
|
|
]
|
|
|
|
for (const c of containers) {
|
|
const display =
|
|
this._names.get(c.id) || this._names.get(c.shortId) || c.name || c.shortId
|
|
const cpuDef = makeDockerCpuChart(c.shortId, display)
|
|
const memDef = makeDockerMemChart(c.shortId, display)
|
|
registerChart(cpuDef)
|
|
registerChart(memDef)
|
|
|
|
const cpu = readCgroupCpu(c.cgroupPath)
|
|
let usagePct = 0
|
|
if (cpu) {
|
|
const prev = this._prevCpu.get(c.id)
|
|
if (prev && wallMs > prev.wallMs) {
|
|
const dNs = cpu.usageNs - prev.usageNs
|
|
const dWallNs = (wallMs - prev.wallMs) * 1e6
|
|
if (dNs >= 0 && dWallNs > 0) {
|
|
usagePct = Math.min(100 * ncpu, (dNs / dWallNs) * 100)
|
|
}
|
|
}
|
|
this._prevCpu.set(c.id, { usageNs: cpu.usageNs, wallMs })
|
|
}
|
|
|
|
batch.push({
|
|
chart: cpuDef.id,
|
|
context: 'docker.cpu',
|
|
ts,
|
|
values: { usage: usagePct },
|
|
})
|
|
|
|
const mem = readCgroupMemory(c.cgroupPath)
|
|
batch.push({
|
|
chart: memDef.id,
|
|
context: 'docker.mem',
|
|
ts,
|
|
values: {
|
|
usage: mem ? bytesToMiB(mem.usage) : 0,
|
|
limit: mem && mem.limit ? bytesToMiB(mem.limit) : null,
|
|
},
|
|
})
|
|
}
|
|
|
|
this.emit('samples', batch)
|
|
} catch (err) {
|
|
log.warn('Docker tick failed', { error: err.message })
|
|
}
|
|
}
|
|
}
|
|
|
|
/** @type {DockerCollector|null} */
|
|
let singleton = null
|
|
|
|
export function getDockerCollector() {
|
|
if (!singleton) singleton = new DockerCollector()
|
|
return singleton
|
|
}
|