polyrun 2.1.3 → 2.2.1

data/lib/polyrun/rspec/active_record_timeout_recovery.rb

@@ -0,0 +1,51 @@
+module Polyrun
+  module RSpec
+    # Drops pooled connections after per-example Timeout interrupts database I/O.
+    # Uses only ActiveRecord connection-pool APIs (PostgreSQL, MySQL, SQLite, SQL Server, etc.).
+    module ActiveRecordTimeoutRecovery
+      module_function
+
+      def disconnect_all_connection_pools!
+        return unless active_record_loaded?
+
+        if defined?(ActiveRecord) && ActiveRecord.respond_to?(:disconnect_all!)
+          ActiveRecord.disconnect_all!
+          return
+        end
+
+        each_connection_pool(&:disconnect!)
+      end
+
+      def active_record_loaded?
+        defined?(ActiveRecord::Base) &&
+          ActiveRecord::Base.respond_to?(:connection_handler)
+      end
+
+      def each_connection_pool
+        connection_handlers.each do |handler|
+          pools_for(handler).each { |pool| yield pool }
+        end
+      end
+
+      def connection_handlers
+        base = ActiveRecord::Base
+        if base.respond_to?(:connection_handlers)
+          base.connection_handlers.values
+        else
+          [base.connection_handler]
+        end
+      end
+
+      def pools_for(handler)
+        if handler.respond_to?(:all_connection_pools)
+          handler.all_connection_pools
+        elsif handler.respond_to?(:connection_pool_list)
+          handler.connection_pool_list
+        else
+          []
+        end
+      end
+      private_class_method :active_record_loaded?, :each_connection_pool, :connection_handlers, :pools_for
+    end
+  end
+end

data/lib/polyrun/rspec/example_debug.rb

@@ -6,9 +6,10 @@ module Polyrun
   module RSpec
     # Per-example RSpec debugging for local investigation (SQL, TracePoint, timeouts).
     #
-    # +POLYRUN_EXAMPLE_DEBUG=1+ enables installers; +DEBUG=1+ / +POLYRUN_DEBUG=1+ trace orchestration only.
+    # +POLYRUN_EXAMPLE_DEBUG=1+ enables print helpers, Rails logging, and disables per-example timeouts.
     # +POLYRUN_DEBUG_SQL=1+ or legacy +DEBUG_SQL=1+ logs mutating SQL.
     # +POLYRUN_DEBUG_TRACE=1+ or legacy +DEBUG_TRACE=1+ traces :call/:raise under the app root.
