ondemand-obs 0.1.0__tar.gz

ondemand_obs-0.1.0/PKG-INFO

@@ -0,0 +1,51 @@
+Metadata-Version: 2.4
+Name: ondemand-obs
+Version: 0.1.0
+Summary: OpenTelemetry observability layer for the Ondemand platform
+Author-email: Ondemand AI <dev@ondemand-ai.com.br>
+License: Apache-2.0
+Project-URL: Homepage, https://ondemand-ai.com.br
+Project-URL: Repository, https://github.com/Ondemand-AI/ondemand-obs
+Keywords: opentelemetry,observability,tracing,ondemand
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: opentelemetry-api>=1.27
+Requires-Dist: opentelemetry-sdk>=1.27
+Requires-Dist: opentelemetry-exporter-otlp-proto-http>=1.27
+Requires-Dist: opentelemetry-instrumentation-httpx>=0.48
+Requires-Dist: opentelemetry-instrumentation-requests>=0.48
+Provides-Extra: temporal
+Requires-Dist: temporalio>=1.7.0; extra == "temporal"
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23; extra == "dev"
+
+# ondemand-obs
+
+OpenTelemetry observability layer for the [Ondemand AI](https://ondemand-ai.com.br) platform. Ships traces, metrics, and logs to HyperDX (or any OTLP-compatible backend).
+
+## Usage
+
+Set `HYPERDX_API_KEY` in your environment. That's it — the `ondemand-ai[worker]` SDK calls `configure_observability()` automatically at worker startup.
+
+```bash
+HYPERDX_API_KEY=your-key OTEL_SERVICE_NAME=my-robot python -m src.main
+```
+
+## Install
+
+```bash
+pip install ondemand-obs           # base (traces, metrics, logs, httpx/requests auto-instrument)
+pip install "ondemand-obs[temporal]"  # + Temporal TracingInterceptor
+```
+
+## Environment variables
+
+| Variable | Required | Default |
+|---|---|---|
+| `HYPERDX_API_KEY` | Yes (disables if absent) | — |
+| `OTEL_SERVICE_NAME` | No | passed to `configure_observability()` |
+| `OTEL_EXPORTER_OTLP_ENDPOINT` | No | `https://in-otel.hyperdx.io` |

ondemand_obs-0.1.0/README.md

@@ -0,0 +1,26 @@
+# ondemand-obs
+
+OpenTelemetry observability layer for the [Ondemand AI](https://ondemand-ai.com.br) platform. Ships traces, metrics, and logs to HyperDX (or any OTLP-compatible backend).
+
+## Usage
+
+Set `HYPERDX_API_KEY` in your environment. That's it — the `ondemand-ai[worker]` SDK calls `configure_observability()` automatically at worker startup.
+
+```bash
+HYPERDX_API_KEY=your-key OTEL_SERVICE_NAME=my-robot python -m src.main
+```
+
+## Install
+
+```bash
+pip install ondemand-obs           # base (traces, metrics, logs, httpx/requests auto-instrument)
+pip install "ondemand-obs[temporal]"  # + Temporal TracingInterceptor
+```
+
+## Environment variables
+
+| Variable | Required | Default |
+|---|---|---|
+| `HYPERDX_API_KEY` | Yes (disables if absent) | — |
+| `OTEL_SERVICE_NAME` | No | passed to `configure_observability()` |
+| `OTEL_EXPORTER_OTLP_ENDPOINT` | No | `https://in-otel.hyperdx.io` |

ondemand_obs-0.1.0/ondemand_obs/__init__.py

@@ -0,0 +1,73 @@
+"""
+ondemand-obs — OpenTelemetry observability for the Ondemand platform.
+
+Usage in workers (automatic via ondemand-python SDK — no direct call needed):
+
+    from ondemand_obs import configure_observability
+    configure_observability("my-robot")
+
+Set HYPERDX_API_KEY in env to enable. No-op if the key is absent.
+"""
+
+import logging
+import os
+import threading
+
+from opentelemetry.sdk.resources import Resource, SERVICE_NAME
+
+from .config import ObsConfig
+from .traces import setup_traces
+from .metrics import setup_metrics
+from .logs import setup_logs
+from .instruments import setup_instruments
+
+logger = logging.getLogger("ondemand_obs")
+
+_configured = False
+_lock = threading.Lock()
+_log_handler = None
+
+
+def configure_observability(service_name: str, config: ObsConfig | None = None) -> None:
+    global _configured, _log_handler
+
+    if config is None:
+        config = ObsConfig()
+
+    if not config.api_key:
+        return
+
+    with _lock:
+        if _configured:
+            return
+
+        resource = Resource.create({
+            SERVICE_NAME: os.environ.get("OTEL_SERVICE_NAME", service_name),
+        })
+
+        headers = {"authorization": config.api_key}
+
+        setup_traces(config.endpoint, headers, resource)
+        setup_metrics(config.endpoint, headers, resource)
+        _, handler = setup_logs(config.endpoint, headers, resource)
+        setup_instruments()
+
+        _log_handler = handler
+        _configured = True
+
+        logger.info(f"ondemand-obs: observability enabled for service '{service_name}'")
+
+
+def is_configured() -> bool:
+    return _configured
+
+
+def get_otlp_log_handler() -> logging.Handler | None:
+    """Return the OTLP LoggingHandler, or None if not configured."""
+    return _log_handler
+
+
+def get_temporal_tracing_interceptor():
+    """Return a Temporal TracingInterceptor. Requires ondemand-obs[temporal]."""
+    from .temporal import get_tracing_interceptor
+    return get_tracing_interceptor()

ondemand_obs-0.1.0/ondemand_obs/config.py

@@ -0,0 +1,12 @@
+import os
+from dataclasses import dataclass, field
+
+HYPERDX_OTLP_ENDPOINT = "https://in-otel.hyperdx.io"
+
+
+@dataclass
+class ObsConfig:
+    endpoint: str = field(default_factory=lambda: os.environ.get(
+        "OTEL_EXPORTER_OTLP_ENDPOINT", HYPERDX_OTLP_ENDPOINT
+    ))
+    api_key: str = field(default_factory=lambda: os.environ.get("HYPERDX_API_KEY", ""))

ondemand_obs-0.1.0/ondemand_obs/instruments.py

@@ -0,0 +1,13 @@
+def setup_instruments() -> None:
+    """Register auto-instrumentation for common HTTP clients."""
+    try:
+        from opentelemetry.instrumentation.httpx import HTTPXClientInstrumentor
+        HTTPXClientInstrumentor().instrument()
+    except ImportError:
+        pass
+
+    try:
+        from opentelemetry.instrumentation.requests import RequestsInstrumentor
+        RequestsInstrumentor().instrument()
+    except ImportError:
+        pass

ondemand_obs-0.1.0/ondemand_obs/logs.py

@@ -0,0 +1,23 @@
+import logging
+
+from opentelemetry._logs import set_logger_provider
+from opentelemetry.sdk._logs import LoggerProvider
+from opentelemetry.sdk._logs.export import BatchLogRecordProcessor
+from opentelemetry.sdk.resources import Resource
+from opentelemetry.exporter.otlp.proto.http._log_exporter import OTLPLogExporter
+
+# LoggingHandler bridges Python's logging module → OTel log records → OTLP exporter
+try:
+    from opentelemetry.sdk._logs import LoggingHandler
+except ImportError:
+    # opentelemetry-sdk >= 1.28 may move this; fall back gracefully
+    from opentelemetry.sdk.logs import LoggingHandler  # type: ignore[no-redef]
+
+
+def setup_logs(endpoint: str, headers: dict, resource: Resource) -> tuple:
+    exporter = OTLPLogExporter(endpoint=f"{endpoint}/v1/logs", headers=headers)
+    provider = LoggerProvider(resource=resource)
+    provider.add_log_record_processor(BatchLogRecordProcessor(exporter))
+    set_logger_provider(provider)
+    handler = LoggingHandler(level=logging.NOTSET, logger_provider=provider)
+    return provider, handler

ondemand_obs-0.1.0/ondemand_obs/metrics.py

@@ -0,0 +1,13 @@
+from opentelemetry import metrics
+from opentelemetry.sdk.metrics import MeterProvider
+from opentelemetry.sdk.metrics.export import PeriodicExportingMetricReader
+from opentelemetry.sdk.resources import Resource
+from opentelemetry.exporter.otlp.proto.http.metric_exporter import OTLPMetricExporter
+
+
+def setup_metrics(endpoint: str, headers: dict, resource: Resource) -> MeterProvider:
+    exporter = OTLPMetricExporter(endpoint=f"{endpoint}/v1/metrics", headers=headers)
+    reader = PeriodicExportingMetricReader(exporter, export_interval_millis=60_000)
+    provider = MeterProvider(resource=resource, metric_readers=[reader])
+    metrics.set_meter_provider(provider)
+    return provider

ondemand_obs-0.1.0/ondemand_obs/temporal.py

@@ -0,0 +1,13 @@
+def get_tracing_interceptor():
+    """
+    Return a Temporal TracingInterceptor wired to the active OTel tracer provider.
+    Requires ondemand-obs[temporal] (temporalio>=1.7).
+    """
+    try:
+        from temporalio.contrib.opentelemetry import TracingInterceptor
+    except ImportError as e:
+        raise ImportError(
+            "temporalio is required for Temporal tracing. "
+            "Install ondemand-obs[temporal] or ondemand-ai[worker]."
+        ) from e
+    return TracingInterceptor()

ondemand_obs-0.1.0/ondemand_obs/traces.py

@@ -0,0 +1,13 @@
+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
+
+
+def setup_traces(endpoint: str, headers: dict, resource: Resource) -> TracerProvider:
+    exporter = OTLPSpanExporter(endpoint=f"{endpoint}/v1/traces", headers=headers)
+    provider = TracerProvider(resource=resource)
+    provider.add_span_processor(BatchSpanProcessor(exporter))
+    trace.set_tracer_provider(provider)
+    return provider

ondemand_obs-0.1.0/ondemand_obs.egg-info/PKG-INFO

@@ -0,0 +1,51 @@
+Metadata-Version: 2.4
+Name: ondemand-obs
+Version: 0.1.0
+Summary: OpenTelemetry observability layer for the Ondemand platform
+Author-email: Ondemand AI <dev@ondemand-ai.com.br>
+License: Apache-2.0
+Project-URL: Homepage, https://ondemand-ai.com.br
+Project-URL: Repository, https://github.com/Ondemand-AI/ondemand-obs
+Keywords: opentelemetry,observability,tracing,ondemand
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: opentelemetry-api>=1.27
+Requires-Dist: opentelemetry-sdk>=1.27
+Requires-Dist: opentelemetry-exporter-otlp-proto-http>=1.27
+Requires-Dist: opentelemetry-instrumentation-httpx>=0.48
+Requires-Dist: opentelemetry-instrumentation-requests>=0.48
+Provides-Extra: temporal
+Requires-Dist: temporalio>=1.7.0; extra == "temporal"
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23; extra == "dev"
+
+# ondemand-obs
+
+OpenTelemetry observability layer for the [Ondemand AI](https://ondemand-ai.com.br) platform. Ships traces, metrics, and logs to HyperDX (or any OTLP-compatible backend).
+
+## Usage
+
+Set `HYPERDX_API_KEY` in your environment. That's it — the `ondemand-ai[worker]` SDK calls `configure_observability()` automatically at worker startup.
+
+```bash
+HYPERDX_API_KEY=your-key OTEL_SERVICE_NAME=my-robot python -m src.main
+```
+
+## Install
+
+```bash
+pip install ondemand-obs           # base (traces, metrics, logs, httpx/requests auto-instrument)
+pip install "ondemand-obs[temporal]"  # + Temporal TracingInterceptor
+```
+
+## Environment variables
+
+| Variable | Required | Default |
+|---|---|---|
+| `HYPERDX_API_KEY` | Yes (disables if absent) | — |
+| `OTEL_SERVICE_NAME` | No | passed to `configure_observability()` |
+| `OTEL_EXPORTER_OTLP_ENDPOINT` | No | `https://in-otel.hyperdx.io` |

ondemand_obs-0.1.0/ondemand_obs.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+README.md
+pyproject.toml
+ondemand_obs/__init__.py
+ondemand_obs/config.py
+ondemand_obs/instruments.py
+ondemand_obs/logs.py
+ondemand_obs/metrics.py
+ondemand_obs/temporal.py
+ondemand_obs/traces.py
+ondemand_obs.egg-info/PKG-INFO
+ondemand_obs.egg-info/SOURCES.txt
+ondemand_obs.egg-info/dependency_links.txt
+ondemand_obs.egg-info/requires.txt
+ondemand_obs.egg-info/top_level.txt
+tests/test_configure.py

ondemand_obs-0.1.0/ondemand_obs.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

ondemand_obs-0.1.0/ondemand_obs.egg-info/requires.txt

@@ -0,0 +1,12 @@
+opentelemetry-api>=1.27
+opentelemetry-sdk>=1.27
+opentelemetry-exporter-otlp-proto-http>=1.27
+opentelemetry-instrumentation-httpx>=0.48
+opentelemetry-instrumentation-requests>=0.48
+
+[dev]
+pytest>=8.0
+pytest-asyncio>=0.23
+
+[temporal]
+temporalio>=1.7.0

ondemand_obs-0.1.0/ondemand_obs.egg-info/top_level.txt

@@ -0,0 +1 @@
+ondemand_obs

ondemand_obs-0.1.0/pyproject.toml

@@ -0,0 +1,39 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "ondemand-obs"
+version = "0.1.0"
+description = "OpenTelemetry observability layer for the Ondemand platform"
+readme = "README.md"
+requires-python = ">=3.9"
+license = {text = "Apache-2.0"}
+authors = [
+    {name = "Ondemand AI", email = "dev@ondemand-ai.com.br"}
+]
+keywords = ["opentelemetry", "observability", "tracing", "ondemand"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: Apache Software License",
+    "Topic :: Software Development :: Libraries",
+]
+
+dependencies = [
+    "opentelemetry-api>=1.27",
+    "opentelemetry-sdk>=1.27",
+    "opentelemetry-exporter-otlp-proto-http>=1.27",
+    "opentelemetry-instrumentation-httpx>=0.48",
+    "opentelemetry-instrumentation-requests>=0.48",
+]
+
+[project.optional-dependencies]
+temporal = ["temporalio>=1.7.0"]
+dev = ["pytest>=8.0", "pytest-asyncio>=0.23"]
+
+[project.urls]
+Homepage = "https://ondemand-ai.com.br"
+Repository = "https://github.com/Ondemand-AI/ondemand-obs"
+
+[tool.setuptools.packages.find]
+include = ["ondemand_obs*"]

ondemand_obs-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

ondemand_obs-0.1.0/tests/test_configure.py

@@ -0,0 +1,38 @@
+import importlib
+import os
+import sys
+
+
+def _reload_module():
+    """Reload ondemand_obs to reset global state between tests."""
+    for mod in list(sys.modules.keys()):
+        if mod.startswith("ondemand_obs"):
+            del sys.modules[mod]
+    import ondemand_obs
+    return ondemand_obs
+
+
+def test_noop_without_api_key(monkeypatch):
+    monkeypatch.delenv("HYPERDX_API_KEY", raising=False)
+    obs = _reload_module()
+    obs.configure_observability("test-service")
+    assert not obs.is_configured()
+    assert obs.get_otlp_log_handler() is None
+
+
+def test_idempotent(monkeypatch):
+    monkeypatch.setenv("HYPERDX_API_KEY", "test-key-123")
+    obs = _reload_module()
+    obs.configure_observability("svc-a")
+    obs.configure_observability("svc-b")  # second call should be no-op
+    assert obs.is_configured()
+    # If second call ran, it would raise because providers are already set.
+    # Reaching here means idempotency guard worked.
+
+
+def test_configured_with_key(monkeypatch):
+    monkeypatch.setenv("HYPERDX_API_KEY", "test-key-456")
+    obs = _reload_module()
+    obs.configure_observability("my-robot")
+    assert obs.is_configured()
+    assert obs.get_otlp_log_handler() is not None