otlp-test-data 0.9.4__py3-none-any.whl → 0.10.0__py3-none-any.whl

otlp_test_data/__init__.py

@@ -0,0 +1,192 @@
+from __future__ import annotations
+
+import base64
+import dataclasses
+import json
+import random
+from typing import Sequence, TYPE_CHECKING
+from typing_extensions import reveal_type as reveal_type  # temp
+
+import freezegun
+import opentelemetry.trace
+from google.protobuf.json_format import MessageToDict
+from opentelemetry.exporter.otlp.proto.common._internal import trace_encoder
+from opentelemetry.sdk.trace import TracerProvider
+from opentelemetry.sdk.trace.export import SimpleSpanProcessor
+from opentelemetry.sdk.trace.export.in_memory_span_exporter import InMemorySpanExporter
+from opentelemetry.sdk.resources import Resource
+from opentelemetry.trace import set_tracer_provider, get_tracer_provider
+
+if TYPE_CHECKING:
+    from google.protobuf.message import Message
+    from opentelemetry.sdk.trace import ReadableSpan
+    from opentelemetry.proto.collector.trace.v1.trace_service_pb2 import (
+        ExportTraceServiceRequest,
+    )
+
+
+tracer = opentelemetry.trace.get_tracer(__name__)
+provider = TracerProvider()
+exporter = InMemorySpanExporter()
+provider.add_span_processor(SimpleSpanProcessor(exporter))
+set_tracer_provider(provider)
+
+
+@dataclasses.dataclass
+class Config:
+    start_time: str = "2020-01-01 00:00:00Z"
+    random_seed: int = 42
+
+
+time: freezegun.api.FrozenDateTimeFactory = None  # type: ignore
+
+
+def sample_proto(config: Config | None = None) -> bytes:
+    return _proto_to_bytes(_spans_to_proto_object(sample_spans(config)))
+
+
+def sample_json(config: Config | None = None) -> bytes:
+    return _proto_to_json(_spans_to_proto_object(sample_spans(config)))
+
+
+def sample_spans(config: Config | None = None) -> Sequence[ReadableSpan]:
+    """Creates and finishes two spans, then returns them as a list."""
+    global time
+    config = config or Config()
+    resource = Resource.create(
+        attributes={
+            "service.namespace": "1234-1234",  # a unique id
+            "service.name": "my-service",
+            "service.instance.id": "123",
+            "int": 42,
+            "float": 3.14,
+            "bool": False,
+            "str": "sss",
+            "ints": [42, 0],
+            "floats": [3.14, 2.72],
+            "strs": ["sss", "shh"],
+        }
+    )
+    del exporter._finished_spans[:]
+    get_tracer_provider()._resource = resource  # type: ignore
+
+    random.seed(config.random_seed)
+
+    with freezegun.freeze_time(config.start_time) as time:  # type: ignore
+        workload()
+
+    return exporter.get_finished_spans()
+
+
+def _spans_to_proto_object(spans: Sequence[ReadableSpan]) -> ExportTraceServiceRequest:
+    return trace_encoder.encode_spans(spans)
+
+
+def _proto_to_bytes(data: Message) -> bytes:
+    return data.SerializePartialToString()
+
+
+# FIXME: there are probably 3 different enumerated types in the API
+def _proto_to_json(data: Message) -> bytes:
+    dic = MessageToDict(data)
+
+    for rs in dic["resourceSpans"]:
+        for ss in rs["scopeSpans"]:
+            for sp in ss["spans"]:
+                for k in "parentSpanId spanId traceId".split():
+                    if k in sp:
+                        sp[k] = base64.b64decode(sp[k]).hex()
+                sp["kind"] = {
+                    "SPAN_KIND_UNSPECIFIED": 0,
+                    "SPAN_KIND_INTERNAL": 1,
+                    "SPAN_KIND_SERVER": 2,
+                    "SPAN_KIND_CLIENT": 3,
+                    "SPAN_KIND_PRODUCER": 4,
+                    "SPAN_KIND_CONSUMER": 5,
+                }[sp["kind"]]
+
+    return json.dumps(dic).encode("utf-8")
+
+
+def workload():
+    series_of_spans()
+    # nested_spans()
+    # attribute_types()
+    # repeated_attributes()
+    # events()
+
+
+def series_of_spans():
+    with tracer.start_as_current_span("span-one") as one:
+        one.set_attribute("count", "one")
+        time.tick()
+
+    with tracer.start_as_current_span("span-two") as two:
+        two.set_attribute("count", "two")
+        time.tick()
+
+
+def nested_spans():
+    outer()
+
+
+@tracer.start_as_current_span("outer")
+def outer():
+    time.tick()
+    inner()
+    time.tick()
+
+
+@tracer.start_as_current_span("inner")
+def inner():
+    opentelemetry.trace.get_current_span().set_attribute("an-attribute", 42)
+    time.tick()
+
+
+def attribute_types():
+    with tracer.start_as_current_span("attribute-types") as span:
+        span.set_attributes(
+            {"int": 42, "bool": False, "float": 3.14, "str": "string-cheese"}
+        )
+        span.set_attributes(
+            {
+                "ints": [1, 42],
+                "bools": [True, False],
+                "floats": [2.72, 3.14],
+                "strs": ["string-cheese", "strung-cheese"],
+            }
+        )
+
+
+def repeated_attributes():
+    with tracer.start_as_current_span("attribute-types") as span:
+        span.set_attribute("int", 42)
+        span.set_attribute("int", 99)
+
+    with tracer.start_as_current_span("attribute-types") as span:
+        span.set_attributes({"int": 42})
+        span.set_attributes({"int": 99})
+
+
+def events():
+    with tracer.start_as_current_span("attribute-types") as span:
+        span.add_event("first event")
+        time.tick()
+
+        span.add_event("second event")
+        time.tick()
+
+        span.add_event(
+            "event with attributes",
+            attributes={
+                "int": 42,
+                "bool": False,
+                "float": 3.14,
+                "str": "string-cheese",
+                "ints": [1, 42],
+                "bools": [True, False],
+                "floats": [2.72, 3.14],
+                "strs": ["string-cheese", "strung-cheese"],
+            },
+        )
+        time.tick()

