rspec-time-guard 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2236097d6377167a8f7a07f9d37e1d23ca71110aabdfcf0e6b79ca2d9783c8e5
-  data.tar.gz: d9b596f350b3efef6f8fe67513aa7dd03c933208196cbb31808b8d79e305411b
+  metadata.gz: 4bad43592a970ed079b0883df9ffe00474007e363c44647866721dc945a3fd89
+  data.tar.gz: 6f0c0134b10dc3305ad99bdfd7bb0074734371e5592162688dc1f5550d9c95b9
 SHA512:
-  metadata.gz: 3f8aab7a4360a8226ca00e4501eedca92b7c2fdebffcffb89ae5f92e6e7a700b4e225d37445140e6888e8fa58643dea80be4c06d6ef849a02ddb0aa3297532e2
-  data.tar.gz: 006735ff24aa6e288d72d043f7efad35169d4af3c481de695ae3dcc2d5cfc868cc29c28139c7107badf77025fbee846a2e90885e6556d709822982711bf23e81
+  metadata.gz: 775b1ddce8ca6055891d5b12db00d5e3b25aa40b4c6c14697f6231ed6e45b372ecf9db94666ab7a2d2c251a52a7ba9e0d81de85f48a132e900cd67d76da5dff8
+  data.tar.gz: e9097575f7a1d33c07fd339a68294d6b61c9c65397504ef556fc36740c2fde87e48cf154e3b3d50007b0642803476242fc88ca0c5b5f03584dcc5cd5d0745451

data/CHANGELOG.md

@@ -1,4 +1,6 @@
-## [Unreleased]
+## [0.2.0] - 2025-04-22
+- Experimental new implementation, using a single-threaded monitoring approach
+
 
 ## [0.1.0] - 2025-03-11
 

data/README.md

@@ -4,30 +4,33 @@
 
 # RspecTimeGuard
 
-`RspecTimeGuard` helps you identify and manage slow-running tests in your RSpec test suite by setting time limits on individual examples or globally across your test suite.
+`RspecTimeGuard` monitors your tests as they run and provides safeguards against tests that take too long, helping you maintain a fast, reliable test suite.
 
+Why `RspecTimeGuard`?
+- **🔍 Catches slow tests** with customizable time limits and warnings
+- **🛑 Prevents runaway tests** from blocking your CI pipeline
+- **📊 Identifies bottlenecks** in your test suite to help you optimize
 
-## Installation
 
-Add this line to your application's Gemfile:
+## Quick Start
 
 ```ruby
+# Add to your Gemfile
 gem 'rspec-time-guard'
-```
-
-And then execute:
 
-```bash
-$ bundle install
+# In spec_helper.rb or rails_helper.rb
+require 'rspec_time_guard'
 ```
 
-Or install it globally:
+Tag individual tests with specific time limits:
 
