+ + <%# The revision query parameter is kept for machine clients (planned MCP + server) but intentionally has no visible form field. %> + <%= hidden_field_tag :revision, @revision if @revision.present? %> + <%= submit_tag "Search" %> +
++ + + + +
+<% end %> + +<% if @searched %> + <% if @reports.empty? %> +No matching failure logs found<%= " on page #{@page}" if @page > 1 %>.
+ <% else %> +| Server | +Datetime | +Branch | +Option | +Revision | +Summary | +Match | +Diff | +
|---|---|---|---|---|---|---|---|
| <%= report.server.name %> | +<%= link_to report.sjstdt, report.loguri, title: report.jstdt %> | +<%= report.branch %> | +<%= report.option %> | +<%= revision_link %> | +<%= link_to report.shortsummary, failuri, title: report.shortsummary %> |
+ <%= snippet %> |
+ <%= link_to report.diffstat, report.diffuri, title: report.diffstat %> |
+
+ <% if @page > 1 %> + <%= link_to "Prev", search_path(request.query_parameters.merge("page" => @page - 1)) %> + <% end %> + <% if @has_next %> + <%= link_to "Next", search_path(request.query_parameters.merge("page" => @page + 1)) %> + <% end %> +
+ <% end %> +<% else %> +Search the excerpted fail/diff logs of failed builds. Datetimes are UTC.
+<% end %> diff --git a/config/routes.rb b/config/routes.rb index 018709d00..15bc4a4a6 100644 --- a/config/routes.rb +++ b/config/routes.rb @@ -1,6 +1,8 @@ Rails.application.routes.draw do root :to => 'reports#current' + get "search" => "search#index" + resources :reports, only: [:show, :index] do collection do get "current" diff --git a/db/migrate/20260728023000_create_log_excerpts.rb b/db/migrate/20260728023000_create_log_excerpts.rb new file mode 100644 index 000000000..6c418e075 --- /dev/null +++ b/db/migrate/20260728023000_create_log_excerpts.rb @@ -0,0 +1,18 @@ +class CreateLogExcerpts < ActiveRecord::Migration[8.1] + def change + create_table :log_excerpts do |t| + t.integer :report_id, null: false + t.text :content, null: false + t.timestamps + t.index [:report_id], unique: true + end + add_foreign_key :log_excerpts, :reports + + # pg_trgm and GIN index are PostgreSQL-only; development and test run on SQLite + if connection.adapter_name == "PostgreSQL" + enable_extension "pg_trgm" + add_index :log_excerpts, :content, using: :gin, opclass: :gin_trgm_ops, + name: "index_log_excerpts_on_content_trgm" + end + end +end diff --git a/db/schema.rb b/db/schema.rb index 600b9eb82..af1dd98fe 100644 --- a/db/schema.rb +++ b/db/schema.rb @@ -10,9 +10,10 @@ # # It's strongly recommended that you check this file into your version control system. -ActiveRecord::Schema[8.1].define(version: 2026_07_27_095902) do +ActiveRecord::Schema[8.1].define(version: 2026_07_28_023000) do # These are extensions that must be enabled in order to support this database enable_extension "pg_catalog.plpgsql" + enable_extension "pg_trgm" create_table "active_storage_attachments", force: :cascade do |t| t.bigint "blob_id", null: false @@ -42,6 +43,15 @@ t.index ["blob_id", "variation_digest"], name: "index_active_storage_variant_records_uniqueness", unique: true end + create_table "log_excerpts", force: :cascade do |t| + t.text "content", null: false + t.datetime "created_at", null: false + t.integer "report_id", null: false + t.datetime "updated_at", null: false + t.index ["content"], name: "index_log_excerpts_on_content_trgm", opclass: :gin_trgm_ops, using: :gin + t.index ["report_id"], name: "index_log_excerpts_on_report_id", unique: true + end + create_table "recents", force: :cascade do |t| t.datetime "created_at", null: false t.string "etag", null: false @@ -63,7 +73,7 @@ t.datetime "updated_at", precision: nil t.index ["branch"], name: "index_reports_on_branch" t.index ["datetime"], name: "index_reports_on_datetime" - t.index ["revision"], name: "index_reports_on_revision", opclass: :varchar_pattern_ops + t.index ["revision"], name: "index_reports_on_revision" t.index ["server_id", "branch", "option"], name: "index_reports_on_server_id_and_branch_and_option" end @@ -79,5 +89,6 @@ add_foreign_key "active_storage_attachments", "active_storage_blobs", column: "blob_id" add_foreign_key "active_storage_variant_records", "active_storage_blobs", column: "blob_id" + add_foreign_key "log_excerpts", "reports" add_foreign_key "recents", "servers" end diff --git a/lib/tasks/log_excerpts.rake b/lib/tasks/log_excerpts.rake new file mode 100644 index 000000000..1f177a087 --- /dev/null +++ b/lib/tasks/log_excerpts.rake @@ -0,0 +1,93 @@ +module LogExcerptTaskEnv + module_function + + # UTC to match reports.datetime, which Report.scan_recent_ltsv stores as UTC. + def time(key, default) + value = ENV[key].presence or return default + date = begin + Date.strptime(value, "%Y-%m-%d") + rescue Date::Error + abort "#{key} must be a date like 2026-07-20 (UTC), got #{value.inspect}" + end + Time.utc(date.year, date.month, date.day) + end + + def integer(key, default) + value = ENV[key].presence or return default + Integer(value) rescue abort("#{key} must be an integer, got #{value.inspect}") + end + + def float(key, default) + value = ENV[key].presence or return default + Float(value) rescue abort("#{key} must be a number of seconds, got #{value.inspect}") + end +end + +namespace :log_excerpts do + desc "Backfill log excerpts from S3. FROM/TO (UTC date, default last 1 year), START_ID to force resume point, SLEEP seconds between reports (default 0.1), FORCE=1 to refetch reports that already have an excerpt" + task :backfill => :environment do + from = LogExcerptTaskEnv.time("FROM", 1.year.ago) + to = LogExcerptTaskEnv.time("TO", Time.now) + interval = LogExcerptTaskEnv.float("SLEEP", 0.1) + start_id = LogExcerptTaskEnv.integer("START_ID", nil) + + scope = Report.joins(:server). + where(datetime: from..to). + where.not(ltsv: nil). + where("ltsv NOT LIKE '%result:success%'"). + where("servers.uri LIKE 'https://rubyci.s3.amazonaws.com/%'") + + # Resume by skipping reports that already have an excerpt. Using the max + # captured report_id instead would skip everything, because scan_recent_ltsv + # captures new failures as they arrive and that id is always the newest one. + scope = scope.where.missing(:log_excerpt) unless ENV["FORCE"] + scope = scope.where("reports.id > ?", start_id) if start_id + + total = scope.count + puts "backfilling #{total} reports (datetime #{from}..#{to}, sleep #{interval}s#{start_id ? ", report_id > #{start_id}" : ""}#{ENV["FORCE"] ? ", forced" : ""})" + + started = Time.now + captured = empty = failed = 0 + failed_ids = [] + scope.includes(:server).find_each(batch_size: 100) do |report| + begin + excerpt = LogExcerpt.capture(report) + excerpt&.content.presence ? captured += 1 : empty += 1 + rescue => e + failed += 1 + failed_ids << report.id + warn "report #{report.id} (#{report.failtxt_uri}): #{e.class}: #{e.message}" + end + done = captured + empty + failed + puts "#{done}/#{total} (report_id=#{report.id}, #{(Time.now - started).round}s elapsed)" if done % 100 == 0 + sleep interval + end + + puts "done in #{(Time.now - started).round}s: #{captured} captured, #{empty} empty, #{failed} failed" + unless failed.zero? + warn "failed report ids: #{failed_ids.join(", ")}" + abort "backfill finished with #{failed} failures" + end + end + + desc "Delete log excerpts whose report datetime is older than KEEP_DAYS (default 366) days. DRY_RUN=1 to only count." + task :prune => :environment do + keep_days = LogExcerptTaskEnv.integer("KEEP_DAYS", 366) + abort "KEEP_DAYS must be at least 1, got #{keep_days}" if keep_days < 1 + cutoff = keep_days.days.ago + scope = LogExcerpt.where(report_id: Report.where("datetime < ?", cutoff).select(:id)) + + if ENV["DRY_RUN"] + puts "would delete #{scope.count} log excerpts of reports older than #{cutoff}" + next + end + + deleted = 0 + scope.in_batches(of: 10_000) do |batch| + deleted += batch.delete_all + puts "deleted #{deleted} ..." + end + puts "deleted #{deleted} log excerpts of reports older than #{cutoff}" + puts "note: disk space returns via autovacuum; VACUUM FULL is needed to reclaim it immediately" + end +end diff --git a/test/controllers/search_controller_test.rb b/test/controllers/search_controller_test.rb new file mode 100644 index 000000000..4fb2b7cb5 --- /dev/null +++ b/test/controllers/search_controller_test.rb @@ -0,0 +1,72 @@ +require "test_helper" + +class SearchControllerTest < ActionDispatch::IntegrationTest + SHA = "abcdef0123456789abcdef0123456789abcdef01" + + setup do + @server = Server.create!(name: "search-srv", uri: "https://rubyci.s3.amazonaws.com/search-srv/", ordinal: 999) + @report = Report.create!( + server: @server, + branch: "master", + datetime: Time.utc(2026, 7, 20, 1, 2, 3), + revision: SHA, + summary: "ruby 3.5.0dev failed(test-all) (diff:test-all)", + ltsv: "depsuffixed_name:ruby-master\tresult:failure", + ) + LogExcerpt.create!(report: @report, content: "TestSearch#test_hit [foo_test.rb:12]:\nExpected true.") + end + + test "top page without params shows only the form" do + get search_url + assert_response :success + assert_no_match "TestSearch#test_hit", response.body + end + + test "search by text matches excerpt content" do + get search_url, params: { q: "test_hit" } + assert_response :success + assert_match "TestSearch#test_hit", response.body + assert_match @report.loguri, response.body + end + + test "search by text with no match" do + get search_url, params: { q: "does_not_exist_anywhere" } + assert_response :success + assert_match "No matching failure logs", response.body + end + + test "search by revision prefix" do + get search_url, params: { revision: SHA[0, 10] } + assert_response :success + assert_match @report.loguri, response.body + end + + test "search narrowed by branch and date range" do + get search_url, params: { q: "test_hit", branch: "master", from: "2026-07-20", to: "2026-07-20" } + assert_response :success + assert_match @report.loguri, response.body + + get search_url, params: { q: "test_hit", branch: "ruby_3_4" } + assert_match "No matching failure logs", response.body + + get search_url, params: { q: "test_hit", to: "2026-07-19" } + assert_match "No matching failure logs", response.body + end + + test "array page param does not raise" do + get search_url, params: { q: "test_hit", page: ["1"] } + assert_response :success + end + + test "out of range page is clamped" do + get search_url, params: { q: "test_hit", page: "99999999999999999999" } + assert_response :success + assert_match "No matching failure logs", response.body + end + + test "search escapes LIKE wildcards" do + get search_url, params: { q: "%" } + assert_response :success + assert_match "No matching failure logs", response.body + end +end diff --git a/test/models/log_excerpt_test.rb b/test/models/log_excerpt_test.rb new file mode 100644 index 000000000..9fc9ca244 --- /dev/null +++ b/test/models/log_excerpt_test.rb @@ -0,0 +1,176 @@ +require "test_helper" + +class LogExcerptTest < ActiveSupport::TestCase + @@ordinal = 100 + + def create_server(name, uri: "https://rubyci.s3.amazonaws.com/#{name}/") + Server.create!(name: name, uri: uri, ordinal: (@@ordinal += 1)) + end + + # minitest 6 no longer bundles minitest/mock, so swap the singleton method + def stub_fetch_text(callable) + singleton = LogExcerpt.singleton_class + original = LogExcerpt.method(:fetch_text) + singleton.send(:define_method, :fetch_text) { |uri| callable.call(uri) } + yield + ensure + singleton.send(:define_method, :fetch_text, original) + end + + def create_report(server, attrs = {}) + Report.create!({ + server: server, + branch: "master", + datetime: Time.now.utc, + summary: "ruby 3.5.0dev failed(test-all)", + }.merge(attrs)) + end + + test "failtxt_uri and difftxt_uri from ltsv relpath" do + server = create_server("uri-ltsv") + report = create_report(server, ltsv: "depsuffixed_name:ruby-master\tcompressed_failhtml_relpath:log/20260727T023004Z.fail.html.gz\tcompressed_diffhtml_relpath:log/20260727T023004Z.diff.html.gz") + assert_equal "https://rubyci.s3.amazonaws.com/uri-ltsv/ruby-master/log/20260727T023004Z.fail.txt.gz", report.failtxt_uri + assert_equal "https://rubyci.s3.amazonaws.com/uri-ltsv/ruby-master/log/20260727T023004Z.diff.txt.gz", report.difftxt_uri + end + + test "failtxt_uri falls back to datetime" do + server = create_server("uri-dt") + report = create_report(server, datetime: Time.utc(2026, 7, 27, 2, 30, 4)) + assert_equal "https://rubyci.s3.amazonaws.com/uri-dt/master/log/20260727T023004Z.fail.txt.gz", report.failtxt_uri + end + + test "capture stores fail and diff content" do + server = create_server("cap-both") + report = create_report(server) + fetch = ->(uri) { uri.include?(".fail.") ? "FAIL BODY" : "DIFF BODY" } + stub_fetch_text(fetch) do + LogExcerpt.capture(report) + end + assert_equal "FAIL BODY\nDIFF BODY", report.reload.log_excerpt.content + end + + test "capture truncates content to MAX_CONTENT_BYTES" do + server = create_server("cap-trunc") + report = create_report(server) + stub_fetch_text(->(uri) { "x" * 200_000 }) do + LogExcerpt.capture(report) + end + assert_operator report.reload.log_excerpt.content.bytesize, :<=, LogExcerpt::MAX_CONTENT_BYTES + end + + test "capture keeps the diff section when fail is over budget" do + server = create_server("cap-budget") + report = create_report(server) + fetch = ->(uri) { uri.include?(".fail.") ? "F" * 200_000 : "D" * 1_000 } + stub_fetch_text(fetch) do + LogExcerpt.capture(report) + end + content = report.reload.log_excerpt.content + assert_operator content.bytesize, :<=, LogExcerpt::MAX_CONTENT_BYTES + assert_equal 1_000, content.count("D") + assert_operator content.count("F"), :>, 90_000 + end + + test "capture lets one section use the other's unused budget" do + server = create_server("cap-slack") + report = create_report(server) + fetch = ->(uri) { uri.include?(".fail.") ? "F" * 90_000 : "D" * 1_000 } + stub_fetch_text(fetch) do + LogExcerpt.capture(report) + end + content = report.reload.log_excerpt.content + assert_equal 90_000, content.count("F") + assert_equal 1_000, content.count("D") + end + + test "capture saves empty row when nothing is available" do + server = create_server("cap-empty") + report = create_report(server) + stub_fetch_text(->(uri) { nil }) do + LogExcerpt.capture(report) + end + assert_equal "", report.reload.log_excerpt.content + end + + test "capture skips non-rubyci servers" do + server = create_server("cap-other", uri: "https://example.com/chkbuild/logs") + report = create_report(server) + stub_fetch_text(->(uri) { flunk "must not fetch" }) do + assert_nil LogExcerpt.capture(report) + end + assert_nil report.reload.log_excerpt + end + + test "capture is idempotent per report" do + server = create_server("cap-idem") + report = create_report(server) + stub_fetch_text(->(uri) { "first" }) do + LogExcerpt.capture(report) + end + stub_fetch_text(->(uri) { "second" }) do + LogExcerpt.capture(report) + end + assert_equal 1, LogExcerpt.where(report_id: report.id).count + assert_equal "second\nsecond", report.reload.log_excerpt.content + end + + test "content_match finds substring" do + server = create_server("cap-match") + report = create_report(server) + LogExcerpt.create!(report: report, content: "TestFoo#test_bar [test.rb:1]:\nExpected 1 to equal 2.") + assert_includes LogExcerpt.content_match("test_bar").to_a.map(&:report_id), report.id + assert_empty LogExcerpt.content_match("no_such_token").where(report_id: report.id).to_a + end + + test "matching_line returns first matching line" do + excerpt = LogExcerpt.new(content: "line one\nTestFoo#test_bar failed\nline three") + assert_equal "TestFoo#test_bar failed", excerpt.matching_line("TEST_BAR") + assert_nil excerpt.matching_line("absent") + assert_nil excerpt.matching_line("") + end + + test "scan_recent_ltsv captures excerpt for failed build" do + server = create_server("scan-fail") + line = [ + "start_time:20260727T051800Z", + "title:ruby 3.5.0dev (2026-07-27) [x86_64-linux]", + "result:failure", + "compressed_failhtml_relpath:log/20260727T051800Z.fail.html.gz", + "compressed_diffhtml_relpath:log/20260727T051800Z.diff.html.gz", + ].join("\t") + stub_fetch_text(->(uri) { "some failure output" }) do + Report.scan_recent_ltsv(server, "ruby-master", line + "\n") + end + report = Report.where(server_id: server.id).last + assert_equal "some failure output\nsome failure output", report.log_excerpt.content + end + + test "scan_recent_ltsv does not capture excerpt for success build" do + server = create_server("scan-ok") + line = [ + "start_time:20260727T051800Z", + "title:ruby 3.5.0dev (2026-07-27) [x86_64-linux]", + "result:success", + ].join("\t") + stub_fetch_text(->(uri) { flunk "must not fetch" }) do + Report.scan_recent_ltsv(server, "ruby-master", line + "\n") + end + report = Report.where(server_id: server.id).last + assert_nil report.log_excerpt + end + + test "scan_recent_ltsv survives capture errors" do + server = create_server("scan-err") + line = [ + "start_time:20260727T051800Z", + "title:ruby 3.5.0dev (2026-07-27) [x86_64-linux]", + "result:failure", + ].join("\t") + stub_fetch_text(->(uri) { raise Net::OpenTimeout }) do + Report.scan_recent_ltsv(server, "ruby-master", line + "\n") + end + report = Report.where(server_id: server.id).last + assert_not_nil report + assert_nil report.log_excerpt + end +end