pmdtester 1.6.2 → 1.7.0

data/lib/pmdtester/builders/pmd_report_builder.rb

@@ -20,9 +20,17 @@ module PmdTester
 
       @pmd_branch_details = PmdBranchDetail.new(@pmd_branch_name)
       @project_builder = ProjectBuilder.new(@projects)
+      @run_pmd = options.run_pmd
+      @run_cpd = options.run_cpd
     end
 
-    def get_pmd_binary_file
+    def with_changes(rules_changed, impl_changed)
+      @run_pmd &&= rules_changed
+      @run_cpd &&= impl_changed
+      self
+    end
+
+    def create_pmd_package
       logger.info "#{@pmd_branch_name}: Start packaging PMD"
       Dir.chdir(@local_git_repo) do
         checkout_build_branch # needs a clean working tree, otherwise fails
@@ -32,7 +40,7 @@ module PmdTester
         # for local branches.
         build_branch_sha = Cmd.execute_successfully("git rev-parse #{@pmd_branch_name}^{commit}")
 
-        raise "Wrong branch #{get_last_commit_sha}" unless build_branch_sha == get_last_commit_sha
+        raise "Wrong branch #{determine_last_commit_sha}" unless build_branch_sha == determine_last_commit_sha
 
         distro_path = saved_distro_path(build_branch_sha)
         logger.debug "#{@pmd_branch_name}: PMD Version is #{@pmd_version} " \
@@ -47,7 +55,7 @@ module PmdTester
 
         # we're still on the build branch
         @pmd_branch_details.branch_last_sha = build_branch_sha
-        @pmd_branch_details.branch_last_message = get_last_commit_message
+        @pmd_branch_details.branch_last_message = determine_last_commit_message
       end
       logger.info "#{@pmd_branch_name}: Packaging PMD completed"
     end
@@ -82,38 +90,31 @@ module PmdTester
       Cmd.execute_successfully(version_cmd)
     end
 
-    def get_last_commit_sha
-      get_last_commit_sha_cmd = 'git rev-parse HEAD^{commit}'
-      Cmd.execute_successfully(get_last_commit_sha_cmd)
+    def determine_last_commit_sha
+      last_commit_sha_cmd = 'git rev-parse HEAD^{commit}'
+      Cmd.execute_successfully(last_commit_sha_cmd)
     end
 
-    def get_last_commit_message
-      get_last_commit_message_cmd = 'git log -1 --pretty=%B'
-      Cmd.execute_successfully(get_last_commit_message_cmd)
+    def determine_last_commit_message
+      last_commit_message_cmd = 'git log -1 --pretty=%B'
+      Cmd.execute_successfully(last_commit_message_cmd)
     end
 
     def generate_pmd_report(project)
-      error_recovery_options = @error_recovery ? 'PMD_JAVA_OPTS="-Dpmd.error_recovery -ea" ' : ''
-      fail_on_violation = create_failonviolation_option
-      auxclasspath_option = create_auxclasspath_option(project)
-      pmd_cmd = "#{error_recovery_options}" \
-                "#{determine_run_path} -d #{project.local_source_path} -f xml " \
-                "-R #{project.get_config_path(@pmd_branch_name)} " \
-                "-r #{project.get_pmd_report_path(@pmd_branch_name)} " \
-                "#{fail_on_violation} -t #{@threads} " \
-                "#{auxclasspath_option}" \
-                "#{' --no-progress' if pmd7?}"
       start_time = Time.now
       exit_code = nil
+      stdout = ''
+      stderr = ''
       if File.exist?(project.get_pmd_report_path(@pmd_branch_name))
         logger.warn "#{@pmd_branch_name}: Skipping PMD run - report " \
                     "#{project.get_pmd_report_path(@pmd_branch_name)} already exists"
       else
