moat-link-metrics 0.0.4__tar.gz

moat_link_metrics-0.0.4/LICENSE.txt

@@ -0,0 +1,3 @@
+MIT License
+
+Copyright (c) Matthias Urlichs

moat_link_metrics-0.0.4/Makefile

@@ -0,0 +1,14 @@
+#!/usr/bin/make -f
+
+PACKAGE = moat-link-metrics
+MAKEINCL ?= $(shell python3 -mmoat src path)/make/py
+
+ifneq ($(wildcard $(MAKEINCL)),)
+include $(MAKEINCL)
+# availabe via http://github.com/smurfix/sourcemgr
+
+else
+%:
+	@echo "Please fix 'python3 -mmoat src path'."
+	@exit 1
+endif

moat_link_metrics-0.0.4/PKG-INFO

@@ -0,0 +1,73 @@
+Metadata-Version: 2.4
+Name: moat-link-metrics
+Version: 0.0.4
+Summary: Metrics time-series connector for MoaT-Link
+Author-email: Matthias Urlichs <matthias@urlichs.de>
+Project-URL: homepage, https://m-o-a-t.org
+Project-URL: repository, https://github.com/M-o-a-T/moat
+Keywords: MoaT
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Framework :: AsyncIO
+Classifier: Framework :: Trio
+Classifier: Framework :: AnyIO
+Classifier: Development Status :: 4 - Beta
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: anyio~=4.2
+Requires-Dist: asyncclick
+Requires-Dist: attrs
+Requires-Dist: moat-util~=0.62.6
+Requires-Dist: moat-link~=0.3.2
+Requires-Dist: moat-lib-config~=0.1.2
+Provides-Extra: akumuli
+Requires-Dist: moat-link-metrics-akumuli~=0.0.1; extra == "akumuli"
+Provides-Extra: victoria
+Requires-Dist: moat-link-metrics-victoria~=0.0.1; extra == "victoria"
+Dynamic: license-file
+
+# Metrics time-series connector
+
+% start synopsis
+Forwards MoaT-Link values to metrics time-series storage backends.
+% end synopsis
+
+% start main
+
+This module watches MoaT-Link entries and writes their values to metrics backends
+whenever they change. It replaces the legacy ``moat-kv-akumuli`` and ``moat-link-akumuli`` packages.
+
+## Features
+
+- Pluggable backend support (currently: Akumuli)
+- Per-server configuration stored in MoaT-Link
+- Dynamic series management: add, remove, or modify series at runtime
+- Configurable scaling (factor/offset) and rate limiting (t_min)
+- Attribute extraction from nested source values
+
+## Quick start
+
+1. Configure a metrics server:
+
+   ```shell
+   moat link metrics add myserver my.entry source.path series_name host=myhost
+   ```
+
+2. Run the connector:
+
+   ```shell
+   moat link metrics monitor myserver
+   ```
+
+## Backends
+
+The default backend is Akumuli. To specify a different backend, set the `backend`
+field in the server configuration to the backend module name (e.g., `akumuli`).
+
+## Deprecation
+
+This package supersedes ``moat-kv-akumuli`` and ``moat-link-akumuli``.  The raw
+MQTT topic monitoring feature has been removed; use MoaT-Link's native data paths instead.
+
+% end main

moat_link_metrics-0.0.4/README.md

@@ -0,0 +1,44 @@
+# Metrics time-series connector
+
+% start synopsis
+Forwards MoaT-Link values to metrics time-series storage backends.
+% end synopsis
+
+% start main
+
+This module watches MoaT-Link entries and writes their values to metrics backends
+whenever they change. It replaces the legacy ``moat-kv-akumuli`` and ``moat-link-akumuli`` packages.
+
+## Features
+
+- Pluggable backend support (currently: Akumuli)
+- Per-server configuration stored in MoaT-Link
+- Dynamic series management: add, remove, or modify series at runtime
+- Configurable scaling (factor/offset) and rate limiting (t_min)
+- Attribute extraction from nested source values
+
+## Quick start
+
+1. Configure a metrics server:
+
+   ```shell
+   moat link metrics add myserver my.entry source.path series_name host=myhost
+   ```
+
+2. Run the connector:
+
+   ```shell
+   moat link metrics monitor myserver
+   ```
+
+## Backends
+
+The default backend is Akumuli. To specify a different backend, set the `backend`
+field in the server configuration to the backend module name (e.g., `akumuli`).
+
+## Deprecation
+
+This package supersedes ``moat-kv-akumuli`` and ``moat-link-akumuli``.  The raw
+MQTT topic monitoring feature has been removed; use MoaT-Link's native data paths instead.
+
+% end main

