jirametrics 2.14 → 2.22

data/lib/jirametrics/cycletime_histogram.rb

@@ -62,7 +62,9 @@ class CycletimeHistogram < ChartBase
       )
     end
 
-    return "<h1>#{@header_text}</h1>No data matched the selected criteria. Nothing to show." if data_sets.empty?
+    if data_sets.empty?
+      return "<h1 class='foldable'>#{@header_text}</h1><div>No data matched the selected criteria. Nothing to show.</div>"
+    end
 
     wrap_and_render(binding, __FILE__)
   end

data/lib/jirametrics/cycletime_scatterplot.rb

@@ -35,14 +35,33 @@ class CycletimeScatterplot < ChartBase
     end
 
     @percentage_lines = []
-    @highest_cycletime = 0
+    @highest_y_value = 0
   end
 
-  def run
-    completed_issues = completed_issues_in_range include_unstarted: false
+  def all_items
+    completed_issues_in_range include_unstarted: false
+  end
+
+  def x_value item
+    item.board.cycletime.started_stopped_times(item).last
+  end
+
+  def y_value item
+    item.board.cycletime.cycletime(item)
+  end
 
-    data_sets = create_datasets completed_issues
-    overall_percent_line = calculate_percent_line(completed_issues)
+  def title_value item
+    "#{item.key} : #{item.summary} (#{label_days(y_value(item))})"
+  end
+
+  def y_axis_heading
+    'Cycle time in days'
+  end
+
+  def run
+    items = all_items
+    data_sets = create_datasets items
+    overall_percent_line = calculate_percent_line(items)
     @percentage_lines << [overall_percent_line, CssVariable['--cycletime-scatterplot-overall-trendline-color']]
 
     return "<h1>#{@header_text}</h1>No data matched the selected criteria. Nothing to show." if data_sets.empty?
@@ -50,14 +69,14 @@ class CycletimeScatterplot < ChartBase
     wrap_and_render(binding, __FILE__)
   end
 
-  def create_datasets completed_issues
+  def create_datasets items
     data_sets = []
 
-    group_issues(completed_issues).each do |rules, completed_issues_by_type|
+    group_issues(items).each do |rules, completed_items_by_type|
       label = rules.label
       color = rules.color
-      percent_line = calculate_percent_line completed_issues_by_type
-      data = completed_issues_by_type.filter_map { |issue| data_for_issue(issue) }
+      percent_line = calculate_percent_line completed_items_by_type
+      data = completed_items_by_type.filter_map { |issue| data_for_issue(issue) }
       data_sets << {
         label: "#{label} (85% at #{label_days(percent_line)})",
         data: data,
@@ -86,7 +105,7 @@ class CycletimeScatterplot < ChartBase
     calculator = TrendLineCalculator.new(points)
     data_points = calculator.chart_datapoints(
       range: time_range.begin.to_i..time_range.end.to_i,
-      max_y: @highest_cycletime
+      max_y: @highest_y_value
     )
     data_points.each do |point_hash|
       point_hash[:x] = chart_format Time.at(point_hash[:x])
@@ -106,21 +125,21 @@ class CycletimeScatterplot < ChartBase
     }
   end
 
-  def data_for_issue issue
-    cycle_time = issue.board.cycletime.cycletime(issue)
+  def data_for_issue item
+    cycle_time = y_value(item)
     return nil if cycle_time < 1 # These will get called out on the quality report
 
-    @highest_cycletime = cycle_time if @highest_cycletime < cycle_time
+    @highest_y_value = cycle_time if @highest_y_value < cycle_time
 
     {
       y: cycle_time,
-      x: chart_format(issue.board.cycletime.started_stopped_times(issue).last),
-      title: ["#{issue.key} : #{issue.summary} (#{label_days(cycle_time)})"]
+      x: chart_format(x_value(item)),
+      title: [title_value(item)]
     }
   end
 
-  def calculate_percent_line completed_issues
-    times = completed_issues.collect { |issue| issue.board.cycletime.cycletime(issue) }
+  def calculate_percent_line items
+    times = items.collect { |item| y_value(item) }
     index = times.size * 85 / 100
     times.sort[index]
   end

data/lib/jirametrics/daily_view.rb

@@ -23,7 +23,7 @@ class DailyView < ChartBase
   def run
     aging_issues = select_aging_issues
 
