obtrace-sdk-python 1.0.0__tar.gz → 2.0.0__tar.gz

obtrace_sdk_python-2.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024-present Obtrace
+
+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.

{obtrace_sdk_python-1.0.0 → obtrace_sdk_python-2.0.0}/PKG-INFO

@@ -1,20 +1,30 @@
 Metadata-Version: 2.4
 Name: obtrace-sdk-python
-Version: 1.0.0
+Version: 2.0.0
 Summary: Obtrace Python SDK
 Author: Obtrace
-Classifier: License :: OSI Approved :: MIT License
+License-Expression: MIT
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
-Provides-Extra: requests
-Requires-Dist: requests>=2.31.0; extra == "requests"
-Provides-Extra: httpx
-Requires-Dist: httpx>=0.27.0; extra == "httpx"
-Provides-Extra: fastapi
-Requires-Dist: fastapi>=0.112.0; extra == "fastapi"
-Requires-Dist: starlette>=0.37.0; extra == "fastapi"
-Provides-Extra: flask
-Requires-Dist: flask>=3.0.0; extra == "flask"
+License-File: LICENSE
+Requires-Dist: opentelemetry-sdk>=1.20.0
+Requires-Dist: opentelemetry-api>=1.20.0
+Requires-Dist: opentelemetry-exporter-otlp-proto-http>=1.20.0
+Requires-Dist: opentelemetry-instrumentation-requests
+Requires-Dist: opentelemetry-instrumentation-httpx
+Requires-Dist: opentelemetry-instrumentation-urllib
+Requires-Dist: opentelemetry-instrumentation-flask
+Requires-Dist: opentelemetry-instrumentation-fastapi
+Requires-Dist: opentelemetry-instrumentation-django
+Requires-Dist: opentelemetry-instrumentation-logging
+Requires-Dist: opentelemetry-instrumentation-psycopg2
+Requires-Dist: opentelemetry-instrumentation-redis
+Requires-Dist: opentelemetry-instrumentation-sqlalchemy
+Requires-Dist: opentelemetry-instrumentation-celery
+Requires-Dist: opentelemetry-instrumentation-grpc
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Dynamic: license-file
 
 # obtrace-sdk-python
 
@@ -34,7 +44,7 @@ SDK is thin/dumb.
 ## Install
 
 ```bash
-pip install .
+pip install obtrace-sdk-python
 ```
 
 ## Configuration

{obtrace_sdk_python-1.0.0 → obtrace_sdk_python-2.0.0}/README.md

@@ -16,7 +16,7 @@ SDK is thin/dumb.
 ## Install
 
 ```bash
-pip install .
+pip install obtrace-sdk-python
 ```
 
 ## Configuration

obtrace_sdk_python-2.0.0/pyproject.toml

@@ -0,0 +1,38 @@
+[build-system]
+requires = ["setuptools>=69", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "obtrace-sdk-python"
+version = "2.0.0"
+description = "Obtrace Python SDK"
+license = "MIT"
+requires-python = ">=3.10"
+readme = "README.md"
+authors = [{ name = "Obtrace" }]
+dependencies = [
+    "opentelemetry-sdk>=1.20.0",
+    "opentelemetry-api>=1.20.0",
+    "opentelemetry-exporter-otlp-proto-http>=1.20.0",
+    "opentelemetry-instrumentation-requests",
+    "opentelemetry-instrumentation-httpx",
+    "opentelemetry-instrumentation-urllib",
+    "opentelemetry-instrumentation-flask",
+    "opentelemetry-instrumentation-fastapi",
+    "opentelemetry-instrumentation-django",
+    "opentelemetry-instrumentation-logging",
+    "opentelemetry-instrumentation-psycopg2",
+    "opentelemetry-instrumentation-redis",
+    "opentelemetry-instrumentation-sqlalchemy",
+    "opentelemetry-instrumentation-celery",
+    "opentelemetry-instrumentation-grpc",
+]
+
+[project.optional-dependencies]
+dev = ["pytest>=8.0"]
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]

obtrace_sdk_python-2.0.0/src/obtrace_sdk/__init__.py

@@ -0,0 +1,17 @@
+from .client import ObtraceClient
+from .logging_handler import ObtraceLoggingHandler, install_logging_hook
+from .otel_setup import setup_otel, OtelProviders
+from .semantic_metrics import SemanticMetrics, is_semantic_metric
+from .types import ObtraceConfig, SDKContext
+
+__all__ = [
+    "ObtraceClient",
+    "ObtraceConfig",
+    "ObtraceLoggingHandler",
+    "OtelProviders",
+    "SDKContext",
+    "SemanticMetrics",
+    "install_logging_hook",
+    "is_semantic_metric",
+    "setup_otel",
+]

obtrace_sdk_python-2.0.0/src/obtrace_sdk/client.py

@@ -0,0 +1,169 @@
+from __future__ import annotations
+
+import logging
+from contextlib import contextmanager
+from typing import Any, Dict, Iterator, Optional
+
+from opentelemetry._logs.severity import SeverityNumber
+from opentelemetry.instrumentation.logging.handler import LoggingHandler
+from opentelemetry.trace import StatusCode
+
+from .otel_setup import setup_otel
+from .semantic_metrics import is_semantic_metric
+from .types import ObtraceConfig, SDKContext
+
+_SDK_SCOPE = "obtrace-sdk-python"
+_logger = logging.getLogger("obtrace")
+_initialized = False
+
+
+class ObtraceClient:
+    def __init__(self, cfg: ObtraceConfig):
+        global _initialized
+        if not cfg.api_key or not cfg.ingest_base_url or not cfg.service_name:
+            raise ValueError("api_key, ingest_base_url and service_name are required")
+        if _initialized:
+            _logger.warning("obtrace: ObtraceClient already initialized, creating duplicate instance")
+        _initialized = True
+        self.cfg = cfg
+        self._providers = setup_otel(cfg)
+        self._tracer = self._providers.tracer_provider.get_tracer(_SDK_SCOPE)
+        self._meter = self._providers.meter_provider.get_meter(_SDK_SCOPE)
+        self._logger = self._providers.logger_provider.get_logger(_SDK_SCOPE)
+        self._counters: Dict[str, Any] = {}
+        self._histograms: Dict[str, Any] = {}
+        self._otel_logging_handler = LoggingHandler(
+            level=logging.DEBUG,
+            logger_provider=self._providers.logger_provider,
+        )
+        logging.root.addHandler(self._otel_logging_handler)
+
+    def __enter__(self) -> ObtraceClient:
+        return self
+
+    def __exit__(self, *_: Any) -> None:
+        self.shutdown()
+
+    def log(self, level: str, message: str, context: Optional[SDKContext] = None) -> None:
+        severity = _level_to_severity(level)
+        attrs: Dict[str, Any] = {}
+        if context:
+            if context.trace_id:
+                attrs["obtrace.trace_id"] = context.trace_id
+            if context.span_id:
+                attrs["obtrace.span_id"] = context.span_id
+            if context.session_id:
+                attrs["obtrace.session_id"] = context.session_id
+            if context.route_template:
+                attrs["obtrace.route_template"] = context.route_template
+            if context.endpoint:
+                attrs["obtrace.endpoint"] = context.endpoint
+            if context.method:
+                attrs["obtrace.method"] = context.method
+            if context.status_code is not None:
+                attrs["obtrace.status_code"] = context.status_code
+            for k, v in context.attrs.items():
+                attrs[f"obtrace.attr.{k}"] = v
+        self._logger.emit(
+            body=message,
+            severity_text=level.upper(),
+            severity_number=_severity_number_enum(severity),
+            attributes=attrs if attrs else None,
+        )
+
+    def metric(self, name: str, value: float, unit: str = "1", context: Optional[SDKContext] = None) -> None:
+        if self.cfg.validate_semantic_metrics and self.cfg.debug and not is_semantic_metric(name):
+            print(f"[obtrace-sdk-python] non-canonical metric name: {name}")
+        attrs = {}
+        if context:
+            attrs = dict(context.attrs)
+        key = f"{name}:{unit}"
+        if key not in self._counters:
+            self._counters[key] = self._meter.create_gauge(name, unit=unit)
+        self._counters[key].set(value, attributes=attrs)
+
+    def span(
+        self,
+        name: str,
+        trace_id: Optional[str] = None,
+        span_id: Optional[str] = None,
+        start_unix_nano: Optional[str] = None,
+        end_unix_nano: Optional[str] = None,
+        status_code: Optional[int] = None,
+        status_message: str = "",
+        attrs: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, str]:
+        otel_span = self._tracer.start_span(name, attributes=attrs or {})
+        if status_code is not None and status_code >= 400:
+            otel_span.set_status(StatusCode.ERROR, status_message)
+        else:
+            otel_span.set_status(StatusCode.OK)
+        otel_span.end()
+        ctx = otel_span.get_span_context()
+        return {
+            "trace_id": format(ctx.trace_id, "032x"),
+            "span_id": format(ctx.span_id, "016x"),
+        }
+
+    @contextmanager
+    def start_span(self, name: str, attrs: Optional[Dict[str, Any]] = None) -> Iterator[Any]:
+        with self._tracer.start_as_current_span(name, attributes=attrs or {}) as otel_span:
+            yield otel_span
+
+    def capture_error(self, error: Exception, attrs: Optional[Dict[str, Any]] = None) -> None:
+        with self._tracer.start_as_current_span("exception") as otel_span:
+            otel_span.set_status(StatusCode.ERROR, str(error))
+            otel_span.record_exception(error, attributes=attrs or {})
+
+    def inject_propagation(
+        self,
+        headers: Optional[Dict[str, str]] = None,
+        trace_id: Optional[str] = None,
+        span_id: Optional[str] = None,
+        session_id: Optional[str] = None,
+    ) -> Dict[str, str]:
+        from opentelemetry.propagate import inject
+        out = dict(headers or {})
+        inject(out)
+        if session_id:
+            out.setdefault("x-obtrace-session-id", session_id)
+        return out
+
+    def flush(self) -> None:
+        self._providers.tracer_provider.force_flush()
+        self._providers.meter_provider.force_flush()
+        self._providers.logger_provider.force_flush()
+
+    def shutdown(self) -> None:
+        global _initialized
+        logging.root.removeHandler(self._otel_logging_handler)
+        self._providers.tracer_provider.shutdown()
+        self._providers.meter_provider.shutdown()
+        self._providers.logger_provider.shutdown()
+        _initialized = False
+
+
+def _level_to_severity(level: str) -> int:
+    mapping = {
+        "debug": 5,
+        "info": 9,
+        "warn": 13,
+        "warning": 13,
+        "error": 17,
+        "fatal": 21,
+        "critical": 21,
+    }
+    return mapping.get(level.lower(), 9)
+
+
+_SEVERITY_MAP = {
+    5: SeverityNumber.DEBUG,
+    9: SeverityNumber.INFO,
+    13: SeverityNumber.WARN,
+    17: SeverityNumber.ERROR,
+    21: SeverityNumber.FATAL,
+}
+
+
+def _severity_number_enum(num: int) -> SeverityNumber:
+    return _SEVERITY_MAP.get(num, SeverityNumber.INFO)

obtrace_sdk_python-2.0.0/src/obtrace_sdk/logging_handler.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING
+
+from opentelemetry.instrumentation.logging.handler import LoggingHandler
+
+if TYPE_CHECKING:
+    from .client import ObtraceClient
+
+
+class ObtraceLoggingHandler(LoggingHandler):
+    def __init__(self, client: ObtraceClient, level: int = logging.DEBUG):
+        super().__init__(
+            level=level,
+            logger_provider=client._providers.logger_provider,
+        )
+
+
+def install_logging_hook(client: ObtraceClient, level: int = logging.DEBUG) -> ObtraceLoggingHandler:
+    handler = ObtraceLoggingHandler(client, level)
+    logging.root.addHandler(handler)
+    return handler

obtrace_sdk_python-2.0.0/src/obtrace_sdk/otel_setup.py

@@ -0,0 +1,142 @@
+from __future__ import annotations
+
+import logging
+from typing import Any, Optional
+
+logger = logging.getLogger("obtrace")
+
+from opentelemetry import metrics, trace
+from opentelemetry.exporter.otlp.proto.http._log_exporter import OTLPLogExporter
+from opentelemetry.exporter.otlp.proto.http.metric_exporter import OTLPMetricExporter
+from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
+from opentelemetry.sdk._logs import LoggerProvider, LoggingHandler
+from opentelemetry.sdk._logs.export import BatchLogRecordProcessor
+from opentelemetry.sdk.metrics import MeterProvider
+from opentelemetry.sdk.metrics.export import PeriodicExportingMetricReader
+from opentelemetry.sdk.resources import Resource
+from opentelemetry.sdk.trace import TracerProvider
+from opentelemetry.sdk.trace.export import BatchSpanProcessor
+
+from .types import ObtraceConfig
+
+_INSTRUMENTATION_MODULES = [
+    ("opentelemetry.instrumentation.requests", "RequestsInstrumentor"),
+    ("opentelemetry.instrumentation.httpx", "HTTPXClientInstrumentor"),
+    ("opentelemetry.instrumentation.urllib", "URLLibInstrumentor"),
+    ("opentelemetry.instrumentation.flask", "FlaskInstrumentor"),
+    ("opentelemetry.instrumentation.fastapi", "FastAPIInstrumentor"),
+    ("opentelemetry.instrumentation.django", "DjangoInstrumentor"),
+    ("opentelemetry.instrumentation.logging", "LoggingInstrumentor"),
+    ("opentelemetry.instrumentation.psycopg2", "Psycopg2Instrumentor"),
+    ("opentelemetry.instrumentation.redis", "RedisInstrumentor"),
+    ("opentelemetry.instrumentation.sqlalchemy", "SQLAlchemyInstrumentor"),
+    ("opentelemetry.instrumentation.celery", "CeleryInstrumentor"),
+    ("opentelemetry.instrumentation.grpc", "GrpcInstrumentorClient"),
+]
+
+
+class OtelProviders:
+    __slots__ = ("tracer_provider", "meter_provider", "logger_provider")
+
+    def __init__(
+        self,
+        tracer_provider: TracerProvider,
+        meter_provider: MeterProvider,
+        logger_provider: LoggerProvider,
+    ):
+        self.tracer_provider = tracer_provider
+        self.meter_provider = meter_provider
+        self.logger_provider = logger_provider
+
+
+def setup_otel(cfg: ObtraceConfig) -> OtelProviders:
+    resource_attrs: dict[str, Any] = {
+        "service.name": cfg.service_name,
+        "service.version": cfg.service_version,
+        "deployment.environment": cfg.env or "dev",
+        "runtime.name": "python",
+    }
+    if cfg.tenant_id:
+        resource_attrs["obtrace.tenant_id"] = cfg.tenant_id
+    if cfg.project_id:
+        resource_attrs["obtrace.project_id"] = cfg.project_id
+    if cfg.app_id:
+        resource_attrs["obtrace.app_id"] = cfg.app_id
+    if cfg.env:
+        resource_attrs["obtrace.env"] = cfg.env
+
+    resource = Resource.create(resource_attrs)
+    base_url = cfg.ingest_base_url.rstrip("/")
+    headers = {
+        **cfg.default_headers,
+        "Authorization": f"Bearer {cfg.api_key}",
+    }
+
+    tracer_provider = TracerProvider(resource=resource)
+    tracer_provider.add_span_processor(
+        BatchSpanProcessor(
+            OTLPSpanExporter(
+                endpoint=f"{base_url}/otlp/v1/traces",
+                headers=headers,
+                timeout=int(cfg.request_timeout_sec),
+            )
+        )
+    )
+    try:
+        trace.set_tracer_provider(tracer_provider)
+    except Exception:
+        pass
+
+    meter_provider = MeterProvider(
+        resource=resource,
+        metric_readers=[
+            PeriodicExportingMetricReader(
+                OTLPMetricExporter(
+                    endpoint=f"{base_url}/otlp/v1/metrics",
+                    headers=headers,
+                    timeout=int(cfg.request_timeout_sec),
+                ),
+                export_interval_millis=60000,
+            )
+        ],
+    )
+    try:
+        metrics.set_meter_provider(meter_provider)
+    except Exception:
+        pass
+
+    logger_provider = LoggerProvider(resource=resource)
+    logger_provider.add_log_record_processor(
+        BatchLogRecordProcessor(
+            OTLPLogExporter(
+                endpoint=f"{base_url}/otlp/v1/logs",
+                headers=headers,
+                timeout=int(cfg.request_timeout_sec),
+            )
+        )
+    )
+
+    providers = OtelProviders(
+        tracer_provider=tracer_provider,
+        meter_provider=meter_provider,
+        logger_provider=logger_provider,
+    )
+
+    if cfg.auto_instrument_http:
+        import threading
+        threading.Thread(target=_auto_instrument, daemon=True).start()
+
+    return providers
+
+
+def _auto_instrument() -> None:
+    import importlib
+
+    for module_path, class_name in _INSTRUMENTATION_MODULES:
+        try:
+            mod = importlib.import_module(module_path)
+            instrumentor = getattr(mod, class_name)()
+            if not instrumentor.is_instrumented_by_opentelemetry:
+                instrumentor.instrument()
+        except (ImportError, Exception) as e:
+            logger.debug("obtrace: skipped %s: %s", module_path, e)

{obtrace_sdk_python-1.0.0 → obtrace_sdk_python-2.0.0}/src/obtrace_sdk/types.py

@@ -15,9 +15,9 @@ class ObtraceConfig:
     app_id: Optional[str] = None
     env: Optional[str] = None
     request_timeout_sec: float = 5.0
-    max_queue_size: int = 1000
     validate_semantic_metrics: bool = False
     debug: bool = False
