bryel 0.1.0__py3-none-any.whl

bryel/__init__.py

@@ -0,0 +1,131 @@
+"""bryel — OpenTelemetry-native tracing for LLM apps and agents.
+
+One call configures OpenTelemetry to ship traces to bryel; then any
+OpenInference instrumentor (OpenAI, Anthropic, LangChain, LlamaIndex, …) flows
+through automatically:
+
+    import bryel
+    bryel.init(api_key="bk_…", service_name="my-app")
+
+    from openinference.instrumentation.openai import OpenAIInstrumentor
+    OpenAIInstrumentor().instrument()
+
+or let bryel instrument every installed OpenInference library for you:
+
+    bryel.init(api_key="bk_…", instrument=True)
+
+bryel's ingest normalizes both the OpenInference (`llm.*`, `openinference.*`) and
+OpenTelemetry GenAI (`gen_ai.*`) conventions, so there is nothing to map
+client-side — the SDK is just the exporter.
+"""
+
+from __future__ import annotations
+
+import os
+from typing import List, Mapping, Optional
+
+from opentelemetry import trace
+from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
+from opentelemetry.sdk.resources import SERVICE_NAME, Resource
+from opentelemetry.sdk.trace import TracerProvider
+from opentelemetry.sdk.trace.export import BatchSpanProcessor
+
+__all__ = ["init", "auto_instrument", "shutdown", "DEFAULT_INGEST_ENDPOINT", "__version__"]
+
+__version__ = "0.1.0"
+
+#: OTLP/HTTP traces endpoint for the bryel SaaS ingest. The receiver stamps
+#: tenant/project from the API key server-side — the SDK never sends them.
+DEFAULT_INGEST_ENDPOINT = "https://ingest.eu.bryel.ai/v1/traces"
+
+# Common OpenInference instrumentors, tried in order by auto_instrument(). Each
+# is optional — missing ones are skipped, nothing is a hard dependency.
+_INSTRUMENTORS = [
+    ("openinference.instrumentation.openai", "OpenAIInstrumentor"),
+    ("openinference.instrumentation.anthropic", "AnthropicInstrumentor"),
+    ("openinference.instrumentation.langchain", "LangChainInstrumentor"),
+    ("openinference.instrumentation.llama_index", "LlamaIndexInstrumentor"),
+    ("openinference.instrumentation.bedrock", "BedrockInstrumentor"),
+    ("openinference.instrumentation.groq", "GroqInstrumentor"),
+    ("openinference.instrumentation.mistralai", "MistralAIInstrumentor"),
+    ("openinference.instrumentation.vertexai", "VertexAIInstrumentor"),
+]
+
+_provider: Optional[TracerProvider] = None
+
+
+def init(
+    api_key: Optional[str] = None,
+    *,
+    service_name: Optional[str] = None,
+    endpoint: Optional[str] = None,
+    headers: Optional[Mapping[str, str]] = None,
+    set_global: bool = True,
+    instrument: bool = False,
+) -> TracerProvider:
+    """Configure OpenTelemetry to ship traces to bryel and return the provider.
+
+    Args:
+        api_key: your bryel project API key (``bk_…``). Falls back to the
+            ``BRYEL_KEY`` environment variable.
+        service_name: OpenTelemetry ``service.name`` for this app. Optional.
+        endpoint: OTLP/HTTP traces URL. Defaults to the bryel ingest, or the
+            ``BRYEL_INGEST_URL`` env var if set (for self-hosting).
+        headers: extra headers, merged after the auth header.
+        set_global: register the provider as the global OpenTelemetry provider
+            (so instrumentors pick it up automatically). Default True.
+        instrument: also auto-instrument every installed OpenInference library
+            (see :func:`auto_instrument`). Default False.
+
+    Returns:
+        The configured ``TracerProvider`` (keep it to call ``.shutdown()``).
+    """
+    global _provider
+
+    key = api_key or os.environ.get("BRYEL_KEY")
+    if not key:
+        raise ValueError("bryel.init: api_key is required (pass api_key=… or set BRYEL_KEY)")
+
+    resource = Resource.create({SERVICE_NAME: service_name} if service_name else {})
+    exporter = OTLPSpanExporter(
+        endpoint=endpoint or os.environ.get("BRYEL_INGEST_URL") or DEFAULT_INGEST_ENDPOINT,
+        headers={"Authorization": f"Bearer {key}", **(dict(headers) if headers else {})},
+    )
+    provider = TracerProvider(resource=resource)
+    provider.add_span_processor(BatchSpanProcessor(exporter))
+
+    if set_global:
+        trace.set_tracer_provider(provider)
+    _provider = provider
+
+    if instrument:
+        auto_instrument(tracer_provider=provider)
+
+    return provider
+
+
+def auto_instrument(tracer_provider: Optional[TracerProvider] = None) -> List[str]:
+    """Best-effort: instrument every installed OpenInference library.
+
+    Safe to call whether or not any instrumentors are installed — missing ones
+    are skipped. Returns the names of the libraries that were instrumented.
+    """
+    instrumented: List[str] = []
+    kwargs = {"tracer_provider": tracer_provider} if tracer_provider is not None else {}
+    for module_name, class_name in _INSTRUMENTORS:
+        try:
+            module = __import__(module_name, fromlist=[class_name])
+            getattr(module, class_name)().instrument(**kwargs)
+            instrumented.append(class_name)
+        except Exception:
+            # not installed, or already instrumented — skip it
+            continue
+    return instrumented
+
+
+def shutdown() -> None:
+    """Flush pending spans and shut down the provider. Call on process exit."""
+    global _provider
+    if _provider is not None:
+        _provider.shutdown()
+        _provider = None