moat_link_metrics-0.0.4/debian/.gitignore

@@ -0,0 +1,7 @@
+/files
+/*.log
+/*.debhelper
+/*.debhelper-build-stamp
+/*.substvars
+/debhelper-build-stamp
+/moat-link-metrics

moat_link_metrics-0.0.4/debian/changelog

@@ -0,0 +1,5 @@
+moat-link-metrics (0.0.4-2) unstable; urgency=medium
+
+  * Initial release for 26.0.1
+
+ -- Matthias Urlichs <matthias@urlichs.de>  Wed, 18 Feb 2026 18:28:43 +0100

moat_link_metrics-0.0.4/debian/control

@@ -0,0 +1,29 @@
+Source: moat-link-metrics
+Maintainer: Matthias Urlichs <matthias@urlichs.de>
+Section: python
+Priority: optional
+Build-Depends: dh-python, python3-all, debhelper (>= 13),
+  python3-setuptools,
+  python3-wheel,
+Standards-Version: 3.9.6
+Homepage: https://github.com/M-o-a-T/moat
+X-DH-Compat: 13
+
+Package: moat-link-metrics
+Architecture: all
+Depends: ${misc:Depends}, ${python3:Depends},
+  moat-util,
+  moat-link,
+Recommends:
+  python3-trio (>= 0.22),
+  moat-link-metrics-backend-akumuli,
+Suggests:
+  moat-link-metrics-backend-akumuli,
+Description: Metrics time-series connector for MoaT-Link
+ Watches MoaT-Link data entries and writes their values to metrics
+ time-series backends whenever they change.
+ .
+ Backends are provided by separate packages (e.g.,
+ moat-link-metrics-backend-akumuli for Akumuli support).
+ .
+ Part of the MoaT ecosystem for distributed home automation.

moat_link_metrics-0.0.4/debian/rules

@@ -0,0 +1,10 @@
+#!/usr/bin/make -f
+
+export PYBUILD_NAME=moat-link-akumuli
+%:
+	dh $@ --with python3 --buildsystem=pybuild
+
+override_dh_auto_install:
+	dh_auto_install
+	install -D -m 644 systemd/moat-link-metrics@.service \
+		debian/moat-link-akumuli/usr/lib/systemd/system/moat-link-metrics@.service

moat_link_metrics-0.0.4/pyproject.toml

@@ -0,0 +1,50 @@
+[build-system]
+build-backend = "setuptools.build_meta"
+requires = [ "setuptools", "wheel",]
+
+[project]
+classifiers = [
+	"Intended Audience :: Developers",
+	"Programming Language :: Python :: 3",
+	"Framework :: AsyncIO",
+	"Framework :: Trio",
+	"Framework :: AnyIO",
+	"Development Status :: 4 - Beta",
+	]
+dependencies = [
+	"anyio ~= 4.2",
+	"asyncclick",
+	"attrs",
+	"moat-util ~= 0.62.6",
+	"moat-link ~= 0.3.2",
+	"moat-lib-config ~= 0.1.2",
+	]
+version = "0.0.4"
+keywords = [ "MoaT",]
+requires-python = ">=3.13"
+name = "moat-link-metrics"
+description = "Metrics time-series connector for MoaT-Link"
+readme = "README.md"
+
+[project.optional-dependencies]
+akumuli = [
+	"moat-link-metrics-akumuli ~= 0.0.1",
+]
+victoria = [
+	"moat-link-metrics-victoria ~= 0.0.1",
+]
+
+[[project.authors]]
+name = "Matthias Urlichs"
+email = "matthias@urlichs.de"
+
+[project.urls]
+homepage = "https://m-o-a-t.org"
+repository = "https://github.com/M-o-a-T/moat"
+
+[tool.setuptools]
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+"*" = ["*.yaml"]

moat_link_metrics-0.0.4/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

moat_link_metrics-0.0.4/src/moat/link/metrics/__init__.py

@@ -0,0 +1,9 @@
+"""Metrics time-series connector for MoaT-Link."""
+
+from __future__ import annotations
+
+from moat.lib.config import register as _register
+
+__all__: list[str] = []
+
+_register(__name__)

moat_link_metrics-0.0.4/src/moat/link/metrics/_cfg.yaml

@@ -0,0 +1,5 @@
+prefix: !P metrics
+server_default:
+  backend: akumuli
+  host: localhost
+  port: 8282

moat_link_metrics-0.0.4/src/moat/link/metrics/_main.py

@@ -0,0 +1,122 @@
+"""
+Command-line interface for moat.link.metrics.
+"""
+
+from __future__ import annotations
+
+import logging
+
+import asyncclick as click
+
+from moat.util import NotGiven
+from moat.lib.path import P
+from moat.link._data import data_get
+from moat.link.client import Link
+
+logger = logging.getLogger(__name__)
+
+
+@click.group(short_help="Manage metrics series.")
+@click.pass_context
+async def cli(ctx):
+    """Configure metrics time-series forwarding.
+
+    Series entries live below the configured ``link.metrics.prefix``
+    path, grouped by server name.
+    """
+    obj = ctx.obj
+    cfg = obj.cfg["link"]
+    obj.conn = await ctx.with_async_resource(Link(cfg))
+    obj.metrics_cfg = obj.cfg.link.metrics
+    obj.prefix = obj.metrics_cfg.prefix
+
+
+@cli.command("list")
+@click.argument("server", type=str)
+@click.pass_obj
+async def list_(obj, server):
+    """List series entries for a server."""
+    path = obj.prefix + P(server)
+    await data_get(obj.conn, path, recursive=True, out=obj.stdout)
+
+
+@cli.command("show")
+@click.argument("server", type=str)
+@click.argument("name", type=P)
+@click.pass_obj
+async def show_(obj, server, name):
+    """Show a single series entry."""
+    path = obj.prefix + P(server) + name
+    await data_get(obj.conn, path, recursive=False, out=obj.stdout)
+
+
+@cli.command("add")
+@click.argument("server", type=str)
+@click.argument("name", type=P)
+@click.argument("source", type=P)
+@click.argument("series", type=str)
+@click.argument("tags", nargs=-1)
+@click.option("-m", "--mode", default="gauge", help="Mode (default: gauge).")
+@click.option(
+    "-a",
+    "--attr",
+    default=None,
+    type=P,
+    help="Attribute path to extract from the source value.",
+)
+@click.option("-f", "--force", is_flag=True, help="Overwrite existing entry.")
+@click.pass_obj
+async def add_(obj, server, name, source, series, tags, mode, attr, force):
+    """Add a series entry.
+
+    \\b
+    SERVER: server name.
+    NAME:   unique entry name (path).
+    SOURCE: MoaT-Link path of the value to watch.
+    SERIES: Backend series name.
+    TAGS:   key=value pairs for backend tags.
+    """
+    path = obj.prefix + P(server) + name
+    if not tags:
+        raise click.UsageError("At least one tag is required")
+
+    tagged = {}
+    for t in tags:
+        try:
+            k, v = t.split("=", 1)
+        except ValueError:
+            raise click.UsageError("Tags must be key=value") from None
+        tagged[k] = v
+
+    if not force:
+        try:
+            await obj.conn.d_get(path)
+        except (KeyError, ValueError):
+            pass
+        else:
+            raise click.UsageError("Entry exists. Use --force to overwrite.")
+
+    val: dict = {"source": source, "series": series, "tags": tagged, "mode": mode}
+    if attr:
+        val["attr"] = attr
+    await obj.conn.d_set(path, val)
+
+
+@cli.command("delete")
+@click.argument("server", type=str)
+@click.argument("name", type=P)
+@click.pass_obj
+async def delete_(obj, server, name):
+    """Remove a series entry."""
+    path = obj.prefix + P(server) + name
+    await obj.conn.d_set(path, NotGiven)
+
+
+@cli.command("monitor")
+@click.argument("server", type=str)
+@click.pass_obj
+async def monitor_(obj, server):
+    """Run the metrics connector for one server."""
+    from .task import task  # noqa:PLC0415
+
+    await task(obj.conn, obj.metrics_cfg, server)

moat_link_metrics-0.0.4/src/moat/link/metrics/backend/__init__.py

@@ -0,0 +1,12 @@
+"""
+Common code for metrics backends.
+
+Currently the only backend supported is Akumuli, but who knows.
+"""
+
+from __future__ import annotations
+
+from ._base import Backend as Backend
+from ._base import get_backend as get_backend
+
+__all__ = ["Backend", "get_backend"]

moat_link_metrics-0.0.4/src/moat/link/metrics/backend/_base.py

@@ -0,0 +1,65 @@
+"""
+Common code for metrics backends.
+
+Currently the only backend supported is Akumuli, but who knows.
+"""
+
+from __future__ import annotations
+
+import logging
+from abc import ABCMeta, abstractmethod
+from contextlib import asynccontextmanager
+
+from moat.util import CtxObj
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from moat.link.metrics.model import MetricPoint
+
+    from collections.abc import AsyncIterator
+    from typing import Self
+
+__all__ = ["Backend", "get_backend"]
+
+
+class Backend(CtxObj, metaclass=ABCMeta):
+    """Base class for metrics backends."""
+
+    def __init__(self, cfg: dict, name: str):
+        self.cfg = cfg
+        self.name = name
+        self.logger = logging.getLogger(f"moat.link.metrics.backend.{name}")
+
+    @abstractmethod
+    @asynccontextmanager
+    async def connect(self, *a, **k) -> AsyncIterator[Self]:
+        """
+        This async context manager returns a connection to the backend.
+        """
+
+    @asynccontextmanager
+    async def _ctx(self) -> AsyncIterator[Self]:
+        async with self.connect():
+            yield self
+
+    @abstractmethod
+    async def put(self, point: MetricPoint) -> None:
+        """
+        Send a metric data point to the backend.
+
+        Args:
+            point: The data point to send.
+        """
+
+
+def get_backend(cfg: dict, name: str) -> Backend:
+    """
+    Fetch the backend named in the config and initialize it.
+    """
+    from importlib import import_module  # noqa: PLC0415
+
+    backend_name = cfg.get("backend", "akumuli")
+    if "." not in backend_name:
+        backend_name = "moat.link.metrics.backend." + backend_name
+    return import_module(backend_name).Backend(cfg, name)

moat_link_metrics-0.0.4/src/moat/link/metrics/model.py

@@ -0,0 +1,154 @@
+"""
+Node model for metrics series configuration.
+
+The tree mirrors the MoaT-Link subtree under the configured prefix.
+Each server entry contains per-series child nodes.
+"""
+
+from __future__ import annotations
+
+import logging
+
+from attrs import define, field
+
+from moat.util import NotGiven
+from moat.link.node import Node
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    import anyio
+
+    from moat.lib.rpc import Key
+
+    from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+@define
+class MetricPoint:
+    """
+    A backend-agnostic metric data point.
+
+    Args:
+        series: Series name.
+        value: Numeric value.
+        tags: Dictionary of tags.
+        mode: Backend-specific mode string.
+        timestamp: Optional timestamp (seconds since epoch, or ``None``
+            for "now").
+    """
+
+    series: str
+    value: float
+    tags: dict[str, Any]
+    mode: str
+    timestamp: float | None = None
+
+
+def _test_hook(e: MetricPoint) -> None:
+    """Hook for testing; called with every MetricPoint before sending."""
+
+
+@define
+class MetricsEntry(Node):
+    """A single metrics series mapping.
+
+    Reads a source value from MoaT-Link, applies *factor* and *offset*,
+    and writes the result to a metrics backend.
+    """
+
+    _work: anyio.CancelScope | None = field(init=False, default=None)
+    _t_last: float | None = field(init=False, default=None)
+
+    # --- helpers --------------------------------------------------------
+
+    @property
+    def source(self) -> tuple | None:
+        """Source path from the stored config, or None."""
+        d = self.data_
+        if d is NotGiven or not isinstance(d, dict):
+            return None
+        return d.get("source")
+
+    @property
+    def series(self) -> str | None:
+        """Akumuli series name."""
+        d = self.data_
+        if d is NotGiven or not isinstance(d, dict):
+            return None
+        return d.get("series")
+
+    @property
+    def tags(self) -> dict | None:
+        """Akumuli tags dict."""
+        d = self.data_
+        if d is NotGiven or not isinstance(d, dict):
+            return None
+        return d.get("tags")
+
+    @property
+    def mode(self) -> str:
+        """Backend-specific data-series mode."""
+        d = self.data_ if self.data_ is not NotGiven else {}
+        m = d.get("mode", "gauge") if isinstance(d, dict) else "gauge"
+        return m if isinstance(m, str) else str(m)
+
+    @property
+    def attr(self) -> tuple:
+        """Attribute path to extract from the watched value."""
+        d = self.data_ if self.data_ is not NotGiven else {}
+        return d.get("attr", ()) if isinstance(d, dict) else ()
+
+    @property
+    def factor(self) -> float:
+        """Multiplicative scaling factor."""
+        d = self.data_ if self.data_ is not NotGiven else {}
+        return d.get("factor", 1) if isinstance(d, dict) else 1
+
+    @property
+    def offset(self) -> float:
+        """Additive offset."""
+        d = self.data_ if self.data_ is not NotGiven else {}
+        return d.get("offset", 0) if isinstance(d, dict) else 0
+
+    @property
+    def t_min(self) -> float | None:
+        """Minimum interval between writes, in seconds."""
+        d = self.data_ if self.data_ is not NotGiven else {}
+        return d.get("t_min") if isinstance(d, dict) else None
+
+    def is_complete(self) -> bool:
+        """Check whether this entry has enough data to start a worker."""
+        return bool(self.source and self.series and self.tags)
+
+
+@define
+class MetricsServer(Node):
+    """Represents one metrics server instance in the configuration tree.
+
+    Children are :class:`MetricsEntry` nodes.
+    """
+
+    def add_child(self, item: Key) -> MetricsEntry:
+        """Create child entries as :class:`MetricsEntry`."""
+        if item in self._sub:
+            raise ValueError("exists")
+        self._sub[item] = s = MetricsEntry()
+        return s
+
+
+@define
+class MetricsRoot(Node):
+    """Root of the metrics configuration tree.
+
+    Children are :class:`MetricsServer` nodes.
+    """
+
+    def add_child(self, item: Key) -> MetricsServer:
+        """Create child servers as :class:`MetricsServer`."""
+        if item in self._sub:
+            raise ValueError("exists")
+        self._sub[item] = s = MetricsServer()
+        return s

moat_link_metrics-0.0.4/src/moat/link/metrics/task.py

@@ -0,0 +1,117 @@
+"""
+Main supervisor task for metrics.
+
+Connects to a metrics backend and monitors the MoaT-Link configuration
+subtree.  Spawns / cancels per-series workers as entries appear or change.
+"""
+
+from __future__ import annotations
+
+import anyio
+import logging
+
+from moat.util import combine_dict
+from moat.lib.path import Path
+
+from .backend import get_backend
+from .model import MetricsEntry, MetricsServer
+from .worker import run_entry
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from moat.link.client import LinkSender
+
+    from collections.abc import Mapping
+
+logger = logging.getLogger(__name__)
+
+
+async def task(
+    link: LinkSender,
+    cfg: Mapping,
+    server_name: str,
+    *,
+    task_status: anyio.abc.TaskStatus = anyio.TASK_STATUS_IGNORED,
+) -> None:
+    """Run the metrics connector for one server.
+
+    Args:
+        link: an active MoaT-Link sender.
+        cfg: the ``link.metrics`` configuration section.
+        server_name: the server entry name inside the config subtree.
+        task_status: task-status for ``tg.start``.
+    """
+    prefix = Path.build(cfg["prefix"])
+    server_path = prefix / server_name
+
+    # Fetch the server-level config (host/port/backend) from its stored value
+    server_data = await link.d_get(server_path)
+    srv_cfg = combine_dict(
+        (server_data if isinstance(server_data, dict) else {}).get("server", {}),
+        cfg.get("server_default", {}),
+    )
+
+    # Get the backend from config
+    backend = get_backend(srv_cfg, server_name)
+
+    async with (
+        backend,
+        anyio.create_task_group() as tg,
+    ):
+        workers: dict[Path, anyio.CancelScope] = {}
+
+        def _cancel(p: Path) -> None:
+            sc = workers.pop(p, None)
+            if sc is not None:
+                sc.cancel()
+
+        async def _start(p: Path, entry: MetricsEntry) -> None:
+            _cancel(p)
+            if not entry.is_complete():
+                logger.warning("Incomplete entry at %s, skipping", p)
+                return
+
+            async def _run(
+                *,
+                task_status: anyio.abc.TaskStatus = anyio.TASK_STATUS_IGNORED,
+            ) -> None:
+                with anyio.CancelScope() as sc:
+                    workers[p] = sc
+                    task_status.started()
+                    try:
+                        await run_entry(link, entry, backend, p)
+                    except Exception:
+                        logger.exception("Worker for %s failed", p)
+
+            await tg.start(_run)
+
+        # Watch the server subtree for configuration entries.
+        # mark=True yields None when the initial state is complete.
+        async with link.d_watch(
+            server_path,
+            subtree=True,
+            mark=True,
+            cls=MetricsServer,
+        ) as mon:
+            task_status.started()
+
+            async for msg in mon:
+                if msg is None:
+                    # Initial state loaded; all entries already spawned.
+                    continue
+                p, _data = msg
+                if not p:
+                    # Server-level data changed (host/port); ignore here.
+                    continue
+
+                node = mon._node.get(p)  # noqa:SLF001
+                if isinstance(node, MetricsEntry):
+                    if node.is_complete():
+                        await _start(p, node)
+                    else:
+                        _cancel(p)
+                else:
+                    _cancel(p)
+
+        tg.cancel_scope.cancel()

moat_link_metrics-0.0.4/src/moat/link/metrics/worker.py

@@ -0,0 +1,77 @@
+"""
+Per-series worker for metrics.
+
+Each worker watches a single MoaT-Link value and writes updates
+to the corresponding metrics backend.
+"""
+
+from __future__ import annotations
+
+import anyio
+import logging
+
+from moat.lib.path import Path
+
+from . import model as _model
+from .model import MetricPoint
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from moat.link.client import LinkSender
+
+    from .backend import Backend
+    from .model import MetricsEntry
+
+logger = logging.getLogger(__name__)
+
+
+async def run_entry(
+    link: LinkSender,
+    entry: MetricsEntry,
+    backend: Backend,
+    subpath: Path,
+) -> None:
+    """Watch one source value and forward it to the metrics backend.
+
+    Args:
+        link: an active MoaT-Link sender.
+        entry: the configuration node for this series.
+        backend: the metrics backend connection.
+        subpath: path of this entry relative to the server node
+            (used for error reporting).
+    """
+    source = Path.build(entry.source)
+    series = entry.series
+    tags = entry.tags
+    mode = entry.mode
+    attr = entry.attr
+    factor = entry.factor
+    offset = entry.offset
+    t_min = entry.t_min
+    t_last: float | None = None
+
+    async with link.d_watch(source) as wp:
+        async for raw in wp:
+            if t_min is not None:
+                t = anyio.current_time()
+                if t_last is not None and t_last + t_min > t:
+                    continue
+                t_last = t
+
+            # Drill into nested data via attr path
+            val = raw
+            for k in attr:
+                try:
+                    val = val[k]
+                except (KeyError, TypeError, IndexError):
+                    logger.warning("Missing attr %r in %s", attr, subpath)
+                    break
+            else:
+                if not isinstance(val, (int, float)):
+                    logger.warning("Non-numeric value at %s: %r", subpath, val)
+                    continue
+                out = val * factor + offset
+                point = MetricPoint(series=series, mode=mode, value=out, tags=tags)
+                _model._test_hook(point)  # noqa:SLF001
+                await backend.put(point)

moat_link_metrics-0.0.4/src/moat_link_metrics.egg-info/PKG-INFO

@@ -0,0 +1,73 @@
+Metadata-Version: 2.4
+Name: moat-link-metrics
+Version: 0.0.4
+Summary: Metrics time-series connector for MoaT-Link
+Author-email: Matthias Urlichs <matthias@urlichs.de>
+Project-URL: homepage, https://m-o-a-t.org
+Project-URL: repository, https://github.com/M-o-a-T/moat
+Keywords: MoaT
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Framework :: AsyncIO
+Classifier: Framework :: Trio
+Classifier: Framework :: AnyIO
+Classifier: Development Status :: 4 - Beta
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: anyio~=4.2
+Requires-Dist: asyncclick
+Requires-Dist: attrs
+Requires-Dist: moat-util~=0.62.6
+Requires-Dist: moat-link~=0.3.2
+Requires-Dist: moat-lib-config~=0.1.2
+Provides-Extra: akumuli
+Requires-Dist: moat-link-metrics-akumuli~=0.0.1; extra == "akumuli"
+Provides-Extra: victoria
+Requires-Dist: moat-link-metrics-victoria~=0.0.1; extra == "victoria"
+Dynamic: license-file
+
+# Metrics time-series connector
+
+% start synopsis
+Forwards MoaT-Link values to metrics time-series storage backends.
+% end synopsis
+
+% start main
+
+This module watches MoaT-Link entries and writes their values to metrics backends
+whenever they change. It replaces the legacy ``moat-kv-akumuli`` and ``moat-link-akumuli`` packages.
+
+## Features
+
+- Pluggable backend support (currently: Akumuli)
+- Per-server configuration stored in MoaT-Link
+- Dynamic series management: add, remove, or modify series at runtime
+- Configurable scaling (factor/offset) and rate limiting (t_min)
+- Attribute extraction from nested source values
+
+## Quick start
+
+1. Configure a metrics server:
+
+   ```shell
+   moat link metrics add myserver my.entry source.path series_name host=myhost
+   ```
+
+2. Run the connector:
+
+   ```shell
+   moat link metrics monitor myserver
+   ```
+
+## Backends
+
+The default backend is Akumuli. To specify a different backend, set the `backend`
+field in the server configuration to the backend module name (e.g., `akumuli`).
+
+## Deprecation
+
+This package supersedes ``moat-kv-akumuli`` and ``moat-link-akumuli``.  The raw
+MQTT topic monitoring feature has been removed; use MoaT-Link's native data paths instead.
+
+% end main

moat_link_metrics-0.0.4/src/moat_link_metrics.egg-info/SOURCES.txt

@@ -0,0 +1,22 @@
+LICENSE.txt
+Makefile
+README.md
+pyproject.toml
+debian/.gitignore
+debian/changelog
+debian/control
+debian/rules
+src/moat/link/metrics/__init__.py
+src/moat/link/metrics/_cfg.yaml
+src/moat/link/metrics/_main.py
+src/moat/link/metrics/model.py
+src/moat/link/metrics/task.py
+src/moat/link/metrics/worker.py
+src/moat/link/metrics/backend/__init__.py
+src/moat/link/metrics/backend/_base.py
+src/moat_link_metrics.egg-info/PKG-INFO
+src/moat_link_metrics.egg-info/SOURCES.txt
+src/moat_link_metrics.egg-info/dependency_links.txt
+src/moat_link_metrics.egg-info/requires.txt
+src/moat_link_metrics.egg-info/top_level.txt
+systemd/moat-link-metrics@.service

moat_link_metrics-0.0.4/src/moat_link_metrics.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

moat_link_metrics-0.0.4/src/moat_link_metrics.egg-info/requires.txt

@@ -0,0 +1,12 @@
+anyio~=4.2
+asyncclick
+attrs
+moat-lib-config~=0.1.2
+moat-link~=0.3.2
+moat-util~=0.62.6
+
+[akumuli]
+moat-link-metrics-akumuli~=0.0.1
+
+[victoria]
+moat-link-metrics-victoria~=0.0.1

moat_link_metrics-0.0.4/src/moat_link_metrics.egg-info/top_level.txt

@@ -0,0 +1 @@
+moat

moat_link_metrics-0.0.4/systemd/moat-link-metrics@.service

@@ -0,0 +1,21 @@
+[Unit]
+Description=MoaT-Link metrics connector (%I)
+After=moat-link-server.service
+Requires=moat-link-server.service
+
+ConditionFileNotEmpty=/etc/moat/moat.yaml
+
+[Install]
+WantedBy=multi-user.target
+
+[Service]
+Type=notify
+ExecStart=/usr/bin/moat link metrics monitor %I
+
+EnvironmentFile=-/etc/moat/link.env
+
+TimeoutSec=300
+WatchdogSec=10
+
+Restart=always
+RestartSec=30