flaky-friend 0.3.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6216aed376755cc4ce188f8c5dc42b0146d1c7b3397c409c3eef9238eb8b987e
-  data.tar.gz: a41b69d5707e4fcb93ebb7bc4bfbefda33ce827c49475a1e8a5d0b85506cba18
+  metadata.gz: 002c918bce57180caeb36b4f4b3d22899a639c975417b6306ac1d771a74c593c
+  data.tar.gz: da819c2128568e5c84f016f841f914e679e169816da642423a4ddd3e48e59ab6
 SHA512:
-  metadata.gz: 7e1fd50da98dfafcf952f79c39b920e7b25e4d381c5f8e3a3afa5dd71cf2eb239a59933163abb7102345aa740aa2ec434b0e94d9e764ab233401cc389bea3ccf
-  data.tar.gz: 1b1f57e521913ff056e5c1732eccf76b5fe41b5ae66c25a830330fc01a2e7ad10b2a47d49d79ac211557ae634d86ca7305b67ff068474e34587d99f95d5c0a5e
+  metadata.gz: ab98c7c884c4a4984db1af236fa9f626d977a9c19aa563da5fd32c7df30c6a26cda2dd1bcd0127aaa06715e4792a5058091fb363bbbb38560f74a181e3710341
+  data.tar.gz: 0ff57b02a4dce8e319607ef90e3819247da560c8f74bc5ef68994bb156143d3d909020c9a79b96d82cd82b9704090daa0e10155241310122e8fdb2ad54325314

data/README.md

@@ -9,11 +9,11 @@ Flaky fetches test results from your CI provider, stores failures in a local SQL
 Add to your Gemfile:
 
 ```ruby
-# From GitHub
-gem 'flaky', github: 'Flytedesk/flaky', group: [:development, :test]
+# From RubyGems
+gem 'flaky-friend', group: [:development, :test]
 
 # Or from a local path during development
-gem 'flaky', path: '../flaky', group: [:development, :test]
+gem 'flaky-friend', path: '../flaky', group: [:development, :test]
 ```
 
 Then `bundle install`.
@@ -27,38 +27,42 @@ if defined?(Flaky)
   Flaky.configure do |c|
     c.provider = :semaphore        # or :github_actions
     c.project  = "my-project"      # CI project name
-    c.branch   = "main"            # branch to track
+    c.branch   = "main"            # branch to track, or :all for every branch
   end
 end
 ```
 
+`:all` gives a much larger sample: flakes on feature branches count too. `flaky:rank` then orders tests by how many distinct branches they failed on, so a test broken by one branch's work in progress (many failures, one branch) ranks below a test that fails on unrelated branches.
+
 ### Prerequisites by provider
 
-**Semaphore**: Install and authenticate the [`sem` CLI](https://docs.semaphoreci.com/reference/sem-command-line-tool/).
+**Semaphore**: Install the [`sem` CLI](https://docs.semaphoreci.com/reference/sem-command-line-tool/) and run `sem connect`. Flaky reads the host and API token of the active context from `~/.sem.yaml` and calls the Semaphore API directly. Server errors and timeouts are retried up to 3 times.
 
 **GitHub Actions**: Install and authenticate the [`gh` CLI](https://cli.github.com/).
 
 ## Rake Tasks
 
-### `rake flaky:fetch[age]`
+Tasks take environment variables rather than rake arguments (no zsh bracket escaping). `bin/rails flaky` prints help.
+
+### `bin/rails flaky:fetch DURATION=24h`
 
 Fetch recent CI results and store failures in the local database.
 
 ```sh