-        status = Cmd.execute(pmd_cmd, project.get_project_target_dir(@pmd_branch_name))
+        pmd_cmd = create_pmd_command(project)
+        status, stdout, stderr = Cmd.execute(pmd_cmd)
         exit_code = status.exitstatus
       end
       end_time = Time.now
-      [end_time - start_time, end_time, exit_code]
+      [pmd_cmd, end_time - start_time, end_time, exit_code, stdout, stderr]
     end
 
     def generate_config_for(project)
@@ -140,34 +141,130 @@ module PmdTester
         progress_logger = SimpleProgressLogger.new("generating #{project.name}'s PMD report")
         progress_logger.start
         generate_config_for(project)
-        execution_time, end_time, exit_code = generate_pmd_report(project)
+        cmd_line, execution_time, end_time, exit_code, stdout, stderr = generate_pmd_report(project)
         progress_logger.stop
         sum_time += execution_time
 
+        jfr_summary = JfrSummary.new.load("#{project.get_project_target_dir(@pmd_branch_name)}/pmd_recording.jfr")
         PmdReportDetail.create(execution_time: execution_time, timestamp: end_time,
-                               exit_code: exit_code, report_info_path: project.get_report_info_path(@pmd_branch_name))
+                               cmdline: cmd_line, exit_code: exit_code, stdout: stdout, stderr: stderr,
+                               oom: stderr.include?('java.lang.OutOfMemoryError'),
+                               report_info_path: project.get_report_info_path(@pmd_branch_name),
+                               jfr_summary: jfr_summary)
         logger.info "#{project.name}'s PMD report was generated successfully (exit code: #{exit_code})"
       end
 
-      @pmd_branch_details.execution_time = sum_time
-      @pmd_branch_details.save
+      @pmd_branch_details.execution_time += sum_time
       FileUtils.cp(@branch_config, @pmd_branch_details.target_branch_config_path)
-      @pmd_branch_details
+    end
+
+    def generate_cpd_reports
+      logger.info "Generating CPD report started -- branch #{@pmd_branch_name}"
+
+      sum_time = 0
+      @projects.each do |project|
+        progress_logger = SimpleProgressLogger.new("generating #{project.name}'s CPD report")
+        progress_logger.start
+        cpd_cmd, execution_time, end_time, exit_code, stdout, stderr = generate_cpd_report(project)
+        progress_logger.stop
+        sum_time += execution_time
+
+        jfr_summary = JfrSummary.new.load("#{project.get_project_target_dir(@pmd_branch_name)}/cpd_recording.jfr")
+        PmdReportDetail.create(execution_time: execution_time, timestamp: end_time,
+                               cmdline: cpd_cmd, exit_code: exit_code, stdout: stdout, stderr: stderr,
+                               oom: stderr.include?('java.lang.OutOfMemoryError'),
+                               report_info_path: project.get_cpd_report_info_path(@pmd_branch_name),
+                               jfr_summary: jfr_summary)
+        logger.info "#{project.name}'s CPD report was generated successfully (exit code: #{exit_code})"
+      end
+
+      @pmd_branch_details.execution_time += sum_time
+    end
+
+    def generate_cpd_report(project)
+      start_time = Time.now
+      exit_code = nil
+      if File.exist?(project.get_cpd_report_path(@pmd_branch_name))
+        logger.warn "#{@pmd_branch_name}: Skipping CPD run - report " \
+                    "#{project.get_cpd_report_path(@pmd_branch_name)} already exists"
+      else
+        cpd_cmd = create_cpd_command(project)
+        status, stdout, stderr = Cmd.execute(cpd_cmd, debug_log_stdout: false)
+        exit_code = status.exitstatus
+      end
+      stdout = filter_cpd_report_from_stdout(project, exit_code, stdout)
+      end_time = Time.now
+      [cpd_cmd, end_time - start_time, end_time, exit_code, stdout, stderr]
     end
 
     # returns the branch details
     def build
       @project_builder.clone_projects
       @project_builder.build_projects
