txray 0.1.0

data/lib/txray/scanner.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Txray
+  Result = Struct.new(:offenses, :files, :skipped, keyword_init: true) do
+    def counts = offenses.group_by(&:severity).transform_values(&:size)
+    def worst = offenses.map(&:severity_rank).max
+    def failing?(level) = worst && worst >= (Offense::SEVERITIES.index(level) || Offense::SEVERITIES.size)
+  end
+
+  class Scanner
+    def initialize(config, paths: nil)
+      @config = config
+      @paths = Array(paths).reject(&:empty?)
+    end
+
+    def run
+      sources = []
+      skipped = []
+      files.each do |path|
+        source = SourceFile.parse(path)
+        source ? sources << source : skipped << path
+      end
+
+      Result.new(offenses: analyze(sources), files: sources.map(&:path), skipped: skipped)
+    end
+
+    def analyze(sources)
+      index = MethodIndex.new
+      clients = ClientIndex.new(Classifier.new(@config))
+      sources.each do |source|
+        index.index(source)
+        clients.index(source)
+      end
+
+      analyzer = Analyzer.new(index: index, clients: clients, config: @config)
+      dedupe(sources.flat_map { |source| analyzer.call(source) }).sort_by(&:sort_key)
+    end
+
+    def dedupe(offenses)
+      offenses.group_by(&:key).values.map { |group| group.min_by { |offense| offense.trace.size } }
+    end
+
+    def files
+      roots = @paths.empty? ? @config.includes : @paths
+      verify(roots) unless @paths.empty?
+      roots.flat_map { |root| expand(root).reject { |path| excluded?(path, root) } }.uniq.sort
+    end
+
+    private
+
+    def verify(roots)
+      missing = roots.reject { |root| File.exist?(root) }
+      raise Error, "no such file or directory: #{missing.join(", ")}" if missing.any?
+    end
+
+    def expand(root)
+      return [ root ] if File.file?(root)
+
+      Dir.glob(File.join(root, "**", "*.rb"))
+    end
+
+    def excluded?(path, root)
+      relative = path.delete_prefix(root.chomp(File::SEPARATOR)).delete_prefix(File::SEPARATOR)
+      segments = relative.split(File::SEPARATOR)
+      @config.excludes.any? do |pattern|
+        segments.include?(pattern) || File.fnmatch?(pattern, relative, File::FNM_PATHNAME)
+      end
+    end
+  end
+end

data/lib/txray/source_file.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Txray
+  class SourceFile
+    DIRECTIVE = /#\s*txray:disable(?<rules>[\w,\s-]*)/
+
+    attr_reader :path, :root
+
+    def self.parse(path, code: nil)
+      code ||= File.read(path)
+      result = Prism.parse(code)
+      return nil if result.failure?
+
+      new(path: path, root: result.value, comments: result.comments)
+    rescue StandardError
+      nil
+    end
+
+    def initialize(path:, root:, comments: [])
+      @path = path
+      @root = root
+      @directives = build_directives(comments)
+    end
+
+    def disabled?(line, rule_id)
+      rules = @directives[line] || @directives[line - 1]
+      return false if rules.nil?
+
+      rules.empty? || rules.include?(rule_id)
+    end
+
+    private
+
+    def build_directives(comments)
+      comments.each_with_object({}) do |comment, directives|
+        match = DIRECTIVE.match(comment.slice)
+        next unless match
+
+        directives[comment.location.start_line] = match[:rules].to_s.split(/[,\s]+/).reject(&:empty?)
+      end
+    end
+  end
+end

data/lib/txray/tail.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Txray
+  class Tail
+    INTERVAL = 0.15
+
+    def initialize(path, from_start: false)
+      @path = path
+      @skip_existing = !from_start && File.exist?(path)
+    end
+
+    def each_batch
+      loop do
+        yield read
+        sleep INTERVAL
+      end
+    end
+
+    private
+
+    def read
+      return [] unless File.exist?(@path)
+
+      reopen if @file.nil? || rotated?
+      @file.read.to_s.lines.map(&:chomp).reject(&:empty?)
+    rescue StandardError
+      []
+    end
+
+    def rotated?
+      return true unless File.identical?(@path, @file)
+
+      File.size(@path) < @file.pos
+    end
+
+    def reopen
+      @file&.close
+      @file = File.open(@path, "r")
+      @file.seek(0, IO::SEEK_END) if @skip_existing
+      @skip_existing = false
+    end
+  end
+end