-rake flaky:fetch              # last 24 hours (default)
-rake flaky:fetch[168h]        # last 7 days
-rake flaky:fetch[2160h]       # last 90 days
+bin/rails flaky:fetch                  # last 24 hours (default)
+bin/rails flaky:fetch DURATION=7d      # last 7 days
+bin/rails flaky:fetch DURATION=90d     # last 90 days
 ```
 
-For each workflow on the configured branch, fetches all test job logs, parses RSpec output for failures and random seeds, and inserts new records into `tmp/flaky.db`.
+`DURATION` accepts `m`, `h`, or `d` suffixes. For each workflow on the configured branch, fetches the logs of failed test jobs, parses RSpec output for failures and random seeds, and inserts new records into `tmp/flaky.db`. Workflows already in the database are skipped. A workflow is stored together with all its jobs or not at all, so an interrupted fetch is picked up again by the next run.
 
-### `rake flaky:rank[since]`
+### `bin/rails flaky:rank SINCE=30`
 
-Rank flaky tests by failure frequency and suggest the next one to investigate.
+Rank flaky tests by the number of branches they failed on, then by failure count, and suggest the next one to investigate.
 
 ```sh
-rake flaky:rank               # last 30 days (default)
-rake flaky:rank[7]            # last 7 days
+bin/rails flaky:rank              # last 30 days (default)
+bin/rails flaky:rank SINCE=7      # last 7 days
 ```
 
 Output:
@@ -66,50 +70,51 @@ Output:
 ```
 Flaky tests on main (last 30 days, 42 CI runs):
 
-Fails  Location                                           Last Failure
-------------------------------------------------------------------------------------------
-5      ...spec/system/inventory_search_modal_spec.rb:83    2026-04-12 09:15:22
+Fails  Branches  Location
+----------------------------------------------------------------------------------------------------
+5      3         ...spec/system/inventory_search_modal_spec.rb:83  (2026-04-12 09:15:22)
 
   > Next to investigate: packs/.../inventory_search_modal_spec.rb:83
     Inventory search modal filters by enrollment
     Seeds: 6432, 51203, 8891
 ```
 
-### `rake flaky:history[spec_location]`
+### `bin/rails flaky:history SPEC=path/to/spec.rb:42`
 
 Show the full failure timeline for a specific test, including every seed and CI job it failed in.
 
 ```sh
-rake flaky:history[inventory_search_modal_spec.rb:83]
-rake flaky:history[inventory_search_modal_spec.rb]     # all failures in this file
+bin/rails flaky:history SPEC=inventory_search_modal_spec.rb:83
+bin/rails flaky:history SPEC=inventory_search_modal_spec.rb     # all failures in this file
 ```
 
-### `rake flaky:stress[spec,iterations,seed,ci]`
+### `bin/rails flaky:stress SPEC=... N=20 SEED=... CI=true TIMEOUT=600`
 
 Run a test repeatedly to reproduce a flaky failure or prove a fix is stable.
 
 ```sh
-# 20 iterations with random seeds
-rake flaky:stress[path/to/spec.rb:83]
+# 20 iterations with the seed it most often failed with on CI
+bin/rails flaky:stress SPEC=path/to/spec.rb:83
 
 # 50 iterations with a specific seed and CI simulation
-rake flaky:stress[path/to/spec.rb:83,50,6432,true]
+bin/rails flaky:stress SPEC=path/to/spec.rb:83 N=50 SEED=6432 CI=true
 ```
 
-Arguments:
-- `spec` (required) -- spec file path, optionally with line number
-- `iterations` -- number of runs (default: 20)
-- `seed` -- RSpec random seed; omit for random each run
-- `ci` -- `true` to enable CI environment simulation (default: false)
+Variables:
+- `SPEC` (required) -- spec file path, optionally with line number
+- `N` -- number of runs (default: 20)
+- `SEED` -- RSpec random seed; omit to use the most frequent failing seed from the database (random if none), `random` for a new seed each run
+- `CI` -- `true` to enable CI environment simulation (default: false)
+- `TIMEOUT` -- total seconds; no new iteration starts after this (default: 600)
 
-Results are recorded to the database and shown in `rake flaky:report`.
+Results are recorded to the database and shown in `bin/rails flaky:report`.
 
-### `rake flaky:report`
+### `bin/rails flaky:report`
 
 Summary dashboard showing overall flaky test health.
 
 ```sh
