otlp-json 0.9.1__py3-none-any.whl

otlp_json-0.9.1.dist-info/METADATA

@@ -0,0 +1,88 @@
+Metadata-Version: 2.2
+Name: otlp-json
+Version: 0.9.1
+Summary: 🐍Lightweight OTEL span to JSON converter, no dependencies, pure Python🐍
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Framework :: OpenTelemetry
+Classifier: Framework :: OpenTelemetry :: Exporters
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# otlp-json
+
+`otpl-json` is an OTLP serialisation library.
+
+It's written in pure Python, without dependencies.
+
+It serialises a bunch of spans into OTLP 1.5 JSON format.
+
+### Motivation
+
+Tracing should be on by default.
+
+OTLP is the standard data format and API, and the standard Python package is `opentelemetry-exporter-otlp-proto-http`. It brings in a total of 18 packages and adds 9MB to the project virtual environment.
+
+A typical Python application, that's being instrumented, only generates own tracing data and needs to send it out. It doesn't need that much complexity.
+
+### Usage
+
+```py
+from otlp_json import CONTENT_TYPE, encode_spans
+
+
+class SomeExporter:
+    def export(self.spans: Sequece[ReadableSpan]) -> None:
+        requests.post(
+            "http://localhost:4318/v1/traces",
+            data=encode_spans(spans),
+            headers={"Content-Type": CONTENT_TYPE},
+        )
+```
+
+### Library size
+
+- 3KB whl, containing:
+  - 4KB Python source
+  - ?? metadata
+
+### TODO(doc)
+
+- link to rust library
+- link to urllib sender
+- link to test vector generator
+
+### TODO(features)
+
+- Events
+- Links
+- Baggage
+- Schemata, when https://github.com/open-telemetry/opentelemetry-python/pull/4359 lands
+
+### TODO(fixes)
+
+- Status fields
+- validate what fields are in fact optional
+- ???
+
+### Limitations
+
+This library is meant to marshal tracing data that's collected in the same Python process.
+
+It is not meant to be used for data received and forwarded.

otlp_json-0.9.1.dist-info/RECORD

@@ -0,0 +1,5 @@
+otlp_json.py,sha256=GCHauwquLROkov7v4WfmevNlKzC45aYDbvqGYCb66lg,3869
+otlp_json-0.9.1.dist-info/METADATA,sha256=3OlCQjfep4nN69aMkIVHxTOawNDCnEqOLIu5cDCKHVQ,2685
+otlp_json-0.9.1.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+otlp_json-0.9.1.dist-info/top_level.txt,sha256=7jOohtnyFAP4ixxnF_1gQz1NKEuVS8ELe3ymA4I5FtU,10
+otlp_json-0.9.1.dist-info/RECORD,,

otlp_json-0.9.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.8.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

otlp_json-0.9.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+otlp_json

otlp_json.py

@@ -0,0 +1,120 @@
+from __future__ import annotations
+
+import json
+from typing import Any, Sequence, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from typing_extensions import TypeAlias
+
+    from opentelemetry.sdk.trace import ReadableSpan
+    from opentelemetry.sdk.resources import Resource
+    from opentelemetry.sdk.util.instrumentation import InstrumentationScope
+    from opentelemetry.trace.status import Status
+
+    _LEAF_VALUE: TypeAlias = "str | int | float | bool"  # TODO: confirm
+    _VALUE: TypeAlias = "_LEAF_VALUE | Sequence[_LEAF_VALUE]"
+
+
+CONTENT_TYPE = "application/json"
+
+
+def encode_spans(spans: Sequence[ReadableSpan]) -> bytes:
+    spans = sorted(spans, key=lambda s: (id(s.resource), id(s.instrumentation_scope)))
+    rv = {"resourceSpans": []}
+    last_rs = last_is = None
+    for span in spans:
+        assert span.resource
+        assert span.instrumentation_scope
+        if span.resource is not last_rs:
+            last_rs = span.resource
+            last_is = None
+            rv["resourceSpans"].append(
+                {
+                    "resource": _resource(span.resource),
+                    "scopeSpans": [],
+                }
+            )
+        if span.instrumentation_scope is not last_is:
+            last_is = span.instrumentation_scope
+            rv["resourceSpans"][-1]["scopeSpans"].append(
+                {
+                    "scope": _scope(span.instrumentation_scope),
+                    "spans": [],
+                }
+            )
+        rv["resourceSpans"][-1]["scopeSpans"][-1]["spans"].append(_span(span))
+    return json.dumps(rv, separators=(",", ":")).encode("utf-8")
+
+
+def _resource(resource: Resource):
+    return {
+        "attributes": [
+            {"key": k, "value": _value(v)} for k, v in resource.attributes.items()
+        ]
+    }
+
+
+def _value(value: _VALUE) -> dict[str, Any]:
+    # Attribute value can be a primitive type, excluging None...
+    # TODO: protobuf allows bytes, but I think OTLP doesn't.
+    # TODO: protobuf allows k:v pairs, but I think OTLP doesn't.
+    if isinstance(value, (str, int, float, bool)):
+        k = {
+            # TODO: move these to module level
+            str: "stringValue",
+            int: "intValue",
+            float: "floatValue",
+            bool: "boolValue",
+        }[type(value)]
+        return {k: value}
+
+    # Or a homogenous array of a primitive type, excluding None.
+    value = list(value)
+
+    # TODO: empty lists are allowed, aren't they?
+    if len({type(v) for v in value}) > 1:
+        raise ValueError(f"Attribute value arrays must be homogenous, got {value}")
+
+    # TODO: maybe prevent recursion, OTEL doesn't allow lists of lists
+    return {"arrayValue": [_value(e) for e in value]}
+
+
+def _scope(scope: InstrumentationScope):
+    rv = {"name": scope.name}
+    if scope.version:
+        rv["version"] = scope.version
+    return rv
+
+
+def _span(span: ReadableSpan):
+    assert span.context
+    rv = {
+        "name": span.name,
+        "kind": span.kind.value or 1,  # unspecified -> internal
+        "traceId": _trace_id(span.context.trace_id),
+        "spanId": _span_id(span.context.span_id),
+        "flags": 0x100 | ([0, 0x200][bool(span.parent)]),
+        "startTimeUnixNano": str(span.start_time),  # TODO: is it ever optional?
+        "endTimeUnixNano": str(span.end_time),  # -"-
+        "status": _status(span.status),
+    }
+    if span.parent:
+        rv["parentSpanId"] = _span_id(span.parent.span_id)
+    return rv
+
+
+def _trace_id(trace_id: int) -> str:
+    if not 0 <= trace_id < 2**128:
+        raise ValueError(f"The {trace_id=} is out of bounds")
+    return hex(trace_id)[2:].rjust(32, "0")
+
+
+def _span_id(span_id: int) -> str:
+    if not 0 <= span_id < 2**64:
+        raise ValueError(f"The {span_id=} is out of bounds")
+    return hex(span_id)[2:].rjust(16, "0")
+
+
+def _status(status: Status) -> dict[str, Any]:
+    # FIXME
+    return {}