-      get_pmd_binary_file
-      generate_pmd_reports
+      create_pmd_package
+      @pmd_branch_details.execution_time = 0
+      generate_pmd_reports if @run_pmd
+      generate_cpd_reports if @run_cpd
+      @pmd_branch_details.save
+      @pmd_branch_details
     end
 
     private
 
+    def create_pmd_command(project)
+      error_recovery_options = @error_recovery ? ' -Dpmd.error_recovery -ea' : ''
+      java_opts = 'PMD_JAVA_OPTS="-XX:StartFlightRecording:' \
+                  "filename=#{project.get_project_target_dir(@pmd_branch_name)}/pmd_recording.jfr," \
+                  "settings=#{ResourceLocator.locate('config/custom.jfc')},dumponexit=true" \
+                  "#{error_recovery_options}\" "
+      fail_on_violation = create_failonviolation_option
+      auxclasspath_option = create_auxclasspath_option(project)
+      "#{java_opts}" \
+        "#{determine_run_path} -d #{project.local_source_path} -f xml " \
+        "-R #{project.get_config_path(@pmd_branch_name)} " \
+        "-r #{project.get_pmd_report_path(@pmd_branch_name)} " \
+        "#{fail_on_violation} -t #{@threads} " \
+        "#{auxclasspath_option}" \
+        "#{' --no-progress' if pmd7?}"
+    end
+
+    def create_cpd_command(project)
+      error_recovery_options = @error_recovery ? ' -Dpmd.error_recovery -ea' : ''
+      java_opts = "PMD_JAVA_OPTS=\"-Xmx#{project.cpd_options.max_memory} -XX:StartFlightRecording:" \
+                  "filename=#{project.get_project_target_dir(@pmd_branch_name)}/cpd_recording.jfr," \
+                  "settings=#{ResourceLocator.locate('config/custom.jfc')},dumponexit=true" \
+                  "#{error_recovery_options}\" "
+      "#{java_opts}" \
+        "#{determine_run_path(command: 'cpd')} #{get_directories_option(project)} -f xml " \
+        "--language #{project.cpd_options.language} --minimum-tokens #{project.cpd_options.minimum_tokens} " \
+        '--skip-lexical-errors'
+    end
+
+    # NOTE: --report-file is only supported in PMD 7.14.0+. To support 7.0.0, we use stdout.
+    def filter_cpd_report_from_stdout(project, exit_code, stdout)
+      if [0, 4, 5].include?(exit_code)
+        # when running with JFR, there are logs from JFR at the beginning
+        # we want to remove those logs from the stdout, because they would break the XML parsing
+        xml_start = stdout.index('<?xml')
+        return stdout if xml_start.nil?
+
+        stdout_filtered = stdout[0, xml_start]
+        cpd_report = stdout[xml_start, stdout.length - xml_start]
+        File.write(project.get_cpd_report_path(@pmd_branch_name), cpd_report)
+        return stdout_filtered
+      end
+      stdout
+    end
+
+    def get_directories_option(project)
+      project.cpd_options.directories.map do |dir|
+        "-d #{Pathname.new("#{project.clone_root_path}/#{dir}").cleanpath}"
+      end.join(' ')
+    end
+
     def checkout_build_branch
       logger.info "#{@pmd_branch_name}: Checking out the branch"
-      # note that this would fail if the tree is dirty
+      # the checkout will fail if the tree is dirty
       Cmd.execute_successfully("git checkout #{@pmd_branch_name}")
 
       # determine the version
@@ -225,15 +322,14 @@ module PmdTester
       Semver.compare(@pmd_version, '7.0.0-SNAPSHOT') >= 0
     end
 
-    def determine_run_path
+    def determine_run_path(command: 'check')
       run_path = "#{saved_distro_path(@pmd_branch_details.branch_last_sha)}/bin"