-rake flaky:report
+bin/rails flaky:report
 ```
 
 Output:
@@ -138,7 +143,7 @@ Recent stress runs:
 
 ## CI Simulation
 
-When `ci=true` is passed to `rake flaky:stress`, the gem simulates CI environment constraints:
+When `CI=true` is passed to `bin/rails flaky:stress`, the gem simulates CI environment constraints:
 
 1. **Rack middleware latency** -- adds 30ms delay per HTTP request (approximates the difference between a Mac and an f1-standard-2 CI machine). Configurable via `FLAKY_LATENCY_MS` env var.
 
@@ -171,11 +176,11 @@ To add a CI provider, implement the three-method interface and register it:
 ```ruby
 class Flaky::Providers::CircleCI < Flaky::Providers::Base
   def fetch_workflows(age: "24h")
-    # Return [{ id:, pipeline_id:, branch:, created_at: }, ...]
+    # Return [{ id:, pipeline_id:, branch:, commit_sha:, created_at: }, ...]
   end
 
   def fetch_jobs(pipeline_id:)
-    # Return [{ id:, name:, block_name:, result: }, ...]
+    # Return [{ id:, name:, block_name:, result: }, ...]  (result: "passed" / "failed")
   end
 
   def fetch_log(job_id:)
@@ -192,22 +197,22 @@ The log parser is CI-agnostic -- it extracts failures, seeds, and counts from st
 
 ```sh
 # 1. Fetch recent CI data
-rake flaky:fetch[168h]
+bin/rails flaky:fetch DURATION=7d
 
 # 2. See what's flaky
-rake flaky:rank
+bin/rails flaky:rank
 
 # 3. Investigate the top offender
-rake flaky:history[the_flaky_spec.rb:42]
+bin/rails flaky:history SPEC=the_flaky_spec.rb:42
 
 # 4. Try to reproduce it locally with CI simulation
-rake flaky:stress[the_flaky_spec.rb:42,30,6432,true]
+bin/rails flaky:stress SPEC=the_flaky_spec.rb:42 N=30 SEED=6432 CI=true
 
 # 5. Fix the test, then prove the fix holds
-rake flaky:stress[the_flaky_spec.rb:42,50,,true]
+bin/rails flaky:stress SPEC=the_flaky_spec.rb:42 N=50 SEED=random CI=true
 
 # 6. Check overall health
-rake flaky:report
+bin/rails flaky:report
 ```
 
 ## License

data/lib/flaky/commands/fetch.rb

@@ -56,19 +56,26 @@ module Flaky
         $stdout.flush
 
         jobs = provider.fetch_jobs(pipeline_id: wf[:pipeline_id])
-        pipeline_result = jobs.any? { |j| j[:result] == "failed" } ? "failed" : "passed"
+        results = jobs.map { |j| j[:result] }
 
-        @repo.insert_ci_run(
-          workflow_id: wf[:id], pipeline_id: wf[:pipeline_id],
-          branch: wf[:branch], result: pipeline_result, created_at: wf[:created_at],
-          commit_sha: wf[:commit_sha]
-        )
+        if results.include?(nil)
+          puts "still running, skipped"
+          return [0, 0]
+        end
+
+        pipeline_result = %w[failed stopped].find { |r| results.include?(r) } || "passed"
 
         puts "#{jobs.length} test jobs (#{pipeline_result})"
 
-        failures = 0
-        jobs.each_with_index do |job, ji|
-          failures += process_job(provider, job, wf, ji, jobs.length)
+        # All or nothing: a workflow in ci_runs counts as fetched and is never revisited.
+        failures = @repo.transaction do
+          @repo.insert_ci_run(
+            workflow_id: wf[:id], pipeline_id: wf[:pipeline_id],
+            branch: wf[:branch], result: pipeline_result, created_at: wf[:created_at],
+            commit_sha: wf[:commit_sha]
+          )
+
+          jobs.each_with_index.sum { |job, ji| process_job(provider, job, wf, ji, jobs.length) }
         end
 
         [jobs.length, failures]
@@ -78,12 +85,13 @@ module Flaky
         print "    [#{index + 1}/#{total}] #{job[:name]}... "
         $stdout.flush
 