-    return "<h1>#{@header_text}</h1>There are no items currently in progress" if aging_issues.empty?
+    return "<h1 class='foldable'>#{@header_text}</h1>There are no items currently in progress" if aging_issues.empty?
 
     result = +''
     result << render_top_text(binding)
@@ -33,10 +33,6 @@ class DailyView < ChartBase
     result
   end
 
-  def atlassian_document_format
-    @atlassian_document_format ||= AtlassianDocumentFormat.new(users: users, timezone_offset: timezone_offset)
-  end
-
   def select_aging_issues
     aging_issues = issues.select do |issue|
       started_at, stopped_at = issue.board.cycletime.started_stopped_times(issue)
@@ -170,13 +166,7 @@ class DailyView < ChartBase
 
     return lines if subtasks.empty?
 
-    id = next_id
-    lines <<
-      "<a href=\"javascript:toggle_visibility('open#{id}', 'close#{id}', 'section#{id}');\">" \
-      "<span id='open#{id}' style='display: none'>▶ Child issues</span>" \
-      "<span id='close#{id}'>▼ Child issues</span></a>"
-    lines << "<section id='section#{id}'>"
-
+    lines << '<section><div class="foldable">Child issues</div>'
     lines += subtasks
     lines << '</section>'
 
@@ -187,16 +177,11 @@ class DailyView < ChartBase
     history = issue.changes.reverse
     lines = []
 
-    id = next_id
-    lines << [
-      "<a href=\"javascript:toggle_visibility('open#{id}', 'close#{id}', 'table#{id}');\">" \
-      "<span id='open#{id}'>▶ Issue History</span>" \
-      "<span id='close#{id}' style='display: none'>▼ Issue History</span></a>"
-    ]
+    lines << '<section><div class="foldable startFolded">Issue history</div>'
     table = +''
-    table << "<table id='table#{id}' style='display: none'>"
+    table << '<table>'
     history.each do |c|
-      time = c.time.strftime '%b %d, %I:%M%P'
+      time = c.time.strftime '%b %d, %Y @ %I:%M%P'
 
       table << '<tr>'
       table << "<td><span class='time' title='Timestamp: #{c.time}'>#{time}</span></td>"
@@ -207,6 +192,7 @@ class DailyView < ChartBase
     end
     table << '</table>'
     lines << [table]
+    lines << '</section>'
     lines
   end
 

data/lib/jirametrics/daily_wip_by_age_chart.rb

@@ -51,8 +51,6 @@ class DailyWipByAgeChart < DailyWipChart
   def default_grouping_rules issue:, rules:
     started, stopped = issue.board.cycletime.started_stopped_dates(issue)
 
-    rules.issue_hint = "(age: #{label_days (rules.current_date - started + 1).to_i})" if started
-
     if stopped && started.nil? # We can't tell when it started
       @has_completed_but_not_started = true
       not_started stopped: stopped, rules: rules, created: issue.created.to_date
@@ -72,7 +70,7 @@ class DailyWipByAgeChart < DailyWipChart
       rules.label = 'Start date unknown'
       rules.color = '--body-background'
       rules.group_priority = 11
-      created_days = rules.current_date - created + 1
+      created_days = rules.current_date - created
       rules.issue_hint = "(created: #{label_days created_days.to_i} earlier, stopped on #{stopped})"
     end
   end
@@ -84,7 +82,8 @@ class DailyWipByAgeChart < DailyWipChart
   end
 
   def group_by_age started:, rules:
-    age = rules.current_date - started + 1
+    age = (rules.current_date - started).to_i + 1
+    rules.issue_hint = "(age: #{label_days age})"
 
     case age
     when 1

data/lib/jirametrics/daily_wip_by_blocked_stalled_chart.rb

@@ -41,21 +41,30 @@ class DailyWipByBlockedStalledChart < DailyWipChart
   def default_grouping_rules issue:, rules:
     started, stopped = issue.board.cycletime.started_stopped_times(issue)
     stopped_date = stopped&.to_date
+    started_date = started&.to_date
 
     date = rules.current_date
     change = issue.blocked_stalled_by_date(date_range: date..date, chart_end_time: time_range.end)[date]
-
     stopped_today = stopped_date == rules.current_date
 
+    days = nil
+    if started_date && stopped_date
+      days = (stopped_date - started_date).to_i + 1 # cycletime
+    elsif started_date
+      days = (time_range.end.to_date - started_date).to_i + 1 # age
+    end
+
     if stopped_today && started.nil?
       @has_completed_but_not_started = true
       rules.label = 'Completed but not started'
       rules.color = '--wip-chart-completed-but-not-started-color'
       rules.group_priority = -1
