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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: beacon-profiling
-Version: 1.2.6
+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
@@ -77,7 +77,12 @@ Configuration
 The following environment variables are supported:
 
 * ``OTEL_PROFILING_ENABLED``
-* ``OTEL_PROFILING_EXPORTER`` (``otlp`` or ``file``; defaults to ``otlp``)
+* ``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)
@@ -137,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:
 
 ::
 
@@ -146,11 +151,11 @@ 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:
 
 ::
 
@@ -160,15 +165,13 @@ To dump pprof files instead of OTLP, set:
 The ``file`` exporter ignores all OTLP endpoint and transport settings.
 It writes gzip pprof files to the configured directory, without network uploads.
 
-For OTLP/gRPC, set::
+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.
 
-    export OTEL_PROFILING_EXPORTER=otlp
-    export OTEL_EXPORTER_OTLP_PROFILES_PROTOCOL=grpc
-    export OTEL_EXPORTER_OTLP_PROFILES_ENDPOINT=http://localhost:4317
-
-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.
+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.6 → beacon_profiling-1.2.7}/README.rst

@@ -50,7 +50,12 @@ Configuration
 The following environment variables are supported:
 
 * ``OTEL_PROFILING_ENABLED``
-* ``OTEL_PROFILING_EXPORTER`` (``otlp`` or ``file``; defaults to ``otlp``)
+* ``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)
@@ -110,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:
 
 ::
 
@@ -119,11 +124,11 @@ 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:
 
 ::
 
@@ -133,15 +138,13 @@ To dump pprof files instead of OTLP, set:
 The ``file`` exporter ignores all OTLP endpoint and transport settings.
 It writes gzip pprof files to the configured directory, without network uploads.
 
-For OTLP/gRPC, set::
+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.
 
-    export OTEL_PROFILING_EXPORTER=otlp
-    export OTEL_EXPORTER_OTLP_PROFILES_PROTOCOL=grpc
-    export OTEL_EXPORTER_OTLP_PROFILES_ENDPOINT=http://localhost:4317
-
-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.
+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.6 → beacon_profiling-1.2.7}/src/opentelemetry/sdk/extension/profiling/environment_variables.py

@@ -35,6 +35,11 @@ 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"
+OTEL_PROFILING_PPROF_HEADERS = "OTEL_PROFILING_PPROF_HEADERS"
 
 OTEL_EXPORTER_OTLP_PROFILES_PROTOCOL = "OTEL_EXPORTER_OTLP_PROFILES_PROTOCOL"
 OTEL_EXPORTER_OTLP_PROFILES_ENDPOINT = "OTEL_EXPORTER_OTLP_PROFILES_ENDPOINT"

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

@@ -12,8 +12,11 @@ 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__ = ("create_otlp_profile_exporter",)
+__all__ = ("CompatiblePPROFExporter", "create_otlp_profile_exporter")
 
 
 def create_otlp_profile_exporter():

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

@@ -0,0 +1,313 @@
+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_ENDPOINT,
+    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://127.0.0.1:9529"
+_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) or environ.get(
+        OTEL_PROFILING_ENDPOINT
+    )
+    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.6 → beacon_profiling-1.2.7}/src/opentelemetry/sdk/extension/profiling/runtime.py

@@ -65,7 +65,7 @@ from opentelemetry.sdk.extension.profiling.environment_variables import (
     OTEL_PROFILING_SAMPLE_INTERVAL,
 )
 from opentelemetry.sdk.extension.profiling.export import (
-    create_otlp_profile_exporter,
+    CompatiblePPROFExporter,
 )
 from opentelemetry.sdk.extension.profiling.export.file import (
     FileProfileExporter,
@@ -74,6 +74,7 @@ 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
@@ -432,6 +433,18 @@ class Profiler:
             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=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)
 
     def force_flush(self) -> None:
@@ -447,20 +460,22 @@ class Profiler:
         return Resource.create()
 
     def _create_builder(self):
+        if isinstance(self._exporter, CompatiblePPROFExporter):
+            return CompatiblePprofProfileBuilder()
         if isinstance(self._exporter, FileProfileExporter):
             return PprofProfileBuilder()
         return ProfilesRequestBuilder()
 
     @staticmethod
     def _create_exporter_from_env():
-        exporter_name = environ.get(OTEL_PROFILING_EXPORTER, "otlp").strip()
+        exporter_name = environ.get(OTEL_PROFILING_EXPORTER, "http").strip()
         if exporter_name == "file":
             return FileProfileExporter()
-        if exporter_name != "otlp":
+        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 = []

{beacon_profiling-1.2.6 → 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.6"
+__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.7/tests/test_pprof_http_exporter.py

@@ -0,0 +1,158 @@
+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"

{beacon_profiling-1.2.6 → beacon_profiling-1.2.7}/tests/test_runtime_exporter_selection.py

@@ -5,23 +5,33 @@ 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
 
 
-def test_runtime_defaults_to_otlp(monkeypatch):
-    sentinel = object()
-    monkeypatch.delenv("OTEL_PROFILING_EXPORTER", raising=False)
+@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_PPROF_UPLOAD_URL", "invalid old endpoint"
+        "OTEL_PROFILING_ENDPOINT", "http://127.0.0.1:9529/profiling/v1/input"
     )
-    monkeypatch.setattr(
-        "opentelemetry.sdk.extension.profiling.runtime.create_otlp_profile_exporter",
-        lambda: sentinel,
+    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
     )
-    assert Profiler._create_exporter_from_env() is sentinel
+    exporter.shutdown()
 
 
 def test_file_ignores_all_endpoint_settings(monkeypatch, tmp_path):
@@ -38,8 +48,8 @@ def test_file_ignores_all_endpoint_settings(monkeypatch, tmp_path):
     assert next(tmp_path.glob("*.pprof")).read_bytes() == b"profile"
 
 
-@pytest.mark.parametrize("name", ["datakit", "pprof", "pprof_http", "none"])
-def test_removed_exporter_names_rejected(monkeypatch, name):
+@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()