-        log = provider.fetch_log(job_id: job[:id])
+        # Only failed jobs have failures to record; passed-job logs are large and slow to fetch.
+        log = job[:result] == "failed" ? provider.fetch_log(job_id: job[:id]) : ""
         parsed = @parser.parse(log)
 
         @repo.insert_job_result(
           job_id: job[:id], workflow_id: wf[:id], job_name: job[:name],
-          block_name: job[:block_name], result: parsed.failure_count.to_i > 0 ? "failed" : "passed",
+          block_name: job[:block_name], result: job[:result],
           example_count: parsed.example_count, failure_count: parsed.failure_count,
           seed: parsed.seed, duration_seconds: parsed.duration_seconds
         )
@@ -99,8 +107,14 @@ module Flaky
           end
           puts "\e[31m#{parsed.failures.length} failure(s)\e[0m"
           parsed.failures.length
+        elsif job[:result] == "failed"
+          puts "\e[31mfailed\e[0m (no RSpec failures in log)"
+          0
+        elsif job[:result] == "stopped"
+          puts "\e[33mstopped\e[0m"
+          0
         else
-          puts "\e[32mok\e[0m (#{parsed.example_count} examples)"
+          puts "\e[32mok\e[0m"
           0
         end
       end

data/lib/flaky/commands/rank.rb

@@ -24,13 +24,12 @@ module Flaky
         total_runs = @repo.total_runs_count(branch: branch, since_days: @since_days)
 
         puts "Flaky tests on #{branch} (last #{@since_days} days, #{total_runs} CI runs):\n\n"
-        puts format("%-6s %-50s %s", "Fails", "Location", "Last Failure")
-        puts "-" * 90
+        puts format("%-6s %-9s %s", "Fails", "Branches", "Location")
+        puts "-" * 100
 
         rows.each_with_index do |row, i|
           location = "#{row['spec_file']}:#{row['line_number']}"
-          truncated = location.length > 48 ? "...#{location[-45..]}" : location
-          puts format("%-6d %-50s %s", row["failure_count"], truncated, row["last_failure"])
+          puts format("%-6d %-9d %s  (%s)", row["failure_count"], row["branch_count"], location, row["last_failure"])
 
           if i == 0
             puts "\n  \e[33m▶ Next to investigate:\e[0m #{location}"

data/lib/flaky/commands/stress.rb

@@ -18,14 +18,14 @@ module Flaky
         env = {}
         env["FLAKY_CI_SIMULATE"] = "1" if @ci_simulate
 
-        seeds = resolve_seeds
+        seed = resolve_seed
         passes = 0
         failures = 0
-        failed_seeds = []
+        failed_seeds = Set.new
         start_time = Time.now
 
         puts "Stress testing: #{@spec_location}"
-        puts "  Iterations: #{@iterations}, Seeds: #{seed_description(seeds)}, CI simulation: #{@ci_simulate}"
+        puts "  Iterations: #{@iterations}, Seed: #{seed_description(seed)}, CI simulation: #{@ci_simulate}"
         puts ""
 
         @iterations.times do |i|
@@ -35,7 +35,7 @@ module Flaky
             break
           end
 
-          run_seed = seeds ? seeds[i % seeds.length] : rand(100_000)
+          run_seed = seed.presence || rand(100_000)
           cmd = "bundle exec rspec #{@spec_location} --seed #{run_seed} --format progress 2>&1"
 
           output = nil
@@ -51,7 +51,7 @@ module Flaky
             print "\e[32m.\e[0m"
           else
             failures += 1
-            failed_seeds << run_seed
+            failed_seeds.add(run_seed)
             print "\e[31mF\e[0m"
           end
         end
@@ -81,30 +81,24 @@ module Flaky
 
       private
 
-      def resolve_seeds
+      def resolve_seed
         case @seed
         when :random
           nil
         when Integer
-          [@seed]
+          @seed
         when nil
           file, line = parse_location(@spec_location)
           db_seeds = @repo.failing_seeds(file: file, line: line)