-```bash
-$ gem install rspec-time-guard
+```ruby
+it "completes quickly", time_limit_seconds: 0.5 do
+  # This test will fail if it takes more than 0.5 seconds
+  expect(fast_operation).to be_truthy
+end
 ```
 
-
 ## Usage
 
 ### Basic Setup
@@ -56,7 +59,7 @@ Create an initializer at `config/initializers/rspec_time_guard.rb` (for Rails) o
 RspecTimeGuard.configure do |config|
   # Set a global time limit in seconds for all examples (nil = no global limit)
   config.global_time_limit_seconds = 1.0
-  
+
   # Whether to continue running tests that exceed their time limit
   # true = shows warning but allows test to complete
   # false = raises TimeLimitExceededError and stops the test (default)
@@ -91,7 +94,7 @@ describe "operations that need more time", time_limit_seconds: 5 do
   it "does a complex operation" do
     # ...
   end
-  
+
   it "does another complex operation" do
     # ...
   end
@@ -149,7 +152,7 @@ RSpec.describe User, type: :model do
     user = User.new(email: "invalid")
     expect(user.valid?).to be false
   end
-  
+
   # This test will use the global time limit if configured
   it "can generate a profile" do
     user = User.create(name: "John", email: "john@example.com")
@@ -168,6 +171,8 @@ RSpec Time Guard works by:
 3. Monitoring execution time
 4. Taking action if the time limit is exceeded
 
+### Performance Considerations
+> ⚠️ **Note**: Setting a global time limit with `global_time_limit_seconds` creates a monitoring thread for each test in your suite. This may result in slightly reduced performance, especially in large test suites. For optimal performance, you might consider applying time limits only to specific tests that are prone to slowness rather than setting a global limit.
 
 ## Contributing
 

data/lib/rspec_time_guard/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RspecTimeGuard
-  VERSION = "0.1.0"
+  VERSION = '0.2.0'
 end

data/lib/rspec_time_guard.rb

@@ -7,6 +7,94 @@ require "rspec_time_guard/railtie" if defined?(Rails)
 module RspecTimeGuard
   class TimeLimitExceededError < StandardError; end
 
+  class TimeoutMonitor
+    def initialize
+      @active_tests = {}
+      @mutex = Mutex.new
+      @monitor_thread = nil
+    end
+
+    def register_test(example, timeout, thread)
+      @mutex.synchronize do
+        @active_tests[example.object_id] = {
+          example: example,
+          start_time: Time.now,
+          timeout: timeout,
+          thread_id: thread.object_id,
+          warned: false
+        }
+
+        # NOTE: We start monitor thread if not already running
+        start_monitor_thread if @monitor_thread.nil? || !@monitor_thread.alive?
+      end
+    end
+
+    def unregister_test(example)
+      @mutex.synchronize do
+        @active_tests.delete(example.object_id)
+      end
+    end
+
+    private
+
+    def start_monitor_thread
+      @monitor_thread = Thread.new do
+        Thread.current[:name] = "rspec_time_guard_monitor"
+
+        loop do
+          check_for_timeouts
+          sleep 0.5 # Check every half second, adjust as needed
+
+          # Exit thread if no more tests to monitor
+          break if @mutex.synchronize { @active_tests.empty? }
+        end
+      end
+    end
+
+    def check_for_timeouts
+      now = Time.now
+      timed_out_examples = []
+
+      @mutex.synchronize do
+        @active_tests.each do |_, info|
+          elapsed = now - info[:start_time]
+          timed_out_examples << info[:example] if elapsed > info[:timeout]
+        end
+      end
+
+      # NOTE: We handle timeouts outside the mutex to avoid deadlocks
+      timed_out_examples.each do |example|
+        group_name = example.example_group.description
+        test_name = example.description
+        timeout = @active_tests[example.object_id][:timeout]
+        elapsed = now - @active_tests[example.object_id][:start_time]
+        thread = begin
+          ObjectSpace._id2ref(@active_tests[example.object_id][:thread_id])
+        rescue
+          nil
+        end
+
+        next unless thread.alive?
+
+        # NOTE: We create an error for RSpec to report
+        error = TimeLimitExceededError.new("Test '#{group_name} #{test_name}' timed out after #{timeout}s (took #{elapsed.round(2)}s)")
+        error.set_backtrace(thread.backtrace || [])
+
+        if RspecTimeGuard.configuration.continue_on_timeout
+          next if @active_tests[example.object_id][:warned]
+
+          warn "WARNING [RSpecTimeGuard] - #{error.message}"
+
+          @active_tests[example.object_id][:warned] = true
+        else
+          # NOTE: We use Thread.raise which is safer than Thread.kill
+          # This allows the thread to clean up properly
+          thread.raise(error)
+        end
+      end
+    end
+  end
+
   class << self
     def configure
       yield(configuration)
@@ -16,10 +104,17 @@ module RspecTimeGuard
       @_configuration ||= RspecTimeGuard::Configuration.new
     end
 
+    def monitor
+      @_monitor ||= TimeoutMonitor.new
+    end
+
+    # TODO: check warnings on test suite
+    # TODO: run test suite with new implementation and compare perfs
+    # TODO: speed up test suite
+    #   => implement the 'single monitor thread' alternative
+    # TODO: CHeck how it works with other Ruby interpreters? (check which implem was tested)
     # TODO: Handle RSpec summary manually?
-    # TODO: Check that it doesn't break RSpec parallel runs in CI (if any)
     # TODO: Run profiling on the whole test suite to check for performance issues
-    # TODO: add PR template
     def setup
       RSpec.configure do |config|
         config.around(:each) do |example|
@@ -27,36 +122,15 @@ module RspecTimeGuard
 
           next example.run unless time_limit_seconds
 
-          completed = false
-
-          # NOTE: We instantiate a monitoring thread, to allow the example to run in the main RSpec thread.
-          # This is required to keep the RSpec context.
-          monitor_thread = Thread.new do
-            Thread.current.report_on_exception = false
-
-            # NOTE: The following logic:
-            #  - Waits for the duration of the time limit
-            #  - If the main thread is still running at that stage, raises a TimeLimitExceededError
-            sleep time_limit_seconds
-
-            unless completed
-              message = "[RspecTimeGuard] Example exceeded timeout of #{time_limit_seconds} seconds"
-              if RspecTimeGuard.configuration.continue_on_timeout
-                warn "#{message} - Running the example anyway (:continue_on_timeout option set to TRUE)"
-                example.run
-              else
-                Thread.main.raise RspecTimeGuard::TimeLimitExceededError, message
-              end
-            end
-          end
+          RspecTimeGuard.monitor.register_test(example, time_limit_seconds, Thread.current)
 
-          # NOTE: Main RSpec thread execution
           begin
             example.run
-            completed = true
+          rescue RspecTimeGuard::TimeLimitExceededError => e
+            # NOTE: This changes the example's status to failed and records our error
+            example.exception = e
           ensure
-            # NOTE: We explicitly clean up the monitoring thread in case the example completes before the time limit.
-            monitor_thread.kill if monitor_thread.alive?
+            RspecTimeGuard.monitor.unregister_test(example)
           end
         end
       end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rspec-time-guard
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Lucas Montorio
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-04-03 00:00:00.000000000 Z
+date: 2025-04-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler