queue-aiops 0.5.0__tar.gz → 0.6.0__tar.gz

{queue_aiops-0.5.0 → queue_aiops-0.6.0}/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## v0.6.0 — 2026-08-03
+
+### Fixed
+- **A cluster node's key count no longer poses as the whole dataset.** `INFO keyspace` on a Redis Cluster node answers for that node's slots only, so `keyspace` / `overview` reported `totalKeys: 100` for a 3-master cluster actually holding 300 — a dataset-wide claim wrong by the shard count, with nothing in the payload to say otherwise. Both now carry `scope` (`node` vs `server`), `clusterMode`, and on a cluster a note explaining that the figure covers one node. Measured on a real 3-master Redis 7.4 cluster (100 / 92 / 108).
+- **`undo apply` replays against the target the original write ran on.** It dispatched the inverse against whatever target the *caller* named — in practice the config's first entry — while the write's own target sat unused in the undo record. On a multi-target config the inverse therefore ran against the wrong host; it only looks harmless because the resource usually is not there, but two hosts holding the same name and the inverse **succeeds on the wrong one, silently**. An explicitly named target still wins. Line-wide: all 24 copies had the identical defect. Caught live in container-host-aiops, where a stop recorded against a Podman target replayed against a Portainer one.
+
 ## v0.5.0 — 2026-08-02
 
 ### Changed (BREAKING)

{queue_aiops-0.5.0 → queue_aiops-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: queue-aiops
-Version: 0.5.0
+Version: 0.6.0
 Summary: Governed AI-ops for redis + rabbitmq: memory-pressure/latency/queue-backlog/connection-churn RCAs, slowlog and SCAN-budgeted big-key sampling, queues/policies/nodes, and governed writes (config set, client kill, purge/delete queue, policies) with a built-in governance harness (audit, budget, undo, risk tiers)
 Author-email: Wei Zhou <zhouwei008@gmail.com>
 License-Expression: MIT

{queue_aiops-0.5.0 → queue_aiops-0.6.0}/docs/VERIFICATION.md

@@ -29,6 +29,13 @@ plus a regression test that asserts the *type*, keeping genuine ratios
 
 - **RabbitMQ** — the entire `rabbitmq` command group and its management-API
   shapes are unit-tested only. This is now the largest gap in this repo.
-- Redis **cluster / sentinel** topologies (only standalone was exercised).
+- ~~Redis **cluster / sentinel** topologies (only standalone was exercised).~~
+  **Both exercised 2026-08-03**, and the cluster one found a defect: a node's
+  `totalKeys` was reported as the dataset total (100 on a 3-master cluster
+  holding 300). Reads, `overview` and the RCAs otherwise behaved correctly on a
+  cluster node, on a Sentinel-fronted primary, and on its replica (`role:
+  slave`). Still untested: an actual **failover** through Sentinel, and any
+  cluster-wide aggregate — this tool talks to one endpoint by design, which is
+  exactly why the scope marker matters.
 - AUTH-enabled Redis and TLS connections.
 - `kill-client` against a real blocked client.

{queue_aiops-0.5.0 → queue_aiops-0.6.0}/mcp_server/tools/undo.py

@@ -87,6 +87,32 @@ def undo_list(limit: int = 50, target: Optional[str] = None) -> dict:
     }
 
 
+def _origin_target(rec: dict) -> Optional[str]:
+    """The target the ORIGINAL write ran against, read from its recorded params.
+
+    Without this the replay goes to whatever target the caller names — in
+    practice the config's first entry — so on a multi-target config the inverse
+    runs against the wrong host. It only *looks* harmless because the resource
+    usually does not exist there; when two hosts both hold a resource with the
+    same name the inverse succeeds on the wrong one, silently.
+
+    Caught live on 2026-08-03 in container-host-aiops: a ``stop_container``
+    recorded against a Podman target replayed against a Portainer target.
+
+    A ``target`` in ``orig_params`` also means the original call accepted one,
+    so the fallback cannot hand a keyword to a tool that has no such parameter.
+    """
+    raw = rec.get("orig_params") or ""
+    try:
+        orig = json.loads(raw) if raw else {}
+    except (ValueError, TypeError):
+        return None  # unreadable: fall back to the caller/default, as before
+    if not isinstance(orig, dict):
+        return None
+    value = orig.get("target")
+    return value if isinstance(value, str) and value else None
+
+
 @mcp.tool()
 @governed_tool(risk_level="medium")
 @tool_errors("dict")
@@ -150,8 +176,10 @@ def undo_apply(undo_id: str, dry_run: bool = False, target: Optional[str] = None
         }
 
     call_params = dict(params)