-          if db_seeds.any?
-            puts "Found #{db_seeds.length} known failing seed(s): #{db_seeds.join(', ')}"
-            db_seeds
-          else
-            puts "No known failing seeds — using random."
-            nil
-          end
+          db_seeds.any? ? db_seeds.first : nil
         end
       end
 
-      def seed_description(seeds)
+      def seed_description(seed)
         case @seed
         when :random then "random"
         when Integer then @seed.to_s
-        else seeds ? "#{seeds.length} from database" : "random"
+        else seed.present? ? seed.to_s : "random (no known failing seeds)"
         end
       end
 

data/lib/flaky/configuration.rb

@@ -14,6 +14,11 @@ module Flaky
       @test_blocks = ["Unit Tests", "System Tests"]
     end
 
+    # `branch = :all` tracks every branch instead of one.
+    def all_branches?
+      branch == :all
+    end
+
     def provider=(name)
       @provider_name = name.to_sym
     end

data/lib/flaky/providers/github_actions.rb

@@ -10,7 +10,8 @@ module Flaky
       def fetch_workflows(age: "24h")
         cutoff = Time.now - AgeParser.to_seconds(age)
 
-        output = run_cmd("gh run list --branch #{config.branch} --limit 100 --json databaseId,conclusion,createdAt,headBranch,headSha,workflowName")
+        branch_flag = config.all_branches? ? "" : "--branch #{config.branch} "
+        output = run_cmd("gh run list #{branch_flag}--limit 100 --json databaseId,conclusion,createdAt,headBranch,headSha,workflowName")
         runs = JSON.parse(output)
 
         runs.filter_map do |run|
@@ -61,7 +62,7 @@ module Flaky
         case conclusion
         when "success" then "passed"
         when "failure" then "failed"
-        else conclusion || "unknown"
+        else conclusion # nil while in progress
         end
       end
     end

data/lib/flaky/providers/semaphore.rb

@@ -10,21 +10,24 @@ require_relative "../age_parser"
 module Flaky
   module Providers
     class Semaphore < Base
+      MAX_ATTEMPTS = 3
+
+      # Semaphore intermittently answers 500/504; worth another try.
+      class TransientError < Error; end
+
       def fetch_workflows(age: "24h")
         cutoff = Time.now - AgeParser.to_seconds(age)
         project_id = resolve_project_id
-        branch = config.branch
+        branch_filter = config.all_branches? ? {} : { branch_name: config.branch }
         workflows = []
 
         page = 1
         loop do
-          data = api_get("plumber-workflows", project_id: project_id, page: page)
+          data = api_get("plumber-workflows", project_id: project_id, **branch_filter, page: page)
           break if data.empty?
 
           data.each do |wf|
             created_at = Time.at(wf.dig("created_at", "seconds").to_i)
-            next unless wf["branch_name"] == branch
-
             if created_at < cutoff
               return workflows # older than cutoff, done
             end
@@ -62,7 +65,7 @@ module Flaky
               id: job["job_id"],
               name: job["name"],
               block_name: block_name,
-              result: job["result"]&.downcase == "passed" ? "passed" : "failed"
+              result: job["result"]&.downcase # passed, failed, stopped; nil while running
             }
           end
         end
@@ -80,7 +83,7 @@ module Flaky
       private
 
       def api_get(path, **params)
-        query = params.map { |k, v| "#{k}=#{v}" }.join("&")
+        query = URI.encode_www_form(params)
         url = "#{api_host}/api/v1alpha/#{path}"
         url += "?#{query}" unless query.empty?
 
@@ -88,15 +91,24 @@ module Flaky
         req = Net::HTTP::Get.new(uri)
         req["Authorization"] = "Token #{api_token}"
 
-        response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
-          http.request(req)
-        end
+        attempt = 1
+        begin
+          response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
+            http.request(req)
+          end
+
+          message = "Semaphore API error (#{response.code}): #{response.body[0..200]}"
+          raise TransientError, message if response.is_a?(Net::HTTPServerError)
+          raise Error, message unless response.is_a?(Net::HTTPSuccess)
 
