beacon-profiling 1.2.3__tar.gz → 1.2.6__tar.gz

{beacon_profiling-1.2.3 → beacon_profiling-1.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: beacon-profiling
-Version: 1.2.3
+Version: 1.2.6
 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,7 @@ Configuration
 The following environment variables are supported:
 
 * ``OTEL_PROFILING_ENABLED``
-* ``OTEL_PROFILING_EXPORTER`` (``otlp`` or ``pprof``)
+* ``OTEL_PROFILING_EXPORTER`` (``otlp`` or ``file``; defaults to ``otlp``)
 * ``OTEL_PROFILING_SAMPLE_INTERVAL``
 * ``OTEL_PROFILING_EXPORT_INTERVAL`` (defaults to 60 seconds and can be
   overridden by the ``Profiler(export_interval=...)`` argument)
@@ -106,11 +106,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
@@ -158,30 +154,21 @@ To dump pprof files instead of OTLP, 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.
+For OTLP/gRPC, set::
 
-Capture and export exceptions are logged; subsequent scheduled captures
-and export attempts continue. Failed batches are not replayed automatically.
+    export OTEL_PROFILING_EXPORTER=otlp
+    export OTEL_EXPORTER_OTLP_PROFILES_PROTOCOL=grpc
+    export OTEL_EXPORTER_OTLP_PROFILES_ENDPOINT=http://localhost:4317
 
-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.
+OTLP/HTTP uses ``http/protobuf`` and an endpoint such as
+``http://localhost:4318/v1development/profiles``. Profile-specific OTLP
+settings take precedence over shared ``OTEL_EXPORTER_OTLP_*`` settings.
+Only ``otlp`` and ``file`` exporter identifiers are accepted; disable
+profiling with ``OTEL_PROFILING_ENABLED=false``. These source changes
+require a new Beacon release. The previous multipart pprof exporter is removed.

{beacon_profiling-1.2.3 → beacon_profiling-1.2.6}/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,7 @@ Configuration
 The following environment variables are supported:
 
 * ``OTEL_PROFILING_ENABLED``
-* ``OTEL_PROFILING_EXPORTER`` (``otlp`` or ``pprof``)
+* ``OTEL_PROFILING_EXPORTER`` (``otlp`` or ``file``; defaults to ``otlp``)
 * ``OTEL_PROFILING_SAMPLE_INTERVAL``
 * ``OTEL_PROFILING_EXPORT_INTERVAL`` (defaults to 60 seconds and can be
   overridden by the ``Profiler(export_interval=...)`` argument)
@@ -79,11 +79,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
@@ -131,30 +127,21 @@ To dump pprof files instead of OTLP, 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.
+For OTLP/gRPC, set::
 
-Capture and export exceptions are logged; subsequent scheduled captures
-and export attempts continue. Failed batches are not replayed automatically.
+    export OTEL_PROFILING_EXPORTER=otlp
+    export OTEL_EXPORTER_OTLP_PROFILES_PROTOCOL=grpc
+    export OTEL_EXPORTER_OTLP_PROFILES_ENDPOINT=http://localhost:4317
 
-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.
+OTLP/HTTP uses ``http/protobuf`` and an endpoint such as
+``http://localhost:4318/v1development/profiles``. Profile-specific OTLP
+settings take precedence over shared ``OTEL_EXPORTER_OTLP_*`` settings.
+Only ``otlp`` and ``file`` exporter identifiers are accepted; disable
+profiling with ``OTEL_PROFILING_ENABLED=false``. These source changes
+require a new Beacon release. The previous multipart pprof exporter is removed.

{beacon_profiling-1.2.3 → beacon_profiling-1.2.6}/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.3 → beacon_profiling-1.2.6}/src/opentelemetry/sdk/extension/profiling/environment_variables.py

@@ -34,10 +34,7 @@ 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_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"
-OTEL_PROFILING_PPROF_HEADERS = "OTEL_PROFILING_PPROF_HEADERS"
+OTEL_PROFILING_FILE_PATH = "OTEL_PROFILING_FILE_PATH"
 
 OTEL_EXPORTER_OTLP_PROFILES_PROTOCOL = "OTEL_EXPORTER_OTLP_PROFILES_PROTOCOL"
 OTEL_EXPORTER_OTLP_PROFILES_ENDPOINT = "OTEL_EXPORTER_OTLP_PROFILES_ENDPOINT"