-    if target is not None and "target" not in call_params:
-        call_params["target"] = target
+    if "target" not in call_params:
+        chosen = target if target is not None else _origin_target(rec)
+        if chosen is not None:
+            call_params["target"] = chosen
     result = fn(**call_params)
 
     # Only mark applied when the inverse did not itself return an error dict.

{queue_aiops-0.5.0 → queue_aiops-0.6.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "queue-aiops"
-version = "0.5.0"
+version = "0.6.0"
 description = "Governed AI-ops for redis + rabbitmq: memory-pressure/latency/queue-backlog/connection-churn RCAs, slowlog and SCAN-budgeted big-key sampling, queues/policies/nodes, and governed writes (config set, client kill, purge/delete queue, policies) with a built-in governance harness (audit, budget, undo, risk tiers)"
 readme = "README.md"
 license = "MIT"

{queue_aiops-0.5.0 → queue_aiops-0.6.0}/queue_aiops/ops/overview.py

@@ -54,6 +54,10 @@ def _redis_overview(conn: Any) -> dict:
         "maxmemoryPolicy": mem.get("maxmemoryPolicy"),
         "fragmentationRatio": mem.get("fragmentationRatio"),
         "totalKeys": keys.get("totalKeys"),
+        # On a cluster node totalKeys covers this node's slots only — the scope
+        # marker has to travel with the number, not be left in a sibling call.
+        "keyScope": keys.get("scope"),
+        "clusterMode": keys.get("clusterMode"),
         "errors": errors,
     }
 

{queue_aiops-0.5.0 → queue_aiops-0.6.0}/queue_aiops/ops/redis_reads.py

@@ -190,8 +190,38 @@ def config_get(conn: Any, pattern: str = "*") -> dict:
         return {"error": s(exc, 200)}
 
 
+def _scope(conn: Any) -> dict:
+    """Whether the counts that follow describe the whole dataset or one shard.
+
+    A Redis Cluster node answers ``INFO keyspace`` for **its own slots only**, so
+    on a three-master cluster holding 300 keys this reports 100 — a number that
+    is wrong by the shard count and, called ``totalKeys`` with nothing else in
+    the payload, reads as the whole dataset. Measured on a real 3-master Redis
+    7.4 cluster. The marker travels with the counts so a consumer can tell a
+    complete answer from a partial one.
+    """
+    try:
+        mode = str(as_obj(conn.redis_info("server")).get("redis_mode") or "")
+    except Exception:  # noqa: BLE001 — scope is an annotation, never the answer
+        return {"scope": "server", "clusterMode": None}
+    if mode != "cluster":
+        return {"scope": "server", "clusterMode": False}
+    return {
+        "scope": "node",
+        "clusterMode": True,
+        "note": (
+            "Redis Cluster: these counts cover THIS node's slots only, not the "
+            "whole cluster. Query each master, or use a cluster-aware client, "
+            "for a dataset-wide figure."
+        ),
+    }
+
+
 def keyspace(conn: Any) -> dict:
-    """[READ] Per-db key counts + expiry coverage from INFO keyspace."""
+    """[READ] Per-db key counts + expiry coverage from INFO keyspace.
+
+    On a cluster node the counts are per-shard; the returned ``scope`` says so.
+    """
     try:
         info = as_obj(conn.redis_info("keyspace"))
         dbs = []
@@ -208,7 +238,11 @@ def keyspace(conn: Any) -> dict:
                     "avgTtlMs": as_int(cell.get("avg_ttl")),
                 }
             )
-        return {"databases": dbs, "totalKeys": sum(d["keys"] for d in dbs)}
+        return {
+            "databases": dbs,
+            "totalKeys": sum(d["keys"] for d in dbs),
+            **_scope(conn),
+        }
     except Exception as exc:  # noqa: BLE001 — report as partial
         return {"error": s(exc, 200)}
 

{queue_aiops-0.5.0 → queue_aiops-0.6.0}/server.json

@@ -7,12 +7,12 @@
     "url": "https://github.com/AIops-tools/Queue-AIops",
     "source": "github"
   },