{otlp_test_data-0.9.4.dist-info → otlp_test_data-0.10.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: otlp-test-data
-Version: 0.9.4
+Version: 0.10.0
 Summary: Produces OTLP data using OTEL instrumentation
 Classifier: Development Status :: 3 - Alpha
 Classifier: Framework :: OpenTelemetry
@@ -37,9 +37,10 @@ Produces OTLP data using OTEL instrumentation.
 
 ### Features
 
-- fixed, configurable timestamps
+- Fixed, configurable timestamps
 - aims to cover as much of OTEL API as possible
-- aims to cover all valid data types
+- Cover all valid data types
+- Events
 
 ### Limitations
 
@@ -48,7 +49,8 @@ Produces OTLP data using OTEL instrumentation.
 
 ### TODO
 
-- Events
 - Links
 - Baggage
 - Schemata, when https://github.com/open-telemetry/opentelemetry-python/pull/4359 lands
+- Attribute value type coercion, e.g. `class Str(str): ...` and objects with `__str__(self)`.
+- Exceptions

otlp_test_data-0.10.0.dist-info/RECORD

@@ -0,0 +1,4 @@
+otlp_test_data/__init__.py,sha256=7GjDanu2fUzjJDGcwmc9c3sk30HagEcwKChAdWdP42o,5551
+otlp_test_data-0.10.0.dist-info/METADATA,sha256=zOkJOyrE3uWsBPC_HMZ5RVJ4lN0V1W-MTrfIVY88HFk,2112
+otlp_test_data-0.10.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+otlp_test_data-0.10.0.dist-info/RECORD,,

otlp_test_data-0.9.4.dist-info/RECORD

@@ -1,4 +0,0 @@
-otlp_test_data.py,sha256=AddLeT3jimGkpm9ejMpk64VpP1GzBh5JS9gOlPAa-G0,3091
-otlp_test_data-0.9.4.dist-info/METADATA,sha256=MBAd2l_5Si7lmLjz8fy9LYaUhGDnfnF7FRn0TEHUPmA,2012
-otlp_test_data-0.9.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-otlp_test_data-0.9.4.dist-info/RECORD,,

otlp_test_data.py

@@ -1,95 +0,0 @@
-from __future__ import annotations
-
-import base64
-import dataclasses
-import json
-import random
-from typing import Sequence, TYPE_CHECKING
-from typing_extensions import reveal_type as reveal_type  # temp
-
-import freezegun
-from google.protobuf.json_format import MessageToDict
-from opentelemetry.exporter.otlp.proto.common._internal import trace_encoder
-from opentelemetry.sdk.trace import TracerProvider
-from opentelemetry.sdk.trace.export import SimpleSpanProcessor
-from opentelemetry.sdk.trace.export.in_memory_span_exporter import InMemorySpanExporter
-
-if TYPE_CHECKING:
-    from google.protobuf.message import Message
-    from opentelemetry.sdk.trace import ReadableSpan
-    from opentelemetry.proto.collector.trace.v1.trace_service_pb2 import (
-        ExportTraceServiceRequest,
-    )
-
-
-@dataclasses.dataclass
-class Config:
-    start_time: str = "2020-01-01 00:00:00Z"
-    random_seed: int = 42
-
-
-time = None
-
-
-def sample_proto(config: Config | None = None) -> bytes:
-    return _proto_to_bytes(_spans_to_proto_object(sample_spans(config)))
-
-
-def sample_json(config: Config | None = None) -> bytes:
-    return _proto_to_json(_spans_to_proto_object(sample_spans(config)))
-
-
-def sample_spans(config: Config | None = None) -> Sequence[ReadableSpan]:
-    """Creates and finishes two spans, then returns them as a list."""
-    global time
-    config = config or Config()
-    tracer_provider = TracerProvider()
-    exporter = InMemorySpanExporter()
-    tracer_provider.add_span_processor(SimpleSpanProcessor(exporter))
-    tracer = tracer_provider.get_tracer(__name__)
-
-    with freezegun.freeze_time(config.start_time) as time:
-        random.seed(config.random_seed)
-
-        # FIXME the workload section is expected to grow a lot
-        # TODO: attributes
-        # bool, int, float, str
-        # list[bool], ...
-        # tuple[bool], ...
-        # Sequence[bool], ... (maybe)
-        with tracer.start_as_current_span("span-one"):
-            time.tick()
-        with tracer.start_as_current_span("span-two"):
-            time.tick()
-
-    return exporter.get_finished_spans()
-
-
-def _spans_to_proto_object(spans: Sequence[ReadableSpan]) -> ExportTraceServiceRequest:
-    return trace_encoder.encode_spans(spans)
-
-
-def _proto_to_bytes(data: Message) -> bytes:
-    return data.SerializePartialToString()
-
-
-# FIXME: there are probably 3 different enumerated types in the API
-def _proto_to_json(data: Message) -> bytes:
-    dic = MessageToDict(data)
-
-    for rs in dic["resourceSpans"]:
-        for ss in rs["scopeSpans"]:
-            for sp in ss["spans"]:
-                for k in "parentSpanId spanId traceId".split():
-                    if k in sp:
-                        sp[k] = base64.b64decode(sp[k]).hex()
-                sp["kind"] = {
-                    "SPAN_KIND_UNSPECIFIED": 0,
-                    "SPAN_KIND_INTERNAL": 1,
-                    "SPAN_KIND_SERVER": 2,
-                    "SPAN_KIND_CLIENT": 3,
-                    "SPAN_KIND_PRODUCER": 4,
-                    "SPAN_KIND_CONSUMER": 5,
-                }[sp["kind"]]
-
-    return json.dumps(dic).encode("utf-8")