+    auto_instrument_http: bool = True
     default_headers: Dict[str, str] = field(default_factory=dict)
 
 

{obtrace_sdk_python-1.0.0 → obtrace_sdk_python-2.0.0}/src/obtrace_sdk_python.egg-info/PKG-INFO

@@ -1,20 +1,30 @@
 Metadata-Version: 2.4
 Name: obtrace-sdk-python
-Version: 1.0.0
+Version: 2.0.0
 Summary: Obtrace Python SDK
 Author: Obtrace
-Classifier: License :: OSI Approved :: MIT License
+License-Expression: MIT
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
-Provides-Extra: requests
-Requires-Dist: requests>=2.31.0; extra == "requests"
-Provides-Extra: httpx
-Requires-Dist: httpx>=0.27.0; extra == "httpx"
-Provides-Extra: fastapi
-Requires-Dist: fastapi>=0.112.0; extra == "fastapi"
-Requires-Dist: starlette>=0.37.0; extra == "fastapi"
-Provides-Extra: flask
-Requires-Dist: flask>=3.0.0; extra == "flask"
+License-File: LICENSE
+Requires-Dist: opentelemetry-sdk>=1.20.0
+Requires-Dist: opentelemetry-api>=1.20.0
+Requires-Dist: opentelemetry-exporter-otlp-proto-http>=1.20.0
+Requires-Dist: opentelemetry-instrumentation-requests
+Requires-Dist: opentelemetry-instrumentation-httpx
+Requires-Dist: opentelemetry-instrumentation-urllib
+Requires-Dist: opentelemetry-instrumentation-flask
+Requires-Dist: opentelemetry-instrumentation-fastapi
+Requires-Dist: opentelemetry-instrumentation-django
+Requires-Dist: opentelemetry-instrumentation-logging
+Requires-Dist: opentelemetry-instrumentation-psycopg2
+Requires-Dist: opentelemetry-instrumentation-redis
+Requires-Dist: opentelemetry-instrumentation-sqlalchemy
+Requires-Dist: opentelemetry-instrumentation-celery
+Requires-Dist: opentelemetry-instrumentation-grpc
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Dynamic: license-file
 
 # obtrace-sdk-python
 
@@ -34,7 +44,7 @@ SDK is thin/dumb.
 ## Install
 
 ```bash
-pip install .
+pip install obtrace-sdk-python
 ```
 
 ## Configuration

{obtrace_sdk_python-1.0.0 → obtrace_sdk_python-2.0.0}/src/obtrace_sdk_python.egg-info/SOURCES.txt

@@ -1,10 +1,10 @@
+LICENSE
 README.md
 pyproject.toml
 src/obtrace_sdk/__init__.py
 src/obtrace_sdk/client.py
-src/obtrace_sdk/context.py
-src/obtrace_sdk/http.py
-src/obtrace_sdk/otlp.py
+src/obtrace_sdk/logging_handler.py
+src/obtrace_sdk/otel_setup.py
 src/obtrace_sdk/semantic_metrics.py
 src/obtrace_sdk/types.py
 src/obtrace_sdk_python.egg-info/PKG-INFO
@@ -13,5 +13,4 @@ src/obtrace_sdk_python.egg-info/dependency_links.txt
 src/obtrace_sdk_python.egg-info/requires.txt
 src/obtrace_sdk_python.egg-info/top_level.txt
 tests/test_client.py
-tests/test_context.py
 tests/test_semantic_metrics.py

obtrace_sdk_python-2.0.0/src/obtrace_sdk_python.egg-info/requires.txt

@@ -0,0 +1,18 @@
+opentelemetry-sdk>=1.20.0
+opentelemetry-api>=1.20.0
+opentelemetry-exporter-otlp-proto-http>=1.20.0
+opentelemetry-instrumentation-requests
+opentelemetry-instrumentation-httpx
+opentelemetry-instrumentation-urllib
+opentelemetry-instrumentation-flask
+opentelemetry-instrumentation-fastapi
+opentelemetry-instrumentation-django
+opentelemetry-instrumentation-logging
+opentelemetry-instrumentation-psycopg2
+opentelemetry-instrumentation-redis
+opentelemetry-instrumentation-sqlalchemy
+opentelemetry-instrumentation-celery
+opentelemetry-instrumentation-grpc
+
+[dev]
+pytest>=8.0

obtrace_sdk_python-2.0.0/tests/test_client.py