-      run_path = if File.exist?("#{run_path}/pmd")
-                   # New PMD 7 CLI script (pmd/pmd#4059)
-                   "#{run_path}/pmd check"
-                 else
-                   "#{run_path}/run.sh pmd"
-                 end
-      run_path
+      if File.exist?("#{run_path}/pmd")
+        # New PMD 7 CLI script (pmd/pmd#4059)
+        "#{run_path}/pmd #{command}"
+      else
+        "#{run_path}/run.sh pmd"
+      end
     end
 
     def find_pmd_dist_target

data/lib/pmdtester/builders/project_hasher.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'differ'
-
 module PmdTester
   # Turn a project report into a hash that can be rendered somewhere else
   module ProjectHasher
@@ -13,34 +11,37 @@ module PmdTester
         'error_counts' => rdiff.error_counts.to_h.transform_keys(&:to_s),
         'configerror_counts' => rdiff.configerror_counts.to_h.transform_keys(&:to_s),
 
-        'base_execution_time' => PmdReportDetail.convert_seconds(rdiff.base_report.exec_time),
-        'patch_execution_time' => PmdReportDetail.convert_seconds(rdiff.patch_report.exec_time),
-        'diff_execution_time' => PmdReportDetail.convert_seconds(rdiff.patch_report.exec_time -
-                                                                   rdiff.base_report.exec_time),
-
-        'base_timestamp' => rdiff.base_report.timestamp,
-        'patch_timestamp' => rdiff.patch_report.timestamp,
+        'base_details' => rdiff.base_report.report_details.to_h,
+        'patch_details' => rdiff.patch_report.report_details.to_h,
 
-        'base_exit_code' => rdiff.base_report.exit_code,
-        'patch_exit_code' => rdiff.patch_report.exit_code,
+        'diff_execution_time' => PmdReportDetail.convert_seconds(rdiff.patch_report.report_details.execution_time -
+                                                                   rdiff.base_report.report_details.execution_time),
 
         'rule_diffs' => rdiff.rule_summaries
       }
     end
 
     def violations_to_hash(project, violations_by_file, is_diff)
+      rulename_index = {}
+      violations_by_file.each_value do |vs|
+        vs.each do |v|
+          rulename_index[v.rule_name] = rulename_index.size unless rulename_index.include?(v.rule_name)
+        end
+      end
       filename_index = []
       all_vs = []
       violations_by_file.each do |file, vs|
         file_ref = filename_index.size
         filename_index.push(project.get_local_path(file))
         vs.each do |v|
-          all_vs.push(make_violation_hash(file_ref, v, is_diff: is_diff))
+          rule_ref = rulename_index[v.rule_name]
+          all_vs.push(make_violation_datable(file_ref, rule_ref, v, is_diff: is_diff))
         end
       end
 
       {
         'file_index' => filename_index,
+        'rule_index' => rulename_index.keys,
         'violations' => all_vs
       }
     end
@@ -111,24 +112,22 @@ module PmdTester
       end
     end
 
-    def make_violation_hash(file_ref, violation, is_diff: true)
-      h = {
-        't' => is_diff ? violation_type(violation) : '+',
-        'l' => violation.line,
-        'f' => file_ref,
-        'r' => violation.rule_name,
-        'm' => create_violation_message(violation, is_diff && violation.changed?)
-      }
-      h['ol'] = violation.old_line if is_diff && violation.changed? && violation.line != violation.old_line
-      h
+    def make_violation_datable(file_ref, rule_ref, violation, is_diff: true)
+      type = is_diff ? violation_type(violation) : '+'
+      old_location = []
+      if is_diff && violation.changed? && !violation.location.eql?(violation.old_location)
+        old_location = [violation.old_location.to_s]
+      end
+
+      [violation.line, violation.location.to_s, type, file_ref, rule_ref,
+       create_violation_message(violation, is_diff && violation.changed?)] + old_location
     end
 
     def create_violation_message(violation, is_diff)
       return escape_html(violation.message) unless is_diff
 