{beacon_profiling-1.2.3 → beacon_profiling-1.2.6}/src/opentelemetry/sdk/extension/profiling/export/__init__.py

@@ -12,11 +12,8 @@ from opentelemetry.sdk.extension.profiling.export.grpc import (
 from opentelemetry.sdk.extension.profiling.export.http import (
     OTLPHTTPProfileExporter,
 )
-from opentelemetry.sdk.extension.profiling.export.pprof_http import (
-    PPROFHTTPExporter as CompatiblePPROFExporter,
-)
 
-__all__ = ("CompatiblePPROFExporter", "create_otlp_profile_exporter")
+__all__ = ("create_otlp_profile_exporter",)
 
 
 def create_otlp_profile_exporter():

beacon_profiling-1.2.3/src/opentelemetry/sdk/extension/profiling/export/pprof.py → beacon_profiling-1.2.6/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.3 → beacon_profiling-1.2.6}/src/opentelemetry/sdk/extension/profiling/runtime.py

@@ -62,21 +62,18 @@ 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,
 )
 from opentelemetry.sdk.extension.profiling.model.pprof_builder import (
-    CompatiblePprofProfileBuilder,
     PprofProfileBuilder,
 )
 from opentelemetry.sdk.extension.profiling.scheduler import ProfileScheduler
@@ -89,7 +86,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 +315,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,25 +427,11 @@ 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,
             sample_period_ns=int(self._sample_interval * 1_000_000_000),
         )
-        if isinstance(self._exporter, CompatiblePPROFExporter):
-            self._exporter.export(
-                payload,
-                resource=resource,
-                start_time_unix_nano=start_time_unix_nano,
-                end_time_unix_nano=end_time_unix_nano,
-            )
-            return
         self._exporter.export(payload)
 
     def force_flush(self) -> None:
@@ -465,27 +447,15 @@ class Profiler:
         return Resource.create()
 
     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()
+        exporter_name = environ.get(OTEL_PROFILING_EXPORTER, "otlp").strip()
+        if exporter_name == "file":
+            return FileProfileExporter()
         if exporter_name != "otlp":
             raise ValueError(
                 f"Unsupported profiling exporter '{exporter_name}'"
@@ -593,7 +563,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.3 → beacon_profiling-1.2.6}/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.3"
+__version__ = "1.2.6"

{beacon_profiling-1.2.3 → beacon_profiling-1.2.6}/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.3 → beacon_profiling-1.2.6}/tests/test_runtime_exporter_selection.py

@@ -1,73 +1,48 @@
 from __future__ import annotations
 
-from opentelemetry.sdk.extension.profiling.export import (
-    CompatiblePPROFExporter,
-)
-from opentelemetry.sdk.extension.profiling.export.pprof import (
-    PPROFProfileExporter,
+import pytest
+
+from opentelemetry.sdk.extension.profiling.export.file import (
+    FileProfileExporter,
 )
 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,
-):
+def test_runtime_defaults_to_otlp(monkeypatch):
     sentinel = object()
-    monkeypatch.setenv("OTEL_PROFILING_EXPORTER", "otlp")
+    monkeypatch.delenv("OTEL_PROFILING_EXPORTER", raising=False)
     monkeypatch.setenv(
-        "OTEL_PROFILING_PPROF_UPLOAD_URL",
-        "http://collector:9529/profiling/v1/input",
+        "OTEL_PROFILING_PPROF_UPLOAD_URL", "invalid old endpoint"
     )
     monkeypatch.setattr(
         "opentelemetry.sdk.extension.profiling.runtime.create_otlp_profile_exporter",
         lambda: sentinel,
     )
-
-    exporter = Profiler._create_exporter_from_env()
-
-    assert exporter is sentinel
+    assert Profiler._create_exporter_from_env() is sentinel
 
 
-def test_runtime_uses_compatible_pprof_builder_for_http_exporter(tmp_path):
-    profiler = Profiler(
-        exporter=CompatiblePPROFExporter(pprof_path=str(tmp_path / "prof"))
+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"
 
-    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()
+@pytest.mark.parametrize("name", ["datakit", "pprof", "pprof_http", "none"])
+def test_removed_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):

