txray 0.1.0 → 0.2.1

data/lib/txray/config.rb

@@ -43,8 +43,13 @@ module Txray
       new(data.is_a?(Hash) ? data : {})
     end
 
+    ARRAY_KEYS = %w[include exclude disabled_rules external_clients].freeze
+    HASH_KEYS = %w[severities runtime].freeze
+    FAIL_LEVELS = %w[low medium high none].freeze
+
     def initialize(data = {})
-      @data = DEFAULTS.merge(data) { |_key, default, given| default.is_a?(Hash) ? default.merge(given.to_h) : given }
+      validate!(data)
+      @data = DEFAULTS.merge(data) { |_key, default, given| default.is_a?(Hash) ? default.merge(given) : given }
     end
 
     def includes = Array(@data["include"])
@@ -58,6 +63,26 @@ module Txray
 
     def rule_enabled?(id) = !disabled_rules.include?(id.to_s)
 
+    def validate!(data)
+      ARRAY_KEYS.each { |key| expect(data, key, Array) }
+      HASH_KEYS.each { |key| expect(data, key, Hash) }
+
+      depth = data["max_depth"]
+      raise Error, "max_depth must be a whole number, got #{depth.inspect}" if depth && !depth.is_a?(Integer)
+
+      level = data["fail_level"]
+      return if level.nil? || FAIL_LEVELS.include?(level.to_s)
+
+      raise Error, "fail_level must be one of #{FAIL_LEVELS.join(", ")}, got #{level.inspect}"
+    end
+
+    def expect(data, key, type)
+      value = data[key]
+      return if value.nil? || value.is_a?(type)
+
+      raise Error, "#{key} must be #{type == Array ? "a list" : "a mapping"}, got #{value.inspect}"
+    end
+
     def rule(id)
       severity = @data["severities"].to_h[id.to_s]
       base = Rules[id]
@@ -70,6 +95,8 @@ module Txray
       self.class.new(@data.merge(overrides.compact.transform_keys(&:to_s)))
     end
 
+    private :validate!, :expect
+
     def to_h = @data
   end
 end

data/lib/txray/monitor.rb

@@ -30,9 +30,28 @@ module Txray
       nil
     end
 
+    BUCKETS = [ [ 10, "<10ms" ], [ 50, "<50ms" ], [ 100, "<100ms" ], [ 250, "<250ms" ],
+                [ 1000, "<1s" ], [ Float::INFINITY, "1s+" ] ].freeze
+
     def recent(limit) = @recent.first(limit)
+    def pids = @transactions.map { |event| event[:pid] }.uniq.size
+
+    def breakdown
+      flagged = @transactions.count { |event| event[:violations].to_a.any? }
+      slow = @transactions.count { |event| slow?(event) && event[:violations].to_a.empty? }
+      { ok: @transactions.size - flagged - slow, slow: slow, flagged: flagged }
+    end
+
+    def histogram
+      BUCKETS.map do |limit, label|
+        { label: label, limit: limit,
+          count: durations.count { |value| value < limit && value >= previous_limit(limit) } }
+      end
+    end
+
     def durations = @transactions.map { |event| event[:duration_ms].to_f }
-    def slow = @transactions.count { |event| event[:duration_ms].to_f >= @threshold_ms }
+    def slow = @transactions.count { |event| slow?(event) }
+    def slow?(event) = event[:duration_ms].to_f >= @threshold_ms
     def flagged = @transactions.count { |event| event[:violations].to_a.any? }
     def uptime = Time.now - @started_at
     def empty? = @transactions.empty? && @violations.empty?
@@ -60,6 +79,11 @@ module Txray
 
     private
 
+    def previous_limit(limit)
+      index = BUCKETS.index { |bucket_limit, _| bucket_limit == limit }
+      index.zero? ? 0 : BUCKETS[index - 1].first
+    end
+
     def add(collection, event)
       collection << event
       collection.shift while collection.size > CAP

data/lib/txray/reporters/github.rb

@@ -4,17 +4,83 @@ module Txray
   module Reporters
     class Github
       LEVELS = { high: "error", medium: "warning", low: "notice" }.freeze
+      SUMMARY_LIMIT = 50
 
-      def initialize(io: $stdout)
+      def initialize(io: $stdout, summary_path: ENV.fetch("GITHUB_STEP_SUMMARY", nil))
         @io = io
+        @summary_path = summary_path
       end
 
       def report(result)
