clawmetry 0.12.485__tar.gz → 0.12.487__tar.gz

{clawmetry-0.12.485 → clawmetry-0.12.487}/CHANGELOG.md

@@ -1,5 +1,10 @@
 ## [Unreleased]
 
+### Release: OTLP spans now actually persist in production (#2896) (2026-06-08)
+- **Bring-your-own-agent was silently dropped:** the /v1/traces receiver runs in the dashboard process, which does not own the DuckDB writer lock, so get_store() returns a proxy that forwards writes to the daemon but only passes keyword args. put_span was called positionally and was not in the daemon allowlist, so every OTLP span no-opped whenever a daemon runs (every real install): the POST returned 200 but nothing persisted, and a foreign OpenLLMetry/OTLP app never appeared in the runtime switcher or Agent Inventory. The OTLP test suite missed it because it forces single-process, where get_store() is the real writer.
+- **Fix:** allowlist put_span in routes/local_query._DAEMON_METHODS and call put_span(span=...) by keyword so the span forwards through the proxy to the daemon writer (same pattern as set_agent_meta). A new regression test forces the proxy path the suite skipped and asserts the span forwards as a keyword plus put_span is allowlisted.
+- **Verified live:** a real OpenLLMetry-shaped OTLP trace sent to a running daemon+dashboard now persists in DuckDB, surfaces via query_otlp_app_rollup with derived cost, flows into runtimeSummary + agentInventory, and renders on the hosted dashboard as an "(OTel)" agent row plus the switcher "OpenLLMetry / OTLP apps" optgroup. Before the fix: zero spans persisted.
+
 ### Release: OpenLLMetry/OTLP apps visible in the runtime switcher + inventory (#2871) (2026-06-08)
 - **Bring your own agent, now visible:** a foreign OpenLLMetry/OTel-instrumented app (LangChain, CrewAI, OpenAI Agents, custom) that sends OTLP traces now appears as its own entry in the global runtime switcher (under an "OpenLLMetry / OTLP apps" group) and as a real row in the Agent Inventory roster, with its cost, tokens, and session counts. Completes #2822 (which gave such apps an agent_type from service.name) and #2853 (the inventory roster).
 - **How:** the daemon's cached rollup runs one GROUP BY agent_type over the spans table for agent_types that are not one of the 12 known session-prefix runtimes (top 50 by recent activity, with a logged warning on truncation), never a per-request scan. Native runtimes still filter by session-id prefix; OTLP apps filter by agent_type, so the two paths stay disjoint and the per-runtime no-leak contract holds (extended test asserts no leak in either direction). Rides the existing runtimeSummary + agentInventory snapshot slices, so the hosted dashboard picks it up on the next version pin with no new interceptor.

{clawmetry-0.12.485/clawmetry.egg-info → clawmetry-0.12.487}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clawmetry
-Version: 0.12.485
+Version: 0.12.487
 Summary: ClawMetry - Real-time observability for 12 AI agent runtimes (OpenClaw, NVIDIA NemoClaw, Claude Code, Codex & more)
 Home-page: https://github.com/vivekchand/clawmetry
 Author: Vivek Chand

{clawmetry-0.12.485 → clawmetry-0.12.487}/clawmetry/local_store.py

@@ -4079,32 +4079,34 @@ class LocalStore:
                     "sessions": int(r[1] or 0),
                     "tokens": int(r[2] or 0),
                     "cost_usd": float(r[3] or 0.0),
-                    "cost_today_usd": 0.0,
-                    "tokens_today": 0,
+                    "cost_24h_usd": 0.0,
+                    "tokens_24h": 0,
                 }
-            # TODAY's cost/tokens per runtime, from events with ts in the current
-            # UTC day. The cost_usd above is LIFETIME (all the runtime's sessions);
-            # the UI shows both. True per-day cost needs event-level cost+ts (which
-            # the cloud sessions table lacks) — so it's computed here on the daemon
-            # and rides the snapshot. Event cost is correct post-#web-accuracy
-            # re-ingest (deduped + current-gen rates).
-            from datetime import datetime as _dt, timezone as _tz
-            _today = _dt.now(_tz.utc).strftime("%Y-%m-%dT00:00:00")
-            sql_today = f"""
+            # Rolling LAST-24h cost/tokens per runtime, from events in the trailing
+            # 24 hours. (A rolling window, not a calendar "today" — a calendar day
+            # starts at an arbitrary UTC midnight that's confusing across
+            # timezones.) cost_usd above is LIFETIME (all the runtime's sessions);
+            # the UI shows both. True windowed cost needs event-level cost+ts
+            # (which the cloud sessions table lacks) — so it's computed here on the
+            # daemon and rides the snapshot. Event cost is correct post-
+            # #web-accuracy re-ingest (deduped + current-gen rates).
+            from datetime import datetime as _dt, timezone as _tz, timedelta as _tdelta
+            _since_24h = (_dt.now(_tz.utc) - _tdelta(hours=24)).isoformat()
+            sql_24h = f"""
                 SELECT {rt_case} AS runtime,