@@ -0,0 +1,91 @@
+import unittest
+
+from opentelemetry.sdk._logs import LoggerProvider
+from opentelemetry.sdk.metrics import MeterProvider
+from opentelemetry.sdk.trace import TracerProvider
+
+from obtrace_sdk.client import ObtraceClient
+from obtrace_sdk.types import ObtraceConfig, SDKContext
+
+
+def _make_client(**overrides):
+    defaults = dict(
+        api_key="devkey",
+        ingest_base_url="https://ingest.obtrace.ai",
+        service_name="py-test",
+        auto_instrument_http=False,
+    )
+    defaults.update(overrides)
+    return ObtraceClient(ObtraceConfig(**defaults))
+
+
+class ClientTests(unittest.TestCase):
+    def test_creates_otel_providers(self):
+        c = _make_client()
+        self.assertIsInstance(c._providers.tracer_provider, TracerProvider)
+        self.assertIsInstance(c._providers.meter_provider, MeterProvider)
+        self.assertIsInstance(c._providers.logger_provider, LoggerProvider)
+        c.shutdown()
+
+    def test_log_does_not_raise(self):
+        c = _make_client()
+        c.log("info", "hello")
+        c.log("error", "bad thing", SDKContext(trace_id="a" * 32, span_id="b" * 16))
+        c.shutdown()
+
+    def test_metric_does_not_raise(self):
+        c = _make_client()
+        c.metric("m", 1.0)
+        c.metric("m2", 42.0, unit="ms", context=SDKContext(attrs={"env": "test"}))
+        c.shutdown()
+
+    def test_span_returns_trace_and_span_id(self):
+        c = _make_client()
+        result = c.span("test-span", attrs={"key": "value"})
+        self.assertIn("trace_id", result)
+        self.assertIn("span_id", result)
+        self.assertEqual(len(result["trace_id"]), 32)
+        self.assertEqual(len(result["span_id"]), 16)
+        c.shutdown()
+
+    def test_span_error_status(self):
+        c = _make_client()
+        result = c.span("error-span", status_code=500, status_message="internal error")
+        self.assertIn("trace_id", result)
+        c.shutdown()
+
+    def test_capture_error(self):
+        c = _make_client()
+        c.capture_error(ValueError("test error"), attrs={"component": "db"})
+        c.shutdown()
+
+    def test_context_manager(self):
+        with _make_client() as c:
+            c.log("info", "inside context")
+
+    def test_start_span_context_manager(self):
+        c = _make_client()
+        with c.start_span("my-operation", attrs={"step": "1"}) as span:
+            span.set_attribute("result", "ok")
+        c.shutdown()
+
+    def test_inject_propagation(self):
+        c = _make_client()
+        headers = c.inject_propagation(session_id="sess-123")
+        self.assertIn("x-obtrace-session-id", headers)
+        self.assertEqual(headers["x-obtrace-session-id"], "sess-123")
+        c.shutdown()
+
+    def test_flush_does_not_raise(self):
+        c = _make_client()
+        c.log("info", "pre-flush")
+        c.flush()
+        c.shutdown()
+
+    def test_validation_error_on_missing_fields(self):
+        with self.assertRaises(ValueError):
+            ObtraceClient(ObtraceConfig(api_key="", ingest_base_url="http://x", service_name="svc"))
+
+
+if __name__ == "__main__":
+    unittest.main()

obtrace_sdk_python-1.0.0/pyproject.toml

@@ -1,25 +0,0 @@
-[build-system]
-requires = ["setuptools>=69", "wheel"]
-build-backend = "setuptools.build_meta"
-
-[project]
-name = "obtrace-sdk-python"
-version = "1.0.0"
-description = "Obtrace Python SDK"
-classifiers = ["License :: OSI Approved :: MIT License"]
-requires-python = ">=3.10"
-readme = "README.md"
-authors = [{ name = "Obtrace" }]
-dependencies = []
-
-[project.optional-dependencies]
-requests = ["requests>=2.31.0"]
-httpx = ["httpx>=0.27.0"]
-fastapi = ["fastapi>=0.112.0", "starlette>=0.37.0"]
-flask = ["flask>=3.0.0"]
-
-[tool.setuptools]
-package-dir = {"" = "src"}
-
-[tool.setuptools.packages.find]
-where = ["src"]

obtrace_sdk_python-1.0.0/src/obtrace_sdk/__init__.py

@@ -1,12 +0,0 @@
-from .client import ObtraceClient, ObtraceConfig
-from .context import create_traceparent, ensure_propagation_headers
-from .semantic_metrics import SemanticMetrics, is_semantic_metric
-
-__all__ = [
-    "ObtraceClient",
-    "ObtraceConfig",
-    "SemanticMetrics",
-    "is_semantic_metric",
-    "create_traceparent",
-    "ensure_propagation_headers",
-]

obtrace_sdk_python-1.0.0/src/obtrace_sdk/client.py

