beacon-profiling 1.2.4__tar.gz → 1.2.7__tar.gz

{beacon_profiling-1.2.4 → beacon_profiling-1.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: beacon-profiling
-Version: 1.2.4
+Version: 1.2.7
 Summary: Beacon Profiling for OpenTelemetry Python
 Project-URL: Homepage, https://github.com/beacon-observability/beacon-python/tree/main/sdk-extension/beacon-profiling
 Project-URL: Repository, https://github.com/beacon-observability/beacon-python
@@ -18,10 +18,10 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Requires-Python: >=3.10
-Requires-Dist: opentelemetry-api==1.45.1
-Requires-Dist: opentelemetry-exporter-otlp==1.45.1
-Requires-Dist: opentelemetry-instrumentation==0.66b1
-Requires-Dist: opentelemetry-sdk==1.45.1
+Requires-Dist: opentelemetry-api==1.45.2
+Requires-Dist: opentelemetry-exporter-otlp==1.45.2
+Requires-Dist: opentelemetry-instrumentation==0.66b2
+Requires-Dist: opentelemetry-sdk==1.45.2
 Requires-Dist: requests>=2.20
 Description-Content-Type: text/x-rst
 
@@ -32,7 +32,7 @@ The current stable version is ``beacon-profiling==1.2.1``.
 
 This package provides a Python profiling runtime for OpenTelemetry
 auto-instrumentation. The current implementation exports profiles via OTLP
-or a compatible pprof endpoint and supports multiple collector types:
+or local pprof files and supports multiple collector types:
 
 * stack sampling
 * handled exceptions
@@ -77,7 +77,12 @@ Configuration
 The following environment variables are supported:
 
 * ``OTEL_PROFILING_ENABLED``
-* ``OTEL_PROFILING_EXPORTER`` (``otlp`` or ``pprof``)
+* ``OTEL_PROFILING_EXPORTER`` (``http`` or ``file``; defaults to ``http``;
+  legacy ``datakit`` and ``pprof_http`` names remain aliases)
+* ``OTEL_PROFILING_ENDPOINT`` (defaults to
+  ``http://127.0.0.1:9529/profiling/v1/input``)
+* ``OTEL_PROFILING_PPROF_UPLOAD_URL`` (legacy explicit endpoint; takes precedence)
+* ``OTEL_PROFILING_PPROF_HEADERS`` (legacy upload headers)
 * ``OTEL_PROFILING_SAMPLE_INTERVAL``
 * ``OTEL_PROFILING_EXPORT_INTERVAL`` (defaults to 60 seconds and can be
   overridden by the ``Profiler(export_interval=...)`` argument)
@@ -106,11 +111,7 @@ The following environment variables are supported:
 * ``OTEL_EXPORTER_OTLP_PROFILES_CERTIFICATE``
 * ``OTEL_EXPORTER_OTLP_PROFILES_CLIENT_KEY``
 * ``OTEL_EXPORTER_OTLP_PROFILES_CLIENT_CERTIFICATE``
-* ``OTEL_PROFILING_PPROF_PATH``
-* ``OTEL_PROFILING_PPROF_MAX_FILES`` (HTTP upload local copies only; defaults
-  to 3 retained files per exporter instance)
-* ``OTEL_PROFILING_PPROF_UPLOAD_URL``
-* ``OTEL_PROFILING_PPROF_HEADERS``
+* ``OTEL_PROFILING_FILE_PATH`` (directory; defaults to ``otel-profiles``)
 
 Service metadata should be configured with standard OpenTelemetry
 resource settings such as ``OTEL_SERVICE_NAME`` and
@@ -141,8 +142,8 @@ periodic memory scheduling uses the positive export cadence instead of spinning.
 Examples
 --------
 
-Collect stack, exception, lock, and heap profiles and export them with
-OTLP/HTTP:
+Collect stack, exception, lock, and heap profiles and upload them over HTTP
+using the existing DataKit-compatible multipart/pprof format:
 
 ::
 
@@ -150,38 +151,27 @@ OTLP/HTTP:
     export OTEL_PROFILING_EXCEPTION_ENABLED=true
     export OTEL_PROFILING_LOCK_ENABLED=true
     export OTEL_PROFILING_MEMORY_ENABLED=true
-    export OTEL_EXPORTER_OTLP_PROFILES_PROTOCOL=http/protobuf
-    export OTEL_EXPORTER_OTLP_PROFILES_ENDPOINT=http://localhost:4318/v1development/profiles
+    export OTEL_PROFILING_EXPORTER=http
+    export OTEL_PROFILING_ENDPOINT=http://127.0.0.1:9529/profiling/v1/input
     beacon python app.py
 
-To dump pprof files instead of OTLP, set:
+To dump pprof files instead of uploading them, set:
 
 ::
 
-    export OTEL_PROFILING_EXPORTER=pprof
-    export OTEL_PROFILING_PPROF_PATH=/tmp/otel-profile
+    export OTEL_PROFILING_EXPORTER=file
+    export OTEL_PROFILING_FILE_PATH=/tmp/otel-profiles
 
-To POST pprof directly to a compatible agent endpoint and keep a local
-copy:
+The ``file`` exporter ignores all OTLP endpoint and transport settings.
+It writes gzip pprof files to the configured directory, without network uploads.
 
-::
-
-    export OTEL_PROFILING_PPROF_UPLOAD_URL=http://localhost:9529/profiling/v1/input
-    export OTEL_PROFILING_PPROF_HEADERS="X-API-Key:xxx"
-    export OTEL_PROFILING_PPROF_PATH=/tmp/otel-profile
-    beacon python app.py
-
-HTTP upload does not write local files unless ``OTEL_PROFILING_PPROF_PATH``
-is set. An empty ``pprof_path`` argument disables copies even when that
-environment variable is set. Local write/cleanup failures are logged and do
-not prevent upload. Retention removes only files written by this exporter
-instance; it never scans or removes files owned by other processes. The
-file-only ``pprof`` exporter retains its existing output behavior.
-
-Capture and export exceptions are logged; subsequent scheduled captures
-and export attempts continue. Failed batches are not replayed automatically.
+The ``http`` configuration name selects the existing multipart/pprof uploader.
+The ``otlp`` exporter name is reserved for future OTLP Profiles support and is
+currently rejected by environment-based selection. Sampling and profile encoding
+are unchanged. This uploader does not inherit the trace exporter's protocol or shared
+OTLP endpoint. A gRPC traces endpoint is not a profiling upload endpoint.
 
-When ``OTEL_PROFILING_EXPORTER`` is unset and
-``OTEL_PROFILING_PPROF_UPLOAD_URL`` is configured, the runtime
-defaults to a legacy-compatible ``pprof`` upload layout. Set
-``OTEL_PROFILING_EXPORTER=otlp`` to force OTLP profile export.
+The ``OTEL_EXPORTER_OTLP_PROFILES_*`` settings above apply only when explicitly
+constructing the low-level OTLP exporters; the environment-selected compatible
+uploader uses ``OTEL_PROFILING_ENDPOINT``. These source changes require a new
+Beacon release.

{beacon_profiling-1.2.4 → beacon_profiling-1.2.7}/README.rst

@@ -5,7 +5,7 @@ The current stable version is ``beacon-profiling==1.2.1``.
 
 This package provides a Python profiling runtime for OpenTelemetry
 auto-instrumentation. The current implementation exports profiles via OTLP
-or a compatible pprof endpoint and supports multiple collector types:
+or local pprof files and supports multiple collector types:
 
 * stack sampling
 * handled exceptions
@@ -50,7 +50,12 @@ Configuration
 The following environment variables are supported:
 
 * ``OTEL_PROFILING_ENABLED``
-* ``OTEL_PROFILING_EXPORTER`` (``otlp`` or ``pprof``)
+* ``OTEL_PROFILING_EXPORTER`` (``http`` or ``file``; defaults to ``http``;
+  legacy ``datakit`` and ``pprof_http`` names remain aliases)
+* ``OTEL_PROFILING_ENDPOINT`` (defaults to
+  ``http://127.0.0.1:9529/profiling/v1/input``)
+* ``OTEL_PROFILING_PPROF_UPLOAD_URL`` (legacy explicit endpoint; takes precedence)
+* ``OTEL_PROFILING_PPROF_HEADERS`` (legacy upload headers)
 * ``OTEL_PROFILING_SAMPLE_INTERVAL``
 * ``OTEL_PROFILING_EXPORT_INTERVAL`` (defaults to 60 seconds and can be
   overridden by the ``Profiler(export_interval=...)`` argument)
@@ -79,11 +84,7 @@ The following environment variables are supported:
 * ``OTEL_EXPORTER_OTLP_PROFILES_CERTIFICATE``
 * ``OTEL_EXPORTER_OTLP_PROFILES_CLIENT_KEY``
 * ``OTEL_EXPORTER_OTLP_PROFILES_CLIENT_CERTIFICATE``
-* ``OTEL_PROFILING_PPROF_PATH``
-* ``OTEL_PROFILING_PPROF_MAX_FILES`` (HTTP upload local copies only; defaults
-  to 3 retained files per exporter instance)
-* ``OTEL_PROFILING_PPROF_UPLOAD_URL``
-* ``OTEL_PROFILING_PPROF_HEADERS``
+* ``OTEL_PROFILING_FILE_PATH`` (directory; defaults to ``otel-profiles``)
 
 Service metadata should be configured with standard OpenTelemetry
 resource settings such as ``OTEL_SERVICE_NAME`` and
@@ -114,8 +115,8 @@ periodic memory scheduling uses the positive export cadence instead of spinning.
 Examples
 --------
 
-Collect stack, exception, lock, and heap profiles and export them with
-OTLP/HTTP:
+Collect stack, exception, lock, and heap profiles and upload them over HTTP
+using the existing DataKit-compatible multipart/pprof format:
 
 ::
 
@@ -123,38 +124,27 @@ OTLP/HTTP:
     export OTEL_PROFILING_EXCEPTION_ENABLED=true
     export OTEL_PROFILING_LOCK_ENABLED=true
     export OTEL_PROFILING_MEMORY_ENABLED=true
-    export OTEL_EXPORTER_OTLP_PROFILES_PROTOCOL=http/protobuf
-    export OTEL_EXPORTER_OTLP_PROFILES_ENDPOINT=http://localhost:4318/v1development/profiles
+    export OTEL_PROFILING_EXPORTER=http
+    export OTEL_PROFILING_ENDPOINT=http://127.0.0.1:9529/profiling/v1/input
     beacon python app.py
 
-To dump pprof files instead of OTLP, set:
+To dump pprof files instead of uploading them, set:
 
 ::
 
-    export OTEL_PROFILING_EXPORTER=pprof
-    export OTEL_PROFILING_PPROF_PATH=/tmp/otel-profile
+    export OTEL_PROFILING_EXPORTER=file
+    export OTEL_PROFILING_FILE_PATH=/tmp/otel-profiles
 
-To POST pprof directly to a compatible agent endpoint and keep a local
-copy:
+The ``file`` exporter ignores all OTLP endpoint and transport settings.
+It writes gzip pprof files to the configured directory, without network uploads.
 
-::
-
-    export OTEL_PROFILING_PPROF_UPLOAD_URL=http://localhost:9529/profiling/v1/input
-    export OTEL_PROFILING_PPROF_HEADERS="X-API-Key:xxx"
-    export OTEL_PROFILING_PPROF_PATH=/tmp/otel-profile
-    beacon python app.py
-
-HTTP upload does not write local files unless ``OTEL_PROFILING_PPROF_PATH``
-is set. An empty ``pprof_path`` argument disables copies even when that
-environment variable is set. Local write/cleanup failures are logged and do
-not prevent upload. Retention removes only files written by this exporter
-instance; it never scans or removes files owned by other processes. The
-file-only ``pprof`` exporter retains its existing output behavior.
-
-Capture and export exceptions are logged; subsequent scheduled captures
-and export attempts continue. Failed batches are not replayed automatically.
+The ``http`` configuration name selects the existing multipart/pprof uploader.
+The ``otlp`` exporter name is reserved for future OTLP Profiles support and is
+currently rejected by environment-based selection. Sampling and profile encoding
+are unchanged. This uploader does not inherit the trace exporter's protocol or shared
+OTLP endpoint. A gRPC traces endpoint is not a profiling upload endpoint.
 
-When ``OTEL_PROFILING_EXPORTER`` is unset and
-``OTEL_PROFILING_PPROF_UPLOAD_URL`` is configured, the runtime
-defaults to a legacy-compatible ``pprof`` upload layout. Set
-``OTEL_PROFILING_EXPORTER=otlp`` to force OTLP profile export.
+The ``OTEL_EXPORTER_OTLP_PROFILES_*`` settings above apply only when explicitly
+constructing the low-level OTLP exporters; the environment-selected compatible
+uploader uses ``OTEL_PROFILING_ENDPOINT``. These source changes require a new
+Beacon release.

{beacon_profiling-1.2.4 → beacon_profiling-1.2.7}/pyproject.toml

@@ -25,10 +25,10 @@ classifiers = [
   "Programming Language :: Python :: 3.14",
 ]
 dependencies = [
-  "opentelemetry-api == 1.45.1",
-  "opentelemetry-sdk == 1.45.1",
-  "opentelemetry-instrumentation == 0.66b1",
-  "opentelemetry-exporter-otlp == 1.45.1",
+  "opentelemetry-api == 1.45.2",
+  "opentelemetry-sdk == 1.45.2",
+  "opentelemetry-instrumentation == 0.66b2",
+  "opentelemetry-exporter-otlp == 1.45.2",
   "requests >= 2.20",
 ]
 

{beacon_profiling-1.2.4 → beacon_profiling-1.2.7}/src/opentelemetry/sdk/extension/profiling/environment_variables.py

@@ -34,6 +34,8 @@ OTEL_PROFILING_MEMORY_ENABLED = "OTEL_PROFILING_MEMORY_ENABLED"
 OTEL_PROFILING_MEMORY_INTERVAL = "OTEL_PROFILING_MEMORY_INTERVAL"
 OTEL_PROFILING_MEMORY_TOP_STATS = "OTEL_PROFILING_MEMORY_TOP_STATS"
 OTEL_PROFILING_MEMORY_IGNORE_PROFILER = "OTEL_PROFILING_MEMORY_IGNORE_PROFILER"
+OTEL_PROFILING_FILE_PATH = "OTEL_PROFILING_FILE_PATH"
+OTEL_PROFILING_ENDPOINT = "OTEL_PROFILING_ENDPOINT"
 OTEL_PROFILING_PPROF_PATH = "OTEL_PROFILING_PPROF_PATH"
 OTEL_PROFILING_PPROF_MAX_FILES = "OTEL_PROFILING_PPROF_MAX_FILES"
 OTEL_PROFILING_PPROF_UPLOAD_URL = "OTEL_PROFILING_PPROF_UPLOAD_URL"

beacon_profiling-1.2.4/src/opentelemetry/sdk/extension/profiling/export/pprof.py → beacon_profiling-1.2.7/src/opentelemetry/sdk/extension/profiling/export/file.py

@@ -1,28 +1,30 @@
 from __future__ import annotations
 
 import os
-from itertools import count
+from pathlib import Path
+from uuid import uuid4
 
 from opentelemetry.sdk.extension.profiling.environment_variables import (
-    OTEL_PROFILING_PPROF_PATH,
+    OTEL_PROFILING_FILE_PATH,
 )
 from opentelemetry.sdk.extension.profiling.export.result import (
     ProfileExportResult,
 )
 
 
-class PPROFProfileExporter:
+class FileProfileExporter:
     def __init__(self, *, directory: str | None = None) -> None:
-        self._directory = directory or os.environ.get(
-            OTEL_PROFILING_PPROF_PATH, "otel-profiles"
+        self._directory = Path(
+            directory
+            or os.environ.get(OTEL_PROFILING_FILE_PATH, "otel-profiles")
         )
-        os.makedirs(os.path.dirname(self._directory) or ".", exist_ok=True)
-        self._counter = count(0)
-        self._pid = os.getpid()
+        self._directory.mkdir(parents=True, exist_ok=True)
 
     def export(self, payload: bytes) -> ProfileExportResult:
-        filename = f"{self._directory}.{self._pid}.{next(self._counter)}.pprof"
-        with open(filename, "wb") as handle:
+        filename = (
+            self._directory / f"profile-{os.getpid()}-{uuid4().hex}.pprof"
+        )
+        with filename.open("xb") as handle:
             handle.write(payload)
         return ProfileExportResult.SUCCESS
 

{beacon_profiling-1.2.4 → beacon_profiling-1.2.7}/src/opentelemetry/sdk/extension/profiling/export/pprof_http.py

@@ -15,6 +15,7 @@ from uuid import uuid4
 import requests
 
 from opentelemetry.sdk.extension.profiling.environment_variables import (
+    OTEL_PROFILING_ENDPOINT,
     OTEL_PROFILING_PPROF_HEADERS,
     OTEL_PROFILING_PPROF_MAX_FILES,
     OTEL_PROFILING_PPROF_PATH,
@@ -28,7 +29,7 @@ from opentelemetry.sdk.resources import Resource
 
 _logger = logging.getLogger(__name__)
 
-_DEFAULT_AGENT_BASE_URL = "http://localhost:8126"
+_DEFAULT_AGENT_BASE_URL = "http://127.0.0.1:9529"
 _DEFAULT_AGENT_PATH = "profiling/v1/input"
 
 
@@ -234,7 +235,9 @@ def _resolve_headers(
 
 
 def _resolve_upload_url() -> str:
-    explicit = environ.get(OTEL_PROFILING_PPROF_UPLOAD_URL)
+    explicit = environ.get(OTEL_PROFILING_PPROF_UPLOAD_URL) or environ.get(
+        OTEL_PROFILING_ENDPOINT
+    )
     if explicit:
         return explicit
     return f"{_DEFAULT_AGENT_BASE_URL}/{_DEFAULT_AGENT_PATH}"

{beacon_profiling-1.2.4 → beacon_profiling-1.2.7}/src/opentelemetry/sdk/extension/profiling/runtime.py

@@ -62,15 +62,13 @@ from opentelemetry.sdk.extension.profiling.environment_variables import (
     OTEL_PROFILING_MEMORY_IGNORE_PROFILER,
     OTEL_PROFILING_MEMORY_INTERVAL,
     OTEL_PROFILING_MEMORY_TOP_STATS,
-    OTEL_PROFILING_PPROF_UPLOAD_URL,
     OTEL_PROFILING_SAMPLE_INTERVAL,
 )
 from opentelemetry.sdk.extension.profiling.export import (
     CompatiblePPROFExporter,
-    create_otlp_profile_exporter,
 )
-from opentelemetry.sdk.extension.profiling.export.pprof import (
-    PPROFProfileExporter,
+from opentelemetry.sdk.extension.profiling.export.file import (
+    FileProfileExporter,
 )
 from opentelemetry.sdk.extension.profiling.model.builder import (
     ProfilesRequestBuilder,
@@ -89,7 +87,7 @@ _DEFAULT_EXPORT_INTERVAL_SECONDS = 60.0
 
 
 class Profiler:
-    _active_instance: "Profiler | None" = None
+    _active_instance: Profiler | None = None
     _active_lock = Lock()
 
     def __init__(
@@ -318,8 +316,7 @@ class Profiler:
             active = self.__class__._active_instance
             if active is not None and active is not self and active._started:
                 _logger.error(
-                    "A profiler is already running. Only one profiler "
-                    "instance can be active at a time."
+                    "A profiler is already running. Only one profiler instance can be active at a time."
                 )
                 return
             if self._started:
@@ -431,12 +428,6 @@ class Profiler:
             batch = self._samples.drain()
 
         resource = self._resolve_resource()
-        start_time_unix_nano = min(
-            sample.timestamp_unix_nano for sample in batch
-        )
-        end_time_unix_nano = max(
-            sample.timestamp_unix_nano for sample in batch
-        )
         payload = self._builder.build(
             samples=batch,
             resource=resource,
@@ -446,8 +437,12 @@ class Profiler:
             self._exporter.export(
                 payload,
                 resource=resource,
-                start_time_unix_nano=start_time_unix_nano,
-                end_time_unix_nano=end_time_unix_nano,
+                start_time_unix_nano=min(
+                    sample.timestamp_unix_nano for sample in batch
+                ),
+                end_time_unix_nano=max(
+                    sample.timestamp_unix_nano for sample in batch
+                ),
             )
             return
         self._exporter.export(payload)
@@ -467,30 +462,20 @@ class Profiler:
     def _create_builder(self):
         if isinstance(self._exporter, CompatiblePPROFExporter):
             return CompatiblePprofProfileBuilder()
-        if isinstance(self._exporter, PPROFProfileExporter):
+        if isinstance(self._exporter, FileProfileExporter):
             return PprofProfileBuilder()
         return ProfilesRequestBuilder()
 
     @staticmethod
     def _create_exporter_from_env():
-        exporter_name = environ.get(OTEL_PROFILING_EXPORTER)
-        if exporter_name is None:
-            if environ.get(OTEL_PROFILING_PPROF_UPLOAD_URL):
-                return CompatiblePPROFExporter()
-            return create_otlp_profile_exporter()
-
-        exporter_name = exporter_name.strip()
-        if exporter_name == "none":
-            return None
-        if exporter_name == "pprof":
-            return PPROFProfileExporter()
-        if exporter_name == "pprof_http":
-            return CompatiblePPROFExporter()
-        if exporter_name != "otlp":
+        exporter_name = environ.get(OTEL_PROFILING_EXPORTER, "http").strip()
+        if exporter_name == "file":
+            return FileProfileExporter()
+        if exporter_name not in ("http", "datakit", "pprof_http"):
             raise ValueError(
                 f"Unsupported profiling exporter '{exporter_name}'"
             )
-        return create_otlp_profile_exporter()
+        return CompatiblePPROFExporter()
 
     def _start_collectors(self) -> list[Collector]:
         active_collectors = []
@@ -593,7 +578,7 @@ class Profiler:
             after_fork()
 
     @staticmethod
-    def _reset_after_fork(component) -> None:  # noqa: ANN001
+    def _reset_after_fork(component) -> None:
         reset = getattr(component, "reset_after_fork", None)
         if callable(reset):
             reset()

{beacon_profiling-1.2.4 → beacon_profiling-1.2.7}/src/opentelemetry/sdk/extension/profiling/version.py

@@ -1,2 +1,2 @@
 # Generated from beacon/version.properties by beacon/scripts/check-version.py.
-__version__ = "1.2.4"
+__version__ = "1.2.7"

beacon_profiling-1.2.7/tests/test_compatible_runtime_http.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+import gzip
+import json
+from email import policy
+from email.parser import BytesParser
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from threading import Event, Thread
+from time import sleep
+
+from opentelemetry.sdk.extension.profiling.export import pprof_pb2
+from opentelemetry.sdk.extension.profiling.runtime import Profiler
+from opentelemetry.sdk.resources import Resource
+
+
+def test_http_environment_name_keeps_real_multipart_pprof_upload(monkeypatch):
+    received = {}
+    ready = Event()
+
+    class Handler(BaseHTTPRequestHandler):
+        def do_POST(self) -> None:
+            body = self.rfile.read(int(self.headers["Content-Length"]))
+            message = BytesParser(policy=policy.default).parsebytes(
+                f"Content-Type: {self.headers['Content-Type']}\r\n\r\n".encode()
+                + body
+            )
+            received["path"] = self.path
+            received["parts"] = {
+                part.get_filename(): part.get_payload(decode=True)
+                for part in message.iter_parts()
+            }
+            self.send_response(200)
+            self.end_headers()
+            ready.set()
+
+        def log_message(self, format: str, *args) -> None:  # noqa: A002
+            return None
+
+    server = ThreadingHTTPServer(("127.0.0.1", 0), Handler)
+    worker = Thread(target=server.serve_forever, daemon=True)
+    worker.start()
+    monkeypatch.setenv("OTEL_PROFILING_EXPORTER", "http")
+    monkeypatch.delenv("OTEL_PROFILING_PPROF_UPLOAD_URL", raising=False)
+    monkeypatch.setenv(
+        "OTEL_PROFILING_ENDPOINT",
+        f"http://127.0.0.1:{server.server_port}/profiling/v1/input",
+    )
+    profiler = Profiler(
+        sample_interval=0.005,
+        export_interval=3600,
+        exception_enabled=False,
+        lock_enabled=False,
+        memory_enabled=False,
+        resource=Resource.create({"service.name": "multipart-regression"}),
+    )
+    try:
+        profiler.start()
+        sleep(0.1)
+        profiler.stop()
+        assert ready.wait(3)
+        assert received["path"] == "/profiling/v1/input"
+        event = json.loads(received["parts"]["event.json"])
+        assert event["family"] == "python"
+        assert event["attachments"] == ["auto.pprof"]
+        assert "service:multipart-regression" in event["tags_profiler"]
+        profile = pprof_pb2.Profile.FromString(
+            gzip.decompress(received["parts"]["auto.pprof"])
+        )
+        assert profile.sample
+        assert profile.function
+    finally:
+        profiler.stop()
+        server.shutdown()
+        server.server_close()
+        worker.join(3)

{beacon_profiling-1.2.4 → beacon_profiling-1.2.7}/tests/test_pprof_exporter.py

@@ -2,18 +2,18 @@ from __future__ import annotations
 
 from pathlib import Path
 
-from opentelemetry.sdk.extension.profiling.export.pprof import (
-    PPROFProfileExporter,
+from opentelemetry.sdk.extension.profiling.export.file import (
+    FileProfileExporter,
 )
 
 
 def test_pprof_exporter_writes_profile(tmp_path: Path):
-    exporter = PPROFProfileExporter(directory=str(tmp_path / "prof"))
+    exporter = FileProfileExporter(directory=str(tmp_path / "prof"))
     payload = b"pprof-data"
 
     result = exporter.export(payload)
 
-    files = list(tmp_path.glob("prof*.pprof"))
+    files = list((tmp_path / "prof").glob("*.pprof"))
     assert files
     assert files[0].read_bytes() == payload
     assert result.name == "SUCCESS"

beacon_profiling-1.2.7/tests/test_runtime_exporter_selection.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+import pytest
+
+from opentelemetry.sdk.extension.profiling.export.file import (
+    FileProfileExporter,
+)
+from opentelemetry.sdk.extension.profiling.export.pprof_http import (
+    PPROFHTTPExporter,
+)
+from opentelemetry.sdk.extension.profiling.model.pprof_builder import (
+    CompatiblePprofProfileBuilder,
+    PprofProfileBuilder,
+)
+from opentelemetry.sdk.extension.profiling.runtime import Profiler
+
+
+@pytest.mark.parametrize("name", [None, "http", "datakit", "pprof_http"])
+def test_runtime_keeps_compatible_upload_for_http_name(monkeypatch, name):
+    monkeypatch.delenv("OTEL_PROFILING_PPROF_UPLOAD_URL", raising=False)
+    if name is None:
+        monkeypatch.delenv("OTEL_PROFILING_EXPORTER", raising=False)
+    else:
+        monkeypatch.setenv("OTEL_PROFILING_EXPORTER", name)
+    monkeypatch.setenv(
+        "OTEL_PROFILING_ENDPOINT", "http://127.0.0.1:9529/profiling/v1/input"
+    )
+    exporter = Profiler._create_exporter_from_env()
+    assert isinstance(exporter, PPROFHTTPExporter)
+    assert exporter._url == "http://127.0.0.1:9529/profiling/v1/input"
+    assert isinstance(
+        Profiler(exporter=exporter)._builder, CompatiblePprofProfileBuilder
+    )
+    exporter.shutdown()
+
+
+def test_file_ignores_all_endpoint_settings(monkeypatch, tmp_path):
+    monkeypatch.setenv("OTEL_PROFILING_EXPORTER", "file")
+    monkeypatch.setenv("OTEL_PROFILING_FILE_PATH", str(tmp_path))
+    monkeypatch.setenv("OTEL_EXPORTER_OTLP_PROFILES_ENDPOINT", "not a URL")
+    monkeypatch.setenv("OTEL_EXPORTER_OTLP_PROFILES_PROTOCOL", "invalid")
+    exporter = Profiler._create_exporter_from_env()
+    assert isinstance(exporter, FileProfileExporter)
+    assert isinstance(
+        Profiler(exporter=exporter)._builder, PprofProfileBuilder
+    )
+    exporter.export(b"profile")
+    assert next(tmp_path.glob("*.pprof")).read_bytes() == b"profile"
+
+
+@pytest.mark.parametrize("name", ["unknown", "pprof", "none", "otlp"])
+def test_unsupported_exporter_names_rejected(monkeypatch, name):
+    monkeypatch.setenv("OTEL_PROFILING_EXPORTER", name)
+    with pytest.raises(ValueError, match="Unsupported profiling exporter"):
+        Profiler._create_exporter_from_env()
+
+
+def test_runtime_defaults_to_sixty_second_intervals(monkeypatch):
+    monkeypatch.delenv("OTEL_PROFILING_EXPORT_INTERVAL", raising=False)
+    monkeypatch.delenv("OTEL_PROFILING_MEMORY_INTERVAL", raising=False)
+
+    profiler = Profiler(exporter=object())
+
+    assert profiler._export_interval == 60.0
+    assert profiler._memory_interval == 60.0
+
+
+def test_runtime_interval_environment_variables_override_defaults(
+    monkeypatch,
+):
+    monkeypatch.setenv("OTEL_PROFILING_EXPORT_INTERVAL", "17.5")
+    monkeypatch.setenv("OTEL_PROFILING_MEMORY_INTERVAL", "23.5")
+
+    profiler = Profiler(exporter=object())
+
+    assert profiler._export_interval == 17.5
+    assert profiler._memory_interval == 23.5
+
+
+def test_runtime_interval_arguments_override_environment(monkeypatch):
+    monkeypatch.setenv("OTEL_PROFILING_EXPORT_INTERVAL", "17.5")
+    monkeypatch.setenv("OTEL_PROFILING_MEMORY_INTERVAL", "23.5")
+
+    profiler = Profiler(
+        exporter=object(),
+        export_interval=31.5,
+        memory_interval=37.5,
+    )
+
+    assert profiler._export_interval == 31.5
+    assert profiler._memory_interval == 37.5

beacon_profiling-1.2.4/tests/test_runtime_exporter_selection.py

@@ -1,106 +0,0 @@
-from __future__ import annotations
-
-from opentelemetry.sdk.extension.profiling.export import (
-    CompatiblePPROFExporter,
-)
-from opentelemetry.sdk.extension.profiling.export.pprof import (
-    PPROFProfileExporter,
-)
-from opentelemetry.sdk.extension.profiling.model.pprof_builder import (
-    CompatiblePprofProfileBuilder,
-    PprofProfileBuilder,
-)
-from opentelemetry.sdk.extension.profiling.runtime import Profiler
-
-
-def test_runtime_defaults_to_compatible_exporter_for_env_fallback(
-    monkeypatch,
-):
-    monkeypatch.delenv("OTEL_PROFILING_EXPORTER", raising=False)
-    monkeypatch.setenv(
-        "OTEL_PROFILING_PPROF_UPLOAD_URL",
-        "http://collector:9529/profiling/v1/input",
-    )
-
-    exporter = Profiler._create_exporter_from_env()
-
-    assert isinstance(exporter, CompatiblePPROFExporter)
-    exporter.shutdown()
-
-
-def test_runtime_explicit_otlp_exporter_overrides_env_fallback(
-    monkeypatch,
-):
-    sentinel = object()
-    monkeypatch.setenv("OTEL_PROFILING_EXPORTER", "otlp")
-    monkeypatch.setenv(
-        "OTEL_PROFILING_PPROF_UPLOAD_URL",
-        "http://collector:9529/profiling/v1/input",
-    )
-    monkeypatch.setattr(
-        "opentelemetry.sdk.extension.profiling.runtime.create_otlp_profile_exporter",
-        lambda: sentinel,
-    )
-
-    exporter = Profiler._create_exporter_from_env()
-
-    assert exporter is sentinel
-
-
-def test_runtime_uses_compatible_pprof_builder_for_http_exporter(tmp_path):
-    profiler = Profiler(
-        exporter=CompatiblePPROFExporter(pprof_path=str(tmp_path / "prof"))
-    )
-
-    try:
-        assert isinstance(profiler._builder, CompatiblePprofProfileBuilder)
-    finally:
-        profiler._exporter.shutdown()
-
-
-def test_runtime_uses_standard_pprof_builder_for_file_exporter(tmp_path):
-    profiler = Profiler(
-        exporter=PPROFProfileExporter(directory=str(tmp_path / "prof"))
-    )
-
-    try:
-        assert isinstance(profiler._builder, PprofProfileBuilder)
-        assert not isinstance(profiler._builder, CompatiblePprofProfileBuilder)
-    finally:
-        profiler._exporter.shutdown()
-
-
-def test_runtime_defaults_to_sixty_second_intervals(monkeypatch):
-    monkeypatch.delenv("OTEL_PROFILING_EXPORT_INTERVAL", raising=False)
-    monkeypatch.delenv("OTEL_PROFILING_MEMORY_INTERVAL", raising=False)
-
-    profiler = Profiler(exporter=object())
-
-    assert profiler._export_interval == 60.0
-    assert profiler._memory_interval == 60.0
-
-
-def test_runtime_interval_environment_variables_override_defaults(
-    monkeypatch,
-):
-    monkeypatch.setenv("OTEL_PROFILING_EXPORT_INTERVAL", "17.5")
-    monkeypatch.setenv("OTEL_PROFILING_MEMORY_INTERVAL", "23.5")
-
-    profiler = Profiler(exporter=object())
-
-    assert profiler._export_interval == 17.5
-    assert profiler._memory_interval == 23.5
-
-
-def test_runtime_interval_arguments_override_environment(monkeypatch):
-    monkeypatch.setenv("OTEL_PROFILING_EXPORT_INTERVAL", "17.5")
-    monkeypatch.setenv("OTEL_PROFILING_MEMORY_INTERVAL", "23.5")
-
-    profiler = Profiler(
-        exporter=object(),
-        export_interval=31.5,
-        memory_interval=37.5,
-    )
-
-    assert profiler._export_interval == 31.5
-    assert profiler._memory_interval == 37.5