oteltest 0.0.1__tar.gz

oteltest-0.0.1/.gitignore

@@ -0,0 +1,68 @@
+*.py[cod]
+*.sw[op]
+
+# C extensions
+*.so
+
+# Packages
+*.egg
+*.egg-info
+dist
+build
+eggs
+parts
+bin
+include
+var
+sdist
+develop-eggs
+.installed.cfg
+pyvenv.cfg
+lib
+share/
+lib64
+__pycache__
+venv*/
+.venv*/
+
+# Installer logs
+pip-log.txt
+
+# Unit test / coverage reports
+coverage.xml
+.coverage
+.nox
+.tox
+.cache
+htmlcov
+
+# Translations
+*.mo
+
+# Mac
+.DS_Store
+
+# Mr Developer
+.mr.developer.cfg
+.project
+.pydevproject
+
+# JetBrains
+.idea
+
+# VSCode
+.vscode
+
+# Sphinx
+_build/
+
+# mypy
+.mypy_cache/
+target
+
+# Django example
+
+docs/examples/django/db.sqlite3
+
+# Semantic conventions
+scripts/semconv/semantic-conventions

oteltest-0.0.1/LICENSE.txt

@@ -0,0 +1,13 @@
+# Copyright The OpenTelemetry Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

oteltest-0.0.1/PKG-INFO