@@ -1,159 +0,0 @@
-from __future__ import annotations
-
-import atexit
-import json
-import threading
-import time
-import urllib.error
-import urllib.request
-from dataclasses import dataclass
-from typing import Any, Dict, List, Optional
-
-from .context import ensure_propagation_headers, random_hex
-from .otlp import build_logs_payload, build_metric_payload, build_span_payload
-from .semantic_metrics import is_semantic_metric
-from .types import ObtraceConfig, SDKContext
-
-
-@dataclass(slots=True)
-class _Queued:
-    endpoint: str
-    payload: Dict[str, Any]
-
-
-class ObtraceClient:
-    def __init__(self, cfg: ObtraceConfig):
-        if not cfg.api_key or not cfg.ingest_base_url or not cfg.service_name:
-            raise ValueError("api_key, ingest_base_url and service_name are required")
-        self.cfg = cfg
-        self._queue: List[_Queued] = []
-        self._lock = threading.Lock()
-        self._circuit_failures = 0
-        self._circuit_open_until = 0.0
-        atexit.register(self.flush)
-
-    def __enter__(self) -> ObtraceClient:
-        return self
-
-    def __exit__(self, *_: Any) -> None:
-        self.flush()
-
-    @staticmethod
-    def _truncate(s: str, max_len: int) -> str:
-        if len(s) <= max_len:
-            return s
-        return s[:max_len] + "...[truncated]"
-
-    def log(self, level: str, message: str, context: Optional[SDKContext] = None) -> None:
-        self._enqueue("/otlp/v1/logs", build_logs_payload(self.cfg, level, self._truncate(message, 32768), context))
-
-    def metric(self, name: str, value: float, unit: str = "1", context: Optional[SDKContext] = None) -> None:
-        if self.cfg.validate_semantic_metrics and self.cfg.debug and not is_semantic_metric(name):
-            print(f"[obtrace-sdk-python] non-canonical metric name: {name}")
-        self._enqueue("/otlp/v1/metrics", build_metric_payload(self.cfg, self._truncate(name, 1024), value, unit, context))
-
-    def span(
-        self,
-        name: str,
-        trace_id: Optional[str] = None,
-        span_id: Optional[str] = None,
-        start_unix_nano: Optional[str] = None,
-        end_unix_nano: Optional[str] = None,
-        status_code: Optional[int] = None,
-        status_message: str = "",
-        attrs: Optional[Dict[str, Any]] = None,
-    ) -> Dict[str, str]:
-        t = trace_id if trace_id and len(trace_id) == 32 else random_hex(16)
-        s = span_id if span_id and len(span_id) == 16 else random_hex(8)
-        start = start_unix_nano or str(int(time.time() * 1_000_000_000))
-        end = end_unix_nano or str(int(time.time() * 1_000_000_000))
-
-        truncated_name = self._truncate(name, 32768)
-        if attrs:
-            attrs = {k: self._truncate(v, 4096) if isinstance(v, str) else v for k, v in attrs.items()}
-
-        self._enqueue(
-            "/otlp/v1/traces",
-            build_span_payload(self.cfg, truncated_name, t, s, start, end, status_code, status_message, attrs),
-        )
-        return {"trace_id": t, "span_id": s}
-
-    def inject_propagation(
-        self,
-        headers: Optional[Dict[str, str]] = None,
-        trace_id: Optional[str] = None,
-        span_id: Optional[str] = None,
-        session_id: Optional[str] = None,
-    ) -> Dict[str, str]:
-        return ensure_propagation_headers(headers, trace_id, span_id, session_id)
-
-    def flush(self) -> None:
-        with self._lock:
-            now = time.time()
-            if now < self._circuit_open_until:
-                return
-            half_open = self._circuit_failures >= 5
-            if half_open:
-                batch = self._queue[:1]
-                self._queue = self._queue[1:]
-            else:
-                batch = list(self._queue)
-                self._queue.clear()
-
-        for item in batch:
-            try:
-                self._send(item)
-                with self._lock:
-                    if self._circuit_failures > 0:
-                        if self.cfg.debug:
-                            print("[obtrace-sdk-python] circuit breaker closed")
-                        self._circuit_failures = 0
-                        self._circuit_open_until = 0.0
-            except Exception:  # noqa: BLE001
-                with self._lock:
-                    self._circuit_failures += 1
-                    if self._circuit_failures >= 5:
-                        self._circuit_open_until = time.time() + 30.0
-                        if self.cfg.debug:
-                            print("[obtrace-sdk-python] circuit breaker opened")
-                if self.cfg.debug:
-                    import traceback
-                    traceback.print_exc()
-
-    def shutdown(self) -> None:
-        self.flush()
-
-    def _enqueue(self, endpoint: str, payload: Dict[str, Any]) -> None:
-        with self._lock:
-            if len(self._queue) >= self.cfg.max_queue_size:
-                if self.cfg.debug:
-                    print(f"[obtrace-sdk-python] queue full, dropping oldest item")
-                self._queue.pop(0)
-            self._queue.append(_Queued(endpoint=endpoint, payload=payload))
-
-    def _send(self, item: _Queued) -> None:
-        try:
-            body = json.dumps(item.payload).encode("utf-8")
-        except (TypeError, ValueError):
-            if self.cfg.debug:
-                print(f"[obtrace-sdk-python] failed to serialize payload for {item.endpoint}")
-            return
-
-        req = urllib.request.Request(
-            url=f"{self.cfg.ingest_base_url.rstrip('/')}{item.endpoint}",
-            method="POST",
-            data=body,
-            headers={
-                **self.cfg.default_headers,
-                "Authorization": f"Bearer {self.cfg.api_key}",
-                "Content-Type": "application/json",
-            },
-        )
-        try:
-            with urllib.request.urlopen(req, timeout=self.cfg.request_timeout_sec) as res:
-                code = int(getattr(res, "status", 200))
-                if code >= 300 and self.cfg.debug:
-                    print(f"[obtrace-sdk-python] status={code} endpoint={item.endpoint}")
-        except (urllib.error.URLError, TypeError, ValueError, OSError) as exc:
-            if self.cfg.debug:
-                print(f"[obtrace-sdk-python] send failed endpoint={item.endpoint} err={exc}")

obtrace_sdk_python-1.0.0/src/obtrace_sdk/context.py

@@ -1,31 +0,0 @@
-from __future__ import annotations
-
-import secrets
-from typing import Dict, Optional
-
-
-def random_hex(nbytes: int) -> str:
-    return secrets.token_hex(nbytes)
-
-
-def create_traceparent(trace_id: Optional[str] = None, span_id: Optional[str] = None) -> str:
-    t = trace_id if trace_id and len(trace_id) == 32 else random_hex(16)
-    s = span_id if span_id and len(span_id) == 16 else random_hex(8)
-    return f"00-{t}-{s}-01"
-
-
-def ensure_propagation_headers(
-    headers: Optional[Dict[str, str]] = None,
-    trace_id: Optional[str] = None,
-    span_id: Optional[str] = None,
-    session_id: Optional[str] = None,
-    trace_header_name: str = "traceparent",
-    session_header_name: str = "x-obtrace-session-id",
-) -> Dict[str, str]:
-    out = dict(headers or {})
-    lower = {k.lower(): k for k in out.keys()}
-    if trace_header_name.lower() not in lower:
-        out[trace_header_name] = create_traceparent(trace_id, span_id)
-    if session_id and session_header_name.lower() not in lower:
-        out[session_header_name] = session_id
-    return out

obtrace_sdk_python-1.0.0/src/obtrace_sdk/http.py