-        result.offenses.each do |offense|
-          level = LEVELS.fetch(offense.severity, "warning")
-          title = "txray: #{offense.id}"
-          @io.puts "::#{level} file=#{offense.path},line=#{offense.line},col=#{offense.column},title=#{title}::#{offense.message}"
+        result.offenses.each { |offense| @io.puts annotation(offense) }
+        write_summary(result)
+      end
+
+      private
+
+      def annotation(offense)
+        level = LEVELS.fetch(offense.severity, "warning")
+        properties = [ "file=#{property(offense.path)}", "line=#{offense.line}", "col=#{offense.column}",
+                       "title=#{property("txray #{offense.id}")}" ].join(",")
+        "::#{level} #{properties}::#{message(offense)}"
+      end
+
+      def message(offense)
+        body = [ offense.message, *offense.trace.map { |frame| "via #{frame}" }, offense.rule.remedy ].join("\n")
+        escape(body)
+      end
+
+      def escape(text)
+        text.to_s.gsub("%", "%25").gsub("\r", "%0D").gsub("\n", "%0A")
+      end
+
+      def property(text)
+        escape(text).gsub(":", "%3A").gsub(",", "%2C")
+      end
+
+      def write_summary(result)
+        return if @summary_path.nil? || @summary_path.empty?
+
+        File.open(@summary_path, "a") { |file| file.puts(summary(result)) }
+      rescue StandardError
+        nil
+      end
+
+      def summary(result)
+        if result.offenses.empty?
+          return [ "## txray", "",
+                   "No slow work found inside transactions across #{result.files.size} files." ].join("\n")
         end
+
+        [ "## txray", "", headline(result), "", table(result), footnote(result) ].compact.join("\n")
+      end
+
+      def headline(result)
+        counts = Offense::SEVERITIES.reverse.filter_map do |severity|
+          "#{result.counts[severity]} #{severity}" if result.counts[severity]
+        end
+        "**#{result.offenses.size} offenses** across #{result.files.size} files (#{counts.join(", ")})."
+      end
+
+      def table(result)
+        rows = result.offenses.first(SUMMARY_LIMIT).map do |offense|
+          "| #{offense.severity} | `#{offense.id}` | #{link(offense)} | #{cell(offense.message)} |"
+        end
+        [ "| Severity | Rule | Location | What happens |", "| --- | --- | --- | --- |", *rows ].join("\n")
+      end
+
+      def link(offense)
+        "`#{offense.path}:#{offense.line}`"
+      end
+
+      def cell(text)
+        text.to_s.gsub("|", "\\|").gsub("\n", " ")
+      end
+
+      def footnote(result)
+        return nil if result.offenses.size <= SUMMARY_LIMIT
+
+        "\n_Showing the first #{SUMMARY_LIMIT} of #{result.offenses.size}. Run `bundle exec txray` locally for the rest._"
       end
     end
   end

data/lib/txray/reporters/live.rb

@@ -6,13 +6,17 @@ module Txray
   module Reporters
     class Live
       SPARKS = %w[▁ ▂ ▃ ▄ ▅ ▆ ▇ █].freeze
+      SEVERITY_COLORS = { high: 91, medium: 93, low: 96 }.freeze
       HIDE_CURSOR = "\e[?25l"
       SHOW_CURSOR = "\e[?25h"
 
-      def initialize(path:, io: $stdout, threshold_ms: 250)
+      def initialize(path:, io: $stdout, threshold_ms: 250, color: Reporters.color?(io))
         @io = io
         @path = path
         @threshold_ms = threshold_ms
+        @color = color
+        @width = 100
+        @height = 40
       end
 
       def open = @io.print(HIDE_CURSOR)
@@ -27,11 +31,12 @@ module Txray
       def draw(monitor)
         @width, @height = viewport
         @io.print("\e[H\e[2J")
-        header(monitor)
-        stats(monitor)
+        title(monitor)
+        meters(monitor)
+        histogram(monitor)
         feed(monitor)
         hotspots(monitor)
-        @io.print(dim("  ctrl-c to stop"))
+        footer
         @io.flush
       end
 
@@ -44,113 +49,202 @@ module Txray
         [ 100, 40 ]
       end
 
-      def feed_limit = (@height - 19).clamp(3, 9)
-
-      def clip(text, budget)
-        budget = [ budget, 12 ].max
-        text.length <= budget ? text : "..#{text[-(budget - 2)..]}"
+      def title(monitor)
+        workers = monitor.pids
+        right = "up #{clock(monitor.uptime)}#{"  #{workers} pids" if workers > 1}"
+        left = " txray  #{@path}"
+        @io.puts bar(left, right)
+        @io.puts
       end
 
-      def header(monitor)
-        @io.puts
-        @io.puts "  #{bold(magenta("txray"))} #{dim("watching #{@path}")}#{" " * 2}#{dim(clock(monitor.uptime))}"
+      def meters(monitor)
+        return setup_hint if monitor.transactions.empty?
+
+        counts = monitor.breakdown
+        summary = legend(monitor, counts)
+        @io.puts "  #{label("txns")}#{stacked(counts, room(summary))}  #{summary}"
+        spread = percentiles(monitor)
+        @io.puts "  #{label("time")}#{sparkline(monitor, room(spread))}  #{spread}"
         @io.puts
       end
 
-      def stats(monitor)
-        if monitor.empty?
+      def room(text) = (@width - 12 - visible(text)).clamp(8, 34)
+
+      def setup_hint
+        if File.exist?(@path)
           @io.puts "  #{dim("waiting for the application to open a transaction")}"
-          @io.puts
-          return
+          return @io.puts
         end
 
-        @io.puts "  #{label("transactions")}#{count(monitor)}"
-        @io.puts "  #{label("duration")}#{spread(monitor)}"
-        @io.puts "  #{label("")}#{sparkline(monitor)}"
+        @io.puts "  #{paint("no event log yet", 93)} #{dim("at #{@path}")}"
+        @io.puts
+        @io.puts "  #{dim("the runtime guard writes it. to turn it on:")}"
+        @io.puts
+        @io.puts "    #{paint("1", 97)}  Gemfile      #{dim('gem "txray"   not require: false')}"
+        @io.puts "    #{paint("2", 97)}  .txray.yml   #{dim("runtime:")}"
+        @io.puts "                   #{dim("  enabled: true")}"
+        @io.puts "    #{paint("3", 97)}  #{dim("restart the app, then exercise it")}"
         @io.puts
       end
 
-      def count(monitor)
-        [ "#{monitor.transactions.size} seen",
-          tint("#{monitor.slow} slow", monitor.slow.zero? ? :dim : :yellow),
-          tint("#{monitor.flagged} with findings", monitor.flagged.zero? ? :dim : :red) ].join(dim("   "))
+      def stacked(counts, width)
+        parts = [ [ counts[:ok], 92 ], [ counts[:slow], 93 ], [ counts[:flagged], 91 ] ]
+        return "#{dim("[")}#{dim("·" * width)}#{dim("]")}" if parts.sum(&:first).zero?
+
+        cells = allocate(parts.map(&:first), width)
+        rendered = parts.each_with_index.map { |(_, color), i| paint("█" * cells[i], color) }.join
+        "#{dim("[")}#{rendered}#{dim("]")}"
       end
 
-      def spread(monitor)
-        [ "p50 #{duration(monitor.percentile(0.5))}",
-          "p95 #{duration(monitor.percentile(0.95))}",
-          "max #{duration(monitor.durations.max.to_f)}" ].join(dim("   "))
+      def allocate(counts, width)
+        total = counts.sum
+        cells = counts.map { |count| count.zero? ? 0 : [ ((count.to_f / total) * width).round, 1 ].max }
+        cells[cells.index(cells.max)] += width - cells.sum
+        cells.map { |cell| [ cell, 0 ].max }
       end
 
-      def sparkline(monitor)
-        values = monitor.durations.last(48)
-        return dim("-") if values.empty?
+      def legend(monitor, counts)
+        [ "#{monitor.transactions.size} txns",
+          paint("#{counts[:ok]} ok", 92),
+          paint("#{counts[:slow]} slow", 93),
+          paint("#{counts[:flagged]} flagged", 91) ].join(dim(" · "))
+      end
 
-        peak = [ values.max, 1.0 ].max
-        values.map { |value| SPARKS[((value / peak) * (SPARKS.size - 1)).round] }.join
+      def percentiles(monitor)
+        [ tinted("p50", monitor.percentile(0.5)),
+          tinted("p95", monitor.percentile(0.95)),
+          tinted("max", monitor.durations.max.to_f) ].join(dim(" · "))
       end
 
+      def tinted(name, value)
+        "#{dim(name)} #{paint(duration(value), heat(value))}"
+      end
+
+      def heat(value)
+        return 91 if value >= @threshold_ms
+        return 93 if value >= @threshold_ms / 2.0
+
+        92
+      end
+
+      def sparkline(monitor, width)
+        values = monitor.durations.last(width)
+        return dim("·" * width) if values.empty?
+
+        scale = Math.log(1 + [ values.max, 1.0 ].max)
+        values.map do |value|
+          level = ((Math.log(1 + value) / scale) * (SPARKS.size - 1)).round
+          paint(SPARKS[level.clamp(0, SPARKS.size - 1)], heat(value))
+        end.join
+      end
+
+      def histogram(monitor)
+        rows = monitor.histogram.reject { |row| row[:count].zero? }
+        return if rows.empty?
+
+        peak = rows.map { |row| row[:count] }.max
+        width = @width < 72 ? [ @width - 20, 10 ].max : [ (@width - 30) / 2, 12 ].max
+        columns = @width < 72 ? 1 : 2
+        rows.each_slice(columns) { |group| @io.puts("  #{group.map { |row| bucket(row, peak, width) }.join("  ")}") }
+        @io.puts
+      end
+
+      def bucket(row, peak, width)
+        filled = [ ((row[:count].to_f / peak) * width).round, 1 ].max
+        color = heat(row[:limit] == Float::INFINITY ? @threshold_ms * 10 : row[:limit] - 1)
+        "#{dim(row[:label].rjust(7))} #{paint("█" * filled, color)}#{dim("·" * [ width - filled, 0 ].max)} " \
+          "#{count_label(row[:count])}"
+      end
+
+      def count_label(count) = paint(count.to_s.ljust(4), 97)
+
       def feed(monitor)
         rows = monitor.recent(feed_limit)
         return if rows.empty?
 
-        @io.puts "  #{dim("LIVE")}"
+        @io.puts bar("  TIME       ELAPSED   SOURCE", "")
         rows.each { |event| @io.puts(event[:type] == "transaction" ? transaction_row(event) : violation_row(event)) }
         @io.puts
       end
 
       def transaction_row(event)
-        marker = if event[:violations].to_a.any?
-                   red("x")
-                 else
-                   (event[:duration_ms].to_f >= @threshold_ms ? yellow("!") : green("."))
-                 end
-        line = "  #{dim(time(event))} #{duration(event[:duration_ms]).rjust(18)}  #{marker}  " \
-               "#{clip(source(event), @width - 36)}"
-        [ line, *event[:violations].to_a.map { |violation| finding_row(violation) } ].join("\n")
+        findings = event[:violations].to_a
+        state = if findings.any?
+                  paint("●", 91)
+                elsif event[:duration_ms].to_f >= @threshold_ms
+                  paint("●", 93)
+                else
+                  paint("·", 92)
+                end
+        elapsed = paint(duration(event[:duration_ms]).rjust(9), heat(event[:duration_ms].to_f))
+        line = "  #{dim(time(event))} #{elapsed} #{state} #{clip(source(event), @width - 34)}"
+        [ line, *findings.map { |finding| finding_row(finding) } ].join("\n")
       end
 
       def violation_row(event)
-        "  #{dim(time(event))} #{elapsed(event[:duration_ms]).rjust(18)}  #{red("x")}  " \
-          "#{red(event[:rule].to_s)} #{dim(clip(source(event), @width - 36 - event[:rule].to_s.length))}"
+        rule = event[:rule].to_s
+        "  #{dim(time(event))} #{dim("        -")} #{paint("●", severity_color(rule))} " \
+          "#{paint(rule, severity_color(rule))} #{dim(clip(source(event), @width - 36 - rule.length))}"
       end
 
-      def elapsed(milliseconds) = milliseconds ? duration(milliseconds) : dim("-")
-
-      def finding_row(violation)
-        detail = [ violation[:message], duration_suffix(violation) ].compact.join(" ")
-        rule = violation[:rule].to_s
-        "  #{" " * 24}#{dim("|")} #{yellow(rule)} #{dim(clip(detail, @width - 28 - rule.length))}"
+      def finding_row(finding)
+        rule = finding[:rule].to_s
+        detail = [ finding[:message], duration_suffix(finding) ].compact.join(" ")
+        "  #{" " * 20}#{dim("└")} #{paint(rule, severity_color(rule))} " \
+          "#{dim(clip(detail, @width - 26 - rule.length))}"
       end
 
-      def duration_suffix(violation)
-        "(#{duration(violation[:duration_ms])})" if violation[:duration_ms]
+      def severity_color(rule)
+        SEVERITY_COLORS.fetch(Rules.all[rule]&.severity, 95)
       end
 
-      def source(event) = event[:source].to_s.sub(/:in\s+[`'"](.+)[`'"]\z/, " \\1")
+      def duration_suffix(finding)
+        "(#{duration(finding[:duration_ms])})" if finding[:duration_ms]
+      end
 
       def hotspots(monitor)
-        rows = monitor.hotspots(5)
+        rows = monitor.hotspots(hotspot_limit)
         return if rows.empty?
 
-        @io.puts "  #{dim("HOTSPOTS")}"
+        @io.puts bar("  HOTSPOTS", "")
         rows.each do |entry|
-          @io.puts "  #{"#{entry[:count]}x".rjust(4)}  #{yellow(entry[:rule].to_s.ljust(32))} " \
-                   "#{dim(clip(source(entry), @width - 42))}"
+          rule = entry[:rule].to_s
+          @io.puts "  #{paint("#{entry[:count]}x".rjust(5), 97)}  #{paint(rule.ljust(32), severity_color(rule))} " \
+                   "#{dim(clip(source(entry), @width - 45))}"
         end
         @io.puts
       end
 
+      def footer = @io.print(bar("  ctrl-c  stop", ""))
+
       def summary(monitor)
         return @io.puts("  no transactions observed") if monitor.empty?
 
-        @io.puts "  #{monitor.transactions.size} transactions, #{monitor.slow} slow, " \
-                 "#{monitor.findings.size} findings over #{clock(monitor.uptime)}"
+        counts = monitor.breakdown
+        @io.puts "  #{monitor.transactions.size} transactions over #{clock(monitor.uptime)}: " \
+                 "#{counts[:ok]} ok, #{counts[:slow]} slow, #{counts[:flagged]} with findings"
         monitor.hotspots(10).each do |entry|
-          @io.puts "  #{"#{entry[:count]}x".rjust(4)}  #{entry[:rule].to_s.ljust(32)} #{source(entry)}"
+          @io.puts "  #{"#{entry[:count]}x".rjust(5)}  #{entry[:rule].to_s.ljust(32)} #{source(entry)}"
         end
       end
 
+      def bar(left, right)
+        padding = [ @width - visible(left) - visible(right) - 1, 1 ].max
+        return "#{left}#{" " * padding}#{right} " unless @color
+
+        "\e[7m#{left}#{" " * padding}#{right} \e[0m"
+      end
+
+      def feed_limit = (@height - 22).clamp(3, 10)
+      def hotspot_limit = (@height - 30).clamp(2, 5)
+
+      def clip(text, budget)
+        budget = [ budget, 12 ].max
+        text.length <= budget ? text : "..#{text[-(budget - 2)..]}"
+      end
+
+      def visible(text) = text.gsub(/\e\[[0-9;?]*[a-zA-Z]/, "").length
+
       def duration(milliseconds)
         value = milliseconds.to_f
         return "#{value.round}ms" if value < 1000
@@ -159,21 +253,15 @@ module Txray
       end
 
       def time(event) = Time.at(event[:at].to_f).strftime("%H:%M:%S")
+      def source(event) = event[:source].to_s.sub(/:in\s+[`'"](.+)[`'"]\z/, " \\1")
+      def label(text) = dim(text.ljust(6))
 
       def clock(seconds)
         format("%02d:%02d:%02d", seconds / 3600, (seconds % 3600) / 60, seconds % 60)
       end
 
-      def label(text) = text.ljust(16)
-
-      def tint(text, color) = color == :dim ? dim(text) : send(color, text)
-
-      def bold(text) = "\e[1m#{text}\e[0m"
-      def dim(text) = "\e[2m#{text}\e[0m"
-      def red(text) = "\e[31m#{text}\e[0m"
-      def green(text) = "\e[32m#{text}\e[0m"
-      def yellow(text) = "\e[33m#{text}\e[0m"
-      def magenta(text) = "\e[35m#{text}\e[0m"
+      def paint(text, color) = @color ? "\e[#{color}m#{text}\e[0m" : text
+      def dim(text) = @color ? "\e[2m#{text}\e[0m" : text
     end
   end
 end

data/lib/txray/reporters/text.rb

@@ -1,44 +1,93 @@
 # frozen_string_literal: true
 
+require "io/console"
+
 module Txray
   module Reporters
     class Text
-      COLORS = { high: 31, medium: 33, low: 36 }.freeze
+      COLORS = { high: 91, medium: 93, low: 96 }.freeze
 
-      def initialize(io: $stdout, color: io.tty?)
+      def initialize(io: $stdout, color: Reporters.color?(io))
         @io = io
         @color = color
+        @width = width
       end
 
       def report(result)
-        result.offenses.group_by(&:path).each do |path, offenses|
-          @io.puts bold(path)
-          offenses.each { |offense| print_offense(offense) }
-          @io.puts
+        result.offenses.group_by(&:path).each_with_index do |(path, offenses), index|
+          @io.puts if index.positive?
+          heading(path, offenses)
+          offenses.each_with_index do |offense, position|
+            @io.puts if position.positive?
+            offense_body(offense)
+          end
         end
-        print_summary(result)
+
+        @io.puts
+        summary(result)
       end
 
       private
 
-      def print_offense(offense)
-        @io.puts "  #{offense.line}:#{offense.column}  #{tint(offense.severity.to_s.ljust(6), offense.severity)} #{offense.id}"
-        @io.puts "    #{offense.message}"
-        offense.trace.each { |frame| @io.puts dim("      via #{frame}") }
-        @io.puts dim("    #{offense.rule.remedy}")
+      def heading(path, offenses)
+        count = "#{offenses.size} #{offenses.size == 1 ? "offense" : "offenses"}"
+        leader = "·" * [ @width - path.length - count.length - 2, 3 ].max
+        @io.puts "#{bold(path)} #{dim(leader)} #{dim(count)}"
+      end
+
+      def offense_body(offense)
+        @io.puts "  #{location(offense)}  #{tint(offense.severity.to_s.ljust(6), offense.severity)}  " \
+                 "#{tint(offense.id, offense.severity)}"
+        paragraph(offense.message, "      ", 6).each { |line| @io.puts line }
+        offense.trace.each { |frame| @io.puts dim("      └ via #{frame}") }
+        paragraph(offense.rule.remedy, "      → ", 8).each { |line| @io.puts dim(line) }
+      end
+
+      def paragraph(text, prefix, indent)
+        lines = fold(text, [ @width - indent, 24 ].max)
+        [ "#{prefix}#{lines.first}", *lines.drop(1).map { |line| "#{" " * indent}#{line}" } ]
+      end
+
+      def fold(text, budget)
+        text.split.each_with_object([ "" ]) do |word, lines|
+          if lines.last.empty?
+            lines[-1] = word
+          elsif lines.last.length + 1 + word.length <= budget
+            lines[-1] = "#{lines.last} #{word}"
+          else
+            lines << word
+          end
+        end
       end
 
-      def print_summary(result)
+      def location(offense) = "#{offense.line}:#{offense.column}".ljust(7)
+
+      def summary(result)
         counts = result.counts
-        summary = Offense::SEVERITIES.reverse.filter_map { |s| "#{counts[s]} #{s}" if counts[s] }
-        @io.puts "#{result.files.size} files scanned, #{result.offenses.size} offenses" \
-                 "#{" (#{summary.join(", ")})" unless summary.empty?}"
+        parts = [ "#{result.files.size} files scanned", "#{result.offenses.size} offenses" ]
+        parts += Offense::SEVERITIES.reverse.filter_map do |severity|
+          tint("#{counts[severity]} #{severity}", severity) if counts[severity]
+        end
+
+        @io.puts dim("─" * @width)
+        @io.puts parts.join(dim(" · "))
+        skipped(result)
+      end
+
+      def skipped(result)
         return if result.skipped.to_a.empty?
 
         @io.puts dim("#{result.skipped.size} files could not be parsed and were skipped:")
         result.skipped.each { |path| @io.puts dim("  #{path}") }
       end
 
+      def width
+        columns = IO.console&.winsize&.last
+        (columns.to_i.positive? ? columns : 88).clamp(40, 100)
+      rescue StandardError
+        88
+      end
+
       def tint(text, severity) = @color ? "\e[#{COLORS.fetch(severity, 0)}m#{text}\e[0m" : text
       def bold(text) = @color ? "\e[1m#{text}\e[0m" : text
       def dim(text) = @color ? "\e[2m#{text}\e[0m" : text

data/lib/txray/reporters.rb

@@ -8,6 +8,10 @@ require_relative "reporters/live"
 
 module Txray
   module Reporters
+    def self.color?(io)
+      ENV["NO_COLOR"].to_s.empty? && io.respond_to?(:tty?) && io.tty?
+    end
+
     FORMATS = { "text" => Text, "json" => Json, "sarif" => Sarif, "github" => Github }.freeze
 
     def self.build(format, io: $stdout)