beacon_profiling-1.2.3/src/opentelemetry/sdk/extension/profiling/export/pprof_http.py

@@ -1,310 +0,0 @@
-from __future__ import annotations
-
-import binascii
-import datetime
-import json
-import logging
-import os
-import platform
-from collections import deque
-from itertools import count
-from os import environ
-from typing import Dict, Optional
-from uuid import uuid4
-
-import requests
-
-from opentelemetry.sdk.extension.profiling.environment_variables import (
-    OTEL_PROFILING_PPROF_HEADERS,
-    OTEL_PROFILING_PPROF_MAX_FILES,
-    OTEL_PROFILING_PPROF_PATH,
-    OTEL_PROFILING_PPROF_UPLOAD_URL,
-)
-from opentelemetry.sdk.extension.profiling.export.result import (
-    ProfileExportResult,
-)
-from opentelemetry.sdk.extension.profiling.version import __version__
-from opentelemetry.sdk.resources import Resource
-
-_logger = logging.getLogger(__name__)
-
-_DEFAULT_AGENT_BASE_URL = "http://localhost:8126"
-_DEFAULT_AGENT_PATH = "profiling/v1/input"
-
-
-class PPROFHTTPExporter:
-    def __init__(
-        self,
-        *,
-        upload_url: str | None = None,
-        headers: Optional[Dict[str, str]] = None,
-        timeout: float = 10.0,
-        session: Optional[requests.Session] = None,
-        pprof_path: str | None = None,
-        max_files: int | None = None,
-        service: str | None = None,
-        env_name: str | None = None,
-        version: str | None = None,
-    ) -> None:
-        self._url = upload_url or _resolve_upload_url()
-        self._headers = _resolve_headers(headers)
-        self._timeout = timeout
-        self._session = session or requests.Session()
-        self._pprof_path = (
-            pprof_path
-            if pprof_path is not None
-            else environ.get(OTEL_PROFILING_PPROF_PATH)
-        )
-        self._max_files = (
-            max_files
-            if max_files is not None
-            else int(environ.get(OTEL_PROFILING_PPROF_MAX_FILES, "3"))
-        )
-        if self._max_files < 1:
-            raise ValueError("max_files must be >= 1")
-        self._written_paths: deque[str] = deque()
-        self._service = service
-        self._env = env_name
-        self._version = version
-        self._runtime_id = uuid4().hex
-        self._host = platform.node()
-        self._runtime = platform.python_implementation()
-        self._runtime_version = platform.python_version()
-        self._pid = os.getpid()
-        self._counter = count()
-
-    def export(
-        self,
-        payload: bytes,
-        *,
-        resource: Resource | None = None,
-        start_time_unix_nano: int | None = None,
-        end_time_unix_nano: int | None = None,
-    ) -> ProfileExportResult:
-        try:
-            filename = self._write_payload(payload)
-        except OSError as exc:
-            # Local copies are diagnostic output, not a prerequisite for
-            # upload. Read-only/full disks must not discard a valid profile.
-            _logger.warning("Cannot save local pprof payload: %s", exc)
-            filename = None
-        try:
-            request_headers = dict(self._headers)
-            content_type, body = self._build_request(
-                payload=payload,
-                resource=resource,
-                start_time_unix_nano=start_time_unix_nano,
-                end_time_unix_nano=end_time_unix_nano,
-            )
-            request_headers["Content-Type"] = content_type
-            response = self._session.post(
-                url=self._url,
-                data=body,
-                headers=request_headers,
-                timeout=self._timeout,
-            )
-        except Exception as exc:
-            _logger.error("pprof HTTP export failed: %s", exc)
-            return ProfileExportResult.FAILURE
-
-        if response.status_code not in (200, 202):
-            _logger.error(
-                "pprof HTTP export failed status %s: %s",
-                response.status_code,
-                response.text,
-            )
-            return ProfileExportResult.FAILURE
-
-        _logger.debug(
-            "pprof payload saved to %s and posted to %s",
-            filename,
-            self._url,
-        )
-        return ProfileExportResult.SUCCESS
-
-    def _build_request(
-        self,
-        *,
-        payload: bytes,
-        resource: Resource | None,
-        start_time_unix_nano: int | None,
-        end_time_unix_nano: int | None,
-    ) -> tuple[str, bytes]:
-        service = self._resolve_service(resource)
-        event = {
-            "version": "4",
-            "family": "python",
-            "attachments": ["auto.pprof"],
-            "tags_profiler": self._format_tags(service, resource),
-            "start": _format_timestamp(
-                start_time_unix_nano
-                or datetime.datetime.now(tz=datetime.timezone.utc).timestamp()
-                * 1_000_000_000
-            ),
-            "end": _format_timestamp(
-                end_time_unix_nano
-                or start_time_unix_nano
-                or datetime.datetime.now(tz=datetime.timezone.utc).timestamp()
-                * 1_000_000_000
-            ),
-        }
-        files = [
-            {
-                "name": "auto",
-                "filename": "auto.pprof",
-                "content_type": "application/octet-stream",
-                "data": payload,
-            }
-        ]
-        return _encode_multipart_formdata(event=event, files=files)
-
-    def _format_tags(self, service: str, resource: Resource | None) -> str:
-        tags = {
-            "service": service,
-            "runtime-id": self._runtime_id,
-            "host": self._host,
-            "language": "python",
-            "runtime": self._runtime,
-            "runtime_version": self._runtime_version,
-            "profiler_version": __version__,
-        }
-        env_name = self._resolve_env(resource)
-        if env_name:
-            tags["env"] = env_name
-        version = self._resolve_version(resource)
-        if version:
-            tags["version"] = version
-        return ",".join(f"{key}:{value}" for key, value in tags.items())
-
-    def _resolve_service(self, resource: Resource | None) -> str:
-        return (
-            _resource_attribute(resource, "service.name")
-            or self._service
-            or "unknown_service"
-        )
-
-    def _resolve_env(self, resource: Resource | None) -> str | None:
-        return (
-            _resource_attribute(
-                resource,
-                "deployment.environment.name",
-                "deployment.environment",
-            )
-            or self._env
-        )
-
-    def _resolve_version(self, resource: Resource | None) -> str | None:
-        return (
-            _resource_attribute(resource, "service.version") or self._version
-        )
-
-    def _write_payload(self, payload: bytes) -> str | None:
-        if not self._pprof_path:
-            return None
-        filename = (
-            f"{self._pprof_path}.{self._pid}.{next(self._counter)}.pprof"
-        )
-        os.makedirs(os.path.dirname(filename) or ".", exist_ok=True)
-        with open(filename, "wb") as handle:
-            handle.write(payload)
-        self._written_paths.append(filename)
-        while len(self._written_paths) > self._max_files:
-            previous = self._written_paths.popleft()
-            try:
-                os.remove(previous)
-            except OSError as exc:
-                _logger.warning("Cannot remove local pprof payload: %s", exc)
-        return filename
-
-    def force_flush(self, timeout_millis: int = 30000) -> bool:
-        del timeout_millis
-        return True
-
-    def shutdown(self) -> None:
-        self._session.close()
-
-
-def _resolve_headers(
-    headers: Optional[Dict[str, str]],
-) -> Dict[str, str]:
-    resolved = _parse_headers(environ.get(OTEL_PROFILING_PPROF_HEADERS, ""))
-    if headers is not None:
-        resolved.update(headers)
-    return resolved
-
-
-def _resolve_upload_url() -> str:
-    explicit = environ.get(OTEL_PROFILING_PPROF_UPLOAD_URL)
-    if explicit:
-        return explicit
-    return f"{_DEFAULT_AGENT_BASE_URL}/{_DEFAULT_AGENT_PATH}"
-
-
-def _parse_headers(value: str) -> Dict[str, str]:
-    headers = {}
-    for header in value.split(","):
-        if ":" not in header:
-            continue
-        key, header_value = header.split(":", 1)
-        key = key.strip()
-        header_value = header_value.strip()
-        if key:
-            headers[key] = header_value
-    return headers
-
-
-def _resource_attribute(resource: Resource | None, *keys: str) -> str | None:
-    if resource is None:
-        return None
-    for key in keys:
-        value = resource.attributes.get(key)
-        if isinstance(value, str) and value:
-            return value
-    return None
-
-
-def _format_timestamp(timestamp_unix_nano: float | int) -> str:
-    timestamp = datetime.datetime.fromtimestamp(
-        float(timestamp_unix_nano) / 1e9,
-        tz=datetime.timezone.utc,
-    )
-    return timestamp.replace(microsecond=0).isoformat()[0:-6] + "Z"
-
-
-def _encode_multipart_formdata(
-    *,
-    event: dict[str, str | list[str]],
-    files: list[dict[str, str | bytes]],
-) -> tuple[str, bytes]:
-    boundary = binascii.hexlify(os.urandom(16)).decode("ascii")
-    boundary_bytes = boundary.encode("ascii")
-    body = (
-        (b"--%s\r\n" % boundary_bytes)
-        + b'Content-Disposition: form-data; name="event"; filename="event.json"\r\n'
-        + b"Content-Type: application/json\r\n\r\n"
-        + _encode_json(event)
-        + b"\r\n"
-        + b"".join(
-            (b"--%s\r\n" % boundary_bytes)
-            + (
-                b'Content-Disposition: form-data; name="%s"; filename="%s"\r\n'
-                % (
-                    str(item["name"]).encode("utf-8"),
-                    str(item["filename"]).encode("utf-8"),
-                )
-            )
-            + (
-                b"Content-Type: %s\r\n\r\n"
-                % str(item["content_type"]).encode("utf-8")
-            )
-            + bytes(item["data"])
-            + b"\r\n"
-            for item in files
-        )
-        + b"--%s--\r\n" % boundary_bytes
-    )
-    return f"multipart/form-data; boundary={boundary}", body
-
-
-def _encode_json(payload: dict[str, str | list[str]]) -> bytes:
-    return json.dumps(payload).encode("utf-8")