-        raise Error, "Semaphore API error (#{response.code}): #{response.body[0..200]}" unless response.is_a?(Net::HTTPSuccess)
+          JSON.parse(response.body)
+        rescue TransientError, Net::OpenTimeout, Net::ReadTimeout => e
+          raise Error, "#{e.message} (gave up after #{attempt} attempts)" if attempt >= MAX_ATTEMPTS
 
-        JSON.parse(response.body)
-      rescue Net::OpenTimeout, Net::ReadTimeout => e
-        raise Error, "Semaphore API timeout: #{e.message}"
+          sleep(2**attempt)
+          attempt += 1
+          retry
+        end
       rescue SocketError => e
         raise Error, "Cannot reach Semaphore API: #{e.message}"
       rescue Errno::ECONNREFUSED => e

data/lib/flaky/repository.rb

@@ -12,6 +12,10 @@ module Flaky
       @db.close
     end
 
+    def transaction(&)
+      connection.transaction(&)
+    end
+
     # --- CI Runs ---
 
     def workflow_fetched?(workflow_id)
@@ -46,29 +50,31 @@ module Flaky
     # --- Ranking ---
 
     def rank_failures(branch:, since_days:, min_failures: 1)
-      connection.execute(<<~SQL, [branch, "-#{since_days} days", min_failures])
+      connection.execute(<<~SQL, [branch_param(branch), "-#{since_days} days", min_failures])
         SELECT
           tf.spec_file,
           tf.line_number,
           tf.description,
           COUNT(*) as failure_count,
+          COUNT(DISTINCT tf.branch) as branch_count,
           MAX(tf.failed_at) as last_failure,
           GROUP_CONCAT(DISTINCT tf.seed) as seeds,
           GROUP_CONCAT(DISTINCT cr.commit_sha) as commit_shas
         FROM test_failures tf
         JOIN ci_runs cr ON cr.workflow_id = tf.workflow_id
-        WHERE cr.branch = ?
-          AND cr.created_at >= datetime('now', ?)
+        WHERE (?1 IS NULL OR cr.branch = ?1)
+          AND cr.created_at >= datetime('now', ?2)
         GROUP BY tf.spec_file, tf.line_number
-        HAVING COUNT(*) >= ?
-        ORDER BY failure_count DESC, last_failure DESC
+        HAVING COUNT(*) >= ?3
+        -- A flake fails on unrelated branches; a branch's own regression fails only there.
+        ORDER BY branch_count DESC, failure_count DESC, last_failure DESC
       SQL
     end
 
     def total_runs_count(branch:, since_days:)
       connection.get_first_value(
-        "SELECT COUNT(DISTINCT workflow_id) FROM ci_runs WHERE branch = ? AND created_at >= datetime('now', ?)",
-        [branch, "-#{since_days} days"]
+        "SELECT COUNT(DISTINCT workflow_id) FROM ci_runs WHERE (?1 IS NULL OR branch = ?1) AND created_at >= datetime('now', ?2)",
+        [branch_param(branch), "-#{since_days} days"]
       ).to_i
     end
 
@@ -104,23 +110,25 @@ module Flaky
     # --- Report ---
 
     def run_stats(branch:)
+      branch = branch_param(branch)
       {
-        total_runs: connection.get_first_value("SELECT COUNT(*) FROM ci_runs WHERE branch = ?", branch).to_i,
-        failed_runs: connection.get_first_value("SELECT COUNT(*) FROM ci_runs WHERE branch = ? AND result = 'failed'", branch).to_i,
-        total_failures: connection.get_first_value("SELECT COUNT(*) FROM test_failures WHERE branch = ?", branch).to_i,
-        unique_specs: connection.get_first_value("SELECT COUNT(DISTINCT spec_file || ':' || line_number) FROM test_failures WHERE branch = ?", branch).to_i,
+        total_runs: connection.get_first_value("SELECT COUNT(*) FROM ci_runs WHERE (?1 IS NULL OR branch = ?1)", branch).to_i,
+        failed_runs: connection.get_first_value("SELECT COUNT(*) FROM ci_runs WHERE (?1 IS NULL OR branch = ?1) AND result = 'failed'", branch).to_i,
+        total_failures: connection.get_first_value("SELECT COUNT(*) FROM test_failures WHERE (?1 IS NULL OR branch = ?1)", branch).to_i,
+        unique_specs: connection.get_first_value("SELECT COUNT(DISTINCT spec_file || ':' || line_number) FROM test_failures WHERE (?1 IS NULL OR branch = ?1)", branch).to_i,
         last_fetch: connection.get_first_value("SELECT MAX(fetched_at) FROM ci_runs")
       }
     end
 
     def failure_trend(branch:, period_days: 7)
