Filter PIDs to profile

gprofiler/main.py

@@ -15,7 +15,7 @@
 from pathlib import Path
 from threading import Event
 from types import FrameType, TracebackType
-from typing import Iterable, Optional, Type, cast
+from typing import Iterable, List, Optional, Type, cast
 
 import configargparse
 import humanfriendly
@@ -117,6 +117,7 @@ def __init__(
         duration: int,
         profile_api_version: str,
         profiling_mode: str,
+        pids_to_profile: List[int],
         profile_spawned_processes: bool = True,
         remote_logs_handler: Optional[RemoteLogsHandler] = None,
         controller_process: Optional[Process] = None,
@@ -153,6 +154,7 @@ def __init__(
             profile_spawned_processes,
             bool(user_args.get("insert_dso_name")),
             profiling_mode,
+            pids_to_profile,
             container_names_client,
         )
         self.system_profiler, self.process_profilers = get_profilers(user_args, profiler_state=self._profiler_state)
@@ -521,6 +523,14 @@ def parse_cmd_args() -> configargparse.Namespace:
     parser.add_argument(
         "--rotating-output", action="store_true", default=False, help="Keep only the last profile result"
     )
+    parser.add_argument(
+        "--pids",
+        dest="pids_to_profile",
+        action="append",
+        default=list(),
+        type=str,
+        help="Coma separated list of processes that will be filtered to profile",
+    )
 
     _add_profilers_arguments(parser)
 
@@ -791,6 +801,26 @@ def parse_cmd_args() -> configargparse.Namespace:
     if args.nodejs_mode in ("perf", "attach-maps") and args.perf_mode not in ("fp", "smart"):
         parser.error("--nodejs-mode perf or attach-maps requires --perf-mode 'fp' or 'smart'")
 
+    if args.profile_spawned_processes and len(args.pids_to_profile) > 0:
+        parser.error("--pids is not allowed when profiling spawned processes")
+
+    pids_to_profile = []
+    try:
+        if len(args.pids_to_profile) > 0:
+            for input in args.pids_to_profile:
+                pids = [int(pid) for pid in input.split(",")]
+                for pid in pids:
+                    try:
+                        Process(pid)
+                        pids_to_profile.append(pid)
+                    except NoSuchProcess:
+                        continue
+            if len(pids_to_profile) == 0:
+                parser.error("There aren't any alive processes from provided PID list")
+    except ValueError:
+        parser.error("--pids should be integer or coma separated list of integers f.e. --pids 13,452,2388")
+    setattr(args, "pids_to_profile", pids_to_profile)
+
     return args
 
 
@@ -1048,6 +1078,7 @@ def main() -> None:
             args.duration,
             args.profile_api_version,
             args.profiling_mode,
+            args.pids_to_profile,
             args.profile_spawned_processes,
             remote_logs_handler,
             controller_process,

gprofiler/profiler_state.py

@@ -1,5 +1,5 @@
 from threading import Event
-from typing import Optional
+from typing import List, Optional
 
 from gprofiler.containers_client import ContainerNamesClient
 from gprofiler.utils import TemporaryDirectoryWithMode
@@ -15,6 +15,7 @@ def __init__(
         profile_spawned_processes: bool,
         insert_dso_name: bool,
         profiling_mode: str,
+        pids_to_profile: List[int],
         container_names_client: Optional[ContainerNamesClient],
     ) -> None:
         self._stop_event = stop_event
@@ -24,6 +25,7 @@ def __init__(
         self._temporary_dir = TemporaryDirectoryWithMode(dir=storage_dir, mode=0o755)
         self._storage_dir = self._temporary_dir.name
         self._container_names_client = container_names_client
+        self._pids_to_profile = pids_to_profile
 
     @property
     def stop_event(self) -> Event:
@@ -49,6 +51,13 @@ def profiling_mode(self) -> str:
     def container_names_client(self) -> Optional[ContainerNamesClient]:
         return self._container_names_client
 
+    @property
+    def pids_to_profile(self) -> Optional[List[int]]:
+        if len(self._pids_to_profile) > 0:
+            return self._pids_to_profile
+        else:
+            return None
+
     def get_container_name(self, pid: int) -> str:
         if self._container_names_client is not None:
             return self._container_names_client.get_container_name(pid)

gprofiler/profilers/perf.py

@@ -160,7 +160,10 @@ def merge_global_perfs(
 
     total_fp_samples = sum([sum(stacks.values()) for stacks in fp_perf.values()])
     total_dwarf_samples = sum([sum(stacks.values()) for stacks in dwarf_perf.values()])
-    fp_to_dwarf_sample_ratio = total_fp_samples / total_dwarf_samples
+    if total_dwarf_samples == 0:
+        fp_to_dwarf_sample_ratio = 0.0  # ratio can be 0 because if total_dwarf_samples is 0 then it will be never used
+    else:
+        fp_to_dwarf_sample_ratio = total_fp_samples / total_dwarf_samples
 
     # The FP perf is used here as the "main" perf, to which the DWARF perf is scaled.
     merged_pid_to_stacks_counters: ProcessToStackSampleCounters = defaultdict(Counter)
@@ -389,6 +392,10 @@ def __init__(
         self._node_processes: List[Process] = []
         self._node_processes_attached: List[Process] = []
         self._perf_memory_restart = perf_memory_restart
+        extra_args: List[str] = []
+        if self._profiler_state.pids_to_profile is not None:
+            extra_args.append("--pid")
+            extra_args.append(",".join([str(pid) for pid in self._profiler_state.pids_to_profile]))
 
         if perf_mode in ("fp", "smart"):
             self._perf_fp: Optional[PerfProcess] = PerfProcess(
@@ -397,20 +404,21 @@ def __init__(
                 os.path.join(self._profiler_state.storage_dir, "perf.fp"),
                 False,
                 perf_inject,
-                [],
+                extra_args,
             )
             self._perfs.append(self._perf_fp)
         else:
             self._perf_fp = None
 
         if perf_mode in ("dwarf", "smart"):
+            extra_args.extend(["--call-graph", f"dwarf,{perf_dwarf_stack_size}"])
             self._perf_dwarf: Optional[PerfProcess] = PerfProcess(
                 self._frequency,
                 self._profiler_state.stop_event,
                 os.path.join(self._profiler_state.storage_dir, "perf.dwarf"),
                 True,
                 False,  # no inject in dwarf mode, yet
-                ["--call-graph", f"dwarf,{perf_dwarf_stack_size}"],
+                extra_args,
             )
             self._perfs.append(self._perf_dwarf)
         else:

gprofiler/profilers/php.py

@@ -194,6 +194,11 @@ def extract_metadata_section(re_expr: Pattern, metadata_line: str) -> str:
 
         profiles: ProcessToProfileData = {}
         for pid in results:
+            # Because of https://github.com/Granulate/gprofiler/issues/763,
+            # for now we only filter output of phpspy to return only profiles from chosen pids
+            if profiler_state.pids_to_profile is not None:
+                if pid not in profiler_state.pids_to_profile:
+                    continue
             # TODO: appid & app metadata for php!
             appid = None
             app_metadata = None

gprofiler/profilers/profiler_base.py

@@ -171,6 +171,11 @@ def _profiling_error_stack(
     def snapshot(self) -> ProcessToProfileData:
         processes_to_profile = self._select_processes_to_profile()
         logger.debug(f"{self.__class__.__name__}: selected {len(processes_to_profile)} processes to profile")
+        if self._profiler_state.pids_to_profile is not None:
+            processes_to_profile = [
+                process for process in processes_to_profile if process.pid in self._profiler_state.pids_to_profile
+            ]
+            logger.debug(f"Processes left after filtering: {len(processes_to_profile)}")
         self._notify_selected_processes(processes_to_profile)
 
         if not processes_to_profile:

gprofiler/profilers/python_ebpf.py

@@ -238,6 +238,11 @@ def snapshot(self) -> ProcessToProfileData:
             parsed = python._add_versions_to_stacks(parsed)
         profiles = {}
         for pid in parsed:
+            # Because of https://github.com/Granulate/gprofiler/issues/764,
+            # for now we only filter output of pyperf to return only profiles from chosen pids
+            if self._profiler_state.pids_to_profile is not None:
+                if pid not in self._profiler_state.pids_to_profile:
+                    continue
             try:
                 process = Process(pid)
                 appid = application_identifiers.get_python_app_id(process)

tests/conftest.py

@@ -90,7 +90,9 @@ def java_args() -> Tuple[str]:
 
 @fixture()
 def profiler_state(tmp_path: Path, insert_dso_name: bool) -> ProfilerState:
-    return ProfilerState(Event(), str(tmp_path), False, insert_dso_name, CPU_PROFILING_MODE, ContainerNamesClient())
+    return ProfilerState(
+        Event(), str(tmp_path), False, insert_dso_name, CPU_PROFILING_MODE, list(), ContainerNamesClient()
+    )
 
 
 def make_path_world_accessible(path: Path) -> None:

tests/test_sanity.py

@@ -281,3 +281,35 @@ def test_container_name_when_stopped(
     collapsed_text = wait_for_gprofiler_container(container, output_collapsed)
     assert "py-spy> Stopped sampling because process exited" in container.logs().decode()
     assert f";{application_container_name};python" in collapsed_text
+
+
+@pytest.mark.parametrize("in_container", [False])
+@pytest.mark.parametrize("runtime", ["java"])
+@pytest.mark.parametrize("profiler_type", ["ap"])
+def test_profiling_provided_pids(
+    docker_client: DockerClient,
+    gprofiler_docker_image: Image,
+    output_directory: Path,
+    output_collapsed: Path,
+    runtime_specific_args: List[str],
+    profiler_flags: List[str],
+    application_factory: Callable[[], _GeneratorContextManager],
+    profiler_type: str,
+) -> None:
+    """
+    Tests that gprofiler will profile only processes provided via flag --pids
+    """
+    with application_factory() as pid1:
+        with application_factory() as pid2:
+            profiler_flags.extend(["--pids", str(pid1)])
+            container = start_gprofiler_in_container_for_one_session(
+                docker_client,
+                gprofiler_docker_image,
+                output_directory,
+                output_collapsed,
+                runtime_specific_args,
+                profiler_flags,
+            )
+            wait_for_gprofiler_container(container, output_collapsed)
+            assert f"Profiling process {pid1} with async-profiler" in container.logs().decode()
+            assert f"Profiling process {pid2} with async-profiler" not in container.logs().decode()