@@ -0,0 +1,160 @@
+Metadata-Version: 2.3
+Name: oteltest
+Version: 0.0.1
+Project-URL: Documentation, https://github.com/open-telemetry/opentelemetry-python#readme
+Project-URL: Issues, https://github.com/open-telemetry/opentelemetry-python/issues
+Project-URL: Source, https://github.com/open-telemetry/opentelemetry-python/
+Author-email: OpenTelemetry Authors <cncf-opentelemetry-contributors@lists.cncf.io>
+License-Expression: Apache-2.0
+License-File: LICENSE.txt
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.7
+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 :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Python: >=3.7
+Requires-Dist: grpcio
+Requires-Dist: opentelemetry-api
+Requires-Dist: opentelemetry-proto
+Requires-Dist: protobuf
+Description-Content-Type: text/markdown
+
+# oteltest
+
+[![PyPI - Version](https://img.shields.io/pypi/v/oteltest.svg)](https://pypi.org/project/oteltest)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/oteltest.svg)](https://pypi.org/project/oteltest)
+
+-----
+
+**Table of Contents**
+
+- [Installation](#installation)
+- [License](#license)
+
+## Installation
+
+```console
+pip install oteltest
+```
+
+## Overview
+
+The `oteltest` package contains utilities for testing OpenTelemetry Python.
+
+### oteltest
+
+`oteltest` is a CLI command which you can use to run black box tests against OpenTelemetry Python scripts.
+
+#### Execution
+
+You can run `oteltest` as a shell command and provide as an argument either a file:
+
+```shell
+oteltest my_script.py
+```
+
+or a directory:
+
+```shell
+oteltest my_script_dir
+```
+
+Given a directory, the `oteltest` command will attempt to run all `oteltest`-runnable scripts in `my_script_dir`,
+non-recursively.
+
+#### Operation
+
+Running `oteltest` against `my_script.py` 1) starts a Python OTLP listener, 2) creates a new Python virtual
+environment, 3) installs any `requirements()`, 4) starts a subprocess with any requested `wrapper_script()`
+and `environment_variables()`, 5) waits for `my_script.py` to complete, 6) stops the OTLP listener, and finally 7) sends
+the listener's telemetry received back to `my_script.py` in the form of a call to `validate(telemetry)`. It also writes
+a `.json` file with that telemetry next to the script (with the same name but `.json` extension).
+
+#### Scripts
+
+For a Python script to be runnable by `oteltest`, it must both be executable and define an implementation of
+`OtelTest`. The script below has an implementation called `MyTest`:
+
+```python
+import time
+from opentelemetry import trace
+from oteltest.common import OtelTest, Telemetry
+
+SERVICE_NAME = "my-test"
+NUM_ADDS = 12
+
+if __name__ == "__main__":
+    tracer = trace.get_tracer("my-tracer")
+    for i in range(NUM_ADDS):
+        with tracer.start_as_current_span("my-span"):
+            print(f"{i + 1}/{NUM_ADDS}")
+            time.sleep(0.5)
+
+
+class MyTest(OtelTest):
+    def requirements(self):
+        return "opentelemetry-distro", "opentelemetry-exporter-otlp-proto-grpc"
+
+    def wrapper_script(self):
+        return "opentelemetry-instrument"
+
+    def environment_variables(self):
+        return {"OTEL_SERVICE_NAME": SERVICE_NAME}
+
+    def validate(self, telemetry: Telemetry):
+        assert telemetry.num_spans() == NUM_ADDS
+```
+
+#### Usage with OTel Examples
+
+Runnable examples are a great way for new users to get up to speed, but it would be nice to give them an opportunity
+to see the telemetry they just generated. Adding an `OtelTest` implementation (e.g. `MyTest` above) to existing
+example scripts lets users run examples without having to set up Python environments with dependencies. It also lets
+them potentially see the output of their instrumented script.
+
+### otelsink
+
+`otelsink` is a gRPC server that listens for OTel metrics, traces, and logs.
+
+#### Operation
+
+You can run it either from the command line by using the `otelsink` command (installed when you
+`pip install oteltest`), or programatically.
+
+Either way, `otelsink` runs a gRPC server listening on 0.0.0.0:4317.
+
+#### Command Line
+
+```
+% otelsink
+starting otelsink with print handler
+```
+
+#### Programmatic
+
+```
+from oteltest.sink import GrpcSink, PrintHandler
+
+class MyHandler(RequestHandler):
+    def handle_logs(self, request, context):
+        print(f"received log request: {request}")
+
+    def handle_metrics(self, request, context):
+        print(f"received metrics request: {request}")
+
+    def handle_trace(self, request, context):
+        print(f"received trace request: {request}")
+
+
+sink = GrpcSink(MyHandler())
+sink.start()
+sink.wait_for_termination()
+```
+
+## License
+
+`oteltest` is distributed under the terms of the [Apache-2.0](https://spdx.org/licenses/Apache-2.0.html) license.

oteltest-0.0.1/README.md

@@ -0,0 +1,135 @@
+# oteltest
+
+[![PyPI - Version](https://img.shields.io/pypi/v/oteltest.svg)](https://pypi.org/project/oteltest)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/oteltest.svg)](https://pypi.org/project/oteltest)
+
+-----
+
+**Table of Contents**
+
+- [Installation](#installation)
+- [License](#license)
+
+## Installation
+
+```console
+pip install oteltest
+```
+
+## Overview
+
+The `oteltest` package contains utilities for testing OpenTelemetry Python.
+
+### oteltest
+
+`oteltest` is a CLI command which you can use to run black box tests against OpenTelemetry Python scripts.
+
+#### Execution
+
+You can run `oteltest` as a shell command and provide as an argument either a file:
+
+```shell
+oteltest my_script.py
+```
+
+or a directory:
+
+```shell
+oteltest my_script_dir
+```
+
+Given a directory, the `oteltest` command will attempt to run all `oteltest`-runnable scripts in `my_script_dir`,
+non-recursively.
+
+#### Operation
+
+Running `oteltest` against `my_script.py` 1) starts a Python OTLP listener, 2) creates a new Python virtual
+environment, 3) installs any `requirements()`, 4) starts a subprocess with any requested `wrapper_script()`
+and `environment_variables()`, 5) waits for `my_script.py` to complete, 6) stops the OTLP listener, and finally 7) sends
+the listener's telemetry received back to `my_script.py` in the form of a call to `validate(telemetry)`. It also writes
+a `.json` file with that telemetry next to the script (with the same name but `.json` extension).
+
+#### Scripts
+
+For a Python script to be runnable by `oteltest`, it must both be executable and define an implementation of
+`OtelTest`. The script below has an implementation called `MyTest`:
+
+```python
+import time
+from opentelemetry import trace
+from oteltest.common import OtelTest, Telemetry
+
+SERVICE_NAME = "my-test"
+NUM_ADDS = 12
+
+if __name__ == "__main__":
+    tracer = trace.get_tracer("my-tracer")
+    for i in range(NUM_ADDS):
+        with tracer.start_as_current_span("my-span"):
+            print(f"{i + 1}/{NUM_ADDS}")
+            time.sleep(0.5)
+
+
+class MyTest(OtelTest):
+    def requirements(self):
+        return "opentelemetry-distro", "opentelemetry-exporter-otlp-proto-grpc"
+
+    def wrapper_script(self):
+        return "opentelemetry-instrument"
+
+    def environment_variables(self):
+        return {"OTEL_SERVICE_NAME": SERVICE_NAME}
+
+    def validate(self, telemetry: Telemetry):
+        assert telemetry.num_spans() == NUM_ADDS
+```
+
+#### Usage with OTel Examples
+
+Runnable examples are a great way for new users to get up to speed, but it would be nice to give them an opportunity
+to see the telemetry they just generated. Adding an `OtelTest` implementation (e.g. `MyTest` above) to existing
+example scripts lets users run examples without having to set up Python environments with dependencies. It also lets
+them potentially see the output of their instrumented script.
+
+### otelsink
+
+`otelsink` is a gRPC server that listens for OTel metrics, traces, and logs.
+
+#### Operation
+
+You can run it either from the command line by using the `otelsink` command (installed when you
+`pip install oteltest`), or programatically.
+
+Either way, `otelsink` runs a gRPC server listening on 0.0.0.0:4317.
+
+#### Command Line
+
+```
+% otelsink
+starting otelsink with print handler
+```
+
+#### Programmatic
+
+```
+from oteltest.sink import GrpcSink, PrintHandler
+
+class MyHandler(RequestHandler):
+    def handle_logs(self, request, context):
+        print(f"received log request: {request}")
+
+    def handle_metrics(self, request, context):
+        print(f"received metrics request: {request}")
+
+    def handle_trace(self, request, context):
+        print(f"received trace request: {request}")
+
+
+sink = GrpcSink(MyHandler())
+sink.start()
+sink.wait_for_termination()
+```
+
+## License
+
+`oteltest` is distributed under the terms of the [Apache-2.0](https://spdx.org/licenses/Apache-2.0.html) license.

oteltest-0.0.1/example_scripts/simple_loop.json

@@ -0,0 +1,222 @@
+{
+  "log_reqs": [],
+  "metric_reqs": [],
+  "trace_reqs": [
+    {
+      "request": {
+        "resourceSpans": [
+          {
+            "resource": {
+              "attributes": [
+                {
+                  "key": "telemetry.sdk.language",
+                  "value": {
+                    "stringValue": "python"
+                  }
+                },
+                {
+                  "key": "telemetry.sdk.name",
+                  "value": {
+                    "stringValue": "opentelemetry"
+                  }
+                },
+                {
+                  "key": "telemetry.sdk.version",
+                  "value": {
+                    "stringValue": "1.23.0"
+                  }
+                },
+                {
+                  "key": "service.name",
+                  "value": {
+                    "stringValue": "integration-test"
+                  }
+                },
+                {
+                  "key": "telemetry.auto.version",
+                  "value": {
+                    "stringValue": "0.44b0"
+                  }
+                }
+              ]
+            },
+            "scopeSpans": [
+              {
+                "scope": {
+                  "name": "my-tracer"
+                },
+                "spans": [
+                  {
+                    "traceId": "et4vTTA8/bm5YyjFrF/T7w==",
+                    "spanId": "zsOz4GIerwc=",
+                    "name": "my-span",
+                    "kind": "SPAN_KIND_INTERNAL",
+                    "startTimeUnixNano": "1711635618595538000",
+                    "endTimeUnixNano": "1711635619098602000",
+                    "status": {}
+                  },
+                  {
+                    "traceId": "oQrQAFMZiCEMprV4/LNrwQ==",
+                    "spanId": "iMUV/jNqC5w=",
+                    "name": "my-span",
+                    "kind": "SPAN_KIND_INTERNAL",
+                    "startTimeUnixNano": "1711635619098867000",
+                    "endTimeUnixNano": "1711635619603935000",
+                    "status": {}
+                  },
+                  {
+                    "traceId": "GaHP1buKnyub7z0lFPtltg==",
+                    "spanId": "UTXTLUVZhoU=",
+                    "name": "my-span",
+                    "kind": "SPAN_KIND_INTERNAL",
+                    "startTimeUnixNano": "1711635619604104000",
+                    "endTimeUnixNano": "1711635620105109000",
+                    "status": {}
+                  },
+                  {
+                    "traceId": "oqJOz/B6nzvpq8L3EfcSUQ==",
+                    "spanId": "WYJ0Kpi5F+Q=",
+                    "name": "my-span",
+                    "kind": "SPAN_KIND_INTERNAL",
+                    "startTimeUnixNano": "1711635620105286000",
+                    "endTimeUnixNano": "1711635620607148000",
+                    "status": {}
+                  },
+                  {
+                    "traceId": "dh4hTfwNZhjGamgmvCTSyA==",
+                    "spanId": "VvA2+TOIPPQ=",
+                    "name": "my-span",
+                    "kind": "SPAN_KIND_INTERNAL",
+                    "startTimeUnixNano": "1711635620607325000",
+                    "endTimeUnixNano": "1711635621112208000",
+                    "status": {}
+                  },
+                  {
+                    "traceId": "4THaXRxEQE//Q6Ah9ibzMA==",
+                    "spanId": "9w1RAuVW8R8=",
+                    "name": "my-span",
+                    "kind": "SPAN_KIND_INTERNAL",
+                    "startTimeUnixNano": "1711635621112384000",
+                    "endTimeUnixNano": "1711635621617394000",
+                    "status": {}
+                  },
+                  {
+                    "traceId": "AobQXFEK52+9JtF7cRojrg==",
+                    "spanId": "4bxxVSJdgss=",
+                    "name": "my-span",
+                    "kind": "SPAN_KIND_INTERNAL",
+                    "startTimeUnixNano": "1711635621617543000",
+                    "endTimeUnixNano": "1711635622122152000",
+                    "status": {}
+                  },
+                  {
+                    "traceId": "D1IloLl9gAQWEuHhbMEkjg==",
+                    "spanId": "qTbjatfaKxs=",
+                    "name": "my-span",
+                    "kind": "SPAN_KIND_INTERNAL",
+                    "startTimeUnixNano": "1711635622122414000",
+                    "endTimeUnixNano": "1711635622623191000",
+                    "status": {}
+                  },
+                  {
+                    "traceId": "un5hDAa1mhAiI0cURE/nOw==",
+                    "spanId": "TyT3ZlMSJx0=",
+                    "name": "my-span",
+                    "kind": "SPAN_KIND_INTERNAL",
+                    "startTimeUnixNano": "1711635622623366000",
+                    "endTimeUnixNano": "1711635623126592000",
+                    "status": {}
+                  }
+                ]
+              }
+            ]
+          }
+        ]
+      },
+      "headers": {
+        "user-agent": "grpc-python/1.62.1 grpc-c/39.0.0 (osx; chttp2)"
+      }
+    },
+    {
+      "request": {
+        "resourceSpans": [
+          {
+            "resource": {
+              "attributes": [
+                {
+                  "key": "telemetry.sdk.language",
+                  "value": {
+                    "stringValue": "python"
+                  }
+                },
+                {
+                  "key": "telemetry.sdk.name",
+                  "value": {
+                    "stringValue": "opentelemetry"
+                  }
+                },
+                {
+                  "key": "telemetry.sdk.version",
+                  "value": {
+                    "stringValue": "1.23.0"
+                  }
+                },
+                {
+                  "key": "service.name",
+                  "value": {
+                    "stringValue": "integration-test"
+                  }
+                },
+                {
+                  "key": "telemetry.auto.version",
+                  "value": {
+                    "stringValue": "0.44b0"
+                  }
+                }
+              ]
+            },
+            "scopeSpans": [
+              {
+                "scope": {
+                  "name": "my-tracer"
+                },
+                "spans": [
+                  {
+                    "traceId": "nhjQZtiuQzR7c2gk+ibSCA==",
+                    "spanId": "Qs6Wd6WSyWs=",
+                    "name": "my-span",
+                    "kind": "SPAN_KIND_INTERNAL",
+                    "startTimeUnixNano": "1711635623126694000",
+                    "endTimeUnixNano": "1711635623626949000",
+                    "status": {}
+                  },
+                  {
+                    "traceId": "cIYgFYTWwl+aRkNSHk8/Hw==",
+                    "spanId": "hCN25UIOSao=",
+                    "name": "my-span",
+                    "kind": "SPAN_KIND_INTERNAL",
+                    "startTimeUnixNano": "1711635623627119000",
+                    "endTimeUnixNano": "1711635624131442000",
+                    "status": {}
+                  },
+                  {
+                    "traceId": "bZtpEfpiSVdAVmDhuKOYaw==",
+                    "spanId": "A6gHTRBvC3Y=",
+                    "name": "my-span",
+                    "kind": "SPAN_KIND_INTERNAL",
+                    "startTimeUnixNano": "1711635624131546000",
+                    "endTimeUnixNano": "1711635624631675000",
+                    "status": {}
+                  }
+                ]
+              }
+            ]
+          }
+        ]
+      },
+      "headers": {
+        "user-agent": "grpc-python/1.62.1 grpc-c/39.0.0 (osx; chttp2)"
+      }
+    }
+  ]
+}

oteltest-0.0.1/example_scripts/simple_loop.py

@@ -0,0 +1,43 @@
+# Copyright The OpenTelemetry Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import time
+from typing import Mapping, Sequence
+
+from opentelemetry import trace
+from oteltest.common import OtelTest, Telemetry
+
+SERVICE_NAME = "integration-test"
+NUM_ADDS = 12
+
+if __name__ == "__main__":
+    tracer = trace.get_tracer("my-tracer")
+    for i in range(NUM_ADDS):
+        with tracer.start_as_current_span("my-span"):
+            print(f"{i+1}/{NUM_ADDS}")
+            time.sleep(0.5)
+
+
+class MyTest(OtelTest):
+    def requirements(self) -> Sequence[str]:
+        return "opentelemetry-distro", "opentelemetry-exporter-otlp-proto-grpc"
+
+    def environment_variables(self) -> Mapping[str, str]:
+        return {"OTEL_SERVICE_NAME": SERVICE_NAME}
+
+    def wrapper_script(self) -> str:
+        return "opentelemetry-instrument"
+
+    def validate(self, telemetry: Telemetry) -> None:
+        assert telemetry.num_spans() == NUM_ADDS

oteltest-0.0.1/pyproject.toml

@@ -0,0 +1,166 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "oteltest"
+dynamic = ["version"]
+description = ''
+readme = "README.md"
+requires-python = ">=3.7"
+license = "Apache-2.0"
+keywords = []
+authors = [
+  { name = "OpenTelemetry Authors", email = "cncf-opentelemetry-contributors@lists.cncf.io" },
+]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Programming Language :: Python",
+  "Programming Language :: Python :: 3.7",
+  "Programming Language :: Python :: 3.8",
+  "Programming Language :: Python :: 3.9",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: Implementation :: CPython",
+  "Programming Language :: Python :: Implementation :: PyPy",
+]
+dependencies = [
+  "opentelemetry-proto",
+  "opentelemetry-api",
+  "grpcio",
+  "protobuf",
+]
+
+[project.urls]
+Documentation = "https://github.com/open-telemetry/opentelemetry-python#readme"
+Issues = "https://github.com/open-telemetry/opentelemetry-python/issues"
+Source = "https://github.com/open-telemetry/opentelemetry-python/"
+
+[project.scripts]
+oteltest = "oteltest.main:main"
+otelsink = "otelsink:run_with_print_handler"
+
+[tool.hatch.version]
+path = "src/oteltest/__about__.py"
+
+[tool.hatch.envs.default]
+dependencies = [
+  "coverage[toml]>=6.5",
+  "pytest",
+]
+[tool.hatch.envs.default.scripts]
+test = "pytest {args:tests}"
+test-cov = "coverage run -m pytest {args:tests}"
+cov-report = [
+  "- coverage combine",
+  "coverage report",
+]
+cov = [
+  "test-cov",
+  "cov-report",
+]
+
+[[tool.hatch.envs.all.matrix]]
+python = ["3.7", "3.8", "3.9", "3.10", "3.11"]
+
+[tool.hatch.envs.lint]
+detached = true
+dependencies = [
+  "black>=23.1.0",
+  "mypy>=1.0.0",
+  "ruff>=0.0.243",
+]
+[tool.hatch.envs.lint.scripts]
+typing = "mypy --install-types --non-interactive {args:src/oteltest tests}"
+style = [
+  "ruff {args:.}",
+  "black --check --diff {args:.}",
+]
+fmt = [
+  "black {args:.}",
+  "ruff --fix {args:.}",
+  "style",
+]
+all = [
+  "style",
+  "typing",
+]
+
+[tool.black]
+target-version = ["py37"]
+line-length = 120
+skip-string-normalization = true
+
+[tool.ruff]
+target-version = "py37"
+line-length = 120
+select = [
+  "A",
+  "ARG",
+  "B",
+  "C",
+  "DTZ",
+  "E",
+  "EM",
+  "F",
+  "FBT",
+  "I",
+  "ICN",
+  "ISC",
+  "N",
+  "PLC",
+  "PLE",
+  "PLR",
+  "PLW",
+  "Q",
+  "RUF",
+  "S",
+  "T",
+  "TID",
+  "UP",
+  "W",
+  "YTT",
+]
+ignore = [
+  # Allow non-abstract empty methods in abstract base classes
+  "B027",
+  # Allow boolean positional values in function calls, like `dict.get(... True)`
+  "FBT003",
+  # Ignore checks for possible passwords
+  "S105", "S106", "S107",
+  # Ignore complexity
+  "C901", "PLR0911", "PLR0912", "PLR0913", "PLR0915",
+]
+unfixable = [
+  # Don't touch unused imports
+  "F401",
+]
+
+[tool.ruff.isort]
+known-first-party = ["oteltest"]
+
+[tool.ruff.flake8-tidy-imports]
+ban-relative-imports = "all"
+
+[tool.ruff.per-file-ignores]
+# Tests can use magic values, assertions, and relative imports
+"tests/**/*" = ["PLR2004", "S101", "TID252"]
+
+[tool.coverage.run]
+source_pkgs = ["oteltest", "tests"]
+branch = true
+parallel = true
+omit = [
+  "src/oteltest/__about__.py",
+]
+
+[tool.coverage.paths]
+oteltest = ["src/oteltest", "*/oteltest/src/oteltest"]
+tests = ["tests", "*/oteltest/tests"]
+
+[tool.coverage.report]
+exclude_lines = [
+  "no cov",
+  "if __name__ == .__main__.:",
+  "if TYPE_CHECKING:",
+]

