jents 0.1.0__tar.gz

jents-0.1.0/.gitignore

@@ -0,0 +1,9 @@
+__pycache__/
+*.py[cod]
+*.egg-info/
+.eggs/
+build/
+dist/
+.venv/
+venv/
+.env

jents-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jents
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

jents-0.1.0/PKG-INFO

@@ -0,0 +1,73 @@
+Metadata-Version: 2.4
+Name: jents
+Version: 0.1.0
+Summary: Jents Capture — one line to capture your LLM usage (cost, tokens, latency) into Jents.
+Project-URL: Homepage, https://jents.io
+Project-URL: Documentation, https://app.jents.io/academy
+Author-email: Jents <niv@jents.io>
+License: MIT
+License-File: LICENSE
+Keywords: ai,anthropic,cost,jents,llm,observability,openai,telemetry
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.8
+Requires-Dist: opentelemetry-exporter-otlp-proto-http>=1.20
+Requires-Dist: opentelemetry-instrumentation-openai>=0.30
+Requires-Dist: opentelemetry-sdk>=1.20
+Provides-Extra: all
+Requires-Dist: opentelemetry-instrumentation-anthropic>=0.30; extra == 'all'
+Provides-Extra: anthropic
+Requires-Dist: opentelemetry-instrumentation-anthropic>=0.30; extra == 'anthropic'
+Description-Content-Type: text/markdown
+
+# jents
+
+One line to capture your LLM usage — cost, tokens, latency — into [Jents](https://jents.io).
+
+```bash
+pip install jents
+```
+
+```python
+import jents
+jents.init(api_key="<your ingest key>", team="<your team>")
+```
+
+That's it. Your existing OpenAI / Anthropic calls are now captured automatically and
+sent to your Jents workspace — attributed to the right team (and person, if you set
+`user_id`). Only **metadata** is sent (model, tokens, cost, latency); your prompts and
+responses never leave your process.
+
+Get an ingest key in Jents: **Observability → Capture → Generate ingest key**.
+
+## Options
+
+```python
+jents.init(
+    api_key="<your ingest key>",   # required
+    team="Sales",                  # per-team cost rollups
+    user_id="alice@company.com",   # optional per-person attribution
+    app_name="my-service",         # optional service label
+)
+```
+
+Capture Anthropic calls too:
+
+```bash
+pip install "jents[anthropic]"
+```
+
+Self-hosting Jents? Point at your own endpoint:
+
+```python
+jents.init(api_key="...", endpoint="https://jents.your-company.com/api/capture")
+```
+
+## How it works
+
+`jents` is a thin convenience layer over the [OpenTelemetry](https://opentelemetry.io)
+open standard: it configures an OTLP exporter aimed at your Jents Capture endpoint and
+turns on auto-instrumentation for your LLM clients. It composes cleanly with any other
+OpenTelemetry tracing you already run.

jents-0.1.0/README.md

@@ -0,0 +1,49 @@
+# jents
+
+One line to capture your LLM usage — cost, tokens, latency — into [Jents](https://jents.io).
+
+```bash
+pip install jents
+```
+
+```python
+import jents
+jents.init(api_key="<your ingest key>", team="<your team>")
+```
+
+That's it. Your existing OpenAI / Anthropic calls are now captured automatically and
+sent to your Jents workspace — attributed to the right team (and person, if you set
+`user_id`). Only **metadata** is sent (model, tokens, cost, latency); your prompts and
+responses never leave your process.
+
+Get an ingest key in Jents: **Observability → Capture → Generate ingest key**.
+
+## Options
+
+```python
+jents.init(
+    api_key="<your ingest key>",   # required
+    team="Sales",                  # per-team cost rollups
+    user_id="alice@company.com",   # optional per-person attribution
+    app_name="my-service",         # optional service label
+)
+```
+
+Capture Anthropic calls too:
+
+```bash
+pip install "jents[anthropic]"
+```
+
+Self-hosting Jents? Point at your own endpoint:
+
+```python
+jents.init(api_key="...", endpoint="https://jents.your-company.com/api/capture")
+```
+
+## How it works
+
+`jents` is a thin convenience layer over the [OpenTelemetry](https://opentelemetry.io)
+open standard: it configures an OTLP exporter aimed at your Jents Capture endpoint and
+turns on auto-instrumentation for your LLM clients. It composes cleanly with any other
+OpenTelemetry tracing you already run.

jents-0.1.0/pyproject.toml

@@ -0,0 +1,36 @@
+[project]
+name = "jents"
+version = "0.1.0"
+description = "Jents Capture — one line to capture your LLM usage (cost, tokens, latency) into Jents."
+readme = "README.md"
+requires-python = ">=3.8"
+license = { text = "MIT" }
+authors = [{ name = "Jents", email = "niv@jents.io" }]
+keywords = ["llm", "openai", "anthropic", "observability", "cost", "telemetry", "jents", "ai"]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "License :: OSI Approved :: MIT License",
+  "Operating System :: OS Independent",
+  "Topic :: Software Development :: Libraries",
+]
+dependencies = [
+  "opentelemetry-sdk>=1.20",
+  "opentelemetry-exporter-otlp-proto-http>=1.20",
+  "opentelemetry-instrumentation-openai>=0.30",
+]
+
+[project.optional-dependencies]
+# Capture Anthropic calls too: `pip install "jents[anthropic]"`
+anthropic = ["opentelemetry-instrumentation-anthropic>=0.30"]
+all = ["opentelemetry-instrumentation-anthropic>=0.30"]
+
+[project.urls]
+Homepage = "https://jents.io"
+Documentation = "https://app.jents.io/academy"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/jents"]

jents-0.1.0/src/jents/__init__.py

@@ -0,0 +1,91 @@
+"""Jents Capture — one line to send your LLM usage to Jents.
+
+    import jents
+    jents.init(api_key="<your ingest key>", team="<your team>")
+
+That's it. Your OpenAI / Anthropic calls are then captured automatically and sent
+to your Jents workspace (model, tokens, cost, latency — never prompt/response
+content). Get an ingest key in Jents under Observability → Capture → Generate
+ingest key.
+
+Built on the OpenTelemetry open standard; works alongside any other tracing you
+already run.
+"""
+from __future__ import annotations
+
+import logging
+from typing import Optional
+
+__all__ = ["init", "__version__"]
+__version__ = "0.1.0"
+
+# The Jents cloud Capture endpoint. Pass `endpoint=` to point at a self-hosted Jents.
+DEFAULT_ENDPOINT = "https://app.jents.io/api/capture"
+
+_log = logging.getLogger("jents")
+_initialized = False
+
+
+def init(
+    api_key: str,
+    team: Optional[str] = None,
+    user_id: Optional[str] = None,
+    endpoint: str = DEFAULT_ENDPOINT,
+    app_name: Optional[str] = None,
+) -> None:
+    """Start capturing this process's LLM calls into Jents.
+
+    Args:
+        api_key:  Your Jents ingest key (Observability → Capture → Generate ingest key).
+        team:     Team this usage belongs to, e.g. "Sales" — drives per-team cost rollups.
+        user_id:  Optional per-person attribution, e.g. an email.
+        endpoint: Jents Capture endpoint. Defaults to the Jents cloud.
+        app_name: Optional service name shown alongside the usage.
+
+    Safe to call once at startup; extra calls are ignored.
+    """
+    global _initialized
+    if _initialized:
+        return
+    if not api_key:
+        raise ValueError("jents.init: api_key is required — your Jents ingest key.")
+
+    from opentelemetry import trace
+    from opentelemetry.sdk.resources import Resource
+    from opentelemetry.sdk.trace import TracerProvider
+    from opentelemetry.sdk.trace.export import BatchSpanProcessor
+    from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
+
+    attrs = {}
+    if app_name:
+        attrs["service.name"] = app_name
+    if team:
+        attrs["jents.team"] = team
+    if user_id:
+        attrs["jents.user_id"] = user_id
+    resource = Resource.create(attrs) if attrs else Resource.create({})
+
+    provider = TracerProvider(resource=resource)
+    exporter = OTLPSpanExporter(
+        endpoint=endpoint.rstrip("/") + "/v1/traces",
+        headers={"Authorization": "Bearer " + api_key},
+    )
+    provider.add_span_processor(BatchSpanProcessor(exporter))
+    trace.set_tracer_provider(provider)
+
+    _instrument()
+    _initialized = True
+    _log.debug("jents: capturing to %s", endpoint)
+
+
+def _instrument() -> None:
+    """Best-effort auto-instrumentation for whatever LLM SDKs are installed."""
+    for module_name, class_name in (
+        ("opentelemetry.instrumentation.openai", "OpenAIInstrumentor"),
+        ("opentelemetry.instrumentation.anthropic", "AnthropicInstrumentor"),
+    ):
+        try:
+            module = __import__(module_name, fromlist=[class_name])
+            getattr(module, class_name)().instrument()
+        except Exception:  # SDK not installed / instrumentation unavailable — skip quietly
+            continue