data/lib/txray/tasks.rake

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+namespace :txray do
+  desc "Scan the application for transactions that hold the database open"
+  task :scan do
+    require "txray"
+    exit Txray::CLI.start(ENV.fetch("TXRAY_ARGS", "").split)
+  end
+end

data/lib/txray/transaction_scope.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module Txray
+  TransactionScope = Struct.new(:kind, :label, :body, :namespace, :source, :line, keyword_init: true) do
+    def path = source.path
+  end
+
+  class ScopeFinder
+    LOCK_BLOCKS = %i[with_lock with_advisory_lock].freeze
+
+    def initialize(index)
+      @index = index
+    end
+
+    def call(source)
+      migrations = Set.new
+      modules = Set.new
+      scopes = []
+
+      Namespaces.each(source.root) do |namespace, node|
+        case node
+        when Prism::ClassNode then migrations << namespace if transactional_migration?(node)
+        when Prism::ModuleNode then modules << namespace
+        when Prism::CallNode then scopes.concat(from_call(namespace, node, source, modules))
+        when Prism::DefNode then scopes.concat(from_definition(namespace, node, source, migrations))
+        end
+      end
+
+      scopes.compact
+    end
+
+    private
+
+    def from_call(namespace, call, source, modules)
+      case call.name
+      when *Catalog::CALLBACKS then registration_scopes(namespace, call, source, "callback", modules)
+      when :validate then registration_scopes(namespace, call, source, "validation", modules)
+      when :transaction then [ block_scope(namespace, call, source, :transaction, transaction_label(call)) ]
+      when *LOCK_BLOCKS then [ block_scope(namespace, call, source, :lock, "a `#{call.name}` block") ]
+      else []
+      end
+    end
+
+    def registration_scopes(namespace, call, source, noun, modules)
+      return [] unless call.receiver.nil?
+
+      scopes = NodeHelpers.symbol_arguments(call).filter_map do |method_name|
+        entry = @index.lookup(namespace, method_name)
+        entry ||= @index.unique(method_name) if modules.include?(namespace)
+        next unless entry&.node&.body
+
+        TransactionScope.new(
+          kind: :callback,
+          label: "the `#{call.name} :#{method_name}` #{noun}",
+          body: entry.node.body,
+          namespace: entry.namespace,
+          source: entry.source,
+          line: call.location.start_line
+        )
+      end
+
+      scopes << block_scope(namespace, call, source, :callback, "the `#{call.name}` #{noun} block")
+      scopes
+    end
+
+    def block_scope(namespace, call, source, kind, label)
+      body = NodeHelpers.block_body(call)
+      return unless body
+
+      TransactionScope.new(
+        kind: kind,
+        label: label,
+        body: body,
+        namespace: namespace,
+        source: source,
+        line: call.location.start_line
+      )
+    end
+
+    def transaction_label(call)
+      receiver = NodeHelpers.receiver_name(call)
+      receiver ? "the `#{receiver}.transaction` block" : "an explicit `transaction` block"
+    end
+
+    def from_definition(namespace, node, source, migrations)
+      return [] if node.body.nil?
+
+      if migrations.include?(namespace) && Catalog::MIGRATION_METHODS.include?(node.name)
+        return [ scope_for(:migration, "`#{namespace}##{node.name}`, which runs in a DDL transaction", node,
+                           namespace, source) ]
+      end
+
+      return [] unless locks_row?(node.body)
+
+      [ scope_for(:lock, "`#{namespace}##{node.name}`, which locks a row", node, namespace, source) ]
+    end
+
+    def scope_for(kind, label, node, namespace, source)
+      TransactionScope.new(
+        kind: kind,
+        label: label,
+        body: node.body,
+        namespace: namespace,
+        source: source,
+        line: node.location.start_line
+      )
+    end
+
+    def transactional_migration?(node)
+      return false unless node.superclass&.slice.to_s.include?("ActiveRecord::Migration")
+
+      NodeHelpers.each_node(node.body) do |child|
+        return false if child.is_a?(Prism::CallNode) && child.name == :disable_ddl_transaction!
+      end
+      true
+    end
+
+    def locks_row?(body)
+      NodeHelpers.each_node(body) do |node|
+        return true if node.is_a?(Prism::CallNode) && node.name == :lock! && node.block.nil?
+      end
+      false
+    end
+  end
+end

