jirametrics 2.30.1pre1 → 2.31

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c1b70c2648c844b678a4b20ae4f9ed570e2a471ff306b4b682d1d0566ba9c334
-  data.tar.gz: ce6972d092d1f5b1bd7425f9d19a8dbbb1d2a7f584e0fe48b9f140faaca96e57
+  metadata.gz: e5d255e03d686d0bf827ab0cd09191777b9586574971d6e274704a85df1059a6
+  data.tar.gz: 60fbf1432b7399186a5e854ef58e83ee59ae96b5bee859371b09f992b4854db7
 SHA512:
-  metadata.gz: 98e35757d64618ff0ee87854a88b98196ccf87cb47761c4a065ead4aae84cb6653cbb37c6746f06a61418fee4c75f31089172028b485b276939f3c07d99b045d
-  data.tar.gz: 1c509febc055eec7ca7d8d9a89a9136e6b6ded8ff8b0585c9b1432b0e2aeb8a8d7301808070eb52b8919e6340928b9aecf137e98a2acd79e6c271fd36a1bc83a
+  metadata.gz: 79003fc0ab19a3253e9611c74e5d5772b7e0cf17250ec668c9c21cf871056020fa1d6af979387b4e76395b47a687e300b288555d0709c9fa50a7c227d359dbe2
+  data.tar.gz: 7587f1a620a1015f174bfa5b2b2e31251f3b0c0e2be0a688aa31e1da423bdefa2deaab7a8d40c4e3a8fd54f8c495a3b43db1a0ad231feab6624d8cf74b08adff

data/lib/jirametrics/download_config.rb

@@ -30,7 +30,7 @@ class DownloadConfig
   end
 
   def github_repo *repos
-    github_repos.concat(repos.map { |r| normalize_github_repo(r) })
+    github_repos.concat(repos)
   end
 
   def start_date today:
@@ -42,8 +42,4 @@ class DownloadConfig
 
   private
 
-  def normalize_github_repo repo
-    match = repo.match(%r{github\.com/([^/]+/[^/]+?)/?$})
-    match ? match[1] : repo
-  end
 end

data/lib/jirametrics/downloader_for_cloud.rb

@@ -101,6 +101,7 @@ class DownloaderForCloud < Downloader
     )
 
     attach_changelog_to_issues issue_datas: issue_datas, issue_jsons: response['issues']
+    attach_worklogs_to_issues issue_datas: issue_datas, issue_jsons: response['issues']
 
     response['issues'].each do |issue_json|
       issue_json['exporter'] = {
@@ -129,6 +130,49 @@ class DownloaderForCloud < Downloader
     issue_datas
   end
 
+  def attach_worklogs_to_issues issue_datas:, issue_jsons:, max_results: 100 # rubocop:disable Lint/UnusedMethodArgument
+    issue_jsons.each do |issue_json|
+      worklog = issue_json['fields']['worklog']
+      next unless worklog
+
+      total = worklog['total'].to_i
+      all_worklogs = worklog['worklogs'] || []
+      next if all_worklogs.size >= total
+
+      key = issue_json['key']
+      start_at = all_worklogs.size
+
+      loop do
+        response = @jira_gateway.call_url(
+          relative_url: "/rest/api/3/issue/#{CGI.escape(key)}/worklog?startAt=#{start_at}&maxResults=#{max_results}"
+        )
+
+        worklogs = response['worklogs'] || []
+        all_worklogs.concat(worklogs)
+
+        total = response['total'].to_i
+        log "        #{key} worklogs: page startAt=#{start_at}, " \
+            "received=#{worklogs.size}, fetched=#{all_worklogs.size}/#{total}"
+        break if all_worklogs.size >= total
+        # Guard against Jira reporting a higher total than it will actually return — seen when
+        # worklogs are deleted or access-restricted after the initial fetch. Without this,
+        # start_at never advances and we loop forever requesting the same empty page.
+        break if worklogs.empty?
+
+        start_at += worklogs.size
+      end
+
+      issue_json['fields']['worklog'] = {
+        'startAt' => 0,
+        'maxResults' => all_worklogs.size,
+        'total' => all_worklogs.size,
+        'worklogs' => all_worklogs
+      }
+
+      log "      Enhanced #{key} with #{all_worklogs.size} worklogs"
+    end
+  end
+
   def attach_changelog_to_issues issue_datas:, issue_jsons:
     max_results = 10_000 # The max jira accepts is 10K
     payload = {
@@ -187,10 +231,14 @@ class DownloaderForCloud < Downloader
     loop do
       related_issue_keys = Set.new
       stale = issue_data_hash.values.reject { |data| data.up_to_date }
+      if in_related_phase
+        @file_system.diagnostic "Download loop: #{issue_data_hash.size} total known, " \
+                                "#{stale.size} stale, #{checked_for_related.size} link-scanned"
+      end
       unless stale.empty?
         log_start '  Downloading more issues ' unless in_related_phase
         stale.each_slice(100) do |slice|
-          slice = bulk_fetch_issues(issue_datas: slice, board: board, in_initial_query: true)
+          slice = bulk_fetch_issues(issue_datas: slice, board: board, in_initial_query: !in_related_phase)
           progress_dot
           slice.each do |data|
             next unless data.issue
@@ -202,23 +250,20 @@ class DownloaderForCloud < Downloader
             # to parse the file just to find the timestamp
             @file_system.utime time: data.issue.updated, file: data.cache_path
 
-            collect_related_issue_keys issue: data.issue, related_issue_keys: related_issue_keys
+            collect_or_log_related(
+              issue: data.issue, found_in_primary_query: data.found_in_primary_query,
+              related_issue_keys: related_issue_keys, issue_data_hash: issue_data_hash
+            )
             checked_for_related << data.key
           end
         end
         end_progress unless in_related_phase
       end
 
-      # Also scan up-to-date cached issues we haven't checked yet — they may reference
-      # related issues that are not in the primary query result.
-      issue_data_hash.each_value do |data|
-        next if checked_for_related.include?(data.key)
-        next unless @file_system.file_exist?(data.cache_path)
-
-        checked_for_related << data.key
-        raw = @file_system.load_json(data.cache_path)
-        collect_related_issue_keys issue: Issue.new(raw: raw, board: board), related_issue_keys: related_issue_keys
-      end
+      scan_cached_issues_for_related(
+        issue_data_hash: issue_data_hash, board: board,
+        checked_for_related: checked_for_related, related_issue_keys: related_issue_keys
+      )
 
       # Remove all the ones we already have
       related_issue_keys.reject! { |key| issue_data_hash[key] }
@@ -232,11 +277,11 @@ class DownloaderForCloud < Downloader
       end
       break if related_issue_keys.empty?
 
-      unless in_related_phase
-        in_related_phase = true
-        log "  Identifying related issues (parents, subtasks, links) for board #{board.id}", both: true
-        log_start '  Downloading more issues '
-      end
+      next if in_related_phase
+
+      in_related_phase = true
+      log "  Identifying related issues (parents, subtasks, links) for board #{board.id}", both: true
+      log_start '  Downloading more issues '
     end
 
     end_progress if in_related_phase
@@ -265,20 +310,68 @@ class DownloaderForCloud < Downloader
     end
   end
 
+  # Scan up-to-date cached primary issues we haven't checked yet — they may reference related
+  # issues that are not in the primary query result. We only follow links one hop out from the
+  # primary issues, so related (non-primary) cached issues are not followed (just logged).
+  def scan_cached_issues_for_related issue_data_hash:, board:, checked_for_related:, related_issue_keys:
+    issue_data_hash.each_value do |data|
+      next if checked_for_related.include?(data.key)
+      next unless @file_system.file_exist?(data.cache_path)
+
+      checked_for_related << data.key
+      issue = Issue.new(raw: @file_system.load_json(data.cache_path), board: board)
+      collect_or_log_related(
+        issue: issue, found_in_primary_query: data.found_in_primary_query,
+        related_issue_keys: related_issue_keys, issue_data_hash: issue_data_hash
+      )
+    end
+  end
+
+  # Follow links one hop out from primary issues; for related (non-primary) issues, log the
+  # onward links we are deliberately not following rather than recursing into them.
+  def collect_or_log_related issue:, found_in_primary_query:, related_issue_keys:, issue_data_hash:
+    if found_in_primary_query
+      collect_related_issue_keys issue: issue, related_issue_keys: related_issue_keys
+    else
+      log_unfollowed_related_keys issue: issue, issue_data_hash: issue_data_hash
+    end
+  end
+
   def collect_related_issue_keys issue:, related_issue_keys:
+    related_issue_keys.merge related_keys_for(issue)
+  end
+
+  # The parents, subtasks, and (non-cloner) linked issues that this issue references.
+  def related_keys_for issue
+    keys = Set.new
+
     parent_key = issue.parent_key(project_config: @download_config.project_config)
-    related_issue_keys << parent_key if parent_key
+    keys << parent_key if parent_key
 
     issue.raw['fields']['subtasks']&.each do |raw_subtask|
-      related_issue_keys << raw_subtask['key']
+      keys << raw_subtask['key']
     end
 
     issue.raw['fields']['issuelinks']&.each do |link|
       next if link['type']['name'] == 'Cloners'
 
       linked = link['inwardIssue'] || link['outwardIssue']
-      related_issue_keys << linked['key'] if linked
+      keys << linked['key'] if linked
     end
+
+    keys
+  end
+
+  # We only follow links one hop out from the primary (board) issues. If a related issue
+  # itself references further issues we haven't already downloaded, we deliberately don't
+  # follow them — but log it so we can diagnose later if an export fails because a
+  # second-hop issue was missing. See GitHub #72.
+  def log_unfollowed_related_keys issue:, issue_data_hash:
+    onward = related_keys_for(issue).reject { |key| issue_data_hash[key] }
+    return if onward.empty?
+
+    @file_system.diagnostic "One-hop limit: not following #{onward.size} onward link(s) from related " \
+                            "issue #{issue.key}: #{onward.to_a.sort.join(', ')}"
   end
 
   def last_modified filename:

data/lib/jirametrics/downloader_for_data_center.rb

@@ -49,8 +49,12 @@ class DownloaderForDataCenter < Downloader
         }
         identify_other_issues_to_be_downloaded raw_issue: issue_json, board: board
         file = "#{issue_json['key']}-#{board.id}.json"
+        issue_path = File.join(path, file)
 
-        @file_system.save_json(json: issue_json, filename: File.join(path, file))
+        @file_system.save_json(json: issue_json, filename: issue_path)
+
+        # Fetch complete worklog data for this issue
+        enhance_issue_with_worklogs(issue_key: issue_json['key'], issue_path: issue_path)
       end
 
       total = json['total'].to_i
@@ -63,6 +67,36 @@ class DownloaderForDataCenter < Downloader
     end
   end
 
+  def enhance_issue_with_worklogs issue_key:, issue_path:, max_results: 100
+    all_worklogs = []
+    start_at = 0
+
+    loop do
+      url = "/rest/api/2/issue/#{CGI.escape(issue_key)}/worklog?startAt=#{start_at}&maxResults=#{max_results}"
+      response = @jira_gateway.call_url(relative_url: url)
+
+      worklogs = response['worklogs'] || []
+      all_worklogs.concat(worklogs)
+
+      total = response['total'].to_i
+      break if start_at + worklogs.size >= total
+
+      start_at += worklogs.size
+    end
+
+    issue_json = @file_system.load_json(issue_path)
+    issue_json['fields'] ||= {}
+    issue_json['fields']['worklog'] = {
+      'startAt' => 0,
+      'maxResults' => all_worklogs.size,
+      'total' => all_worklogs.size,
+      'worklogs' => all_worklogs
+    }
+    @file_system.save_json(json: issue_json, filename: issue_path)
+
+    log "      Enhanced #{issue_key} with #{all_worklogs.size} worklogs" if all_worklogs.any?
+  end
+
   def make_jql filter_id:, today: nil
     today ||= today_in_project_timezone
     segments = []

data/lib/jirametrics/file_system.rb

@@ -55,6 +55,10 @@ class FileSystem
     log "Error: #{message}", more: more, also_write_to_stderr: true
   end
 
+  def diagnostic message, more: nil
+    log "  [diag] #{message}", more: more
+  end
+
   def log message, more: nil, also_write_to_stderr: false
     message += " See #{logfile_name} for more details about this message." if more
 

data/lib/jirametrics/github_gateway.rb

@@ -6,6 +6,18 @@ require 'json'
 class GithubGateway
   attr_reader :repo
 
+  TRANSIENT_ERROR_PATTERNS = (
+    [429, 500, 502, 503, 504].map { |code| "HTTP #{code}" } +
+    ['stream error:', 'unexpected end of JSON input']
+  ).freeze
+  MAX_RETRIES = 3
+  REVIEW_STATES = %w[APPROVED CHANGES_REQUESTED].freeze
+
+  # How many keyless PRs to request commits for in a single graphql call, and how many commits
+  # to pull per PR. Kept bounded so node counts stay well under GitHub's graphql node limit.
+  COMMIT_FETCH_BATCH_SIZE = 30
+  MAX_COMMITS_PER_PR = 100
+
   def initialize repo:, project_keys:, file_system:, raw_pr_cache: {}
     @repo = repo
     @project_keys = project_keys
@@ -16,11 +28,12 @@ class GithubGateway
 
   def fetch_pull_requests since: nil
     raw_prs = @raw_pr_cache[[@repo, since]] ||= fetch_raw_pull_requests(since: since)
+    prefetch_commit_messages(raw_prs)
     raw_prs.filter_map { |pr| build_pr_data(pr) }
   end
 
   def fetch_raw_pull_requests since: nil
-    # Note: 'commits' is intentionally excluded — including it triggers GitHub's GraphQL node
+    # NOTE: 'commits' is intentionally excluded — including it triggers GitHub's GraphQL node
     # limit (authors sub-connection × PRs × commits exceeds 500,000 nodes). Branch name,
     # title, and body are sufficient for issue key extraction in the vast majority of cases.
     json_fields = %w[number title body headRefName createdAt closedAt mergedAt
@@ -58,21 +71,20 @@ class GithubGateway
   def extract_issue_keys raw_pr
     return [] if @issue_key_pattern.nil?
 
-    sources = [
-      raw_pr['headRefName'],
-      raw_pr['title'],
-      raw_pr['body']
-    ]
-
-    keys = sources.compact.flat_map { |s| s.scan(@issue_key_pattern) }.uniq
+    keys = keys_from_text_fields(raw_pr)
     return keys unless keys.empty?
 
     commit_messages_for(raw_pr['number']).flat_map { |msg| msg.scan(@issue_key_pattern) }.uniq
   end
 
+  def keys_from_text_fields raw_pr
+    sources = [raw_pr['headRefName'], raw_pr['title'], raw_pr['body']]
+    sources.compact.flat_map { |s| s.scan(@issue_key_pattern) }.uniq
+  end
+
   def extract_reviews raw_reviews
     raw_reviews
-      .select { |r| %w[APPROVED CHANGES_REQUESTED].include?(r['state']) }
+      .select { |r| REVIEW_STATES.include?(r['state']) }
       .map do |r|
         {
           'author'       => r.dig('author', 'login'),
@@ -84,11 +96,73 @@ class GithubGateway
 
   private
 
+  # Pre-populate the shared commit cache for every PR with no key in its branch/title/body, using
+  # batched graphql requests instead of one "gh pr view" per PR. build_pr_data -> commit_messages_for
+  # then reads straight from the cache for those PRs (no per-PR network call). Any PR the batch can't
+  # fully cover (more commits than one page, or absent from the response) is left uncached so the
+  # single-PR fallback in commit_messages_for fills it in.
+  def prefetch_commit_messages raw_prs
+    return if @issue_key_pattern.nil?
+
+    numbers = raw_prs
+      .select { |raw_pr| keys_from_text_fields(raw_pr).empty? }
+      .map { |raw_pr| raw_pr['number'] }
+      .reject { |number| @raw_pr_cache.key?([@repo, :commits, number]) }
+
+    numbers.each_slice(COMMIT_FETCH_BATCH_SIZE) do |batch|
+      fetch_commits_batch(batch).each do |number, messages|
+        @raw_pr_cache[[@repo, :commits, number]] = messages
+      end
+    end
+  end
+
+  def fetch_commits_batch numbers
+    owner, name = owner_and_name
+    aliases = numbers.each_with_index.map do |number, index|
+      "pr#{index}: pullRequest(number: #{number}) " \
+        "{ commits(first: #{MAX_COMMITS_PER_PR}) { totalCount nodes { commit { messageHeadline messageBody } } } }"
+    end
+    query = %(query { repository(owner: "#{owner}", name: "#{name}") { #{aliases.join(' ')} } })
+    result = run_command(['api', 'graphql', '-f', "query=#{query}"])
+    parse_commits_batch result: result, numbers: numbers
+  end
+
+  def parse_commits_batch result:, numbers:
+    repository = result.dig('data', 'repository') || {}
+    messages_by_number = {}
+    numbers.each_with_index do |number, index|
+      commits = repository.dig("pr#{index}", 'commits')
+      next if commits.nil?
+
+      nodes = commits['nodes'] || []
+      # Skip caching when the PR has more commits than this page covers, so the single-PR
+      # fallback fetches the complete set rather than us caching a partial answer.
+      next if commits['totalCount'] && commits['totalCount'] > nodes.size
+
+      messages_by_number[number] = nodes.flat_map do |node|
+        commit = node['commit'] || {}
+        [commit['messageHeadline'], commit['messageBody']].compact
+      end
+    end
+    messages_by_number
+  end
+
+  def owner_and_name
+    # @repo may be a full URL (https://github.com/owner/name.git) or an owner/name slug.
+    @repo.sub(%r{\Ahttps?://[^/]+/}, '').delete_suffix('.git').split('/', 2)
+  end
+
   def commit_messages_for pr_number
-    args = ['pr', 'view', pr_number.to_s, '--json', 'commits', '--repo', @repo]
-    result = run_command(args)
-    (result['commits'] || []).flat_map do |commit|
-      [commit['messageHeadline'], commit['messageBody']].compact
+    # Cached in the shared per-run cache (keyed by repo + PR) so the fallback isn't re-fetched
+    # when the same repo is downloaded by more than one project. Commit text doesn't depend on
+    # project_keys, so it's safe to share across projects with different keys. prefetch_commit_messages
+    # normally fills this in via a batched request; this single-PR path is the fallback.
+    @raw_pr_cache[[@repo, :commits, pr_number]] ||= begin
+      args = ['pr', 'view', pr_number.to_s, '--json', 'commits', '--repo', @repo]
+      result = run_command(args)
+      (result['commits'] || []).flat_map do |commit|
+        [commit['messageHeadline'], commit['messageBody']].compact
+      end
     end
   end
 
@@ -99,17 +173,44 @@ class GithubGateway
     Regexp.new("\\b(?:#{keys_pattern})-\\d+(?![A-Za-z0-9])")
   end
 
-  def run_command args
-    stdout, stderr, status = Open3.capture3('gh', *args)
+  def monotonic_time
+    # In its own method so we can mock it out in tests
+    Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  end
 
-    # This extra check seems to only matter on Windows. On the mac, auth failures don't pass status.success?
-    if stderr.include?('SAML enforcement')
-      raise "GitHub CLI is not authorized to access #{@repo}. " \
-            'Run: gh auth refresh -h github.com -s read:org'
-    end
+  def run_command args
+    attempts = 0
+    loop do
+      attempts += 1
+      started = monotonic_time
+      stdout, stderr, status = Open3.capture3('gh', *args)
+      @file_system.diagnostic "gh #{args.first(2).join(' ')} call took #{format('%.2f', monotonic_time - started)}s"
+
+      # This extra check seems to only matter on Windows. On the mac, auth failures don't pass status.success?
+      if stderr.include?('SAML enforcement')
+        raise "GitHub CLI is not authorized to access #{@repo}. " \
+              'Run: gh auth refresh -h github.com -s read:org'
+      end
 
-    raise "GitHub CLI command failed for #{@repo}: #{stderr}" unless status.success?
+      unless status.success?
+        error_message = "  GitHub CLI command failed for #{@repo} " \
+                        "(attempt #{attempts}/#{MAX_RETRIES}): #{stderr.strip}"
+        if attempts < MAX_RETRIES && TRANSIENT_ERROR_PATTERNS.any? { |pattern| stderr.include?(pattern) }
+          delay = 2**attempts
+          @file_system.log error_message
+          @file_system.log "  Transient error detected. Retrying in #{delay}s..."
+          sleep delay
+          next
+        end
+        @file_system.warning error_message
+        raise "GitHub CLI command failed for #{@repo}: #{stderr}"
+      end
 
-    JSON.parse(stdout)
+      result = JSON.parse(stdout)
+      if result.nil? || (result.is_a?(Array) && result.empty?)
+        @file_system.warning "No data was found in GitHub for #{@repo}. Is that what you expected?"
+      end
+      return result
+    end
   end
 end

data/lib/jirametrics/jira_gateway.rb

@@ -32,17 +32,21 @@ class JiraGateway
 
     retries = 0
     loop do
+      started = monotonic_time
       stdout, stderr, status = capture3(command, stdin_data: stdin_data)
+      @file_system.diagnostic format('Jira call took %.2fs', monotonic_time - started)
 
       if status.success?
         @file_system.log "Returned (stderr): #{stderr.inspect}" unless stderr == ''
         raise 'no response from curl on stdout' if stdout == ''
+
         return parse_response(command: command, result: stdout)
       end
 
-      if RETRYABLE_EXIT_CODES.include?(status.exitstatus) && retries < MAX_RETRIES
+      if RETRYABLE_EXIT_CODES.include?(status.exitstatus) && retries < MAX_RETRIES && !stderr.include?('503')
         retries += 1
-        @file_system.log "Transient network error (exit #{status.exitstatus}), retrying in #{RETRY_DELAY_SECONDS}s (attempt #{retries}/#{MAX_RETRIES})..."
+        @file_system.log "Transient network error (exit #{status.exitstatus}), retrying in " \
+                         "#{RETRY_DELAY_SECONDS}s (attempt #{retries}/#{MAX_RETRIES})..."
         sleep_between_retries
         next
       end
@@ -53,6 +57,11 @@ class JiraGateway
       if stderr.include?('401')
         raise 'The request was not authorized. Verify that your authentication token hasn\'t expired'
       end
+      if stderr.include?('503')
+        raise 'Jira returned 503 (Service Unavailable). This may be a temporary outage, or your ' \
+              'Jira account may have been deactivated due to inactivity. Check your Jira subscription ' \
+              'and try again later.'
+      end
       raise "Failed call with exit status #{status.exitstatus}. " \
         "See #{@file_system.logfile_name} for details"
     end
@@ -68,6 +77,11 @@ class JiraGateway
     sleep RETRY_DELAY_SECONDS
   end
 
+  def monotonic_time
+    # In its own method so we can mock it out in tests
+    Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  end
+
   def call_url relative_url:
     command = make_curl_command url: "#{@jira_url}#{relative_url}"
     exec_and_parse_response command: command, stdin_data: nil

data/lib/jirametrics/project_config.rb

@@ -478,22 +478,28 @@ class ProjectConfig
 
       issues_path = File.join @target_path, "#{get_file_prefix}_issues"
       if File.exist?(issues_path) && File.directory?(issues_path)
+        file_system.diagnostic "Loading issues from #{issues_path}"
         issues = load_issues_from_issues_directory path: issues_path, timezone_offset: timezone_offset
+        file_system.diagnostic "Loaded #{issues.size} issues from disk"
       else
         file_system.log "Can't find directory #{issues_path}. Has a download been done?", also_write_to_stderr: true
         return IssueCollection.new
       end
 
       # Attach related issues
+      file_system.diagnostic 'Starting attach phase'
+      issues_by_key = issues.to_h { |i| [i.key, i] }
       issues.each do |i|
-        attach_subtasks issue: i, all_issues: issues
-        attach_parent issue: i, all_issues: issues
-        attach_linked_issues issue: i, all_issues: issues
+        attach_subtasks issue: i, issues_by_key: issues_by_key
+        attach_parent issue: i, issues_by_key: issues_by_key
+        attach_linked_issues issue: i, issues_by_key: issues_by_key
       end
+      file_system.diagnostic 'Attach phase complete'
 
       # We'll have some issues that are in the list that weren't part of the initial query. Once we've
       # attached them in the appropriate places, remove any that aren't part of that initial set.
       issues.reject! { |i| !i.in_initial_query? } # rubocop:disable Style/InverseMethods
+      file_system.diagnostic "Retained #{issues.size} primary issues"
       @issues = issues
       attach_github_prs
     end
@@ -501,24 +507,22 @@ class ProjectConfig
     @issues
   end
 
-  def attach_subtasks issue:, all_issues:
+  def attach_subtasks issue:, issues_by_key:
     issue.raw['fields']['subtasks']&.each do |subtask_element|
-      subtask_key = subtask_element['key']
-      subtask = all_issues.find { |i| i.key == subtask_key }
+      subtask = issues_by_key[subtask_element['key']]
       issue.subtasks << subtask if subtask
     end
   end
 
-  def attach_parent issue:, all_issues:
+  def attach_parent issue:, issues_by_key:
     parent_key = issue.parent_key
-    parent = all_issues.find { |i| i.key == parent_key }
-    issue.parent = parent if parent
+    issue.parent = issues_by_key[parent_key] if parent_key
   end
 
-  def attach_linked_issues issue:, all_issues:
+  def attach_linked_issues issue:, issues_by_key:
     issue.issue_links.each do |link|
       if link.other_issue.artificial?
-        other = all_issues.find { |i| i.key == link.other_issue.key }
+        other = issues_by_key[link.other_issue.key]
         link.other_issue = other if other
       end
     end
@@ -638,6 +642,7 @@ class ProjectConfig
       end
     end
 
+    file_system.diagnostic "discard_changes_before: processing #{issues.size} issues"
     issues.each do |issue|
       cutoff_time = block.call(issue)
       next if cutoff_time.nil?

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jirametrics
 version: !ruby/object:Gem::Version
-  version: 2.30.1pre1
+  version: '2.31'
 platform: ruby
 authors:
 - Mike Bowler
@@ -210,7 +210,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.10
+rubygems_version: 4.0.13
 specification_version: 4
 summary: Extract Jira metrics
 test_files: []