beacon_profiling-1.2.3/tests/test_pprof_http_exporter.py

@@ -1,158 +0,0 @@
-from __future__ import annotations
-
-import errno
-from unittest.mock import Mock
-
-import pytest
-
-from opentelemetry.sdk.extension.profiling.export.pprof_http import (
-    PPROFHTTPExporter,
-)
-from opentelemetry.sdk.resources import Resource
-
-
-def test_pprof_http_exporter_posts_multipart_payload(monkeypatch, tmp_path):
-    session = Mock()
-    session.post.return_value = Mock(status_code=202, text="ok")
-    monkeypatch.setenv(
-        "OTEL_PROFILING_PPROF_HEADERS",
-        "X-API-Key:api-key",
-    )
-    monkeypatch.setenv(
-        "OTEL_PROFILING_PPROF_UPLOAD_URL",
-        "http://agent:8126/profiling/v1/input",
-    )
-    exporter = PPROFHTTPExporter(
-        session=session,
-        pprof_path=str(tmp_path / "prof"),
-    )
-    payload = b"foo"
-    resource = Resource.create(
-        {
-            "service.name": "svc",
-            "service.version": "1.2.3",
-            "deployment.environment.name": "prod",
-        }
-    )
-
-    result = exporter.export(
-        payload,
-        resource=resource,
-        start_time_unix_nano=1_700_000_000_000_000_000,
-        end_time_unix_nano=1_700_000_060_000_000_000,
-    )
-
-    assert result.name == "SUCCESS"
-    session.post.assert_called_once()
-    kwargs = session.post.call_args.kwargs
-    assert kwargs["url"] == "http://agent:8126/profiling/v1/input"
-    assert kwargs["headers"]["X-API-Key"] == "api-key"
-    assert kwargs["headers"]["Content-Type"].startswith(
-        "multipart/form-data; boundary="
-    )
-    body = kwargs["data"]
-    assert b'filename="event.json"' in body
-    assert b'filename="auto.pprof"' in body
-    assert b'"family": "python"' in body
-    assert b"service:svc" in body
-    assert b"env:prod" in body
-    assert b"version:1.2.3" in body
-    assert payload in body
-    files = list(tmp_path.glob("prof*.pprof"))
-    assert files
-
-
-def test_pprof_http_exporter_handles_failure(monkeypatch, tmp_path):
-    session = Mock()
-    session.post.side_effect = Exception("boom")
-    exporter = PPROFHTTPExporter(
-        session=session,
-        pprof_path=str(tmp_path / "prof"),
-    )
-
-    result = exporter.export(b"bar")
-
-    assert result.name == "FAILURE"
-    files = list(tmp_path.glob("prof*.pprof"))
-    assert files
-
-
-def test_http_upload_does_not_require_a_writable_directory(
-    monkeypatch, tmp_path
-) -> None:
-    monkeypatch.chdir(tmp_path)
-    monkeypatch.delenv("OTEL_PROFILING_PPROF_PATH", raising=False)
-    session = Mock()
-    session.post.return_value = Mock(status_code=202)
-    exporter = PPROFHTTPExporter(session=session)
-    assert exporter.export(b"payload").name == "SUCCESS"
-    assert list(tmp_path.iterdir()) == []
-    session.post.assert_called_once()
-
-
-@pytest.mark.parametrize("error_number", [errno.EACCES, errno.ENOSPC])
-def test_local_write_failure_still_uploads_and_recovers(
-    monkeypatch, tmp_path, error_number: int, caplog
-) -> None:
-    session = Mock()
-    session.post.return_value = Mock(status_code=202)
-    exporter = PPROFHTTPExporter(
-        session=session, pprof_path=str(tmp_path / "profile")
-    )
-    write = exporter._write_payload
-
-    def fail(payload: bytes) -> None:
-        raise OSError(error_number, "write unavailable")
-
-    monkeypatch.setattr(exporter, "_write_payload", fail)
-    assert exporter.export(b"first").name == "SUCCESS"
-    assert "Cannot save local pprof" in caplog.text
-    monkeypatch.setattr(exporter, "_write_payload", write)
-    assert exporter.export(b"second").name == "SUCCESS"
-    assert session.post.call_count == 2
-    assert next(tmp_path.glob("*.pprof")).read_bytes() == b"second"
-
-
-def test_http_local_copies_have_bounded_instance_retention(
-    monkeypatch, tmp_path
-) -> None:
-    session = Mock()
-    session.post.return_value = Mock(status_code=202)
-    monkeypatch.setenv("OTEL_PROFILING_PPROF_MAX_FILES", "2")
-    exporter = PPROFHTTPExporter(
-        session=session, pprof_path=str(tmp_path / "profile")
-    )
-    other = tmp_path / "profile.other-process.pprof"
-    other.write_bytes(b"keep")
-    for index in range(5):
-        assert exporter.export(str(index).encode()).name == "SUCCESS"
-    copies = [path for path in tmp_path.glob("*.pprof") if path != other]
-    assert {path.read_bytes() for path in copies} == {b"3", b"4"}
-    assert other.read_bytes() == b"keep"
-
-
-def test_explicit_empty_path_disables_environment_local_copies(
-    monkeypatch, tmp_path
-) -> None:
-    monkeypatch.setenv("OTEL_PROFILING_PPROF_PATH", str(tmp_path / "profile"))
-    session = Mock()
-    session.post.return_value = Mock(status_code=202)
-    exporter = PPROFHTTPExporter(session=session, pprof_path="")
-    assert exporter.export(b"payload").name == "SUCCESS"
-    assert list(tmp_path.iterdir()) == []
-
-
-def test_build_failure_returns_failure_and_next_export_recovers(
-    monkeypatch,
-) -> None:
-    session = Mock()
-    session.post.return_value = Mock(status_code=202)
-    exporter = PPROFHTTPExporter(session=session, pprof_path="")
-    build = exporter._build_request
-    monkeypatch.setattr(
-        exporter, "_build_request", Mock(side_effect=ValueError("bad build"))
-    )
-    assert exporter.export(b"first").name == "FAILURE"
-    session.post.assert_not_called()
-    monkeypatch.setattr(exporter, "_build_request", build)
-    assert exporter.export(b"second").name == "SUCCESS"