@@ -1,159 +0,0 @@
-from __future__ import annotations
-
-import time
-from typing import Any, Callable, Dict, Optional
-
-from .client import ObtraceClient
-from .types import SDKContext
-
-
-def instrument_requests(client: ObtraceClient, request_func: Callable[..., Any]) -> Callable[..., Any]:
-    def wrapped(method: str, url: str, **kwargs: Any) -> Any:
-        started = time.time()
-        trace = client.span(f"http.client {method.upper()}", attrs={"http.method": method.upper(), "http.url": url})
-
-        headers = dict(kwargs.pop("headers", {}) or {})
-        headers = client.inject_propagation(headers, trace_id=trace["trace_id"], span_id=trace["span_id"])
-        kwargs["headers"] = headers
-
-        try:
-            res = request_func(method, url, **kwargs)
-            dur_ms = int((time.time() - started) * 1000)
-            client.log(
-                "info",
-                f"requests {method.upper()} {url} -> {getattr(res, 'status_code', 200)}",
-                SDKContext(
-                    trace_id=trace["trace_id"],
-                    span_id=trace["span_id"],
-                    method=method.upper(),
-                    endpoint=url,
-                    status_code=int(getattr(res, "status_code", 200)),
-                    attrs={"duration_ms": dur_ms},
-                ),
-            )
-            return res
-        except Exception as exc:  # noqa: BLE001
-            dur_ms = int((time.time() - started) * 1000)
-            client.log(
-                "error",
-                f"requests {method.upper()} {url} failed: {exc}",
-                SDKContext(
-                    trace_id=trace["trace_id"],
-                    span_id=trace["span_id"],
-                    method=method.upper(),
-                    endpoint=url,
-                    attrs={"duration_ms": dur_ms},
-                ),
-            )
-            raise
-
-    return wrapped
-
-
-def instrument_httpx(client: ObtraceClient, request_func: Callable[..., Any]) -> Callable[..., Any]:
-    async def wrapped(method: str, url: str, **kwargs: Any) -> Any:
-        started = time.time()
-        trace = client.span(f"http.client {method.upper()}", attrs={"http.method": method.upper(), "http.url": url})
-
-        headers = dict(kwargs.pop("headers", {}) or {})
-        headers = client.inject_propagation(headers, trace_id=trace["trace_id"], span_id=trace["span_id"])
-        kwargs["headers"] = headers
-
-        try:
-            res = await request_func(method, url, **kwargs)
-            dur_ms = int((time.time() - started) * 1000)
-            client.log(
-                "info",
-                f"httpx {method.upper()} {url} -> {getattr(res, 'status_code', 200)}",
-                SDKContext(
-                    trace_id=trace["trace_id"],
-                    span_id=trace["span_id"],
-                    method=method.upper(),
-                    endpoint=url,
-                    status_code=int(getattr(res, "status_code", 200)),
-                    attrs={"duration_ms": dur_ms},
-                ),
-            )
-            return res
-        except Exception as exc:  # noqa: BLE001
-            dur_ms = int((time.time() - started) * 1000)
-            client.log(
-                "error",
-                f"httpx {method.upper()} {url} failed: {exc}",
-                SDKContext(
-                    trace_id=trace["trace_id"],
-                    span_id=trace["span_id"],
-                    method=method.upper(),
-                    endpoint=url,
-                    attrs={"duration_ms": dur_ms},
-                ),
-            )
-            raise
-
-    return wrapped
-
-
-def fastapi_middleware(client: ObtraceClient):
-    async def middleware(request: Any, call_next: Callable[..., Any]) -> Any:
-        started = time.time()
-        trace = client.span(
-            f"http.server {getattr(request, 'method', 'GET')}",
-            attrs={"http.method": getattr(request, "method", "GET"), "http.route": str(getattr(request, "url", ""))},
-        )
-        try:
-            response = await call_next(request)
-            dur_ms = int((time.time() - started) * 1000)
-            client.log(
-                "info",
-                f"fastapi {request.method} {request.url.path} {response.status_code}",
-                SDKContext(
-                    trace_id=trace["trace_id"],
-                    span_id=trace["span_id"],
-                    method=request.method,
-                    endpoint=request.url.path,
-                    status_code=response.status_code,
-                    attrs={"duration_ms": dur_ms},
-                ),
-            )
-            return response
-        except Exception as exc:  # noqa: BLE001
-            dur_ms = int((time.time() - started) * 1000)
-            client.log(
-                "error",
-                f"fastapi request failed: {exc}",
-                SDKContext(
-                    trace_id=trace["trace_id"],
-                    span_id=trace["span_id"],
-                    method=getattr(request, "method", "GET"),
-                    endpoint=str(getattr(request, "url", "")),
-                    attrs={"duration_ms": dur_ms},
-                ),
-            )
-            raise
-
-    return middleware
-
-
-def flask_before_after(client: ObtraceClient):
-    def before() -> Dict[str, Any]:
-        started = time.time()
-        trace = client.span("http.server request")
-        return {"started": started, "trace": trace}
-
-    def after(meta: Dict[str, Any], method: str, path: str, status_code: int) -> None:
-        dur_ms = int((time.time() - meta["started"]) * 1000)
-        tr = meta["trace"]
-        client.log(
-            "info",
-            f"flask {method} {path} {status_code}",
-            SDKContext(
-                trace_id=tr["trace_id"],
-                span_id=tr["span_id"],
-                method=method,
-                endpoint=path,
-                status_code=status_code,
-                attrs={"duration_ms": dur_ms},
-            ),
-        )
-
-    return before, after

obtrace_sdk_python-1.0.0/src/obtrace_sdk/otlp.py