+      rules.issue_hint = '(Cycle time: Unknown)'
     elsif stopped_today
       rules.label = 'Completed'
       rules.color = '--wip-chart-completed-color'
       rules.group_priority = -2
+      rules.issue_hint = "(Cycle time: #{label_days days})"
     elsif started.nil?
       rules.label = 'Start date unknown'
       rules.color = '--body-background'
@@ -64,16 +73,17 @@ class DailyWipByBlockedStalledChart < DailyWipChart
       rules.label = 'Blocked'
       rules.color = '--blocked-color'
       rules.group_priority = 1
-      rules.issue_hint = "(#{change.reasons})"
+      rules.issue_hint = "(Age: #{label_days days}, #{change.reasons})"
     elsif change&.stalled?
       rules.label = 'Stalled'
       rules.color = '--stalled-color'
       rules.group_priority = 2
-      rules.issue_hint = "(#{change.reasons})"
+      rules.issue_hint = "(Age: #{label_days days}, #{change.reasons})"
     else
       rules.label = 'Active'
       rules.color = '--wip-chart-active-color'
       rules.group_priority = 3
+      rules.issue_hint = "(Age: #{label_days days})"
     end
   end
 end

data/lib/jirametrics/daily_wip_chart.rb

@@ -66,7 +66,7 @@ class DailyWipChart < ChartBase
     hash = {}
 
     @issues.each do |issue|
-      start, stop = issue.board.cycletime.started_stopped_dates(issue)
+      start, stop = cycletime_for_issue(issue).started_stopped_dates(issue)
       next if start.nil? && stop.nil?
 
       # If it stopped but never started then assume it started at creation so the data points

data/lib/jirametrics/data_quality_report.rb

@@ -266,6 +266,8 @@ class DataQualityReport < ChartBase
 
   def scan_for_items_blocked_on_closed_tickets entry:
     entry.issue.issue_links.each do |link|
+      next unless settings['blocked_link_text'].include?(link.label)
+
       this_active = !entry.stopped
       other_active = !link.other_issue.board.cycletime.started_stopped_times(link.other_issue).last
       next unless this_active && !other_active
@@ -410,14 +412,17 @@ class DataQualityReport < ChartBase
   def render_status_not_on_board problems
     <<-HTML
       #{label_issues problems.size} were not visible on the board for some period of time. This may impact
-      timings as the work was likely to have been forgotten if it wasn't visible.
+      timings as the work was likely to have been forgotten if it wasn't visible. What does "not visible"
+      mean in this context? The issue was in a status that is not mapped to any visible column on the board.
+      Look in "unmapped statuses" on your board.
     HTML
   end
 
   def render_created_in_wrong_status problems
     <<-HTML
-      #{label_issues problems.size} were created in a status not designated as Backlog. This will impact
-      the measurement of start times and will therefore impact whether it's shown as in progress or not.
+      #{label_issues problems.size} were created in a status that is not considered to be some varient
+      of To Do. Most likely this means that the issue was created from one of the columns on the board,
+      rather than in the backlog. Why Jira allows this is still a mystery.
     HTML
   end
 

data/lib/jirametrics/dependency_chart.rb

@@ -51,7 +51,10 @@ class DependencyChart < ChartBase
     instance_eval(&@rules_block) if @rules_block
 
     dot_graph = build_dot_graph
-    return "<h1>#{@header_text}</h1>No data matched the selected criteria. Nothing to show." if dot_graph.nil?
+    if dot_graph.nil?
+      return "<h1 class='foldable'>#{@header_text}</h1>" \
+        '<div>No data matched the selected criteria. Nothing to show.</div>'
+    end
 
     svg = execute_graphviz(dot_graph.join("\n"))
     "<h1>#{@header_text}</h1><div>#{@description_text}</div>#{shrink_svg svg}"

data/lib/jirametrics/downloader.rb

@@ -3,8 +3,29 @@
 require 'cgi'
 require 'json'
 
+class DownloadIssueData
+  attr_accessor :key, :found_in_primary_query, :last_modified,
+    :up_to_date, :cache_path, :issue
+
+  def initialize(
+    key:,
+    found_in_primary_query: true,
+    last_modified: nil,
+    up_to_date: true,
+    cache_path: nil,
+    issue: nil
+  )
+    @key = key
+    @found_in_primary_query = found_in_primary_query
+    @last_modified = last_modified
+    @up_to_date = up_to_date
+    @cache_path = cache_path
+    @issue = issue
+  end
+end
+
 class Downloader