-      diff = Differ.diff_by_word(escape_html(violation.message),
-                                 escape_html(violation.old_message))
-      diff.format_as(:html)
+      WordDiffer.diff_words(escape_html(violation.old_message),
+                            escape_html(violation.message))
     end
 
     def escape_html(string)

data/lib/pmdtester/builders/rule_set_builder.rb

@@ -23,6 +23,7 @@ module PmdTester
     # Returns false, when no rules are affected and regression tester can be skipped.
     #
     def build?
+      logger.info 'Autogenerating a dynamic ruleset based on source changes'
       languages = determine_languages
       filenames = diff_filenames(languages)
       all_rules_hash = determine_all_rules
@@ -34,6 +35,7 @@ module PmdTester
       else
         logger.info NO_RULES_CHANGED_MESSAGE
       end
+      logger.debug "Rules have changed: #{run_required}"
       run_required
     end
 

data/lib/pmdtester/builders/summary_report_builder.rb

@@ -6,6 +6,7 @@ module PmdTester
     include PmdTester
     include LiquidRenderer
     include ProjectHasher
+    include CpdProjectHasher
 
     REPORT_DIR = 'target/reports/diff'
     BASE_CONFIG_NAME = 'base_config.xml'
@@ -52,7 +53,8 @@ module PmdTester
           'name' => p.name,
           'tag' => p.tag,
           'report_url' => "./#{p.name}/index.html",
-          **report_diff_to_h(p.report_diff)
+          'pmd_report' => report_diff_to_h(p.report_diff),
+          'cpd_report' => cpd_report_diff_to_h(p.cpd_report_diff)
         }
       end
 
@@ -83,6 +85,9 @@ module PmdTester
         'timestamp' => details.timestamp,
         'execution_time' => PmdReportDetail.convert_seconds(details.execution_time),
         'jdk_info' => details.jdk_version,
+        'cpu_info' => details.cpu_info,
+        'physical_memory' => details.physical_memory,
+        'os_info' => details.os_info,
         'locale' => details.language,
         'config_url' => config_name,
         'pr_number' => details.pull_request

data/lib/pmdtester/cmd.rb

@@ -7,13 +7,22 @@ module PmdTester
   class Cmd
     extend PmdTester
 
+    #
+    # Executes the given command and returns the process status,
+    # stdout and stderr.
+    #
+    def self.execute(cmd, debug_log_stdout: true)
+      stdout, stderr, status = internal_execute(cmd, nil, debug_log_stdout)
+      [status, stdout, stderr]
+    end
+
     #
     # Executes the given command and returns the process status.
     # stdout and stderr are written to the files "stdout.txt" and "stderr.txt"
     # in path.
     #
-    def self.execute(cmd, path)
-      stdout, stderr, status = internal_execute(cmd, nil)
+    def self.execute_save_output(cmd, path)
+      stdout, stderr, status = internal_execute(cmd, nil, true)
 
       file = File.new("#{path}/stdout.txt", 'w')
       file.puts stdout
@@ -26,8 +35,8 @@ module PmdTester
       status
     end
 
-    def self.execute_successfully(cmd, extra_java_home = nil)
-      stdout, stderr, status = internal_execute(cmd, extra_java_home)
+    def self.execute_successfully(cmd, extra_java_home = nil, debug_log_stdout: true)
+      stdout, stderr, status = internal_execute(cmd, extra_java_home, debug_log_stdout)
 
       unless status.success?
         logger.error "Command failed: #{cmd}"
@@ -40,11 +49,11 @@ module PmdTester
     end
 
     def self.stderr_of(cmd)
-      _stdout, stderr, _status = internal_execute(cmd, nil)
+      _stdout, stderr, _status = internal_execute(cmd, nil, true)
       stderr
     end
 
-    def self.internal_execute(cmd, extra_java_home)
+    def self.internal_execute(cmd, extra_java_home, debug_log_stdout)
       logger.debug "execute command '#{cmd}' (extra_java_home: #{extra_java_home})"
 
       new_env = ENV.to_h
