otlp-json 0.9.4__py3-none-any.whl → 0.9.5__py3-none-any.whl

otlp_json/__init__.py

@@ -18,45 +18,51 @@ if TYPE_CHECKING:
     _VALUE: TypeAlias = "_LEAF_VALUE | Sequence[_LEAF_VALUE]"
 
 
-CONTENT_TYPE = "application/json"
-
+__all__ = [
+    "CONTENT_TYPE",
+    "encode_spans",
+]
 
-_VALUE_TYPES = {
-    # NOTE: order matters, for isinstance(True, int).
-    bool: ("boolValue", bool),
-    int: ("intValue", str),
-    float: ("doubleValue", float),
-    bytes: ("bytesValue", bytes),
-    str: ("stringValue", str),
-    Sequence: (
-        "arrayValue",
-        lambda value: {"values": [_value(e) for e in _homogeneous_array(value)]},
-    ),
-    Mapping: (
-        "kvlistValue",
-        lambda value: {"values": [{k: _value(v) for k, v in value.items()}]},
-    ),
-}
+CONTENT_TYPE = "application/json"
 
 
 def encode_spans(spans: Sequence[ReadableSpan]) -> bytes:
-    spans = sorted(spans, key=lambda s: (id(s.resource), id(s.instrumentation_scope)))
+    resource_cache: dict[Resource, tuple] = {}
+    scope_cache: dict[InstrumentationScope, tuple] = {}
+
+    def linearise(span: ReadableSpan):
+        r = span.resource
+        if r not in resource_cache:
+            resource_cache[r] = (r.schema_url, tuple(r.attributes.items()))
+        s = span.instrumentation_scope
+        assert s
+        assert s.attributes is not None
+        if s not in scope_cache:
+            scope_cache[s] = (
+                s.schema_url,
+                s.name,
+                s.version,
+                tuple(s.attributes.items()),
+            )
+        return (resource_cache[r], scope_cache[s])
+
+    spans = sorted(spans, key=linearise)
     rv = {"resourceSpans": []}
-    last_rs = last_is = None
+    last_resource = last_scope = 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
+        if span.resource != last_resource:
+            last_resource = span.resource
+            last_scope = None
             rv["resourceSpans"].append(
                 {
                     "resource": _resource(span.resource),
                     "scopeSpans": [],
                 }
             )
-        if span.instrumentation_scope is not last_is:
-            last_is = span.instrumentation_scope
+        if span.instrumentation_scope != last_scope:
+            last_scope = span.instrumentation_scope
             rv["resourceSpans"][-1]["scopeSpans"].append(
                 {
                     "scope": _scope(span.instrumentation_scope),
@@ -93,35 +99,51 @@ def _attributes(
     return rv
 
 
-def _homogeneous_array(value: list[_LEAF_VALUE]) -> list[_LEAF_VALUE]:
+def _ensure_homogeneous(value: Sequence[_LEAF_VALUE]) -> Sequence[_LEAF_VALUE]:
     # TODO: empty lists are allowed, aren't they?
     if len(types := {type(v) for v in value}) > 1:
         raise ValueError(f"Attribute value arrays must be homogeneous, got {types=}")
     return value
 
 
-def _value(value: _VALUE) -> dict[str, Any]:
-    # Attribute value can be a primitive type, excluging None...
-    # protobuf allows bytes, but I think OTLP spec does not?
-    # protobuf allows k:v pairs, but I think OTLP doesn't.
-    # TODO: read up the spec and validate the allowed type range.
-    for klass, (key, post) in _VALUE_TYPES.items():
-        if isinstance(value, klass):
-            return {key: post(value)}
+def _value(v: _VALUE) -> dict[str, Any]:
+    if isinstance(v, bool):
+        return {"boolValue": bool(v)}
+    if isinstance(v, int):
+        return {"intValue": str(int(v))}
+    if isinstance(v, float):
+        return {"doubleValue": float(v)}
+    if isinstance(v, bytes):
+        return {
+            "bytesValue": bytes(v)
+        }  # FIXME this can't be right; gotta encode this somehow
+    if isinstance(v, str):
+        return {"stringValue": str(v)}
+    if isinstance(v, Sequence):
+        return {"arrayValue": {"values": [_value(e) for e in _ensure_homogeneous(v)]}}
+    if isinstance(v, Mapping):
+        return {"kvlistValue": {"values": [{k: _value(vv) for k, vv in v.items()}]}}
 
-    raise ValueError(f"Cannot convert attribute of {type(value)=}")
+    raise ValueError(f"Cannot convert attribute value of {type(v)=}")
 
 
 def _scope(scope: InstrumentationScope):
     rv = {
         "name": scope.name,
-        **_attributes(scope),
+        # Upstream code for attrs and schema has landed, but wasn't released yet
+        # https://github.com/open-telemetry/opentelemetry-python/pull/4359
+        # "schema_url": scope.schema_url,  # check if it may be null
+        # **_attributes(scope),
     }
     if scope.version:
         rv["version"] = scope.version
     return rv
 
 
+_REMOTE = 0x300
+_LOCAL = 0x100
+
+
 def _span(span: ReadableSpan):
     assert span.context
     rv = {
@@ -129,7 +151,7 @@ def _span(span: ReadableSpan):
         "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 and span.parent.is_remote)]),
+        "flags": _REMOTE if span.parent and span.parent.is_remote else _LOCAL,
         "startTimeUnixNano": str(span.start_time),
         "endTimeUnixNano": str(span.end_time),  # can this be unset?
         "status": _status(span.status),
@@ -159,8 +181,12 @@ def _span_id(span_id: int) -> str:
 
 
 def _status(status: Status) -> dict[str, Any]:
-    # FIXME: need an example of bad status
-    return {}
+    rv = {}
+    if status.status_code.value:
+        rv["code"] = status.status_code.value
+    if status.description:
+        rv["message"] = status.description
+    return rv
 
 
 def _event(event: Event) -> dict[str, Any]:

{otlp_json-0.9.4.dist-info → otlp_json-0.9.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: otlp-json
-Version: 0.9.4
+Version: 0.9.5
 Summary: 🐍Lightweight OTEL span to JSON converter, no dependencies, pure Python🐍
 Project-URL: Repository, https://github.com/dimaqq/otlp-json
 Project-URL: Issues, https://github.com/dimaqq/otlp-json/issues

otlp_json-0.9.5.dist-info/RECORD

@@ -0,0 +1,5 @@
+otlp_json/__init__.py,sha256=sUClLoVbl5pXQtY3qBpKHx8O7ahZPPTcbRdv6enmC4Q,6198
+otlp_json/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+otlp_json-0.9.5.dist-info/METADATA,sha256=3g016j1QprMogf3He-BHvBK1meNoOLGWOf6pUcjQLJM,2810
+otlp_json-0.9.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+otlp_json-0.9.5.dist-info/RECORD,,

otlp_json-0.9.4.dist-info/RECORD

@@ -1,5 +0,0 @@
-otlp_json/__init__.py,sha256=Ur95iX9xoeylZxq_ZKr5jqUNPvlp7ELcgxwU71SC42A,5364
-otlp_json/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-otlp_json-0.9.4.dist-info/METADATA,sha256=swioA9pQ_LXYVL-J0WgTcKjkbdaC7xh70m2rQ4FSBSs,2810
-otlp_json-0.9.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-otlp_json-0.9.4.dist-info/RECORD,,