feat: which logs a host writes, and who writes each (4.30.0)
driver / standard (pull_request) Failing after 19s
driver / lint (pull_request) Successful in 20s
driver / types (pull_request) Successful in 1m14s
driver / test (3.13) (pull_request) Successful in 1m11s
driver / test (3.12) (pull_request) Successful in 1m18s
driver / lowest (pull_request) Successful in 38s
driver / build (pull_request) Successful in 33s
driver / security (pull_request) Successful in 1m14s
CI / driver (pull_request) Failing after 2m45s
driver / publish (pull_request) Skipped

LogSourcesMixin.get_log_sources() reads, in one sh -c call as root, the
units journald holds entries for, the log files running processes hold
open (/proc/<pid>/fd: *.log, *.log.N, anything under /var/log) with size
and last write from stat -L on the descriptor, and the engine's own file
of each container's output as that container's stream. Each file names
the service or container of its first writer from /proc/<pid>/cgroup; a
file a container writes keeps the container's own path.

journald's store, deleted files and a database's write-ahead log
(LevelDB's 000004.log) are left out. Without root it reads again and says
so (attributed: false); a host whose find cannot list open files (busybox)
raises LogSourcesUnavailable rather than reading as no files.

Refs NetOrk/netork#2049
This commit is contained in:
christianmanivong committed 2026-11-05 00:24:24 +01:00
1 parent dacd10fcce
commit 5daba5d37c
7 files changed
+545 -1

No files matched your search

+11
View File
@@ -50,6 +50,7 @@ instead of being restated on every role that happens to need it:
* :class:`~napalm_device_types.kernel.KernelFactsMixin`
* :class:`~napalm_device_types.listening.ListeningSocketsMixin`
* :class:`~napalm_device_types.local_accounts.LocalAccountsMixin`
* :class:`~napalm_device_types.log_sources.LogSourcesMixin`
* :class:`~napalm_device_types.host_firewall.HostFirewallMixin`
* :class:`~napalm_device_types.mac_acl.MacAclMixin`
* :class:`~napalm_device_types.nat_vpn.NatVpnMixin`
@@ -166,6 +167,12 @@ from napalm_device_types.local_accounts import (
LocalAccountDict,
LocalAccountsMixin,
)
from napalm_device_types.log_sources import (
LOG_SOURCES_COMMAND,
LogSourcesMixin,
LogSourcesUnavailable,
parse_log_sources,
)
from napalm_device_types.mac_acl import MacAclMixin
from napalm_device_types.management_controller import ManagementControllerDriver
from napalm_device_types.media import MediaDriver
@@ -398,6 +405,10 @@ __all__ = [
"parse_host_firewall",
"ListeningSocketsMixin",
"ListeningSocketsUnavailable",
"LOG_SOURCES_COMMAND",
"LogSourcesMixin",
"LogSourcesUnavailable",
"parse_log_sources",
"parse_listening_sockets",
"LLDPCTL_KEYVALUE_COMMAND",
"LldpNeighborDict",
+236
View File
@@ -0,0 +1,236 @@
"""Log sources: which logs a host writes, and who writes each of them.
Before anything can watch a host's logs -- a person, CrowdSec, a syslog
forwarder -- it has to know which logs there are. That is read the same way on
every Linux host, so the command and its parse live here once, and a driver
only carries the command across (NetOrk/netork#2049).
**Three kinds.** journald names every unit it holds entries for
(``journalctl -F _SYSTEMD_UNIT``); only services count, not login sessions.
``/proc/<pid>/fd`` shows the files running processes hold open, a log being a
``*.log`` / ``*.log.N`` file or anything under ``/var/log``; ``stat -L`` on the
descriptor gives its size and last write, also for a file inside a container,
whose path is the container's own. The engine's own file of a container's
output (``/var/lib/docker/containers/<id>/…``) is that container's stream, not
a file of ``dockerd``.
**Who writes it.** ``/proc/<pid>/cgroup`` says which systemd service or
container the first process holding a file runs in, as for listening sockets
(:mod:`napalm_device_types.listening`). journald's own files, files already
deleted and a database's write-ahead log (LevelDB's ``000004.log``) are left out.
**One round trip, root, and without it.** As for listening sockets the script
goes as one ``sh -c`` argument. Without root only the login user's processes
show their files; the command then runs again unprivileged, and the reading
says it is not ``attributed``. A report whose end is missing raises: a list cut
short must never read as logs that went away, and so must a host whose
``find`` cannot list open files (busybox): it raises
:class:`LogSourcesUnavailable`.
"""
from __future__ import annotations
import re
from datetime import UTC, datetime
from shlex import quote
from typing import TYPE_CHECKING
from napalm_device_types.listening import _cgroup_paths, _container, _sections, _unit
from napalm_device_types.models import LogSourceDict, LogSourcesDict
from napalm_device_types.terminal import strip_terminal_codes
_BEGIN = "LOGS_BEGIN"
_END = "LOGS_END"
#: One line, POSIX ``sh`` with GNU ``find`` (``-lname``, ``-printf``), read-only.
#: The frame markers are printed in two halves so that a transport which echoes
#: the command does not show them early. ``-printf '%p %l'`` puts the descriptor
#: before its target, so a target with a space in it stays whole.
LOG_SOURCES_COMMAND = (
"PATH=$PATH:/usr/sbin:/sbin; "
"printf '%s%s\\n' LOGS_ BEGIN; "
"if [ -d /run/systemd/system ] && command -v journalctl >/dev/null 2>&1; then "
"j=journalctl; command -v timeout >/dev/null 2>&1 && j='timeout 30 journalctl'; "
"echo '[journald]'; $j -F _SYSTEMD_UNIT 2>/dev/null; fi; "
"if find / -maxdepth 0 -lname x -printf '' >/dev/null 2>&1; then "
"o=$(find /proc/[0-9]*/fd -mindepth 1 -maxdepth 1 -type l "
"\\( -lname '*.log' -o -lname '*.log.[0-9]*' -o -lname '/var/log/*' \\) "
"-printf '%p %l\\n' 2>/dev/null); "
"echo '[open]'; printf '%s\\n' \"$o\"; "
"echo '[stat]'; printf '%s\\n' \"$o\" | cut -d' ' -f1 "
"| xargs -r stat -L -c '%n %s %Y' 2>/dev/null; "
"pids=$(printf '%s\\n' \"$o\" | cut -d/ -f3 | sort -un); "
"echo '[cgroups]'; for p in $pids; do sed \"s|^|$p |\" /proc/$p/cgroup 2>/dev/null; done; "
"echo '[comm]'; for p in $pids; do c=$(cat /proc/$p/comm 2>/dev/null) && echo \"$p $c\"; done; "
"else echo '[no-find]'; fi; "
"printf '%s%s\\n' LOGS_ END"
)
#: ``/proc/900/fd/5`` -- the process and its descriptor.
_FD_RE = re.compile(r"^/proc/(\d+)/fd/\d+$")
#: The engine's file of a container's output: json-file and local drivers.
_STREAM_RE = re.compile(r"^/var/lib/docker/containers/([0-9a-f]{64})/")
#: Files that are no log to read: journald's store, a file already deleted, and
#: the write-ahead log LevelDB and RocksDB name ``000004.log``.
_NOT_A_SOURCE = re.compile(r"^/var/log/journal/|\.journal~?$| \(deleted\)$|/\d{6}\.log$")
_SERVICE_SUFFIX = ".service"
_NO_FIND = "no-find"
class LogSourcesUnavailable(NotImplementedError):
"""The host's ``find`` cannot list open files (busybox); nothing to read, nothing to retry."""
def _frame(output: str) -> list[str]:
lines = [line.strip() for line in strip_terminal_codes(output).splitlines()]
try:
start = lines.index(_BEGIN)
end = lines.index(_END, start)
except ValueError:
raise ValueError("no intact log source report in the output") from None
return [line for line in lines[start + 1 : end] if line]
def _stats(lines: list[str]) -> dict[str, tuple[int, str]]:
"""Each descriptor's size and last write: ``/proc/900/fd/5 2048 1762250200``."""
stats: dict[str, tuple[int, str]] = {}
for line in lines:
fd, _, rest = line.partition(" ")
size, _, mtime = rest.partition(" ")
if size.isdigit() and mtime.isdigit():
stats[fd] = (int(size), datetime.fromtimestamp(int(mtime), UTC).isoformat())
return stats
def _names(lines: list[str]) -> dict[int, str]:
names: dict[int, str] = {}
for line in lines:
pid, _, name = line.partition(" ")
if pid.isdigit() and name:
names[int(pid)] = name
return names
def _journals(units: list[str]) -> list[LogSourceDict]:
services = {u[: -len(_SERVICE_SUFFIX)] for u in units if u.endswith(_SERVICE_SUFFIX)}
return [
{
"kind": "journald",
"path": None,
"unit": unit,
"container_id": None,
"process": None,
"size": None,
"modified": None,
}
for unit in sorted(services)
]
def _held(lines: list[str]) -> list[tuple[int, str, str]]:
"""(pid, descriptor, target) for every log a process holds, by pid."""
held = []
for line in lines:
fd, _, target = line.partition(" ")
match = _FD_RE.match(fd)
if match and target and not _NOT_A_SOURCE.search(target):
held.append((int(match.group(1)), fd, target))
return sorted(held)
def _files(sections: dict[str, list[str]]) -> list[LogSourceDict]:
stats = _stats(sections.get("stat", []))
paths = _cgroup_paths(sections.get("cgroups", []))
names = _names(sections.get("comm", []))
found: dict[tuple[str, str | None, str], LogSourceDict] = {}
for pid, fd, target in _held(sections.get("open", [])):
stream = _STREAM_RE.match(target)
cgroup = paths.get(pid)
kind, container = ("container", stream.group(1)) if stream else ("file", _container(cgroup))
source = found.get((kind, container, target))
if source is None:
source = found[(kind, container, target)] = {
"kind": kind,
"path": target,
"unit": None if stream else _unit(cgroup),
"container_id": container,
"process": names.get(pid),
"size": None,
"modified": None,
}
if source["size"] is None and fd in stats:
source["size"], source["modified"] = stats[fd]
return list(found.values())
def _order(source: LogSourceDict) -> tuple[str, str, str]:
return (source["kind"], source["container_id"] or "", source["path"] or source["unit"] or "")
def parse_log_sources(output: str) -> tuple[bool, list[LogSourceDict]]:
"""Parse what :data:`LOG_SOURCES_COMMAND` printed: whether the host has a
journal, and every source, sorted by kind, container and name.
:raises LogSourcesUnavailable: when the host has no GNU ``find``.
:raises ValueError: when the output carries no intact report.
"""
sections = _sections(_frame(output))
if _NO_FIND in sections:
raise LogSourcesUnavailable("the host's find cannot list open files (no GNU find)")
journald = "journald" in sections
sources = _journals(sections.get("journald", [])) + _files(sections)
return journald, sorted(sources, key=_order)
class LogSourcesMixin:
"""Adds :meth:`get_log_sources` to a driver that can run a command on a Linux host.
The template form (README, "Function classes"): the command and its parse
are the same everywhere, so they are concrete here, and a driver supplies
only :meth:`_run_log_sources_command` -- how a command reaches its host, and
how it gains root there. Mixed in by the drivers that can, so
``hasattr(driver, "get_log_sources")`` stays truthful.
"""
if TYPE_CHECKING: # pragma: no cover - declared for type checkers only
def _run_log_sources_command(self, command: str, *, privileged: bool) -> str:
"""Run *command* on the host and return what it printed; as root
when *privileged*. The command is a single ``sh -c`` invocation."""
...
def get_log_sources(self) -> LogSourcesDict:
"""
Returns every log the host writes, with the service or container writing it.
* attributed (bool) - read as root, so every process's files are listed
* journald (bool) - the host keeps systemd's journal
* sources (list) - see :class:`~napalm_device_types.models.LogSourceDict`
Example::
{
"attributed": True,
"journald": True,
"sources": [
{"kind": "journald", "path": None, "unit": "nginx",
"container_id": None, "process": None, "size": None, "modified": None},
{"kind": "file", "path": "/var/log/nginx/access.log", "unit": "nginx",
"container_id": None, "process": "nginx", "size": 2048,
"modified": "2026-11-04T09:56:40+00:00"},
],
}
:raises LogSourcesUnavailable: if the host has no GNU ``find``.
:raises ValueError: if neither reading carried an intact report.
"""
command = f"sh -c {quote(LOG_SOURCES_COMMAND)}"
try:
output = self._run_log_sources_command(command, privileged=True)
journald, sources = parse_log_sources(output)
return {"attributed": True, "journald": journald, "sources": sources}
except ValueError:
pass
output = self._run_log_sources_command(command, privileged=False)
journald, sources = parse_log_sources(output)
return {"attributed": False, "journald": journald, "sources": sources}
+31
View File
@@ -406,6 +406,37 @@ class ListeningSocketsDict(TypedDict):
sockets: list[ListeningSocketDict]
class LogSourceDict(TypedDict):
"""A log the host writes: a unit's journal, a file a process holds open, or a
container's stream as the engine keeps it.
``path`` is as its writer sees it: a file a container writes is named inside
that container. Whether anything reads the log is the consumer's question.
"""
kind: str # "journald", "file" or "container"
path: str | None # the file; None for a journal
unit: str | None # the journal's unit, or the file writer's service; without ".service"
container_id: str | None # the full container ID: the writer's, or the stream's
process: str | None # the first process holding the file
size: int | None # bytes; None for a journal, or when the file could not be read
modified: str | None # the last write, ISO 8601 UTC; None as for size
class LogSourcesDict(TypedDict):
"""What ``LogSourcesMixin.get_log_sources`` read.
``attributed`` is False when the reading ran without root: only the login
user's own processes show their files then, so a missing log means "not
told", not "not there". ``journald`` is False on a host without systemd's
journal, where no unit has one.
"""
attributed: bool
journald: bool
sources: list[LogSourceDict]
class NetfilterMatchDict(TypedDict):
"""One condition of a netfilter rule.