@@ -56,7 +65,7 @@ module PmdTester
       stdout, stderr, status = Open3.capture3(new_env, "#{cmd};")
 
       logger.debug "status: #{status}"
-      logger.debug "stdout: #{stdout}"
+      logger.debug "stdout: #{stdout}" if debug_log_stdout
       logger.debug "stderr: #{stderr}"
 
       stdout&.chomp!

data/lib/pmdtester/cpd_report_diff.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module PmdTester
+  # A full CPD report, created by the report XML parser,
+  # can be diffed with another report into a CpdReportDiff
+  class CpdReport
+    attr_reader :duplications, :errors,
+                :file,
+                :report_details
+
+    def initialize(report_details:, report_document:, file:)
+      initialize_empty
+      initialize_with_report_document report_document unless report_document.nil?
+      @report_details = report_details
+      @file = file
+    end
+
+    def self.empty
+      new(report_details: PmdTester::PmdReportDetail.empty, report_document: nil, file: '')
+    end
+
+    private
+
+    def initialize_with_report_document(report_document)
+      @duplications = report_document.duplications
+      @errors = report_document.errors
+
+      PmdTester.logger.debug("Loaded #{@duplications.size} duplications")
+      PmdTester.logger.debug("Loaded #{@errors.size} errors")
+    end
+
+    def initialize_empty
+      @duplications = []
+      @errors = []
+    end
+  end
+
+  # This class represents all the diff report information,
+  # including the summary information of the original cpd reports,
+  # as well as the specific information of the diff report.
+  class CpdReportDiff
+    include PmdTester
+
+    attr_reader :duplication_counts, :error_counts, :duplication_diffs, :error_diffs
+    attr_accessor :base_report, :patch_report
+
+    def initialize(base_report:, patch_report:)
+      @duplication_counts = RunningDiffCounters.new(base_report.duplications.size)
+      @error_counts = RunningDiffCounters.new(base_report.errors.size)
+
+      @base_report = base_report
+      @patch_report = patch_report
+
+      @duplication_diffs = []
+      @error_diffs = []
+
+      diff_base_with_patch
+    end
+
+    private
+
+    def diff_base_with_patch
+      @duplication_counts.patch_total = @patch_report.duplications.size
+      @error_counts.patch_total = @patch_report.errors.size
+
+      @duplication_diffs = (@base_report.duplications + @patch_report.duplications) \
+              - (@base_report.duplications & @patch_report.duplications)
+      merge_changed_items(@duplication_diffs)
+      count(@duplication_diffs, @duplication_counts)
+
+      @error_diffs = (@base_report.errors + @patch_report.errors) \
+              - (@base_report.errors & @patch_report.errors)
+      merge_changed_items(@error_diffs)
+      count(@error_diffs, @error_counts)
+
+      self
+    end
+
+    def count(diffs, counter)
+      diffs.each do |item|
+        if item.changed?
+          counter.changed += 1
+        elsif item.branch.eql?(BASE)
+          counter.removed += 1
+        else
+          counter.new += 1
+        end
+      end
+    end
+
+    def merge_changed_items(diffs)
+      diffs.delete_if do |item|
+        item.branch == BASE &&
+          # try_merge will set item2.changed = true if it succeeds
+          diffs.any? { |item2| item2.branch == PATCH && item2.try_merge?(item) }
+      end
+    end
+  end
+end