-  CURRENT_METADATA_VERSION = 4
+  CURRENT_METADATA_VERSION = 5
 
   attr_accessor :metadata
   attr_reader :file_system
@@ -12,6 +33,15 @@ class Downloader
   # For testing only
   attr_reader :start_date_in_query, :board_id_to_filter_id
 
+  def self.create download_config:, file_system:, jira_gateway:
+    is_cloud = jira_gateway.settings['jira_cloud'] || jira_gateway.cloud?
+    (is_cloud ? DownloaderForCloud : DownloaderForDataCenter).new(
+      download_config: download_config,
+      file_system: file_system,
+      jira_gateway: jira_gateway
+    )
+  end
+
   def initialize download_config:, file_system:, jira_gateway:
     @metadata = {}
     @download_config = download_config
@@ -28,7 +58,6 @@ class Downloader
     log '', both: true
     log @download_config.project_config.name, both: true
 
-    init_gateway
     load_metadata
 
     if @metadata['no-download']
@@ -50,11 +79,6 @@ class Downloader
     save_metadata
   end
 
-  def init_gateway
-    @jira_gateway.load_jira_config(@download_config.project_config.jira_config)
-    @jira_gateway.ignore_ssl_errors = @download_config.project_config.settings['ignore_ssl_errors']
-  end
-
   def log text, both: false
     @file_system.log text, also_write_to_stderr: both
   end
@@ -66,93 +90,6 @@ class Downloader
     ids
   end
 
-  def download_issues board:
-    log "  Downloading primary issues for board #{board.id}", both: true
-    path = File.join(@target_path, "#{file_prefix}_issues/")
-    unless Dir.exist?(path)
-      log "  Creating path #{path}"
-      Dir.mkdir(path)
-    end
-
-    filter_id = @board_id_to_filter_id[board.id]
-    jql = make_jql(filter_id: filter_id)
-    jira_search_by_jql(jql: jql, initial_query: true, board: board, path: path)
-
-    log "  Downloading linked issues for board #{board.id}", both: true
-    loop do
-      @issue_keys_pending_download.reject! { |key| @issue_keys_downloaded_in_current_run.include? key }
-      break if @issue_keys_pending_download.empty?
-
-      keys_to_request = @issue_keys_pending_download[0..99]
-      @issue_keys_pending_download.reject! { |key| keys_to_request.include? key }
-      jql = "key in (#{keys_to_request.join(', ')})"
-      jira_search_by_jql(jql: jql, initial_query: false, board: board, path: path)
-    end
-  end
-
-  def jira_search_by_jql jql:, initial_query:, board:, path:
-    intercept_jql = @download_config.project_config.settings['intercept_jql']
-    jql = intercept_jql.call jql if intercept_jql
-
-    log "  JQL: #{jql}"
-    escaped_jql = CGI.escape jql
-
-    if @jira_gateway.cloud?
-      max_results = 5_000 # The maximum allowed by Jira
-      next_page_token = nil
-      issue_count = 0
-
-      loop do
-        json = @jira_gateway.call_url relative_url: '/rest/api/3/search/jql' \
-          "?jql=#{escaped_jql}&maxResults=#{max_results}&" \
-          "nextPageToken=#{next_page_token}&expand=changelog&fields=*all"
-        next_page_token = json['nextPageToken']
-
-        json['issues'].each do |issue_json|
-          issue_json['exporter'] = {
-            'in_initial_query' => initial_query
-          }
-          identify_other_issues_to_be_downloaded raw_issue: issue_json, board: board
-          file = "#{issue_json['key']}-#{board.id}.json"
-
-          @file_system.save_json(json: issue_json, filename: File.join(path, file))
-          issue_count += 1
-        end
-
-        message = "    Downloaded #{issue_count} issues"
-        log message, both: true
-
-        break unless next_page_token
-      end
-    else
-      max_results = 100
-      start_at = 0
-      total = 1
-      while start_at < total
-        json = @jira_gateway.call_url relative_url: '/rest/api/2/search' \
-          "?jql=#{escaped_jql}&maxResults=#{max_results}&startAt=#{start_at}&expand=changelog&fields=*all"
-
-        json['issues'].each do |issue_json|
-          issue_json['exporter'] = {
-            'in_initial_query' => initial_query
-          }
-          identify_other_issues_to_be_downloaded raw_issue: issue_json, board: board
-          file = "#{issue_json['key']}-#{board.id}.json"
-
-          @file_system.save_json(json: issue_json, filename: File.join(path, file))
-        end
-
-        total = json['total'].to_i
-        max_results = json['maxResults']
-
-        message = "    Downloaded #{start_at + 1}-#{[start_at + max_results, total].min} of #{total} issues to #{path} "
-        log message, both: true
-
-        start_at += json['issues'].size
-      end
-    end
-  end
-
   def identify_other_issues_to_be_downloaded raw_issue:, board:
     issue = Issue.new raw: raw_issue, board: board
     @issue_keys_downloaded_in_current_run << issue.key