bryel-0.1.0.dist-info/METADATA

@@ -0,0 +1,101 @@
+Metadata-Version: 2.4
+Name: bryel
+Version: 0.1.0
+Summary: OpenTelemetry-native tracing for LLM apps and agents — ships OpenInference/OTLP traces to bryel.
+Project-URL: Homepage, https://docs.bryel.ai
+Project-URL: Documentation, https://docs.bryel.ai
+Author: bryel
+License-Expression: MIT
+Keywords: bryel,genai,llm,observability,openinference,opentelemetry,tracing
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Requires-Dist: opentelemetry-api>=1.20.0
+Requires-Dist: opentelemetry-exporter-otlp-proto-http>=1.20.0
+Requires-Dist: opentelemetry-sdk>=1.20.0
+Provides-Extra: anthropic
+Requires-Dist: openinference-instrumentation-anthropic; extra == 'anthropic'
+Provides-Extra: bedrock
+Requires-Dist: openinference-instrumentation-bedrock; extra == 'bedrock'
+Provides-Extra: langchain
+Requires-Dist: openinference-instrumentation-langchain; extra == 'langchain'
+Provides-Extra: llama-index
+Requires-Dist: openinference-instrumentation-llama-index; extra == 'llama-index'
+Provides-Extra: openai
+Requires-Dist: openinference-instrumentation-openai; extra == 'openai'
+Description-Content-Type: text/markdown
+
+# bryel (Python)
+
+OpenTelemetry-native tracing for LLM apps and agents. One call ships your model
+calls, tool calls, tokens, and cost to [bryel](https://docs.bryel.ai) as
+OpenInference traces — from any framework.
+
+```bash
+uv add bryel            # or: pip install bryel
+```
+
+## Quickstart
+
+```python
+import bryel
+bryel.init(api_key="bk_…", service_name="my-app")
+
+# Trace OpenAI (any OpenInference instrumentor works the same way):
+from openinference.instrumentation.openai import OpenAIInstrumentor
+OpenAIInstrumentor().instrument()
+
+from openai import OpenAI
+OpenAI().chat.completions.create(
+    model="gpt-4o-mini",
+    messages=[{"role": "user", "content": "hello"}],
+)
+```
+
+Prefer bryel to wire up everything it can find? Let it instrument every installed
+OpenInference library for you:
+
+```python
+import bryel
+bryel.init(api_key="bk_…", instrument=True)   # instruments openai, anthropic, langchain, …
+```
+
+## How it works
+
+bryel is just the exporter. It configures an OpenTelemetry `TracerProvider` with
+an OTLP/HTTP exporter pointed at the bryel ingest, authenticated with your API
+key. The [OpenInference instrumentors](https://github.com/Arize-ai/openinference)
+emit the spans; bryel's ingest normalizes both the OpenInference (`llm.*`) and
+OpenTelemetry GenAI (`gen_ai.*`) conventions — so there's nothing to map.
+
+## API
+
+### `bryel.init(api_key=None, *, service_name=None, endpoint=None, headers=None, set_global=True, instrument=False)`
+
+Configures the exporter and returns the `TracerProvider`.
+
+- `api_key` — your project API key (`bk_…`). Falls back to `$BRYEL_KEY`.
+- `service_name` — OpenTelemetry `service.name`.
+- `endpoint` — OTLP/HTTP traces URL. Defaults to the bryel ingest, or
+  `$BRYEL_INGEST_URL` for self-hosting.
+- `headers` — extra headers, merged after auth.
+- `set_global` — register as the global OTel provider (default `True`).
+- `instrument` — also auto-instrument installed OpenInference libraries.
+
+### `bryel.auto_instrument(tracer_provider=None) -> list[str]`
+
+Best-effort instrument every installed OpenInference library. Returns the ones it
+wired up. Safe to call with none installed.
+
+### `bryel.shutdown()`
+
+Flush pending spans and shut down. Call on process exit.
+
+## Feedback and grouping
+
+Group turns into a conversation and attach 👍/👎 by stamping metadata on your
+spans — set `session.id`, `user.id`, and a `bryel.interaction.id` you mint. See
+the [docs](https://docs.bryel.ai).
+
+MIT © bryel

bryel-0.1.0.dist-info/RECORD

@@ -0,0 +1,4 @@
+bryel/__init__.py,sha256=dqV7aNlFLFET6vJ2vB1rNZ-BHMc_k_y6qTrBc9FOQt8,5219
+bryel-0.1.0.dist-info/METADATA,sha256=5kCHdDytGGzuMHmedi842Flh1kpablzcFtHPG9HBZtk,3727
+bryel-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+bryel-0.1.0.dist-info/RECORD,,

bryel-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any