oteltest-0.0.1/src/oteltest/__about__.py

@@ -0,0 +1,15 @@
+# Copyright The OpenTelemetry Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+__version__ = "0.0.1"

oteltest-0.0.1/src/oteltest/__init__.py

@@ -0,0 +1,13 @@
+# Copyright The OpenTelemetry Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

oteltest-0.0.1/src/oteltest/common.py

@@ -0,0 +1,132 @@
+# Copyright The OpenTelemetry Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import abc
+import dataclasses
+import json
+from typing import List, Mapping, Optional
+
+
+@dataclasses.dataclass
+class Request:
+    request: dict
+    headers: dict
+
+    def get_header(self, name):
+        return self.headers.get(name)
+
+    def to_json(self):
+        return json.dumps(self.to_dict())
+
+    def to_dict(self):
+        return {
+            "request": self.request,
+            "headers": self.headers,
+        }
+
+
+class Telemetry:
+    def __init__(
+        self,
+        log_reqs: Optional[List[Request]] = None,
+        metric_reqs: Optional[List[Request]] = None,
+        trace_reqs: Optional[List[Request]] = None,
+    ):
+        self.log_reqs: List[Request] = log_reqs or []
+        self.metric_reqs: List[Request] = metric_reqs or []
+        self.trace_reqs: List[Request] = trace_reqs or []
+
+    def add_log(self, log: dict, headers: dict):
+        self.log_reqs.append(Request(log, headers))
+
+    def add_metric(self, metric: dict, headers: dict):
+        self.metric_reqs.append(Request(metric, headers))
+
+    def add_trace(self, trace: dict, headers: dict):
+        self.trace_reqs.append(Request(trace, headers))
+
+    def get_trace_requests(self) -> List[Request]:
+        return self.trace_reqs
+
+    def num_metrics(self) -> int:
+        out = 0
+        for req in self.metric_reqs:
+            for rm in req.request["resourceMetrics"]:
+                for sm in rm["scopeMetrics"]:
+                    out += len(sm["metrics"])
+        return out
+
+    def metric_names(self) -> set:
+        out = set()
+        for req in self.metric_reqs:
+            for rm in req.request["resourceMetrics"]:
+                for sm in rm["scopeMetrics"]:
+                    for m in sm["metrics"]:
+                        out.add(m["name"])
+        return out
+
+    def num_spans(self) -> int:
+        out = 0
+        for req in self.trace_reqs:
+            for rs in req.request["resourceSpans"]:
+                for ss in rs["scopeSpans"]:
+                    out += len(ss["spans"])
+        return out
+
+    def has_trace_header(self, key, expected) -> bool:
+        for req in self.trace_reqs:
+            actual = req.get_header(key)
+            if expected == actual:
+                return True
+        return False
+
+    def to_json(self):
+        return json.dumps(self.to_dict(), indent=2)
+
+    def to_dict(self):
+        return {
+            "log_reqs": [req.to_dict() for req in self.log_reqs],
+            "metric_reqs": [req.to_dict() for req in self.metric_reqs],
+            "trace_reqs": [req.to_dict() for req in self.trace_reqs],
+        }
+
+    def __str__(self):
+        return self.to_json()
+
+
+def trace_attribute_as_str_array(tr: dict, attr_name) -> [str]:
+    out = []
+    for rs in tr["resourceSpans"]:
+        for attr in rs["resource"]["attributes"]:
+            if attr["key"] == attr_name:
+                out.append(attr["value"]["stringValue"])
+    return out
+
+
+class OtelTest(abc.ABC):
+    @abc.abstractmethod
+    def environment_variables(self) -> Mapping[str, str]:
+        pass
+
+    @abc.abstractmethod
+    def requirements(self) -> List[str]:
+        pass
+
+    @abc.abstractmethod
+    def wrapper_script(self) -> str:
+        pass
+
+    @abc.abstractmethod
+    def validate(self, telemetry: Telemetry) -> None:
+        pass