data/lib/pmdtester/jfr_summary.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module PmdTester
+  # This class reads a jfr recording and extract a summary
+  class JfrSummary
+    attr_accessor :execution_time, :max_heap_memory, :max_cpu_load, :avg_cpu_load, :recording_path
+
+    def initialize
+      @execution_time = 0
+      @max_heap_memory = 0
+      @max_cpu_load = 0
+      @avg_cpu_load = 0
+      @recording_path = ''
+    end
+
+    def load(jfr_recording)
+      @recording_path = jfr_recording
+      start_time = get_start_time(jfr_recording)
+      end_time = get_end_time(jfr_recording)
+      @execution_time = end_time - start_time
+
+      gc_heap_summary = get_gc_heap_summary(jfr_recording)
+      unless gc_heap_summary.empty?
+        @max_heap_memory = gc_heap_summary.map do |e|
+          e.dig(:values, :heapUsed)
+        end.max
+      end
+
+      cpu_load = get_cpu_load(jfr_recording)
+      unless cpu_load.empty?
+        @max_cpu_load = cpu_load.map { |e| e.dig(:values, :jvmUser) }.max
+        @avg_cpu_load = cpu_load.map { |e| e.dig(:values, :jvmUser) }.sum / cpu_load.size
+      end
+
+      self
+    end
+
+    def to_h
+      {
+        execution_time: @execution_time,
+        max_heap_memory: @max_heap_memory,
+        max_cpu_load: @max_cpu_load,
+        avg_cpu_load: @avg_cpu_load,
+        recording_path: @recording_path
+      }
+    end
+
+    def to_h_for_liquid
+      {
+        'execution_time' => PmdReportDetail.convert_seconds(@execution_time),
+        'max_heap_memory' => format_memory(@max_heap_memory),
+        'max_cpu_load' => format_percentage(@max_cpu_load),
+        'avg_cpu_load' => format_percentage(@avg_cpu_load)
+      }
+    end
+
+    def self.from_h(hash)
+      jfr_summary = JfrSummary.new
+      jfr_summary.execution_time = hash[:execution_time] || 0
+      jfr_summary.max_heap_memory = hash[:max_heap_memory] || 0
+      jfr_summary.max_cpu_load = hash[:max_cpu_load] || 0
+      jfr_summary.avg_cpu_load = hash[:avg_cpu_load] || 0
+      jfr_summary.recording_path = hash[:recording_path] || ''
+      jfr_summary
+    end
+
+    private
+
+    def get_start_time(jfr_recording)
+      stdout = Cmd.execute_successfully("jfr print --json --events jdk.JVMInformation #{jfr_recording}",
+                                        nil, debug_log_stdout: false)
+      jvm_info = JSON.parse(stdout, symbolize_names: true).dig(:recording, :events, 0, :values, :jvmStartTime)
+      return Time.at(0) if jvm_info.nil?
+
+      Time.parse(jvm_info)
+    end
+
+    def get_end_time(jfr_recording)
+      stdout = Cmd.execute_successfully("jfr print --json --events jdk.Shutdown #{jfr_recording}",
+                                        nil, debug_log_stdout: false)
+      shutdown_info = JSON.parse(stdout, symbolize_names: true).dig(:recording, :events, 0, :values, :startTime)
+      return Time.at(0) if shutdown_info.nil?
+
+      Time.parse(shutdown_info)
+    end
+
+    def get_gc_heap_summary(jfr_recording)
+      stdout = Cmd.execute_successfully("jfr print --json --events jdk.GCHeapSummary #{jfr_recording}",
+                                        nil, debug_log_stdout: false)
+      events = JSON.parse(stdout, symbolize_names: true).dig(:recording, :events)
+      return [] if events.nil?
+
+      events
+    end
+
+    def get_cpu_load(jfr_recording)
+      stdout = Cmd.execute_successfully("jfr print --json --events jdk.CPULoad #{jfr_recording}",
+                                        nil, debug_log_stdout: false)
+      events = JSON.parse(stdout, symbolize_names: true).dig(:recording, :events)
+      return [] if events.nil?
+
+      events
+    end
+
+    def format_memory(bytes)
+      return '0 MB' if bytes.nil? || bytes.zero?
+
+      "#{(bytes / (1024 * 1024)).round} MB"
+    end
+
+    def format_percentage(value)
+      return '0%' if value.nil? || value.zero?
+
+      "#{(value * 100).round}%"
+    end
+  end
+end