-  "version": "0.5.0",
+  "version": "0.6.0",
   "packages": [
     {
       "registryType": "pypi",
       "identifier": "queue-aiops",
-      "version": "0.5.0",
+      "version": "0.6.0",
       "transport": {
         "type": "stdio"
       }

{queue_aiops-0.5.0 → queue_aiops-0.6.0}/tests/test_reads.py

@@ -308,3 +308,36 @@ def test_queue_overview_rabbitmq_shape_degrades_partially():
     assert out["platform"] == "rabbitmq"
     assert out["queues"] == 12
     assert any("nodes:" in e for e in out["errors"])
+
+
+@pytest.mark.unit
+def test_keyspace_marks_a_cluster_node_count_as_partial():
+    """A cluster node's key count is per-shard and must say so.
+
+    ``INFO keyspace`` on a Redis Cluster node answers for its own slots only, so
+    a 3-master cluster holding 300 keys reports 100 here. Emitting that as
+    ``totalKeys`` with nothing else in the payload states a dataset-wide figure
+    that is wrong by the shard count. Measured on a real 3-master Redis 7.4
+    cluster: 100 / 92 / 108.
+    """
+    conn = redis_conn(info={
+        "keyspace": {"db0": "keys=100,expires=0,avg_ttl=0"},
+        "server": {"redis_mode": "cluster"},
+    })
+    out = redis_reads.keyspace(conn)
+    assert out["totalKeys"] == 100
+    assert out["scope"] == "node"
+    assert out["clusterMode"] is True
+    assert "THIS node" in out["note"]
+
+
+@pytest.mark.unit
+def test_keyspace_on_a_standalone_server_is_scoped_whole():
+    conn = redis_conn(info={
+        "keyspace": {"db0": "keys=7,expires=0,avg_ttl=0"},
+        "server": {"redis_mode": "standalone"},
+    })
+    out = redis_reads.keyspace(conn)
+    assert out["scope"] == "server"
+    assert out["clusterMode"] is False
+    assert "note" not in out

{queue_aiops-0.5.0 → queue_aiops-0.6.0}/tests/test_undo_executor.py

@@ -21,18 +21,21 @@ from mcp_server.tools import undo as gov
 from queue_aiops.governance import governed_tool
 
 _CALLS: list[dict] = []
+_TARGETS: list = []
 
 
 @governed_tool(risk_level="low")
 def _undo_probe(value: str = "", target=None) -> dict:
     """Synthetic inverse target used only by the undo-executor tests."""
     _CALLS.append({"value": value})
+    _TARGETS.append(target)
     return {"ok": True, "value": value}
 
 
 @pytest.fixture
 def gov_home(tmp_path, monkeypatch):
     _CALLS.clear()
+    _TARGETS.clear()
     # Register the probe only for the duration of these tests so it never
     # pollutes the real tool registry (which exact-count smoke tests assert on).
     mcp.add_tool(_undo_probe, name="_undo_probe")
@@ -77,6 +80,52 @@ def test_undo_apply_dispatches_inverse_and_marks_applied(gov_home):
     assert uid not in {u["undoId"] for u in gov.undo_list()["undos"]}
 
 
+@pytest.mark.unit
+def test_undo_apply_replays_against_the_target_the_write_ran_on(gov_home):
+    """A replay must go to the host the original write went to.
+
+    Without this the inverse ran against whatever target the caller named — in
+    practice the config's first entry — so on a multi-target config it hit the
+    wrong host. It only looked harmless because the resource usually does not
+    exist there; two hosts holding the same name and the inverse succeeds on the
+    wrong one, silently. Caught live on 2026-08-03 in container-host-aiops: a
+    stop recorded against a Podman target replayed against a Portainer target.
+    """
+    uid = undo_mod.get_undo_store().record(
+        skill="probe",
+        tool="orig_op",
+        undo_descriptor={"tool": "_undo_probe", "params": {"value": "v1"}},
+        orig_params={"value": "v1", "target": "second-host"},
+    )
+    result = gov.undo_apply(undo_id=uid)
+    assert result["applied"] is True
+    assert _TARGETS == ["second-host"]
+
+
+@pytest.mark.unit
+def test_undo_apply_prefers_an_explicit_caller_target(gov_home):
+    """An explicitly named target still wins — the fallback is only a default."""
+    uid = undo_mod.get_undo_store().record(
+        skill="probe",
+        tool="orig_op",
+        undo_descriptor={"tool": "_undo_probe", "params": {"value": "v1"}},
+        orig_params={"value": "v1", "target": "second-host"},
+    )
+    gov.undo_apply(undo_id=uid, target="chosen-host")
+    assert _TARGETS == ["chosen-host"]
+
+
+@pytest.mark.unit
+def test_undo_apply_survives_unreadable_orig_params(gov_home):
+    """Corrupt orig_params must not break the replay — just lose the fallback."""
+    uid = _record(params={"value": "v1"})
+    with sqlite3.connect(gov_home / "undo.db") as db:
+        db.execute("UPDATE undo_log SET orig_params = ? WHERE undo_id = ?",
+                   ("{not json", uid))
+    assert gov.undo_apply(undo_id=uid)["applied"] is True
+    assert _TARGETS == [None]
+
+
 @pytest.mark.unit
 def test_undo_apply_dry_run_previews_without_running(gov_home):
     uid = _record()

{queue_aiops-0.5.0 → queue_aiops-0.6.0}/uv.lock

@@ -812,7 +812,7 @@ wheels = [
 
 [[package]]
 name = "queue-aiops"
-version = "0.5.0"
+version = "0.6.0"
 source = { editable = "." }
 dependencies = [
     { name = "cryptography" },