@@ -1,161 +0,0 @@
-from __future__ import annotations
-
-import time
-from typing import Any, Dict, Optional
-
-from .types import ObtraceConfig, SDKContext
-
-
-def _now_unix_nano_str() -> str:
-    return str(int(time.time() * 1_000_000_000))
-
-
-def _attrs(attrs: Optional[Dict[str, Any]]) -> list[dict[str, Any]]:
-    out: list[dict[str, Any]] = []
-    if not attrs:
-        return out
-    for k, v in attrs.items():
-        if isinstance(v, bool):
-            val = {"boolValue": v}
-        elif isinstance(v, (int, float)):
-            val = {"doubleValue": float(v)}
-        else:
-            val = {"stringValue": str(v)}
-        out.append({"key": str(k), "value": val})
-    return out
-
-
-def _resource(cfg: ObtraceConfig) -> list[dict[str, Any]]:
-    base: Dict[str, Any] = {
-        "service.name": cfg.service_name,
-        "service.version": cfg.service_version,
-        "deployment.environment": cfg.env or "dev",
-        "runtime.name": "python",
-    }
-    if cfg.tenant_id:
-        base["obtrace.tenant_id"] = cfg.tenant_id
-    if cfg.project_id:
-        base["obtrace.project_id"] = cfg.project_id
-    if cfg.app_id:
-        base["obtrace.app_id"] = cfg.app_id
-    if cfg.env:
-        base["obtrace.env"] = cfg.env
-    return _attrs(base)
-
-
-def build_logs_payload(cfg: ObtraceConfig, level: str, body: str, ctx: Optional[SDKContext] = None) -> Dict[str, Any]:
-    context_attrs: Dict[str, Any] = {"obtrace.log.level": level}
-    if ctx:
-        if ctx.trace_id:
-            context_attrs["obtrace.trace_id"] = ctx.trace_id
-        if ctx.span_id:
-            context_attrs["obtrace.span_id"] = ctx.span_id
-        if ctx.session_id:
-            context_attrs["obtrace.session_id"] = ctx.session_id
-        if ctx.route_template:
-            context_attrs["obtrace.route_template"] = ctx.route_template
-        if ctx.endpoint:
-            context_attrs["obtrace.endpoint"] = ctx.endpoint
-        if ctx.method:
-            context_attrs["obtrace.method"] = ctx.method
-        if ctx.status_code is not None:
-            context_attrs["obtrace.status_code"] = ctx.status_code
-        for k, v in ctx.attrs.items():
-            context_attrs[f"obtrace.attr.{k}"] = v
-
-    return {
-        "resourceLogs": [
-            {
-                "resource": {"attributes": _resource(cfg)},
-                "scopeLogs": [
-                    {
-                        "scope": {"name": "obtrace-sdk-python", "version": "1.0.0"},
-                        "logRecords": [
-                            {
-                                "timeUnixNano": _now_unix_nano_str(),
-                                "severityText": level.upper(),
-                                "body": {"stringValue": body},
-                                "attributes": _attrs(context_attrs),
-                            }
-                        ],
-                    }
-                ],
-            }
-        ]
-    }
-
-
-def build_metric_payload(
-    cfg: ObtraceConfig,
-    metric_name: str,
-    value: float,
-    unit: str = "1",
-    ctx: Optional[SDKContext] = None,
-) -> Dict[str, Any]:
-    return {
-        "resourceMetrics": [
-            {
-                "resource": {"attributes": _resource(cfg)},
-                "scopeMetrics": [
-                    {
-                        "scope": {"name": "obtrace-sdk-python", "version": "1.0.0"},
-                        "metrics": [
-                            {
-                                "name": metric_name,
-                                "unit": unit,
-                                "gauge": {
-                                    "dataPoints": [
-                                        {
-                                            "timeUnixNano": _now_unix_nano_str(),
-                                            "asDouble": float(value),
-                                            "attributes": _attrs(ctx.attrs if ctx else None),
-                                        }
-                                    ]
-                                },
-                            }
-                        ],
-                    }
-                ],
-            }
-        ]
-    }
-
-
-def build_span_payload(
-    cfg: ObtraceConfig,
-    name: str,
-    trace_id: str,
-    span_id: str,
-    start_unix_nano: str,
-    end_unix_nano: str,
-    status_code: Optional[int] = None,
-    status_message: str = "",
-    attrs: Optional[Dict[str, Any]] = None,
-) -> Dict[str, Any]:
-    return {
-        "resourceSpans": [
-            {
-                "resource": {"attributes": _resource(cfg)},
-                "scopeSpans": [
-                    {
-                        "scope": {"name": "obtrace-sdk-python", "version": "1.0.0"},
-                        "spans": [
-                            {
-                                "traceId": trace_id,
-                                "spanId": span_id,
-                                "name": name,
-                                "kind": 3,
-                                "startTimeUnixNano": start_unix_nano,
-                                "endTimeUnixNano": end_unix_nano,
-                                "attributes": _attrs(attrs),
-                                "status": {
-                                    "code": 2 if (status_code is not None and status_code >= 400) else 1,
-                                    "message": status_message,
-                                },
-                            }
-                        ],
-                    }
-                ],
-            }
-        ]
-    }

obtrace_sdk_python-1.0.0/src/obtrace_sdk_python.egg-info/requires.txt

@@ -1,13 +0,0 @@
-
-[fastapi]
-fastapi>=0.112.0
-starlette>=0.37.0
-
-[flask]
-flask>=3.0.0
-
-[httpx]
-httpx>=0.27.0
-
-[requests]
-requests>=2.31.0

obtrace_sdk_python-1.0.0/tests/test_client.py

@@ -1,32 +0,0 @@
-import unittest
-from unittest.mock import patch, MagicMock
-
-from obtrace_sdk.client import ObtraceClient
-from obtrace_sdk.types import ObtraceConfig
-
-
-class ClientTests(unittest.TestCase):
-    def test_enqueue_and_flush(self):
-        c = ObtraceClient(
-            ObtraceConfig(
-                api_key="devkey",
-                ingest_base_url="https://inject.obtrace.ai",
-                service_name="py-test",
-            )
-        )
-        c.log("info", "hello")
-        c.metric("m", 1)
-        c.span("s")
-
-        with patch("urllib.request.urlopen") as urlopen:
-            cm = MagicMock()
-            cm.__enter__.return_value.status = 202
-            cm.__exit__.return_value = False
-            urlopen.return_value = cm
-            c.flush()
-
-        self.assertEqual(urlopen.call_count, 3)
-
-
-if __name__ == "__main__":
-    unittest.main()

obtrace_sdk_python-1.0.0/tests/test_context.py

@@ -1,21 +0,0 @@
-import unittest
-
-from obtrace_sdk.context import create_traceparent, ensure_propagation_headers
-
-
-class ContextTests(unittest.TestCase):
-    def test_create_traceparent(self):
-        tp = create_traceparent()
-        self.assertTrue(tp.startswith("00-"))
-        parts = tp.split("-")
-        self.assertEqual(len(parts[1]), 32)
-        self.assertEqual(len(parts[2]), 16)
-
-    def test_ensure_propagation_headers(self):
-        out = ensure_propagation_headers({}, session_id="s1")
-        self.assertIn("traceparent", {k.lower(): v for k, v in out.items()})
-        self.assertIn("x-obtrace-session-id", {k.lower(): v for k, v in out.items()})
-
-
-if __name__ == "__main__":
-    unittest.main()