txray 0.1.0 → 0.2.1

data/lib/txray/runtime.rb

@@ -89,6 +89,22 @@ module Txray
         @sink.write(event)
       end
 
+      def open_transaction
+        Stack.push(app_backtrace.first)
+      end
+
+      def close_transaction(outcome)
+        transaction = Stack.pop
+        return if transaction.nil? || ignoring?
+
+        duration = transaction.duration_ms
+        slow = duration >= @options[:threshold_ms]
+        return unless slow || transaction.violations.any?
+
+        report(transaction.to_event(outcome || :commit))
+        announce_slow(duration) if slow
+      end
+
       private
 
       def announce(rule, message)
@@ -121,31 +137,25 @@ module Txray
       end
 
       def watch_transactions
-        subscribe("start_transaction.active_record") { open_transaction }
-        subscribe("transaction.active_record") { |event| close_transaction(event) }
-      end
-
-      def open_transaction
-        Stack.push(app_backtrace.first)
+        if notifies_transaction_start?
+          subscribe("start_transaction.active_record") { open_transaction }
+          subscribe("transaction.active_record") { |event| close_transaction(event.payload[:outcome]) }
+        else
+          patch_transaction_manager
+        end
       end
 
-      def close_transaction(event)
-        transaction = Stack.pop
-        return if ignoring?
-
-        duration = transaction&.duration_ms || event.duration.round(1)
-        slow = duration >= @options[:threshold_ms]
-        violations = transaction&.violations.to_a
-        return unless slow || violations.any?
+      def notifies_transaction_start?
+        return false unless defined?(ActiveRecord::VERSION::STRING)
 
-        outcome = event.payload[:outcome] || :commit
-        report((transaction&.to_event(outcome) || fallback_event(duration, outcome)).merge(duration_ms: duration))
-        announce_slow(duration) if slow
+        Gem::Version.new(ActiveRecord::VERSION::STRING) >= Gem::Version.new("7.2")
       end
 
-      def fallback_event(duration, outcome)
-        { type: "transaction", at: Time.now.to_f, pid: Process.pid, duration_ms: duration,
-          outcome: outcome.to_s, source: app_backtrace.first, violations: [] }
+      def patch_transaction_manager
+        return if @transactions_patched
+
+        ActiveRecord::ConnectionAdapters::DatabaseStatements.prepend(TransactionTimer)
+        @transactions_patched = true
       end
 
       def announce_slow(duration)
@@ -179,6 +189,23 @@ module Txray
       end
     end
 
+    module TransactionTimer
+      def within_new_transaction(*, **, &)
+        return super unless Txray::Runtime.installed?
+
+        Txray::Runtime.open_transaction
+        outcome = :commit
+        begin
+          super
+        rescue Exception # rubocop:disable Lint/RescueException
+          outcome = :rollback
+          raise
+        ensure
+          Txray::Runtime.close_transaction(outcome)
+        end
+      end
+    end
+
     module NetHttpGuard
       def request(req, body = nil, &)
         return super unless Txray::Runtime.transaction_open?

data/lib/txray/scanner.rb

@@ -43,11 +43,24 @@ module Txray
     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
+      roots.flat_map { |root| expand(root).reject { |path| excluded?(path, root) } }
+           .map { |path| relative(path) }.uniq.sort
     end
 
     private
 
+    def relative(path)
+      absolute = resolve(path)
+      root = "#{Dir.pwd}#{File::SEPARATOR}"
+      absolute.start_with?(root) ? absolute.delete_prefix(root) : path
+    end
+
+    def resolve(path)
+      File.realpath(path)
+    rescue StandardError
+      File.expand_path(path)
+    end
+
     def verify(roots)
       missing = roots.reject { |root| File.exist?(root) }
       raise Error, "no such file or directory: #{missing.join(", ")}" if missing.any?

data/lib/txray/source_file.rb

@@ -2,7 +2,7 @@
 
 module Txray
   class SourceFile
-    DIRECTIVE = /#\s*txray:disable(?<rules>[\w,\s-]*)/
+    DIRECTIVE = /\A#\s*txray:(?<action>disable|enable)\b(?<rules>[\w,\s-]*)/
 
     attr_reader :path, :root
 
@@ -11,33 +11,79 @@ module Txray
       result = Prism.parse(code)
       return nil if result.failure?
 
-      new(path: path, root: result.value, comments: result.comments)
+      new(path: path, root: result.value, comments: result.comments, code: code)
     rescue StandardError
       nil
     end
 
-    def initialize(path:, root:, comments: [])
+    def initialize(path:, root:, comments: [], code: "")
       @path = path
       @root = root
-      @directives = build_directives(comments)
+      @lines = code.lines
+      @inline = {}
+      @regions = []
+      index(comments)
     end
 
     def disabled?(line, rule_id)
-      rules = @directives[line] || @directives[line - 1]
+      return true if covers?(@inline[line], rule_id)
+
+      @regions.any? { |region| line.between?(region[:from], region[:to]) && covers?(region[:rules], rule_id) }
+    end
+
+    private
+
+    def covers?(rules, rule_id)
       return false if rules.nil?
 
       rules.empty? || rules.include?(rule_id)
     end
 
-    private
+    def index(comments)
+      open = {}
 
-    def build_directives(comments)
-      comments.each_with_object({}) do |comment, directives|
-        match = DIRECTIVE.match(comment.slice)
+      comments.each do |comment|
+        match = DIRECTIVE.match(comment.slice.to_s.strip)
         next unless match
 
-        directives[comment.location.start_line] = match[:rules].to_s.split(/[,\s]+/).reject(&:empty?)
+        apply(match, comment, open)
+      end
+
+      open.each { |key, from| @regions << region(key, from, Float::INFINITY) }
+    end
+
+    def apply(match, comment, open)
+      rules = named_rules(match[:rules])
+      line = comment.location.start_line
+
+      if trailing?(comment)
+        @inline[line] = rules if match[:action] == "disable"
+      elsif match[:action] == "disable"
+        (rules.empty? ? [ :all ] : rules).each { |key| open[key] ||= line }
+      else
+        close(open, rules, line)
       end
     end
+
+    def close(open, rules, line)
+      keys = rules.empty? ? open.keys.dup : rules
+      keys.each do |key|
+        from = open.delete(key)
+        @regions << region(key, from, line) if from
+      end
+    end
+
+    def region(key, from, to)
+      { from: from, to: to, rules: key == :all ? [] : [ key ] }
+    end
+
+    def named_rules(text)
+      text.to_s.split(/[,\s]+/).reject { |rule| rule.empty? || rule == "all" }
+    end
+
+    def trailing?(comment)
+      prefix = @lines[comment.location.start_line - 1].to_s[0, comment.location.start_column].to_s
+      !prefix.strip.empty?
+    end
   end
 end

data/lib/txray/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: txray
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Theo Wecker
@@ -37,10 +37,15 @@ extensions: []
 extra_rdoc_files: []
 files:
 - CHANGELOG.md
+- CONTRIBUTING.md
 - LICENSE.txt
 - README.md
 - Rakefile
+- doc/monitor.png
+- doc/monitor.svg
 - exe/txray
+- lib/generators/txray/install_generator.rb
+- lib/generators/txray/templates/txray.yml
 - lib/txray.rb
 - lib/txray/analyzer.rb
 - lib/txray/catalog.rb
@@ -94,7 +99,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.8
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Static analysis that finds slow work hidden inside database transactions.
 test_files: []