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

otlp_json/__init__.py

@@ -7,6 +7,8 @@ from typing import Any, TYPE_CHECKING
 if TYPE_CHECKING:
     from typing_extensions import TypeAlias
 
+    from opentelemetry.trace import Link
+    from opentelemetry._logs import LogRecord
     from opentelemetry.sdk.trace import ReadableSpan, Event
     from opentelemetry.sdk.resources import Resource
     from opentelemetry.sdk.util.instrumentation import InstrumentationScope
@@ -16,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),
@@ -66,55 +74,76 @@ def encode_spans(spans: Sequence[ReadableSpan]) -> bytes:
 
 
 def _resource(resource: Resource):
-    rv = {"attributes": []}
-    for k, v in resource.attributes.items():
+    # TODO: add schema_url once that lands in opentelemetry-sdk
+    return _attributes(resource)
+
+
+def _attributes(
+    thing: Resource | InstrumentationScope | ReadableSpan | Event | Link | LogRecord,
+) -> dict[str, Any]:
+    rv = {"attributes": [], "dropped_attributes_count": 0}
+
+    assert thing.attributes is not None
+    for k, v in thing.attributes.items():
         try:
             rv["attributes"].append({"key": k, "value": _value(v)})
         except ValueError:
             pass
 
-    # NOTE: blocks that contain droppedAttributesCount:
-    # - Event
-    # - Link
-    # - InstrumentationScope
-    # - LogRecord (out of scope for this library)
-    # - Resource
-    rv["dropped_attributes_count"] = len(resource.attributes) - len(rv["attributes"])  # type: ignore
+    rv["dropped_attributes_count"] = len(thing.attributes) - len(rv["attributes"])  # type: ignore
 
-    if not rv["attributes"]:
-        del rv["attributes"]
-
-    if not rv["dropped_attributes_count"]:
-        del rv["dropped_attributes_count"]
+    for k in ("attributes", "dropped_attributes_count"):
+        if not rv[k]:
+            del rv[k]
 
     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...
-    # TODO: protobuf allows bytes, but I think OTLP doesn't.
-    # TODO: protobuf allows k:v pairs, but I think OTLP doesn't.
-    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}
+    rv = {
+        "name": scope.name,
+        # 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 = {
@@ -122,30 +151,17 @@ 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)]),
-        "startTimeUnixNano": str(span.start_time),  # TODO: is it ever optional?
-        "endTimeUnixNano": str(span.end_time),  # -"-
+        "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),
-        "attributes": [],
+        **_attributes(span),
     }
 
     if span.parent:
         rv["parentSpanId"] = _span_id(span.parent.span_id)
 
-    for k, v in span.attributes.items():  # type: ignore
-        try:
-            rv["attributes"].append({"key": k, "value": _value(v)})
-        except ValueError:
-            pass
-
-    rv["dropped_attributes_count"] = len(span.attributes) - len(rv["attributes"])  # type: ignore
-
-    if not rv["attributes"]:
-        del rv["attributes"]
-
-    if not rv["dropped_attributes_count"]:
-        del rv["dropped_attributes_count"]
-
+    # TODO: is this field really nullable?
     if span.events:
         rv["events"] = [_event(e) for e in span.events]
 
@@ -165,29 +181,19 @@ def _span_id(span_id: int) -> str:
 
 
 def _status(status: Status) -> dict[str, Any]:
-    # FIXME
-    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]:
     rv = {
         "name": event.name,
         "timeUnixNano": str(event.timestamp),
-        "attributes": [],
+        **_attributes(event),
     }
-
-    for k, v in event.attributes.items():  # type: ignore
-        try:
-            rv["attributes"].append({"key": k, "value": _value(v)})
-        except ValueError:
-            pass
-
-    rv["dropped_attributes_count"] = len(event.attributes) - len(rv["attributes"])  # type: ignore
-
-    if not rv["attributes"]:
-        del rv["attributes"]
-
-    if not rv["dropped_attributes_count"]:
-        del rv["dropped_attributes_count"]
-
+    # TODO: any optional attributes?
     return rv

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: otlp-json
-Version: 0.9.3
+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.3.dist-info/RECORD

@@ -1,5 +0,0 @@
-otlp_json/__init__.py,sha256=KFI4PCFiyTOw3wTUClS1hIeUyAMCCZp1F9F6K6Qi_IQ,5862
-otlp_json/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-otlp_json-0.9.3.dist-info/METADATA,sha256=7RMTwaC70Vni4nVgZt-VB1-yCv-qlb7908cUTEWPQRs,2810
-otlp_json-0.9.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-otlp_json-0.9.3.dist-info/RECORD,,