+    # +DEBUG_PROSOPITE=1+ runs Prosopite N+1 scans when the gem is loaded.
     # +DEBUG_LOG_LEVEL+ accepts Ruby Logger severities as integers (0 debug … 4 fatal) or names.
     module ExampleDebug
       LOG_LEVEL_BY_NAME = {
@@ -26,15 +27,15 @@ module Polyrun
       end
 
       def sql_enabled?
-        enabled? && (truthy?(ENV["POLYRUN_DEBUG_SQL"]) || truthy?(ENV["DEBUG_SQL"]))
+        truthy?(ENV["POLYRUN_DEBUG_SQL"]) || truthy?(ENV["DEBUG_SQL"])
       end
 
       def trace_enabled?
-        enabled? && (truthy?(ENV["POLYRUN_DEBUG_TRACE"]) || truthy?(ENV["DEBUG_TRACE"]))
+        truthy?(ENV["POLYRUN_DEBUG_TRACE"]) || truthy?(ENV["DEBUG_TRACE"])
       end
 
       def prosopite_enabled?
-        enabled? && truthy?(ENV["DEBUG_PROSOPITE"])
+        truthy?(ENV["DEBUG_PROSOPITE"])
       end
 
       def print_spec_enabled?
@@ -82,7 +83,7 @@ module Polyrun
           group = example.metadata[:example_group]
           Polyrun::Log.puts "\n\nRunning #{group[:file_path]}:#{group[:line_number]}"
 
-          level = log_level
+          level = ExampleDebug.log_level
           Rails.logger.level = level
           if defined?(ActiveRecord::Base)
             ar_logger = Logger.new(Polyrun::Log.stdout)
@@ -99,14 +100,22 @@ module Polyrun
         return if seconds <= 0
         return if example_timeout_disabled?
 
+        require_relative "active_record_timeout_recovery"
+
         rspec_config.around(:each) do |example|
-          if example.metadata[:benchmark] || example.metadata[:slow]
-            example.run
-          else
-            Timeout.timeout(seconds) { example.run }
+          timed_out = false
+          begin
+            if example.metadata[:benchmark] || example.metadata[:slow]
+              example.run
+            else
+              Timeout.timeout(seconds) { example.run }
+            end
+          rescue Timeout::Error
+            timed_out = true
+            raise "Example timed out after #{seconds}s (#{example.location})"
+          ensure
+            ActiveRecordTimeoutRecovery.disconnect_all_connection_pools! if timed_out
           end
-        rescue Timeout::Error
-          raise "Example timed out after #{seconds}s (#{example.location})"
         end
       end
 

data/lib/polyrun/rspec/sharded_formatter_compat.rb

@@ -1,27 +1,50 @@
 module Polyrun
   module RSpec
-    # Formatter tweaks for progress bars (e.g. Fuubar) under +POLYRUN_SHARD_*+ workers.
+    # Formatter tweaks for progress formatters under +POLYRUN_SHARD_*+ workers.
     module ShardedFormatterCompat
+      TextFormatterSilencer = Module.new do
+        def seed(_notification)
+        end
+
+        def dump_summary(_notification)
+        end
+
+        def dump_pending(_notification)
+        end
+      end
+
+      FuubarSeedSilencer = Module.new do
+        def seed(_notification)
+        end
+      end
+
       module_function
 
       def install!(rspec_config: fetch_rspec_configuration!)
         return unless sharded_worker?
 
         rspec_config.silence_filter_announcements = true
-        noop_fuubar_seed! if defined?(Fuubar)
+        silence_text_formatter_noise!
+        silence_fuubar_seed! if defined?(Fuubar)
       end
 
       def sharded_worker?
         !ENV["POLYRUN_SHARD_TOTAL"].to_s.strip.empty?
       end
 
-      def noop_fuubar_seed!
+      def silence_text_formatter_noise!
+        require "rspec/core/formatters/base_text_formatter"
+        klass = ::RSpec::Core::Formatters::BaseTextFormatter
+        return if klass.ancestors.include?(TextFormatterSilencer)
+
+        klass.prepend(TextFormatterSilencer)
+      end
+
+      def silence_fuubar_seed!
         return unless defined?(Fuubar)
+        return if Fuubar.ancestors.include?(FuubarSeedSilencer)
 
-        Fuubar.class_eval do
-          def seed(_notification)
-          end
-        end
+        Fuubar.prepend(FuubarSeedSilencer)
       end
 
       def fetch_rspec_configuration!

data/lib/polyrun/spec_quality/profile.rb

@@ -4,18 +4,30 @@ module Polyrun
     module Profile
       module_function
 
-      def snapshot
-        cpu = Process.times
-        gc = GC.stat
-        io = read_proc_io
-        {
-          "cpu_user" => cpu.utime,
-          "cpu_system" => cpu.stime,
-          "gc_allocated" => gc[:total_allocated_objects],
-          "gc_heap_live" => gc[:heap_live_slots],
-          "io_read_bytes" => io[:read_bytes],
-          "io_write_bytes" => io[:write_bytes]
-        }
+      def snapshot(dimensions: %w[cpu mem io wall])
+        dims = enabled_dimensions(dimensions)
+        capture_all = dims.empty?
+        out = {}
+
+        if capture_all || dims.include?("cpu") || dims.include?("wall")
+          cpu = Process.times
+          out["cpu_user"] = cpu.utime
+          out["cpu_system"] = cpu.stime
+        end
+
+        if capture_all || dims.include?("mem")
+          gc = GC.stat
+          out["gc_allocated"] = gc[:total_allocated_objects]
+          out["gc_heap_live"] = gc[:heap_live_slots]
+        end
+
+        if capture_all || dims.include?("io")
+          io = read_proc_io
+          out["io_read_bytes"] = io[:read_bytes]
+          out["io_write_bytes"] = io[:write_bytes]
+        end
+
+        out
       end
 
       def diff(before, after)

data/lib/polyrun/spec_quality/report.rb

@@ -1,4 +1,7 @@
 # rubocop:disable Polyrun/FileLength, Metrics/ModuleLength -- report analysis + text formatting
+require_relative "../export/csv"
+require_relative "../export/markdown"
+
 module Polyrun
   module SpecQuality
     # Human-readable spec quality report from merged JSON.
@@ -55,6 +58,96 @@ module Polyrun
         lines.join("\n") + "\n"
       end
 
+      EXAMPLE_CSV_HEADERS = %w[example unique_lines line_churn max_line_churn shard_index].freeze
+
+      def format_csv(merged, cfg: {}, top: 30, profile: nil, plan_shards: nil)
+        rows = merged.fetch("examples", {}).map do |location, row|
+          [
+            location,
+            row["unique_lines"],
+            row["line_churn"],
+            row["max_line_churn"],
+            row["polyrun_shard_index"]
+          ]
+        end.sort_by { |row| [-row[2].to_i, row[0].to_s] }
+        rows = rows.first(top) if top
+        Export::Csv.generate(EXAMPLE_CSV_HEADERS, rows)
+      end
+
+      def format_markdown(merged, cfg: {}, top: 30, profile: nil, plan_shards: nil)
+        analysis = analyze(merged, cfg, plan_shards: plan_shards)
+        sections = markdown_sections(analysis, top).compact
+        Export::Markdown.document("Polyrun spec quality report", sections)
+      end
+
+      def markdown_sections(analysis, top)
+        [
+          markdown_shard_section(analysis[:shard_summary]),
+          markdown_zero_hit_section(analysis[:zero_hit], top),
+          markdown_hot_lines_section(analysis[:hot_lines], top),
+          markdown_churn_section(analysis[:line_churn], top)
+        ]
+      end
+
+      def markdown_shard_section(shard_summary)
+        shard_rows = (shard_summary || {}).sort_by { |shard, _| shard.to_s }.map do |shard, stats|
+          [shard, stats["examples"], stats["zero_hit"], stats["line_churn"]]
+        end
+        return if shard_rows.empty?
+
+        {
+          heading: "Shard attribution",
+          headers: %w[shard examples zero_hit line_churn],
+          rows: shard_rows
+        }
+      end
+
+      def markdown_zero_hit_section(zero_hit, top)
+        zero_rows = zero_hit.keys.sort.first(top).zip
+        {
+          heading: "Zero production lines",
+          headers: %w[example],
+          rows: zero_rows.empty? ? [["(none)"]] : zero_rows
+        }
+      end
+
+      def markdown_hot_lines_section(hot_lines, top)
+        hot_rows = hot_lines.first(top).map do |line, stats|
+          [line, stats["example_count"], stats["total_hits"]]
+        end
+        {
+          heading: "Hot lines",
+          headers: %w[line example_count total_hits],
+          rows: hot_rows.empty? ? [["(none)", 0, 0]] : hot_rows
+        }
+      end
+
+      def markdown_churn_section(churn_rows, top)
+        rows = churn_rows.first(top).map do |location, row|
+          [location, row["line_churn"], row["max_line_churn"]]
+        end
+        {
+          heading: "Per-example line churn",
+          headers: %w[example line_churn max_line_churn],
+          rows: rows.empty? ? [["(none)", 0, 0]] : rows
+        }
+      end
+
+      def render(merged, format: "text", **kwargs)
+        case format.to_s.downcase
+        when "text", "console", "txt"
+          format_report(merged, **kwargs)
+        when "json"
+          JSON.pretty_generate(analyze(merged, kwargs[:cfg] || {}, plan_shards: kwargs[:plan_shards]))
+        when "csv"
+          format_csv(merged, **kwargs)
+        when "markdown", "md"
+          format_markdown(merged, **kwargs)
+        else
+          raise Polyrun::Error, "report-spec-quality: unknown format #{format.inspect} (use text, json, csv, or markdown)"
+        end
+      end
+
       def gate_violations(merged, cfg = {})
         cfg = default_cfg(cfg)
         analysis = analyze(merged, cfg)

data/lib/polyrun/spec_quality.rb

@@ -58,8 +58,12 @@ module Polyrun
         @current = {
           location: normalize_location(location),
           wall_start: wall_start || Process.clock_gettime(Process::CLOCK_MONOTONIC),
-          coverage_before: Coverage::ExampleDiff.peek_blob,
-          profile_before: Profile.snapshot,
+          coverage_before: Coverage::ExampleDiff.peek_blob(
+            root: @config["root"],
+            track_under: @config["track_under"],
+            ignore_paths: @config["ignore_paths"]
+          ),
+          profile_before: Profile.snapshot(dimensions: @config["profile"]),
           sql_count: 0,
           sql_fingerprints: Hash.new(0),
           factory_counts: {}
@@ -78,16 +82,9 @@ module Polyrun
         loc = location || cur[:location]
         return if loc.nil? || loc.to_s.empty?
 
-        after_cov = Coverage::ExampleDiff.peek_blob
-        delta = Coverage::ExampleDiff.diff(cur[:coverage_before], after_cov)
-        delta = Coverage::ExampleDiff.apply_track_under(
-          delta,
-          root: @config["root"],
-          track_under: @config["track_under"],
-          ignore_paths: @config["ignore_paths"]
-        )
+        delta = coverage_delta_for_example(cur)
 
-        profile_after = Profile.snapshot
+        profile_after = Profile.snapshot(dimensions: @config["profile"])
         profile_delta = Profile.diff(cur[:profile_before], profile_after)
         wall = Process.clock_gettime(Process::CLOCK_MONOTONIC) - cur[:wall_start]
         profile_delta["wall"] = wall
@@ -169,6 +166,17 @@ module Polyrun
         Polyrun::Partition::TimingKeys.canonical_file_path(File.expand_path(s, root))
       end
 
+      def coverage_delta_for_example(cur)
+        after_source = Coverage::ExampleDiff.coverage_active? ? ::Coverage.peek_result : {}
+        Coverage::ExampleDiff.diff(
+          cur[:coverage_before],
+          after_source,
+          root: @config["root"],
+          track_under: @config["track_under"],
+          ignore_paths: @config["ignore_paths"]
+        )
+      end
+
       def build_row(cur, location, delta, profile_delta, factory_counts)
         profile = Profile.slice_profile(profile_delta, @config["profile"])
         repeated_sql = cur[:sql_fingerprints].select { |_sql, n| n >= min_query_count }.transform_keys(&:to_s)

data/lib/polyrun/timing/summary.rb

@@ -1,26 +1,76 @@
 require_relative "stats"
+require_relative "../export/csv"
+require_relative "../export/markdown"
 
 module Polyrun
   module Timing
     # Human-readable slow-file list from merged timing JSON (per-file cost).
     module Summary
+      CSV_HEADERS = %w[rank path last_seconds min max mean p95 runs failures timeouts].freeze
+      MARKDOWN_HEADERS = %w[rank path seconds].freeze
+
       module_function
 
+      def ranked_entries(merged, top: 30)
+        return [] if merged.nil? || merged.empty?
+
+        merged.map { |path, entry| [path, Stats.normalize_entry(entry)] }
+          .sort_by { |(_, entry)| -Stats.binpack_weight(entry) }
+          .first(Integer(top))
+      end
+
       # +merged+ is path (String) => seconds (Float) or stats Hash, as produced by +Timing::Merge.merge_files+.
       def format_slow_files(merged, top: 30, title: "Polyrun slowest files (by wall time, seconds)")
         return "#{title}\n  (no data)\n" if merged.nil? || merged.empty?
 
-        pairs = merged.map { |path, sec| [path, Stats.binpack_weight(sec)] }
-          .sort_by { |(_, sec)| -sec.to_f }.first(Integer(top))
         lines = [title, ""]
-        pairs.each_with_index do |(path, sec), i|
-          lines << format("  %2d. %s  %.4f", i + 1, path, sec.to_f)
+        ranked_entries(merged, top: top).each_with_index do |(path, entry), index|
+          lines << format("  %2d. %s  %.4f", index + 1, path, Stats.binpack_weight(entry).to_f)
         end
         lines.join("\n") + "\n"
       end
 
+      def format_csv(merged, top: 30)
+        rows = ranked_entries(merged, top: top).each_with_index.map do |(path, entry), index|
+          [
+            index + 1,
+            path,
+            entry["last_seconds"],
+            entry["min"],
+            entry["max"],
+            entry["mean"],
+            entry["p95"],
+            entry["runs"],
+            entry["failures"],
+            entry["timeouts"]
+          ]
+        end
+        Export::Csv.generate(CSV_HEADERS, rows)
+      end
+
+      def format_markdown(merged, top: 30, title: "Polyrun slowest files")
+        rows = ranked_entries(merged, top: top).each_with_index.map do |(path, entry), index|
+          [index + 1, path, format("%.4f", Stats.binpack_weight(entry).to_f)]
+        end
+        Export::Markdown.document(
+          title,
+          [{heading: "Slow files", headers: MARKDOWN_HEADERS, rows: rows}]
+        )
+      end
+
+      def render(merged, format: "text", **kwargs)
+        case format.to_s.downcase
+        when "text", "console", "txt" then format_slow_files(merged, **kwargs)
+        when "csv" then format_csv(merged, **kwargs)
+        when "markdown", "md" then format_markdown(merged, **kwargs)
+        else
+          raise Polyrun::Error, "report-timing: unknown format #{format.inspect} (use text, csv, or markdown)"
+        end
+      end
+
       def write_file(merged, path, **kwargs)
-        File.write(path, format_slow_files(merged, **kwargs))
+        format = kwargs.delete(:format) || "text"
+        File.write(path, render(merged, format: format, **kwargs))
         path
       end
     end

data/lib/polyrun/version.rb

@@ -1,3 +1,3 @@
 module Polyrun
-  VERSION = "2.1.3"
+  VERSION = "2.2.1"
 end

data/polyrun.gemspec

@@ -10,10 +10,14 @@ Gem::Specification.new do |spec|
   spec.license = "MIT"
   spec.required_ruby_version = ">= 3.1.0"
 
-  spec.files = Dir["lib/**/*", "sig/**/*.rbs", "bin/polyrun", "README.md", "CHANGELOG.md", "docs/SETUP_PROFILE.md", "LICENSE", "CONTRIBUTING.md", "CODE_OF_CONDUCT.md", "SECURITY.md", "polyrun.gemspec"].reject { |f| File.directory?(f) }
+  spec.files = (
+    Dir["lib/**/*", "sig/**/*.rbs", "bin/polyrun", "README.md", "CHANGELOG.md", "docs/SETUP_PROFILE.md", "LICENSE", "CONTRIBUTING.md", "CODE_OF_CONDUCT.md", "SECURITY.md", "polyrun.gemspec"] +
+    Dir["ext/**/extconf.rb", "ext/**/*.c", "ext/**/*.h"]
+  ).uniq.reject { |f| File.directory?(f) }
   spec.bindir = "bin"
   spec.executables = ["polyrun"]
   spec.require_paths = ["lib"]
+  spec.extensions = ["ext/polyrun_coverage_merge/extconf.rb"]
 
   spec.metadata = {
     "homepage_uri" => spec.homepage,
@@ -25,6 +29,9 @@ Gem::Specification.new do |spec|
   # Normative: zero runtime dependencies (stdlib + vendored/native code only).
   # Ruby 3.5+: `benchmark` is no longer a default gem; keep scripts and `rake bench_merge` warning-free.
   spec.add_development_dependency "benchmark", ">= 0.3"
+  spec.add_development_dependency "benchmark-ips", "~> 2"
+  spec.add_development_dependency "memory_profiler", "~> 1"
+  spec.add_development_dependency "stackprof", "~> 0.2"
   spec.add_development_dependency "rake", "~> 13.0"
   spec.add_development_dependency "rspec", "~> 3.12"
   spec.add_development_dependency "appraisal", "~> 2.5"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: polyrun
 version: !ruby/object:Gem::Version
-  version: 2.1.3
+  version: 2.2.1
 platform: ruby
 authors:
 - Andrei Makarov
@@ -23,6 +23,48 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0.3'
+- !ruby/object:Gem::Dependency
+  name: benchmark-ips
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: memory_profiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+- !ruby/object:Gem::Dependency
+  name: stackprof
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -153,7 +195,8 @@ email:
 - contact@kiskolabs.com
 executables:
 - polyrun
-extensions: []
+extensions:
+- ext/polyrun_coverage_merge/extconf.rb
 extra_rdoc_files: []
 files:
 - CHANGELOG.md
@@ -164,8 +207,13 @@ files:
 - SECURITY.md
 - bin/polyrun
 - docs/SETUP_PROFILE.md
+- ext/polyrun_coverage_merge/coverage_merge.c
+- ext/polyrun_coverage_merge/extconf.rb
 - lib/polyrun.rb
+- lib/polyrun/benchmark/profile.rb
+- lib/polyrun/benchmark/report.rb
 - lib/polyrun/cli.rb
+- lib/polyrun/cli/benchmark_commands.rb
 - lib/polyrun/cli/ci_shard_hooks.rb
 - lib/polyrun/cli/ci_shard_run_command.rb
 - lib/polyrun/cli/ci_shard_run_parse.rb
@@ -208,6 +256,9 @@ files:
 - lib/polyrun/coverage/collector_finish.rb
 - lib/polyrun/coverage/collector_fragment_meta.rb
 - lib/polyrun/coverage/example_diff.rb
+- lib/polyrun/coverage/example_diff_snapshot.rb
+- lib/polyrun/coverage/example_diff_track_filter.rb
+- lib/polyrun/coverage/file_stats_report.rb
 - lib/polyrun/coverage/filter.rb
 - lib/polyrun/coverage/formatter.rb
 - lib/polyrun/coverage/merge.rb
@@ -222,6 +273,7 @@ files:
 - lib/polyrun/coverage/merge/html/template.html.erb
 - lib/polyrun/coverage/merge_fragment_meta.rb
 - lib/polyrun/coverage/merge_merge_two.rb
+- lib/polyrun/coverage/merge_native.rb
 - lib/polyrun/coverage/rails.rb
 - lib/polyrun/coverage/reporting.rb
 - lib/polyrun/coverage/result.rb
@@ -242,8 +294,11 @@ files:
 - lib/polyrun/database/url_builder/template_prepare.rb
 - lib/polyrun/debug.rb
 - lib/polyrun/env/ci.rb
+- lib/polyrun/export/csv.rb
+- lib/polyrun/export/markdown.rb
 - lib/polyrun/hooks.rb
 - lib/polyrun/hooks/dsl.rb
+- lib/polyrun/hooks/shell_runner.rb
 - lib/polyrun/hooks/worker_runner.rb
 - lib/polyrun/hooks/worker_shell.rb
 - lib/polyrun/log.rb
@@ -279,9 +334,11 @@ files:
 - lib/polyrun/reporting/failure_merge.rb
 - lib/polyrun/reporting/junit.rb
 - lib/polyrun/reporting/junit_emit.rb
+- lib/polyrun/reporting/junit_report.rb
 - lib/polyrun/reporting/rspec_failure_fragment_formatter.rb
 - lib/polyrun/reporting/rspec_junit.rb
 - lib/polyrun/rspec.rb
+- lib/polyrun/rspec/active_record_timeout_recovery.rb
 - lib/polyrun/rspec/example_debug.rb
 - lib/polyrun/rspec/example_debug_instrumentation.rb
 - lib/polyrun/rspec/sharded_formatter_compat.rb