tracecast 0.2.5__tar.gz → 0.2.7__tar.gz

{tracecast-0.2.5/tracecast.egg-info → tracecast-0.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tracecast
-Version: 0.2.5
+Version: 0.2.7
 Summary: LLM observability SDK — framework-agnostic tracing for AI applications
 Author: Pedro Castanheira Costa
 License: MIT

{tracecast-0.2.5 → tracecast-0.2.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tracecast"
-version = "0.2.5"
+version = "0.2.7"
 description = "LLM observability SDK — framework-agnostic tracing for AI applications"
 readme = "README.md"
 license = { text = "MIT" }

{tracecast-0.2.5 → tracecast-0.2.7}/tests/test_cost_calculator.py

@@ -1,5 +1,5 @@
 import pytest
-from tracecast.core.cost_calculator import calculate_cost, PRICE_TABLE
+from tracecast.core.cost_calculator import calculate_cost, calculate_audio_cost, PRICE_TABLE
 
 @pytest.mark.parametrize("model", [
     "gpt-4o", "gpt-4o-mini", "gpt-4-turbo",
@@ -151,3 +151,53 @@ def test_modelos_sem_suporte_a_cache_nao_tem_chave_cached():
     modelos_sem_cache = ["gpt-4-turbo", "gemini-2.5-flash", "llama-4-scout"]
     for model in modelos_sem_cache:
         assert "cached" not in PRICE_TABLE[model], f"{model} nao deveria ter preco de cache"
+
+
+# --- gpt-4.1-nano (bug: ausente da tabela, custo virava $0 silenciosamente) ---
+
+def test_gpt_4_1_nano_tem_preco():
+    assert "gpt-4.1-nano" in PRICE_TABLE
+
+
+def test_calcula_custo_gpt_4_1_nano():
+    # $0.10 / $0.40 por 1M tokens = 0.00010 / 0.00040 por 1k
+    cost = calculate_cost("gpt-4.1-nano", tokens_in=1000, tokens_out=1000)
+    assert abs(cost - (0.00010 + 0.00040)) < 1e-9
+
+
+def test_gpt_4_1_nano_cached_e_25_pct_do_input():
+    # mesmo padrao dos irmaos gpt-4.1 / gpt-4.1-mini: cached = 25% do input
+    entry = PRICE_TABLE["gpt-4.1-nano"]
+    assert abs(entry["cached"] - entry["input"] * 0.25) < 1e-9
+
+
+# --- embeddings (bug: nunca precificados, custo $0 mesmo se instrumentados) ---
+
+@pytest.mark.parametrize("model,expected_input", [
+    ("text-embedding-3-small", 0.00002),
+    ("text-embedding-3-large", 0.00013),
+    ("text-embedding-ada-002", 0.00010),
+])
+def test_calcula_custo_embeddings(model, expected_input):
+    cost = calculate_cost(model, tokens_in=1000, tokens_out=0)
+    assert abs(cost - expected_input) < 1e-9
+
+
+# --- audio (bug: whisper/tts nunca precificados nem instrumentados) ---
+
+def test_calculate_audio_cost_whisper_por_minuto():
+    cost = calculate_audio_cost("whisper-1", minutes=2.5)
+    assert abs(cost - (2.5 * 0.006)) < 1e-9
+
+
+def test_calculate_audio_cost_tts_por_caractere():
+    cost = calculate_audio_cost("gpt-4o-mini-tts", chars=1000)
+    assert cost > 0
+
+
+def test_calculate_audio_cost_modelo_desconhecido_retorna_zero():
+    assert calculate_audio_cost("modelo-inexistente", minutes=10) == 0.0
+
+
+def test_calculate_audio_cost_sem_uso_retorna_zero():
+    assert calculate_audio_cost("whisper-1") == 0.0

{tracecast-0.2.5 → tracecast-0.2.7}/tests/test_dashboard_pushdown.py

@@ -108,3 +108,49 @@ def test_index_injects_prefix():
     resp = client.get("/tc/")
     assert resp.status_code == 200
     assert 'window.__TC_PREFIX__ = "/tc"' in resp.text
+
+
+def test_get_traces_for_metrics_bypasses_max_traces_cap():
+    exporter = FakeReadableExporter([_trace(f"t{i}", "p1", i) for i in range(5)])
+    reader = TraceReader([exporter], max_traces=2)
+    assert len(reader.get_traces_for_metrics()) == 5
+
+
+def test_api_metrics_bypasses_max_traces_cap():
+    exporter = FakeReadableExporter([_trace(f"t{i}", "p1", i) for i in range(5)])
+    tracer = Tracer(exporters=[exporter])
+    app = FastAPI()
+    tracer.mount(app, prefix="/tc", max_traces=2)
+    client = TestClient(app)
+    resp = client.get("/tc/api/metrics", params={"from": "2020-01-01T00:00:00Z", "to": "2030-01-01T00:00:00Z"})
+    assert resp.status_code == 200
+    assert resp.json()["total_traces"] == 5
+
+
+def _trace_named_project(trace_id, project_name, offset_min=0):
+    base = datetime(2026, 6, 1, tzinfo=timezone.utc) + timedelta(minutes=offset_min)
+    t = Trace(trace_id=trace_id, name="req", started_at=base, project_name=project_name)
+    t.finished_at = base + timedelta(seconds=1)
+    t._finalize()
+    return t
+
+
+def test_get_filter_options_bypasses_max_traces_cap():
+    # "rare-project" is the oldest trace; a small cap sorted by recency would drop it.
+    exporter = FakeReadableExporter([
+        _trace_named_project("old", "rare-project", offset_min=0),
+        *[_trace_named_project(f"t{i}", "common-project", offset_min=10 + i) for i in range(5)],
+    ])
+    reader = TraceReader([exporter], max_traces=3)
+    opts = reader.get_filter_options()
+    assert "rare-project" in opts["project_names"]
+
+
+def test_get_projects_bypasses_max_traces_cap():
+    exporter = FakeReadableExporter([
+        _trace_named_project("old", "rare-project", offset_min=0),
+        *[_trace_named_project(f"t{i}", "common-project", offset_min=10 + i) for i in range(5)],
+    ])
+    reader = TraceReader([exporter], max_traces=3)
+    names = {p["project_name"] for p in reader.get_projects()}
+    assert "rare-project" in names

{tracecast-0.2.5 → tracecast-0.2.7}/tracecast/core/cost_calculator.py

@@ -8,9 +8,14 @@ PRICE_TABLE: Dict[str, Dict[str, float]] = {
     "gpt-4-turbo":       {"input": 0.01000,  "output": 0.03000},
     "gpt-4.1":           {"input": 0.00200,  "output": 0.00800,  "cached": 0.000500},
     "gpt-4.1-mini":      {"input": 0.00040,  "output": 0.00160,  "cached": 0.000100},
+    "gpt-4.1-nano":      {"input": 0.00010,  "output": 0.00040,  "cached": 0.000025},
     "o3":                {"input": 0.00200,  "output": 0.00800,  "cached": 0.000500},
     "o4-mini":           {"input": 0.00110,  "output": 0.00440,  "cached": 0.000275},
 
+    "text-embedding-3-small": {"input": 0.00002, "output": 0.0},
+    "text-embedding-3-large": {"input": 0.00013, "output": 0.0},
+    "text-embedding-ada-002": {"input": 0.00010, "output": 0.0},
+
     "claude-opus-4-6":   {"input": 0.00500,  "output": 0.02500,  "cached": 0.000500},
     "claude-sonnet-4-6": {"input": 0.00300,  "output": 0.01500,  "cached": 0.000300},
     "claude-haiku-4-5":  {"input": 0.00100,  "output": 0.00500,  "cached": 0.000100},
@@ -62,3 +67,24 @@ def calculate_cost(
 def _prefix_match(model: str, prices: Dict) -> Optional[Dict]:
     provider = model.split("/")[0] + "/*"
     return prices.get(provider)
+
+
+# Audio isn't token-billed: transcription is per-minute of input audio, TTS is
+# per-character of input text. gpt-4o-mini-tts's rate is an approximation
+# (not published on OpenAI's current pricing page as of 2026-07) — verify
+# against an actual invoice before trusting it for reconciliation.
+AUDIO_PRICE_TABLE: Dict[str, Dict[str, float]] = {
+    "whisper-1":       {"unit": "minute", "price": 0.006},
+    "gpt-4o-mini-tts": {"unit": "char",   "price": 0.000015},
+    "tts-1":           {"unit": "char",   "price": 0.000015},
+    "tts-1-hd":        {"unit": "char",   "price": 0.00003},
+}
+
+
+def calculate_audio_cost(model: str, *, minutes: float = 0.0, chars: int = 0) -> float:
+    entry = AUDIO_PRICE_TABLE.get(model)
+    if not entry:
+        return 0.0
+    if entry["unit"] == "minute":
+        return minutes * entry["price"]
+    return chars * entry["price"]

{tracecast-0.2.5 → tracecast-0.2.7}/tracecast/dashboard/reader.py

@@ -71,6 +71,22 @@ class TraceReader:
         )
         return [_hydrate_trace(r) for r in rows], total
 
+    def get_traces_for_metrics(
+        self,
+        project_name: Optional[str] = None,
+        project_id: Optional[str] = None,
+    ) -> List[Trace]:
+        """Like get_traces() but bypasses max_traces for queryable exporters,
+        so dashboard aggregates reflect the full dataset instead of a capped window."""
+        exporter = self._readable()
+        if exporter is None:
+            return self.get_traces()
+        total = exporter.count(project_name=project_name, project_id=project_id)
+        if total <= 0:
+            return []
+        rows = exporter.query(project_name=project_name, project_id=project_id, limit=total, offset=0)
+        return [_hydrate_trace(r) for r in rows]
+
     def get_trace(self, trace_id: str) -> Optional[Trace]:
         exporter = self._readable()
         if exporter is not None and callable(getattr(exporter, "get", None)):
@@ -89,30 +105,30 @@ class TraceReader:
     ) -> list:
         from .aggregator import compute_sessions
         return compute_sessions(
-            self.get_traces(),
+            self.get_traces_for_metrics(),
             project_name=project_name,
             project_id=project_id,
             user_id=user_id,
         )
 
     def get_session(self, session_id: str) -> List[Trace]:
-        return [t for t in self.get_traces() if t.session_id == session_id]
+        return [t for t in self.get_traces_for_metrics() if t.session_id == session_id]
 
     def get_projects(self) -> list:
         from .aggregator import compute_projects
-        return compute_projects(self.get_traces())
+        return compute_projects(self.get_traces_for_metrics())
 
     def get_subprojects(self, project_name: str) -> list:
         from .aggregator import compute_projects_by_id
-        traces = [t for t in self.get_traces() if t.project_name == project_name]
+        traces = [t for t in self.get_traces_for_metrics() if t.project_name == project_name]
         return compute_projects_by_id(traces)
 
     def get_project(self, project_id: str) -> List[Trace]:
-        return [t for t in self.get_traces() if t.project_id == project_id]
+        return [t for t in self.get_traces_for_metrics() if t.project_id == project_id]
 
     def get_filter_options(self) -> dict:
         from .aggregator import compute_filter_options
-        return compute_filter_options(self.get_traces())
+        return compute_filter_options(self.get_traces_for_metrics())
 
     def _read_from(self, exporter) -> List[Trace]:
         name = type(exporter).__name__

{tracecast-0.2.5 → tracecast-0.2.7}/tracecast/dashboard/router.py

@@ -122,7 +122,7 @@ def _make_router(reader: TraceReader, prefix: str = "") -> "APIRouter":
         project_name: Optional[str] = Query(None),
         project_id: Optional[str] = Query(None),
     ):
-        traces = reader.get_traces()
+        traces = reader.get_traces_for_metrics(project_name=project_name, project_id=project_id)
         from_parsed = _parse_iso(from_dt)
         to_parsed = _parse_iso(to_dt)
         return compute_metrics(