data/lib/txray/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Txray
+  VERSION = "0.1.0"
+end

data/lib/txray/watch_command.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Txray
+  class WatchCommand
+    def initialize(path:, threshold_ms:, io: $stdout, from_start: false)
+      @path = path
+      @io = io
+      @monitor = Monitor.new(threshold_ms: threshold_ms)
+      @tail = Tail.new(path, from_start: from_start)
+      @view = Reporters::Live.new(io: io, path: path, threshold_ms: threshold_ms)
+    end
+
+    def run
+      return stream unless @io.tty?
+
+      @view.open
+      @view.draw(@monitor)
+      @tail.each_batch do |lines|
+        next if lines.empty?
+
+        lines.each { |line| @monitor.absorb(line) }
+        @view.draw(@monitor)
+      end
+    rescue Interrupt
+      nil
+    ensure
+      @view.close(@monitor) if @io.tty?
+    end
+
+    private
+
+    def stream
+      @tail.each_batch do |lines|
+        lines.each do |line|
+          event = @monitor.absorb(line)
+          @io.puts(JSON.generate(event)) if event
+        end
+      end
+    rescue Interrupt
+      nil
+    end
+  end
+end

data/lib/txray.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "txray/version"
+require_relative "txray/error"
+require_relative "txray/node_helpers"
+require_relative "txray/catalog"
+require_relative "txray/rule"
+require_relative "txray/config"
+require_relative "txray/offense"
+require_relative "txray/source_file"
+require_relative "txray/method_index"
+require_relative "txray/transaction_scope"
+require_relative "txray/classifier"
+require_relative "txray/client_index"
+require_relative "txray/analyzer"
+require_relative "txray/scanner"
+require_relative "txray/monitor"
+require_relative "txray/tail"
+require_relative "txray/reporters"
+require_relative "txray/watch_command"
+require_relative "txray/runtime"
+require_relative "txray/cli"
+
+module Txray
+  def self.scan(paths = nil, config: Config.load)
+    Scanner.new(config, paths: paths).run
+  end
+
+  def self.analyze(code, path: "(string)", config: Config.new)
+    source = SourceFile.parse(path, code: code) or return []
+    Scanner.new(config).analyze([ source ]).sort_by(&:sort_key)
+  end
+end
+
+require_relative "txray/railtie" if defined?(Rails::Railtie)

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: txray
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Theo Wecker
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: prism
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.24'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.24'
+description: txray parses your Rails application with Prism and follows callbacks,
+  concerns and helper methods to find HTTP requests, external service clients, mail
+  delivery, job enqueues, subprocesses and unbounded loops running inside database
+  transactions. It needs no application boot and no test coverage, so it reports problems
+  on code paths your suite never executes. An optional runtime guard reports the same
+  problems from a running application.
+email:
+- tlwecker@yahoo.com
+executables:
+- txray
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- exe/txray
+- lib/txray.rb
+- lib/txray/analyzer.rb
+- lib/txray/catalog.rb
+- lib/txray/classifier.rb
+- lib/txray/cli.rb
+- lib/txray/client_index.rb
+- lib/txray/config.rb
+- lib/txray/error.rb
+- lib/txray/method_index.rb
+- lib/txray/monitor.rb
+- lib/txray/node_helpers.rb
+- lib/txray/offense.rb
+- lib/txray/railtie.rb
+- lib/txray/reporters.rb
+- lib/txray/reporters/github.rb
+- lib/txray/reporters/json.rb
+- lib/txray/reporters/live.rb
+- lib/txray/reporters/sarif.rb
+- lib/txray/reporters/text.rb
+- lib/txray/rule.rb
+- lib/txray/runtime.rb
+- lib/txray/runtime/sink.rb
+- lib/txray/runtime/transaction.rb
+- lib/txray/scanner.rb
+- lib/txray/source_file.rb
+- lib/txray/tail.rb
+- lib/txray/tasks.rake
+- lib/txray/transaction_scope.rb
+- lib/txray/version.rb
+- lib/txray/watch_command.rb
+homepage: https://github.com/theowecker/txray
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/theowecker/txray
+  bug_tracker_uri: https://github.com/theowecker/txray/issues
+  changelog_uri: https://github.com/theowecker/txray/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.8
+specification_version: 4
+summary: Static analysis that finds slow work hidden inside database transactions.
+test_files: []