+      branch = branch_param(branch)
       recent = connection.get_first_value(
-        "SELECT COUNT(*) FROM test_failures WHERE branch = ? AND failed_at >= datetime('now', ?)",
+        "SELECT COUNT(*) FROM test_failures WHERE (?1 IS NULL OR branch = ?1) AND failed_at >= datetime('now', ?2)",
         [branch, "-#{period_days} days"]
       ).to_i
 
       prior = connection.get_first_value(
-        "SELECT COUNT(*) FROM test_failures WHERE branch = ? AND failed_at >= datetime('now', ?) AND failed_at < datetime('now', ?)",
+        "SELECT COUNT(*) FROM test_failures WHERE (?1 IS NULL OR branch = ?1) AND failed_at >= datetime('now', ?2) AND failed_at < datetime('now', ?3)",
         [branch, "-#{period_days * 2} days", "-#{period_days} days"]
       ).to_i
 
@@ -128,7 +136,7 @@ module Flaky
     end
 
     def top_flaky(branch:, limit: 5)
-      connection.execute(<<~SQL, [branch, limit])
+      connection.execute(<<~SQL, [branch_param(branch), limit])
         SELECT
           spec_file,
           line_number,
@@ -136,10 +144,10 @@ module Flaky
           COUNT(*) as failure_count,
           MAX(failed_at) as last_failure
         FROM test_failures
-        WHERE branch = ?
+        WHERE (?1 IS NULL OR branch = ?1)
         GROUP BY spec_file, line_number
         ORDER BY failure_count DESC
-        LIMIT ?
+        LIMIT ?2
       SQL
     end
 
@@ -159,7 +167,7 @@ module Flaky
       end
 
       connection.execute(
-        "SELECT DISTINCT seed FROM test_failures WHERE #{conditions.join(' AND ')} ORDER BY failed_at DESC",
+        "SELECT seed, COUNT(*) AS n FROM test_failures WHERE #{conditions.join(' AND ')} GROUP BY seed ORDER BY n DESC, MAX(failed_at) DESC",
         params
       ).map { |row| row["seed"] }
     end
@@ -175,6 +183,11 @@ module Flaky
 
     private
 
+    # SQL NULL matches every branch; see Configuration#all_branches?.
+    def branch_param(branch)
+      branch == :all ? nil : branch
+    end
+
     def connection
       @db.connection
     end

data/lib/flaky/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Flaky
-  VERSION = "0.3.1"
+  VERSION = "0.4.0"
 end

data/lib/flaky-friend.rb

@@ -1,5 +1,9 @@
 # frozen_string_literal: true
 
+module Flaky
+  class Error < StandardError; end
+end
+
 require_relative "flaky/version"
 require_relative "flaky/configuration"
 require_relative "flaky/age_parser"
@@ -8,8 +12,6 @@ require_relative "flaky/providers/github_actions"
 require_relative "flaky/railtie" if defined?(Rails::Railtie)
 
 module Flaky
-  class Error < StandardError; end
-
   class << self
     def configuration
       @configuration ||= Configuration.new

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: flaky-friend
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.0
 platform: ruby
 authors:
 - Flytedesk
@@ -109,7 +109,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.16
 specification_version: 4
 summary: Track, rank, and reproduce flaky CI test failures
 test_files: []