oteltest-0.0.1/src/oteltest/main.py

@@ -0,0 +1,184 @@
+# Copyright The OpenTelemetry Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import glob
+import importlib
+import inspect
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+import venv
+from pathlib import Path
+
+from google.protobuf.json_format import MessageToDict
+
+from opentelemetry.proto.collector.logs.v1.logs_service_pb2 import ExportLogsServiceRequest
+from opentelemetry.proto.collector.metrics.v1.metrics_service_pb2 import ExportMetricsServiceRequest
+from opentelemetry.proto.collector.trace.v1.trace_service_pb2 import ExportTraceServiceRequest
+from oteltest.common import OtelTest, Telemetry
+from oteltest.sink import GrpcSink, RequestHandler
+
+import argparse
+
+
+def main():
+    parser = argparse.ArgumentParser(description="OpenTelemetry Python Tester")
+
+    w_help = "Path to a wheel (.whl) file to be used instead of `pip install oteltest`"
+    parser.add_argument("-w", "--wheel-file", type=str, required=False, help=w_help)
+
+    d_help = "A directory to hold per-script venv directories"
+    parser.add_argument("-d", "--venv-parent-dir", type=str, required=False, help=d_help)
+
+    parser.add_argument("script_dir", type=str, help="The directory containing your oteltest scripts")
+
+    args = parser.parse_args()
+    run(args.script_dir, args.wheel_file, args.venv_parent_dir)
+
+
+def run(script_dir: str, wheel_file: str, venv_parent_dir: str):
+    venv_dir = venv_parent_dir or tempfile.mkdtemp()
+    print(f"using temp dir: {venv_dir}")
+
+    sys.path.append(script_dir)
+
+    for script in ls_scripts(script_dir):
+        setup_script_environment(script, script_dir, venv_dir, wheel_file)
+
+
+def ls_scripts(script_dir):
+    original_dir = os.getcwd()
+    os.chdir(script_dir)
+    scripts = [script_name for script_name in glob.glob("*.py")]
+    os.chdir(original_dir)
+    return scripts
+
+
+def setup_script_environment(script, script_dir, tempdir, wheel_file):
+    handler = AccumulatingHandler()
+    sink = GrpcSink(handler)
+    sink.start()
+
+    module_name = script[:-3]
+    test_class = load_test_class_for_script(module_name)
+    test_instance: OtelTest = test_class()
+
+    v = Venv(str(Path(tempdir) / module_name))
+    v.create()
+
+    pip_path = v.path_to_executable("pip")
+
+    oteltest_dep = wheel_file or "oteltest"
+    run_subprocess([pip_path, "install", oteltest_dep])
+
+    for req in test_instance.requirements():
+        print(f"- Will install requirement: '{req}'")
+        run_subprocess([pip_path, "install", req])
+
+    run_python_script(script, script_dir, test_instance, v)
+
+    v.rm()
+
+    with open(str(Path(script_dir) / f"{module_name}.json"), "w") as file:
+        file.write(handler.telemetry_to_json())
+
+    test_instance.validate(handler.telemetry)
+    print(f"- {script} PASSED")
+
+
+def run_python_script(script, script_dir, test_instance, v):
+    python_script_cmd = [v.path_to_executable("python"), str(Path(script_dir) / script)]
+    ws = test_instance.wrapper_script()
+    if ws is not None:
+        python_script_cmd.insert(0, v.path_to_executable(ws))
+    run_subprocess(python_script_cmd, test_instance.environment_variables())
+
+
+def run_subprocess(args, env_vars=None):
+    print(f"- Subprocess: {args}")
+    print(f"- Environment: {env_vars}")
+    result = subprocess.run(
+        args,
+        capture_output=True,
+        env=env_vars,
+    )
+    print(f"- Return Code: {result.returncode}")
+    print("- Standard Output:")
+    if result.stdout:
+        print(result.stdout.decode('utf-8').strip())
+    print("- Standard Error:")
+    if result.stderr:
+        print(result.stderr.decode('utf-8').strip())
+    print("- End Subprocess -\n")
+
+
+def load_test_class_for_script(module_name):
+    module = importlib.import_module(module_name)
+    for attr_name in dir(module):
+        value = getattr(module, attr_name)
+        if is_test_class(value):
+            return value
+    return None
+
+
+def is_test_class(value):
+    return inspect.isclass(value) and issubclass(value, OtelTest) and value is not OtelTest
+
+
+class Venv:
+    def __init__(self, venv_dir):
+        self.venv_dir = venv_dir
+
+    def create(self):
+        venv.create(self.venv_dir, with_pip=True)
+
+    def path_to_executable(self, executable_name: str):
+        return f"{self.venv_dir}/bin/{executable_name}"
+
+    def rm(self):
+        shutil.rmtree(self.venv_dir)
+
+
+class AccumulatingHandler(RequestHandler):
+    def __init__(self):
+        self.telemetry = Telemetry()
+
+    def handle_logs(self, request: ExportLogsServiceRequest, context):  # noqa: ARG002
+        self.telemetry.add_log(MessageToDict(request), get_context_headers(context))
+
+    def handle_metrics(self, request: ExportMetricsServiceRequest, context):  # noqa: ARG002
+        self.telemetry.add_metric(MessageToDict(request), get_context_headers(context))
+
+    def handle_trace(self, request: ExportTraceServiceRequest, context):  # noqa: ARG002
+        self.telemetry.add_trace(MessageToDict(request), get_context_headers(context))
+
+    def telemetry_to_json(self):
+        return self.telemetry.to_json()
+
+
+def get_context_headers(context):
+    return pbmetadata_to_dict(context.invocation_metadata())
+
+
+def pbmetadata_to_dict(pbmetadata):
+    out = {}
+    for k, v in pbmetadata:
+        out[k] = v
+    return out
+
+
+if __name__ == '__main__':
+    main()