@@ -178,6 +115,8 @@ class Downloader
   end
 
   def download_users
+    return unless @jira_gateway.cloud?
+
     log '  Downloading all users', both: true
     json = @jira_gateway.call_url relative_url: '/rest/api/2/users'
 
@@ -327,11 +266,7 @@ class Downloader
 
     if start_date
       @download_date_range = start_date..today.to_date
-
-      # For an incremental download, we want to query from the end of the previous one, not from the
-      # beginning of the full range.
-      @start_date_in_query = metadata['date_end'] || @download_date_range.begin
-      log "    Incremental download only. Pulling from #{@start_date_in_query}", both: true if metadata['date_end']
+      @start_date_in_query = @download_date_range.begin
 
       # Catch-all to pick up anything that's been around since before the range started but hasn't
       # had an update during the range.

data/lib/jirametrics/downloader_for_cloud.rb

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+class DownloaderForCloud < Downloader
+  def jira_instance_type
+    'Jira Cloud'
+  end
+
+  def search_for_issues jql:, board_id:, path:
+    log "  JQL: #{jql}"
+    escaped_jql = CGI.escape jql
+
+    hash = {}
+    max_results = 5_000 # The maximum allowed by Jira
+    next_page_token = nil
+    issue_count = 0
+
+    loop do
+      relative_url = +''
+      relative_url << '/rest/api/3/search/jql'
+      relative_url << "?jql=#{escaped_jql}&maxResults=#{max_results}"
+      relative_url << "&nextPageToken=#{next_page_token}" if next_page_token
+      relative_url << '&fields=updated'
+
+      json = @jira_gateway.call_url relative_url: relative_url
+      next_page_token = json['nextPageToken']
+
+      json['issues'].each do |i|
+        key = i['key']
+        data = DownloadIssueData.new key: key
+        data.key = key
+        data.last_modified = Time.parse i['fields']['updated']
+        data.found_in_primary_query = true
+        data.cache_path = File.join(path, "#{key}-#{board_id}.json")
+        data.up_to_date = last_modified(filename: data.cache_path) == data.last_modified
+        hash[key] = data
+        issue_count += 1
+      end
+
+      message = "    Found #{issue_count} issues"
+      log message, both: true
+
+      break unless next_page_token
+    end
+    hash
+  end
+
+  def bulk_fetch_issues issue_datas:, board:, in_initial_query:
+    # We used to use the expand option to pull in the changelog directly. Unfortunately
+    # that only returns the "recent" changes, not all of them. So now we get the issue
+    # without changes and then make a second call for that changes. Then we insert it
+    # into the raw issue as if it had been there all along.
+    log "  Downloading #{issue_datas.size} issues", both: true
+    payload = {
+      'fields' => ['*all'],
+      'issueIdsOrKeys' => issue_datas.collect(&:key)
+    }
+    response = @jira_gateway.post_request(
+      relative_url: '/rest/api/3/issue/bulkfetch',
+      payload: JSON.generate(payload)
+    )
+
+    attach_changelog_to_issues issue_datas: issue_datas, issue_jsons: response['issues']
+
+    response['issues'].each do |issue_json|
+      issue_json['exporter'] = {
+        'in_initial_query' => in_initial_query
+      }
+      issue = Issue.new(raw: issue_json, board: board)
+      data = issue_datas.find { |d| d.key == issue.key }
+      data.up_to_date = true
+      data.last_modified = issue.updated
+      data.issue = issue
+    end
+
+    issue_datas
+  end
+
+  def attach_changelog_to_issues issue_datas:, issue_jsons:
+    max_results = 10_000 # The max jira accepts is 10K
+    payload = {
+      'issueIdsOrKeys' => issue_datas.collect(&:key),
+      'maxResults' => max_results
+    }
+    loop do
+      response = @jira_gateway.post_request(
+        relative_url: '/rest/api/3/changelog/bulkfetch',
+        payload: JSON.generate(payload)
+      )
+
+      response['issueChangeLogs'].each do |issue_change_log|
+        issue_id = issue_change_log['issueId']
+        json = issue_jsons.find { |json| json['id'] == issue_id }
+
+        unless json['changelog']
+          # If this is our first time in, there won't be a changelog section
+          json['changelog'] = {
+            'startAt' => 0,
+            'maxResults' => max_results,
+            'total' => 0,
+            'histories' => []
+          }
+        end
+
+        new_changes = issue_change_log['changeHistories']
+        json['changelog']['total'] += new_changes.size
+        json['changelog']['histories'] += new_changes
+      end
+
+      next_page_token = response['nextPageToken']
+      payload['nextPageToken'] = next_page_token
+      break if next_page_token.nil?
+    end
+  end
+
+  def download_issues board:
+    log "  Downloading primary issues for board #{board.id} from #{jira_instance_type}", both: true
+    path = File.join(@target_path, "#{file_prefix}_issues/")
+    unless @file_system.dir_exist?(path)
+      log "  Creating path #{path}"
+      @file_system.mkdir(path)
+    end
+
+    filter_id = @board_id_to_filter_id[board.id]
+    jql = make_jql(filter_id: filter_id)
+    intercept_jql = @download_config.project_config.settings['intercept_jql']
+    jql = intercept_jql.call jql if intercept_jql
+
+    issue_data_hash = search_for_issues jql: jql, board_id: board.id, path: path
+
+    loop do
+      related_issue_keys = Set.new
+      issue_data_hash
+        .values
+        .reject { |data| data.up_to_date }
+        .each_slice(100) do |slice|
+          slice = bulk_fetch_issues(
+            issue_datas: slice, board: board, in_initial_query: true
+          )
+          slice.each do |data|
+            @file_system.save_json(
+              json: data.issue.raw, filename: data.cache_path
+            )
+            # Set the timestamp on the file to match the updated one so that we don't have
+            # to parse the file just to find the timestamp
+            @file_system.utime time: data.issue.updated, file: data.cache_path
+
+            issue = data.issue
+            next unless issue
+
+            parent_key = issue.parent_key(project_config: @download_config.project_config)
+            related_issue_keys << parent_key if parent_key
+
+            # Sub-tasks
+            issue.raw['fields']['subtasks']&.each do |raw_subtask|
+              related_issue_keys << raw_subtask['key']
+            end
+          end
+        end
+
+      # Remove all the ones we already downloaded
+      related_issue_keys.reject! { |key| issue_data_hash[key] }
+
+      related_issue_keys.each do |key|
+        data = DownloadIssueData.new key: key
+        data.found_in_primary_query = false
+        data.up_to_date = false
+        data.cache_path = File.join(path, "#{key}-#{board.id}.json")
+        issue_data_hash[key] = data
+      end
+      break if related_issue_keys.empty?
+
+      log "  Downloading linked issues for board #{board.id}", both: true
+    end
+
+    delete_issues_from_cache_that_are_not_in_server(
+      issue_data_hash: issue_data_hash, path: path
+    )
+  end
+
+  def delete_issues_from_cache_that_are_not_in_server issue_data_hash:, path:
+    # The gotcha with deleted issues is that they just stop being returned in queries
+    # and we have no way to know that they should be removed from our local cache.
+    # With the new approach, we ask for every issue that Jira knows about (within
+    # the parameters of the query) and then delete anything that's in our local cache
+    # but wasn't returned.
+    @file_system.foreach path do |file|
+      next if file.start_with? '.'
+      unless /^(?<key>\w+-\d+)-\d+\.json$/ =~ file
+        raise "Unexpected filename in #{path}: #{file}"
+      end
+      next if issue_data_hash[key] # Still in Jira
+
+      file_to_delete = File.join(path, file)
+      log "  Removing #{file_to_delete} from local cache"
+      file_system.unlink file_to_delete
+    end
+  end
+
+  def last_modified filename:
+    File.mtime(filename) if File.exist?(filename)
+  end
+end