-                       SUM(COALESCE(cost_usd, 0.0))    AS cost_today,
-                       SUM(COALESCE(token_count, 0))   AS tokens_today
+                       SUM(COALESCE(cost_usd, 0.0))    AS cost_24h,
+                       SUM(COALESCE(token_count, 0))   AS tokens_24h
                 FROM events
                 WHERE ts >= ?
                 GROUP BY 1
             """
-            for r in self._fetch(sql_today, list(prefixes) + [_today]):
+            for r in self._fetch(sql_24h, list(prefixes) + [_since_24h]):
                 rt = r[0] or "openclaw"
                 b = by_runtime.setdefault(rt, {
                     "sessions": 0, "tokens": 0, "cost_usd": 0.0,
-                    "cost_today_usd": 0.0, "tokens_today": 0})
-                b["cost_today_usd"] = float(r[1] or 0.0)
-                b["tokens_today"] = int(r[2] or 0)
+                    "cost_24h_usd": 0.0, "tokens_24h": 0})
+                b["cost_24h_usd"] = float(r[1] or 0.0)
+                b["tokens_24h"] = int(r[2] or 0)
             by_runtime_model: list[dict[str, Any]] = []
             sql_rtm = f"""
                 SELECT {rt_case} AS runtime,

{clawmetry-0.12.485 → clawmetry-0.12.487}/clawmetry/static/js/app.js

@@ -8493,14 +8493,14 @@ async function _invFetchData() {
   }
 }
 
-// An agent is "active/recent" (shown by default) when it's running, did work
-// today (cost or tokens), or is the currently-selected runtime. Everything else
-// folds under a "Show N inactive" expander so the roster reads like the device's
-// calm view instead of every runtime ever used on this machine (#web-accuracy).
+// An agent is "active/recent" (shown by default) when it's running, did work in
+// the last 24h (cost or tokens), or is the currently-selected runtime. Everything
+// else folds under a "Show N inactive" expander so the roster reads like the
+// device's calm view instead of every runtime ever used here (#web-accuracy).
 function _invIsRecentlyActive(a, rtFilter) {
   return !!(a.running
-    || (Number(a.costTodayUsd || 0) > 0)
-    || (Number(a.tokensToday || 0) > 0)
+    || (Number(a.cost24hUsd || 0) > 0)
+    || (Number(a.tokens24h || 0) > 0)
     || (rtFilter !== 'all' && a.agentKey === rtFilter));
 }
 
