gProfiler 1.2.7 (#216)

And other small fixes.

Author: Jongy

.github/workflows/release.yml

@@ -85,6 +85,7 @@ jobs:
         mkdir -p output
         ./scripts/build_x86_64_executable.sh
         mv build/x86_64/gprofiler output/gprofiler_x86_64
+        cp output/gprofiler_x86_64 output/gprofiler  # for backwards compatibility
 
      - name: Upload the executables as job artifacts
        uses: actions/upload-artifact@v2

gprofiler/__init__.py

@@ -2,4 +2,4 @@
 # Copyright (c) Granulate. All rights reserved.
 # Licensed under the AGPL3 License. See LICENSE.md in the project root for license information.
 #
-__version__ = "1.2.6"
+__version__ = "1.2.7"

gprofiler/profilers/java.py

@@ -377,7 +377,7 @@ def __init__(self, version: Version, build: int, name: str):
         self.name = name
 
     def __repr__(self):
-        return f"JvmVersion({self.version}, {self.build}, {self.name})"
+        return f"JvmVersion({self.version}, {self.build!r}, {self.name!r})"
 
 
 # Parse java version information from "java -version" output
@@ -514,12 +514,14 @@ def __init__(
         self._interval = int((1 / frequency) * 1000_000_000)
         self._buildids = java_async_profiler_buildids
         self._version_check = java_version_check
-        if not java_version_check:
+        if not self._version_check:
             logger.warning("Java version checks are disabled")
         self._mode = java_async_profiler_mode
         self._safemode = java_async_profiler_safemode
         self._saved_mlock: Optional[int] = None
         self._java_safemode = java_safemode
+        if self._java_safemode:
+            logger.debug("Java safemode enabled")
 
     def _is_jvm_type_supported(self, java_version_cmd_output: str) -> bool:
         return all(exclusion not in java_version_cmd_output for exclusion in self.JDK_EXCLUSIONS)
@@ -587,37 +589,49 @@ def _run_java_version() -> None:
         # Version is printed to stderr
         return java_version_cmd_output.stderr.decode()
 
-    def _profile_process(self, process: Process) -> Optional[StackToSampleCount]:
-        logger.info(f"Profiling process {process.pid} with async-profiler")
+    def _check_jvm_type_supported(self, process: Process, java_version_output: str) -> bool:
+        if not self._is_jvm_type_supported(java_version_output):
+            logger.error(f"Process {process.pid} running unsupported JVM ({java_version_output!r}), skipping...")
+            return False
+
+        return True
+
+    def _is_profiling_supported(self, process: Process) -> bool:
         process_basename = os.path.basename(process.exe())
         if self._java_safemode:
             # TODO we can get the "java" binary by extracting the java home from the libjvm path,
             # then check with that instead (if exe isn't java)
             if process_basename != "java":
                 logger.error(
-                    f"Non-java basenamed process {process.pid} ({process.exe()}), skipping..."
+                    f"Non-java basenamed process {process.pid} ({process.exe()!r}), skipping..."
                     " (disable --java-safemode to profile it anyway)"
                 )
-                return None
+                return False
 
             java_version_output = self._get_java_version(process)
 
-            if not self._is_jvm_type_supported(java_version_output):
-                logger.error(f"Process {process.pid} running unsupported JVM, skipping...")
-                return None
+            if not self._check_jvm_type_supported(process, java_version_output):
+                return False
 
             if not self._is_jvm_version_supported(java_version_output):
                 logger.error(
-                    f"Process {process.pid} running unsupported Java version, skipping..."
+                    f"Process {process.pid} running unsupported Java version ({java_version_output!r}), skipping..."
                     " (disable --java-safemode to profile it anyway)"
                 )
-                return None
+                return False
         else:
             if self._version_check and process_basename == "java":
-                if not self._is_jvm_type_supported(self._get_java_version(process)):
-                    logger.error(f"Process {process.pid} running unsupported JVM, skipping...")
-                    return None
+                java_version_output = self._get_java_version(process)
+                if not self._check_jvm_type_supported(process, java_version_output):
+                    return False
+
+        return True
 
+    def _profile_process(self, process: Process) -> Optional[StackToSampleCount]:
+        if not self._is_profiling_supported(process):
+            return None
+
+        logger.info(f"Profiling process {process.pid} with async-profiler")
         with AsyncProfiledProcess(process, self._storage_dir, self._buildids, self._mode, self._safemode) as ap_proc:
             return self._profile_ap_process(ap_proc)