oteltest-0.0.1/src/oteltest/sink.py

@@ -0,0 +1,126 @@
+import abc
+from concurrent import futures
+
+import grpc  # type: ignore
+
+from opentelemetry.proto.collector.logs.v1 import logs_service_pb2, logs_service_pb2_grpc  # type: ignore
+from opentelemetry.proto.collector.logs.v1.logs_service_pb2 import ExportLogsServiceRequest  # type: ignore
+from opentelemetry.proto.collector.metrics.v1 import metrics_service_pb2, metrics_service_pb2_grpc  # type: ignore
+from opentelemetry.proto.collector.metrics.v1.metrics_service_pb2 import ExportMetricsServiceRequest  # type: ignore
+from opentelemetry.proto.collector.trace.v1 import trace_service_pb2, trace_service_pb2_grpc  # type: ignore
+from opentelemetry.proto.collector.trace.v1.trace_service_pb2 import ExportTraceServiceRequest  # type: ignore
+
+
+class _LogsServiceServicer(logs_service_pb2_grpc.LogsServiceServicer):
+    def __init__(self, handle_request):
+        self.handle_request = handle_request
+
+    def Export(self, request, context):  # noqa: N802
+        self.handle_request(request, context)
+        return logs_service_pb2.ExportLogsServiceResponse()
+
+
+class _TraceServiceServicer(trace_service_pb2_grpc.TraceServiceServicer):
+    def __init__(self, handle_request):
+        self.handle_request = handle_request
+
+    def Export(self, request, context):  # noqa: N802
+        self.handle_request(request, context)
+        return trace_service_pb2.ExportTraceServiceResponse()
+
+
+class _MetricsServiceServicer(metrics_service_pb2_grpc.MetricsServiceServicer):
+    def __init__(self, handle_request):
+        self.handle_request = handle_request
+
+    def Export(self, request, context):  # noqa: N802
+        self.handle_request(request, context)
+        return metrics_service_pb2.ExportMetricsServiceResponse()
+
+
+class RequestHandler(abc.ABC):
+    """
+    This interface is meant to be implemented by users of the otelsink API. If you use the API, you'll want to create
+    an implementation, instantiate it, and pass the instance to the GrpcSink constructor. As messages arrive, the
+    callbacks defined by this interface will be invoked.
+
+    grpc_sink = GrpcSink(MyRequestHandler())
+    """
+
+    @abc.abstractmethod
+    def handle_logs(self, request: ExportLogsServiceRequest, context):
+        pass
+
+    @abc.abstractmethod
+    def handle_metrics(self, request: ExportMetricsServiceRequest, context):
+        pass
+
+    @abc.abstractmethod
+    def handle_trace(self, request: ExportTraceServiceRequest, context):
+        pass
+
+
+class GrpcSink:
+    """
+    This is an OTel GRPC server to which you can send metrics, traces, and
+    logs. It requires a RequestHandler implementation passed in.
+    """
+
+    def __init__(self, request_handler: RequestHandler):
+        self.svr = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
+        trace_service_pb2_grpc.add_TraceServiceServicer_to_server(
+            _TraceServiceServicer(request_handler.handle_trace), self.svr
+        )
+        metrics_service_pb2_grpc.add_MetricsServiceServicer_to_server(
+            _MetricsServiceServicer(request_handler.handle_metrics), self.svr
+        )
+        logs_service_pb2_grpc.add_LogsServiceServicer_to_server(
+            _LogsServiceServicer(request_handler.handle_logs), self.svr
+        )
+        self.svr.add_insecure_port("0.0.0.0:4317")
+
+    def start(self):
+        """Starts the server. Does not block."""
+        self.svr.start()
+
+    def wait_for_termination(self):
+        """Blocks until the server stops. Stops the server on KeyboardInterrupt."""
+        try:
+            self.svr.wait_for_termination()
+        except KeyboardInterrupt:
+            print("\nstopping...", end="")
+            self.stop()
+            print("done")
+
+    def stop(self):
+        """Stops the server immediately."""
+        self.svr.stop(grace=None)
+
+
+class PrintHandler(RequestHandler):
+    """
+    A RequestHandler implementation that prints the received messages.
+    """
+
+    def handle_logs(self, request, context):  # noqa: ARG002
+        print(f"log request: {request}")  # noqa: T201
+
+    def handle_metrics(self, request, context):  # noqa: ARG002
+        print(f"metrics request: {request}")  # noqa: T201
+
+    def handle_trace(self, request: ExportTraceServiceRequest, context):  # noqa: ARG002
+        print(f"trace request: {request}")  # noqa: T201
+
+
+def run_with_print_handler():
+    """
+    Runs otelsink with a PrintHandler.
+    """
+    print("starting otelsink with a print handler")
+    sink = GrpcSink(PrintHandler())
+    sink.start()
+    sink.wait_for_termination()
+
+
+if __name__ == "__main__":
+    run_with_print_handler()

oteltest-0.0.1/tests/__init__.py

@@ -0,0 +1,13 @@
+# Copyright The OpenTelemetry Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.