@@ -8511,10 +8511,10 @@ function _invRosterRow(a, rtFilter) {
   var dot = _invAliveDot(a);
   var owner = _invOwnerLabel(a);
   var hasCost = _invHasCost(rt);
-  // TODAY (event-windowed) vs LIFETIME (all the runtime's sessions). The column
-  // used to be labeled "Cost today" but rendered the lifetime total — fixed.
+  // LAST 24h (rolling, event-windowed) vs LIFETIME (all the runtime's sessions).
+  // The column used to be labeled "Cost today" but rendered the lifetime total.
   var naTip = '<span class="inv-na" data-i18n-title="inventory.cost_na_tip" title="This runtime does not report cost yet.">--</span>';
-  var todayCell = hasCost ? _invFmtUsd(a.costTodayUsd) : naTip;
+  var dayCell = hasCost ? _invFmtUsd(a.cost24hUsd) : naTip;
   var lifeCell = hasCost ? _invFmtUsd(a.costUsd) : naTip;
   var work = (a.sessions || 0) + ((a.sessions === 1) ? ' conversation' : ' conversations');
   var model = a.primaryModel || '--';
@@ -8529,7 +8529,7 @@ function _invRosterRow(a, rtFilter) {
     +   '<td class="inv-c-doing"><span class="inv-doing ' + doing.cls + '">' + doing.txt + '</span></td>'
     +   '<td class="inv-c-alive"><span class="inv-dot" style="background:' + dot.color + '"></span>'
     +     '<span class="inv-alive-lbl" title="For OpenClaw and NemoClaw this is a real heartbeat; for other runtimes it means a process is running.">' + dot.label + '</span></td>'
-    +   '<td class="inv-c-cost" title="Cost from today\'s activity (API-equivalent)">' + todayCell + '</td>'
+    +   '<td class="inv-c-cost" title="Cost from the last 24 hours of activity (API-equivalent)">' + dayCell + '</td>'
     +   '<td class="inv-c-cost inv-c-cost-life" title="All-time cost across this agent\'s tracked sessions (API-equivalent)">' + lifeCell + '</td>'
     +   '<td class="inv-c-work">' + escHtml(work) + '</td>'
     +   '<td class="inv-c-model">' + escHtml(model) + '</td>'
@@ -8556,7 +8556,7 @@ function _invRenderRoster(inv) {
       + '<tr class="inv-fold-toggle" onclick="_invToggleInactive(this)">'
       +   '<td colspan="8"><span class="inv-fold-caret">&#9656;</span> '
       +     'Show ' + inactive.length + ' inactive agent' + (inactive.length === 1 ? '' : 's')
-      +     ' <span class="inv-fold-hint">(no activity today)</span></td>'
+      +     ' <span class="inv-fold-hint">(no activity in 24h)</span></td>'
       + '</tr>'
       + '<tbody class="inv-fold-body" style="display:none;">'
       +   inactive.map(function (a) { return _invRosterRow(a, rtFilter); }).join('')
@@ -8570,7 +8570,7 @@ function _invRenderRoster(inv) {
     +     '<th data-i18n="inventory.col_owner">Owner</th>'
     +     '<th data-i18n="inventory.col_doing">Doing now</th>'
     +     '<th data-i18n="inventory.col_alive">Alive</th>'
-    +     '<th data-i18n="inventory.col_cost_today">Cost today</th>'
+    +     '<th data-i18n="inventory.col_cost_24h">Cost (24h)</th>'
     +     '<th data-i18n="inventory.col_cost_life">Cost (lifetime)</th>'
     +     '<th data-i18n="inventory.col_work">Work done</th>'
     +     '<th data-i18n="inventory.col_model">Main model</th>'

{clawmetry-0.12.485 → clawmetry-0.12.487}/clawmetry/sync.py

@@ -10956,9 +10956,10 @@ def _build_runtime_summary(limit: int = 20000):
                 "turns": total,
                 "tokens": int(totals.get("tokens") or 0),
                 "cost_usd": round(float(totals.get("cost_usd") or 0.0), 4),
-                # LIFETIME cost_usd above; today's slice for the dual-column UI.
-                "cost_today_usd": round(float(totals.get("cost_today_usd") or 0.0), 4),
-                "tokens_today": int(totals.get("tokens_today") or 0),
+                # LIFETIME cost_usd above; rolling last-24h slice for the
+                # dual-column UI.
+                "cost_24h_usd": round(float(totals.get("cost_24h_usd") or 0.0), 4),
+                "tokens_24h": int(totals.get("tokens_24h") or 0),
                 "primary_model": sorted_models[0][0] if sorted_models else "",
                 "total_turns": total,
                 "models": models_out,
@@ -11163,9 +11164,9 @@ def _build_agent_inventory(
                 "turns": summ.get("turns", 0),
                 "tokens": summ.get("tokens", 0),
                 "costUsd": round(float(summ.get("cost_usd", 0.0) or 0.0), 4),
-                # LIFETIME (costUsd) vs TODAY split for the dual-column roster.
-                "costTodayUsd": round(float(summ.get("cost_today_usd", 0.0) or 0.0), 4),
-                "tokensToday": summ.get("tokens_today", 0),
+                # LIFETIME (costUsd) vs rolling-24h split for the dual-column roster.
+                "cost24hUsd": round(float(summ.get("cost_24h_usd", 0.0) or 0.0), 4),
+                "tokens24h": summ.get("tokens_24h", 0),
                 "primaryModel": summ.get("primary_model", "") or "",
                 # already bounded to 15 in runtime_summary; trim to 5 for size.
                 "models": (summ.get("models") or [])[:5],

{clawmetry-0.12.485 → clawmetry-0.12.487/clawmetry.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clawmetry
-Version: 0.12.485
+Version: 0.12.487
 Summary: ClawMetry - Real-time observability for 12 AI agent runtimes (OpenClaw, NVIDIA NemoClaw, Claude Code, Codex & more)
 Home-page: https://github.com/vivekchand/clawmetry
 Author: Vivek Chand

{clawmetry-0.12.485 → clawmetry-0.12.487}/dashboard.py

@@ -235,7 +235,7 @@ def _otlp_service_name_to_agent_type(service_name):
     return slug or "custom"
 
 
-__version__ = "0.12.485"
+__version__ = "0.12.487"
 
 # Extensions (Phase 2): import the plugin host now, but defer the actual
 # load_plugins() call until after the Flask app is created below so we can
@@ -2753,7 +2753,16 @@ def _process_otlp_traces(pb_data, content_encoding=None, content_type=None):
                 # retries land as INSERT OR REPLACE without duping.
                 if _store is not None:
                     try:
-                        _store.put_span(_otel_to_row(span, resource_attrs))
+                        # Keyword arg is REQUIRED: in the dashboard process
+                        # get_store() returns a _ProxyStore that forwards to the
+                        # daemon writer, and the proxy only forwards **kwargs
+                        # (positional args are dropped). With a positional span
+                        # the write silently no-ops and OTLP spans never persist
+                        # whenever the daemon owns the writer lock (i.e. every
+                        # real install). put_span is allowlisted in
+                        # routes/local_query._DAEMON_METHODS so the daemon
+                        # executes the real write.
+                        _store.put_span(span=_otel_to_row(span, resource_attrs))
                     except Exception as e:
                         try:
                             import logging as _lg
@@ -10993,7 +11002,16 @@ def _process_otlp_traces(pb_data, content_encoding=None, content_type=None):
                 # retries land as INSERT OR REPLACE without duping.
                 if _store is not None:
                     try:
-                        _store.put_span(_otel_to_row(span, resource_attrs))
+                        # Keyword arg is REQUIRED: in the dashboard process
+                        # get_store() returns a _ProxyStore that forwards to the
+                        # daemon writer, and the proxy only forwards **kwargs
+                        # (positional args are dropped). With a positional span
+                        # the write silently no-ops and OTLP spans never persist
+                        # whenever the daemon owns the writer lock (i.e. every
+                        # real install). put_span is allowlisted in
+                        # routes/local_query._DAEMON_METHODS so the daemon
+                        # executes the real write.
+                        _store.put_span(span=_otel_to_row(span, resource_attrs))
                     except Exception as e:
                         try:
                             import logging as _lg

{clawmetry-0.12.485 → clawmetry-0.12.487}/routes/local_query.py

@@ -569,6 +569,15 @@ _DAEMON_METHODS = frozenset({
     # ever sent OTLP traces. Daemon snapshot-path use; allowlisted so the
     # local Inventory route can read it through the proxy too.
     "query_otlp_app_rollup",
+    # OTLP span WRITE-through. The /v1/traces receiver runs in the dashboard
+    # process, which does not own the DuckDB writer; get_store() returns a
+    # _ProxyStore that forwards put_span here so the daemon (the writer) does
+    # the real INSERT. Without this allowlist entry the proxy 400s and the span
+    # silently vanishes, so a "bring your own agent" OTLP app never persists or
+    # appears in the switcher / Inventory. Same write-through-proxy pattern as
+    # set_agent_meta. The handler calls put_span(span=...) by keyword (the proxy
+    # only forwards kwargs).
+    "put_span",
     # Issue #1364 (Tier-1 2026-05-15): /api/fallbacks model/provider
     # transition aggregator. Replaces a JSONL walker that opened up to 100
     # transcript files per request — multi-second on a busy workspace.

{clawmetry-0.12.485 → clawmetry-0.12.487}/tests/test_model_rollup_uncapped.py

@@ -138,19 +138,19 @@ def test_rollup_includes_every_runtime_with_exact_totals(store):
     assert round(by_rt["claude_code"]["cost_usd"], 2) == 4.00
 
 
-def test_rollup_carries_today_cost_split(store):
-    """by_runtime carries a TODAY slice (events in the current UTC day) distinct
-    from the LIFETIME cost_usd — the dual-column 'Your agents' view."""
+def test_rollup_carries_24h_cost_split(store):
+    """by_runtime carries a rolling LAST-24h slice (events in the trailing 24h)
+    distinct from the LIFETIME cost_usd — the dual-column 'Your agents' view."""
     from datetime import datetime, timezone
     now = datetime.now(timezone.utc).timestamp()
-    old = now - 5 * 86400  # 5 days ago → counts toward lifetime, not today
+    old = now - 5 * 86400  # 5 days ago → counts toward lifetime, not the 24h window
     _seed(store, "claude_code:c1", "claude-opus-4-8", now - 60, cost=2.0, eid="t1")
     _seed(store, "claude_code:c1", "claude-opus-4-8", old, cost=8.0, eid="t2")
     _seed_session(store, "claude_code:c1", tokens=100, cost=10.0)
     _wait_flush(store)
     roll = store.query_model_rollup()
     cc = roll["by_runtime"]["claude_code"]
-    assert round(cc["cost_today_usd"], 2) == 2.0, "today = only today's events"
+    assert round(cc["cost_24h_usd"], 2) == 2.0, "24h = only the last 24h of events"
     assert round(cc["cost_usd"], 2) == 10.0, "lifetime = the session total"
 
 

{clawmetry-0.12.485 → clawmetry-0.12.487}/tests/test_spans_otlp_edge_cases.py

@@ -674,3 +674,67 @@ def test_openllmetry_openai_chat_shape_end_to_end(app):
     sp_body = _spans(c, "?session_id=conv-xyz-789&limit=10")
     assert sp_body["count"] == 1
     assert sp_body["spans"][0]["span_id"] == _hx(0x90)
+
+
+class _RecordingProxy:
+    """Stand-in for the dashboard-process _ProxyStore: records every method
+    call (args + kwargs) and no-ops, mirroring how the real proxy forwards to
+    the daemon. Crucially it lets us assert the OTLP receiver passes the span
+    by KEYWORD (the real proxy drops positional args)."""
+
+    def __init__(self):
+        self.calls = []
+
+    def __getattr__(self, name):
+        def _f(*a, **k):
+            self.calls.append((name, a, k))
+            return None
+        return _f
+
+
+@pytest.mark.skipif(_ts_pb2 is None, reason="opentelemetry-proto not installed")
+def test_otlp_span_write_forwards_through_daemon_proxy(monkeypatch):
+    """Regression (caught live 2026-06-08): when the daemon owns the DuckDB
+    writer, the dashboard's get_store() returns a _ProxyStore that ONLY
+    forwards **kwargs (positional args are dropped). The OTLP /v1/traces
+    receiver therefore MUST call put_span(span=...) by keyword, and put_span
+    MUST be in routes.local_query._DAEMON_METHODS, or every OTLP span silently
+    no-ops and a bring-your-own-agent (OpenLLMetry) app never persists or shows
+    up in the runtime switcher / Agent Inventory. The other tests in this file
+    force single-process (`_daemon_registered` -> False), which is exactly why
+    they missed this; here we force the proxy path."""
+    import importlib
+    import clawmetry.local_store as ls
+    importlib.reload(ls)
+    rec = _RecordingProxy()
+    monkeypatch.setattr(ls, "get_store", lambda *a, **k: rec)
+
+    import dashboard as _d
+    pb = _build_pb(
+        [{
+            "span_id_hex": "1111111111111111",
+            "name": "openai.chat",
+            "start_ts": time.time(),
+            "str_attrs": {"gen_ai.system": "openai", "gen_ai.request.model": "gpt-4o"},
+            "int_attrs": {
+                "gen_ai.usage.input_tokens": 1200,
+                "gen_ai.usage.output_tokens": 350,
+            },
+        }],
+        service_name="my-langchain-app",
+    )
+    _d._process_otlp_traces(pb)
+
+    put_calls = [c for c in rec.calls if c[0] == "put_span"]
+    assert put_calls, "put_span was never called by the OTLP receiver"
+    _name, args, kwargs = put_calls[0]
+    # The real proxy drops positional args; the span MUST ride as a keyword.
+    assert not args, f"positional put_span args are dropped by the proxy: {args!r}"
+    assert "span" in kwargs, "put_span must be called as put_span(span=...)"
+    row = kwargs["span"]
+    # service.name -> per-app agent_type (the bring-your-own-agent identity).
+    assert row.get("agent_type") == "my_langchain_app", row.get("agent_type")
+
+    # And the daemon must accept the write, or the proxy 400s -> silent drop.
+    import routes.local_query as lq
+    assert "put_span" in lq._DAEMON_METHODS