coverband 6.2.0 → 6.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 12802541de3827dd777fba9962270fd2f0a6c7b3debb2ef96c4bcca32f02b48d
-  data.tar.gz: 36fa21009ed2ada842ff90ca4a18195c8bfcddc81ad0951c11f613ede11f6606
+  metadata.gz: c47e38934426a369c81dd7d08e5474ad0d8a784b541975c1aa7ee50fc9e2d1ce
+  data.tar.gz: 346c8263e9c961631bcf4af3019d8473177088c5b9ae3cb3844dc7d86bcd7497
 SHA512:
-  metadata.gz: 03c7e496735cfe705b926b30140b3d704993b0599e470d290fb9ae672a7b204bf5cfa98adfc73d54eb70df1c71e8cbb9d91a5f85862b86d5c2a1ba1d0d3aa704
-  data.tar.gz: 6610a4ec327a69de3bd6878cb256a8f9d605fcf2a4104e6699b6b68acbec3ac9aaaeb957569eaf9ac1e949c58c5a6adbcd75055be464da56a11dde5c873dc4b6
+  metadata.gz: 907a280ce513b23922b81c44674c135ab067e629ae9f8aaec6eb6a667946a52a85fd1e7a0fe17ee9b24c0a6b81b8b22bcb1e1c53e7ce75ccc7a9c3507b6dd183
+  data.tar.gz: 60198f0536094c5505ea532b238d9d38359f936edb6ea21854c946d3a5f63e7e02b66f1240596b787cad898546a3d48d41595d5d4cab28bb09face2a4f405499

data/README.md

@@ -45,6 +45,28 @@ Coverband stores coverage data in Redis. The Redis endpoint is looked for in thi
 
 The redis store can also be explicitly defined within the `config/coverband.rb`. See [advanced config](#advanced-config).
 
+### Redis with TLS
+
+For Redis servers that require TLS (such as AWS serverless ElastiCache), use the `rediss://` URL scheme instead of `redis://`. The Redis gem automatically enables TLS when it detects this scheme:
+
+```bash
+# Example with AWS serverless ElastiCache
+REDIS_URL=rediss://my-elasticache.abcdef.cache.amazonaws.com:6379
+```
+
+Or in `config/coverband.rb`:
+
+```ruby
+config.store = Coverband::Adapters::RedisStore.new(
+  Redis.new(url: "rediss://my-elasticache-endpoint:6379")
+)
+```
+
+The `rediss://` scheme works with:
+- AWS ElastiCache (serverless or provisioned with required TLS)
+- Any self-hosted Redis with TLS enabled
+- Other managed Redis services that require TLS
+
 ## Gem Installation
 
 Add this line to your application's `Gemfile`, remember to `bundle install` after updating:
@@ -271,6 +293,20 @@ This feature is enabled by default. To stop this feature, disable the feature in
 
 `config.track_views = false`
 
+#### ViewComponent Support
+
+Coverband can also track [ViewComponent](https://viewcomponent.org/) renders. This requires:
+
+- ViewComponent **>= 4.6.0**
+- Instrumentation enabled in your app config:
+
+```ruby
+# config/application.rb (or environment-specific config)
+config.view_component.instrumentation_enabled = true
+```
+
+When enabled, Coverband subscribes to the `render.view_component` notification and tracks which component templates are rendered, just like standard Rails views.
+
 ![image](https://raw.github.com/danmayer/coverband/main/docs/coverband_view_tracker.png)
 
 ### Hiding settings
@@ -314,6 +350,8 @@ Add a wiggle (in seconds) to the background thread to avoid all your servers rep
 
 `config.reporting_wiggle = 30`
 
+The default 30-second wiggle is suitable for most deployments. For larger fleets you may want to increase the wiggle proportionally (e.g. 1 second per server). The tradeoff is a small delay in coverage reporting freshness. The `reporting_wiggle` and `background_reporting_sleep_seconds` options work together — consider configuring both when tuning background reporting for your environment.
+
 Another way to avoid cache stampede is to omit some reporting on starting servers. Coverband stores the results of eager_loading to Redis at server startup. The eager_loading results are the same for all servers, so there is no need to save all results. By configuring the eager_loading results of some servers to be stored in Redis, we can reduce the load on Redis during deployment.
 
 ```ruby
@@ -325,11 +363,21 @@ config.send_deferred_eager_loading_data = rand(100) < 5
 config.send_deferred_eager_loading_data = ENV.fetch('ENABLE_EAGER_LOADING_COVERAGE', false)
 ```
 
+Note: `defer_eager_loading_data = true` is required in order to use `send_deferred_eager_loading_data`. With both set, eager_loading data is deferred at startup and only sent by the subset of servers where `send_deferred_eager_loading_data` evaluates to `true`.
+
+### Oneshot Mode
+
+Enabling [oneshot mode](https://docs.ruby-lang.org/en/master/Coverage.html#module-coverage-oneshot-lines-coverage) reduces the Ruby CPU overhead. The tradeoff is that you no longer get frequency data — you will only know whether a line was executed at least once, not how many times.
+
+```ruby
+config.use_oneshot_lines_coverage = true
+```
+
 ### Redis Hash Store
 
 Coverband on very high volume sites with many server processes reporting can have a race condition which can cause hit counts to be inaccurate. To resolve the race condition and reduce Ruby memory overhead we have introduced a new Redis storage option. This moves the some of the work from the Ruby processes to Redis. It is worth noting because of this, it has larger demands on the Redis server. So adjust your Redis instance accordingly. To help reduce the extra redis load you can also change the background reporting frequency.
 
-- Use a dedicated Coverband redis instance: `config.store = Coverband::Adapters::HashRedisStore.new(Redis.new(url: redis_url))`
+- To use Redis Hash Store: `config.store = Coverband::Adapters::HashRedisStore.new(Redis.new(url: redis_url))`
 - Adjust from default 30s reporting `config.background_reporting_sleep_seconds = 120`
 
 See more discussion [here](https://github.com/danmayer/coverband/issues/384).
@@ -402,10 +450,20 @@ gem 'coverband', require: ['alternative_coverband_patch']
 
 This conflict happens when a ruby method is patched twice, once using module prepend, and once using method aliasing. See this ruby issue for details. The fix is to apply all patches the same way. By default, Coverband will apply its patch using prepend, but you can change that to method aliasing by adding require: ['alternative_coverband_patch'] to the gem line as shown above.
 
-### Redis Sizing Info
+### Redis Sizing & Configuration Info
 
 A few folks have asked about what size of Redis is needed to run Coverband. I have some of our largest services with hundreds of servers on cache.m3.medium with plenty of room to spare. I run most apps on the smallest AWS Redis instances available and bump up only if needed or if I am forced to be on a shared Redis instance, which I try to avoid. On Heroku, I have used it with most of the 3rd party and also been fine on the smallest Redis instances, if you have hundreds of dynos you would likely need to scale up. Also note there is a tradeoff one can make, `Coverband::Adapters::HashRedisStore` will use LUA on Redis and increase the Redis load, while being nicer to your app servers and avoid potential lost data during race conditions. While the `Coverband::Adapters::RedisStore` uses in app memory and merging and has lower load on Redis.
 
+For a dedicated Coverband Redis instance, `allkeys-lfu` is a good choice for `maxmemory-policy` as it evicts the least-frequently-used keys first, meaning rarely-hit files are evicted before frequently-reported ones. On a shared Redis instance, be cautious with eviction policies that could interfere with other data. See [issue #595](https://github.com/danmayer/coverband/issues/595) for more discussion.
+
+### Ruby Overhead Reduction Checklist
+
+If Coverband is adding meaningful latency to your application, work through this checklist:
+
+* Enable oneshot mode (`config.use_oneshot_lines_coverage = true`) — reduces CPU overhead by only tracking whether a line ran, not how many times
+* Enable Redis Hash Store — moves merging work from Ruby processes to Redis, reducing per-process memory overhead
+* Only enable Coverband on a subset of server instances — requests routed to those servers will be slightly slower, but coverage data will still be gathered. This is most effective with a Least Outstanding Requests load balancing algorithm. Avoid enabling on all servers but only reporting on a subset of requests — loading the coverage module itself has a performance impact regardless of reporting.
+
 # Newer Features
 
 ### MCP Server for AI Assistants

data/changes.md

@@ -1,3 +1,13 @@
+### 6.2.1
+
+* Fix: Search now includes full filenames hidden by truncation in the web UI; users can search for complete file paths even when displaying truncated versions (#569)
+* Feature: Added support for TLS Redis connections via `rediss://` URL scheme for use with serverless ElastiCache and other TLS-required Redis services (#580)
+* Fix: MCP HTTP handler now properly uses `StreamableHTTPTransport` for full HTTP protocol support including GET, DELETE, and OPTIONS methods (#604)
+* Fix: Suppressed Rails logger stdout pollution in stdio MCP mode to ensure clean JSON-RPC stream for Claude Desktop and other AI clients (#625)
+* Fix: Tracker persistence now gracefully handles non-Redis stores (FileStore, NullStore) without raising errors at process exit (#637)
+* Fix: Resolved Rack 1.6 compatibility issue in web reporter by detecting `Rack::Files` vs `Rack::File` class (#639)
+* Docs: Added TLS Redis setup documentation to README for serverless ElastiCache configurations
+
 ### 6.2.0
 
 * Fix: Correct `Rack::Static` URL handling in the web reporter by using an empty string URL prefix; thanks @alpaca-tc (#635)

data/lib/coverband/collectors/abstract_tracker.rb

@@ -53,6 +53,8 @@ module Coverband
       end
 
       def used_keys
+        return {} unless redis_store
+
         redis_store.hgetall(tracker_key)
       end
 
@@ -74,6 +76,8 @@ module Coverband
       end
 
       def tracking_since
+        return "N/A" unless redis_store
+
         if (tracking_time = redis_store.get(tracker_time_key))
           Time.at(tracking_time.to_i).iso8601
         else
@@ -82,18 +86,24 @@ module Coverband
       end
 
       def reset_recordings
+        return unless redis_store
+
         redis_store.del(tracker_key)
         redis_store.del(tracker_time_key)
       end
 
       def clear_key!(key)
         return unless key
+        return unless redis_store
+
         puts "#{tracker_key} key #{key}"
         redis_store.hdel(tracker_key, key)
         @logged_keys.delete(key)
       end
 
       def save_report
+        return unless redis_store
+
         redis_store.set(tracker_time_key, Time.now.to_i) unless @one_time_timestamp || tracker_time_key_exists?
         @one_time_timestamp = true
         reported_time = Time.now.to_i
@@ -138,10 +148,16 @@ module Coverband
       end
 
       def redis_store
-        store.raw_store
+        @redis_store ||= begin
+          store.raw_store
+        rescue NotImplementedError
+          nil
+        end
       end
 
       def tracker_time_key_exists?
+        return false unless redis_store
+
         if defined?(redis_store.exists?)
           redis_store.exists?(tracker_time_key)
         else

data/lib/coverband/collectors/view_tracker.rb

@@ -33,6 +33,13 @@ module Coverband
         ActiveSupport::Notifications.subscribe(/render_(template|partial|collection).action_view/) do |name, start, finish, id, payload|
           Coverband.configuration.view_tracker.track_key(payload) unless name.include?("!")
         end
+
+        # ViewComponent >= 4.6.0 emits render.view_component with a view_identifier key
+        # containing the template path. Requires config.view_component.instrumentation_enabled = true
+        # in the host app.
+        ActiveSupport::Notifications.subscribe("render.view_component") do |name, start, finish, id, payload|
+          Coverband.configuration.view_tracker.track_key(identifier: payload[:view_identifier]) unless name.include?("!")
+        end
       end
 
       ###
@@ -61,6 +68,8 @@ module Coverband
       end
 
       def used_keys
+        return {} unless redis_store
+
         views = redis_store.hgetall(tracker_key)
         normalized_views = {}
         views.each_pair do |view, time|
@@ -93,6 +102,7 @@ module Coverband
 
       def clear_key!(filename)
         return unless filename
+        return unless redis_store
 
         filename = "#{@project_directory}/#{filename}"
         redis_store.hdel(tracker_key, filename)
@@ -126,7 +136,7 @@ module Coverband
 
       def concrete_target
         if defined?(Rails.application)
-          Dir.glob("#{@project_directory}/{,packs,engines/*}/app/{views,components}/**/*.html.{erb,haml,slim}")
+          Dir.glob("#{@project_directory}/{,packs/*,engines/*}/app/{views,components}/**/*.html.{erb,haml,slim}")
         else
           []
         end

data/lib/coverband/configuration.rb

@@ -213,6 +213,9 @@ module Coverband
         Coverband::Adapters::WebServiceStore.new(service_url)
       else
         begin
+          # Redis gem automatically enables TLS when the scheme is 'rediss://'
+          # For serverless ElastiCache or other TLS-required Redis instances, use:
+          #   REDIS_URL=rediss://your-endpoint:6379
           Coverband::Adapters::RedisStore.new(Redis.new(url: redis_url), redis_store_options)
         rescue Redis::CannotConnectError => error
           logger.info "Redis is not available (#{error}), defaulting to NullStore"

data/lib/coverband/mcp/http_handler.rb

@@ -2,7 +2,7 @@
 
 module Coverband
   module MCP
-    # Rack middleware that adds MCP HTTP endpoint support.
+    # Rack middleware that adds MCP HTTP endpoint support using StreamableHTTPTransport.
     # Can be used to wrap the existing Coverband::Reporters::Web app
     # or mounted standalone.
     #
@@ -10,7 +10,7 @@ module Coverband
     #   map "/coverage" do
     #     run Coverband::MCP::HttpHandler.new(Coverband::Reporters::Web.new)
     #   end
-    #   # MCP endpoint available at POST /coverage/mcp
+    #   # MCP endpoint available at /coverage/mcp with full Streamable HTTP transport support
     #
     # Usage standalone:
     #   map "/mcp" do
@@ -23,6 +23,7 @@ module Coverband
       def initialize(app = nil)
         @app = app
         @server = nil
+        @transport = nil
       end
 
       def call(env)
@@ -40,17 +41,22 @@ module Coverband
       private
 
       def mcp_request?(request)
-        request.post? && request.path_info.end_with?(MCP_PATH)
+        # Accept GET, POST, DELETE, OPTIONS for StreamableHTTPTransport protocol
+        %w[GET POST DELETE OPTIONS].include?(request.request_method) &&
+          request.path_info.end_with?(MCP_PATH)
       end
 
       def handle_mcp_request(request)
+        # Handle CORS preflight
+        return cors_preflight_response if request.request_method == "OPTIONS"
+
         # Check authentication if MCP password is configured
         unless authenticate_mcp_request(request)
           return [401, {
             "Content-Type" => "application/json",
             "Access-Control-Allow-Origin" => "*",
-            "Access-Control-Allow-Methods" => "POST, OPTIONS",
-            "Access-Control-Allow-Headers" => "Content-Type, Authorization",
+            "Access-Control-Allow-Methods" => "GET, POST, DELETE, OPTIONS",
+            "Access-Control-Allow-Headers" => "Content-Type, Authorization, Accept, Mcp-Session-Id",
             "WWW-Authenticate" => 'Bearer realm="Coverband MCP"'
           }, [JSON.generate({
             "error" => "Authentication required",
@@ -58,29 +64,21 @@ module Coverband
           })]]
         end
 
-        body = request.body.read
-        json_request = JSON.parse(body)
-        response = mcp_server.handle_json(json_request)
-
-        # response might already be a JSON string, so check before converting
-        response_body = response.is_a?(String) ? response : response.to_json
-
-        [
-          200,
-          {
-            "content-type" => "application/json",
-            "access-control-allow-origin" => "*",
-            "access-control-allow-methods" => "POST, OPTIONS",
-            "access-control-allow-headers" => "Content-Type"
-          },
-          [response_body]
-        ]
-      rescue JSON::ParserError => e
-        error_response(400, "Invalid JSON: #{e.message}")
+        # Delegate to StreamableHTTPTransport which handles the full MCP HTTP protocol
+        # (GET for SSE streams, POST for requests/responses, DELETE for cleanup, etc.)
+        transport.handle_request(request)
       rescue => e
         error_response(500, "Server error: #{e.message}")
       end
 
+      def cors_preflight_response
+        [204, {
+          "Access-Control-Allow-Origin" => "*",
+          "Access-Control-Allow-Methods" => "GET, POST, DELETE, OPTIONS",
+          "Access-Control-Allow-Headers" => "Content-Type, Authorization, Accept, Mcp-Session-Id"
+        }, []]
+      end
+
       def authenticate_mcp_request(request)
         # If no MCP password is configured, allow access
         mcp_password = Coverband.configuration.mcp_password
@@ -98,8 +96,11 @@ module Coverband
         token == mcp_password
       end
 
-      def mcp_server
-        @server ||= Server.new
+      def transport
+        @transport ||= begin
+          server = ::Coverband::MCP::Server.new
+          ::MCP::Server::Transports::StreamableHTTPTransport.new(server.mcp_server)
+        end
       end
 
       def error_response(status, message)

data/lib/coverband/reporters/web.rb

@@ -32,7 +32,9 @@ module Coverband
 
       def init_web
         full_path = Gem::Specification.find_by_name("coverband").full_gem_path
-        @file_server = Rack::Files.new(
+        # Rack::Files was introduced in Rack 2.0; Rack 1.x uses Rack::File
+        rack_file_server = defined?(Rack::Files) ? Rack::Files : Rack::File
+        @file_server = rack_file_server.new(
           File.expand_path("public", full_path)
         )
       end

data/lib/coverband/utils/configuration_template.rb

@@ -7,6 +7,7 @@
 # Coverband.configure do |config|
 ####
 # set a redis URL and set it with with some reasonable timeouts
+# For TLS connections (e.g. AWS serverless ElastiCache), use rediss:// scheme
 ####
 # redis_url = ENV["COVERBAND_REDIS"] || ENV["REDIS_URL"] || "redis://localhost:6379"
 # config.store = Coverband::Adapters::RedisStore.new(
@@ -18,6 +19,9 @@
 #     reconnect_delay_max: ENV.fetch("REDIS_RECONNECT_DELAY_MAX", 2.5)
 #   )
 # )
+#
+# Example with TLS (rediss:// scheme automatically enables TLS):
+# redis_url = "rediss://my-elasticache.abcdef.cache.amazonaws.com:6379"
 
 # Allow folks to reset the coverband data via the web UI
 # config.web_enable_clear = true

data/lib/coverband/utils/file_list.rb

@@ -11,6 +11,7 @@ module Coverband
   module Utils
     class FileList < Array
       # Returns the count of lines that have coverage
+      # Using sum avoids intermediate array allocation compared to map.inject
       def covered_lines
         return 0.0 if empty?
 

data/lib/coverband/utils/html_formatter.rb

@@ -180,7 +180,10 @@ module Coverband
 
       def link_to_source_file(source_file)
         data_loader_url = "#{base_path}load_file_details?filename=#{source_file.filename}"
-        %(<a href="##{id source_file}" class="src_link" title="#{shortened_filename source_file}" data-loader-url="#{data_loader_url}" onclick="src_link_click(this)">#{truncate(shortened_filename(source_file))}</a>)
+        full_filename = shortened_filename(source_file)
+        truncated_filename = truncate(full_filename)
+        # Include full filename in a hidden span so DataTables search can find it even when truncated
+        %(<a href="##{id source_file}" class="src_link" title="#{full_filename}" data-loader-url="#{data_loader_url}" onclick="src_link_click(this)">#{truncated_filename}<span style="display:none;">#{full_filename}</span></a>)
       end
 
       def truncate(text, length: 50)

data/lib/coverband/utils/tasks.rb

@@ -128,10 +128,28 @@ namespace :coverband do
 
   desc "Start MCP server for AI assistant integration (set COVERBAND_MCP_HTTP=true for HTTP mode)"
   task :mcp do
+    # In stdio mode, we must suppress all non-JSON-RPC output to stdout to comply with
+    # the MCP stdio transport spec. Otherwise, Rails logger and gem output will pollute
+    # the JSON-RPC stream and break clients like Claude Desktop.
+    # See https://github.com/danmayer/coverband/issues/625
+    use_stdio_mode = !ENV["COVERBAND_MCP_HTTP"]
+
+    original_stdout = nil
+    if use_stdio_mode
+      # Save original stdout and redirect stdout to stderr temporarily
+      original_stdout = $stdout
+      $stdout = $stderr
+    end
+
     if Rake::Task.task_defined?("environment")
       Rake.application["environment"].invoke
     end
 
+    if use_stdio_mode
+      # Restore stdout for JSON-RPC communication over stdio
+      $stdout = original_stdout
+    end
+
     begin
       require "coverband/mcp"
     rescue LoadError

data/lib/coverband/version.rb

@@ -5,5 +5,5 @@
 # use format "4.2.1.rc.1" ~> 4.2.1.rc to prerelease versions like v4.2.1.rc.2 and v4.2.1.rc.3
 ###
 module Coverband
-  VERSION = "6.2.0"
+  VERSION = "6.2.1"
 end

data/test/benchmarks/benchmark_file_list_covered_lines.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "benchmark/ips"
+require "memory_profiler"
+
+# Mock SourceFile to simulate the overhead of creating line objects
+class MockSourceFile
+  attr_reader :covered_lines_count
+
+  def initialize(count)
+    @covered_lines_count = count
+  end
+
+  def covered_lines
+    # Simulate allocating an array of objects
+    Array.new(@covered_lines_count) { Object.new }
+  end
+end
+
+class FileList < Array
+  def covered_lines_original
+    return 0.0 if empty?
+    map { |f| f.covered_lines.count }.inject(:+)
+  end
+
+  def covered_lines_optimized
+    return 0.0 if empty?
+    sum(&:covered_lines_count)
+  end
+end
+
+# Generate data: 10,000 files with varying coverage
+files = Array.new(10000) { |i| MockSourceFile.new(i % 100) }
+file_list = FileList.new(files)
+
+puts "---------------------------------------------------"
+puts "Memory Profiling: FileList#covered_lines"
+
+puts "\nOriginal (map.inject):"
+report = MemoryProfiler.report { file_list.covered_lines_original }
+puts "  Total allocated: #{report.total_allocated_memsize} bytes (#{report.total_allocated} objects)"
+
+puts "\nOptimized (sum):"
+report = MemoryProfiler.report { file_list.covered_lines_optimized }
+puts "  Total allocated: #{report.total_allocated_memsize} bytes (#{report.total_allocated} objects)"
+
+puts "\n---------------------------------------------------"
+puts "Benchmark: FileList#covered_lines"
+
+Benchmark.ips do |x|
+  x.report("map.inject") { file_list.covered_lines_original }
+  x.report("sum") { file_list.covered_lines_optimized }
+  x.compare!
+end

data/test/coverband/collectors/view_tracker_test.rb

@@ -107,6 +107,19 @@ class ViewTrackerTest < Minitest::Test
     assert_equal [], tracker.used_keys.keys
   end
 
+  test "track view_component renders via railtie" do
+    Coverband::Collectors::ViewTracker.expects(:supported_version?).returns(true)
+    store = fake_store
+    file_path = "#{File.expand_path(Coverband.configuration.root)}/app/components/example_component.html.erb"
+    tracker = Coverband::Collectors::ViewTracker.new(store: store, roots: "dir")
+    Coverband.configuration.expects(:view_tracker).returns(tracker).at_least_once
+    tracker.railtie!
+
+    ActiveSupport::Notifications.instrument("render.view_component", view_identifier: file_path)
+
+    assert_includes tracker.logged_keys, file_path
+  end
+
   test "reset store" do
     Coverband::Collectors::ViewTracker.expects(:supported_version?).returns(true)
     store = fake_store
@@ -128,6 +141,20 @@ class ViewTrackerTest < Minitest::Test
     assert_equal [], tracker.logged_keys
   end
 
+  test "no-op tracker operations with non-redis stores" do
+    Coverband::Collectors::ViewTracker.expects(:supported_version?).returns(true)
+    store = Coverband::Adapters::NullStore.new
+    tracker = Coverband::Collectors::ViewTracker.new(store: store, roots: "dir")
+
+    tracker.track_key(identifier: "file")
+    tracker.save_report
+
+    assert_equal({}, tracker.used_keys)
+    assert_equal "N/A", tracker.tracking_since
+    assert_nil tracker.reset_recordings
+    assert_nil tracker.clear_key!("file")
+  end
+
   protected
 
   def fake_store

data/test/coverband/configuration_test.rb

@@ -112,4 +112,16 @@ class BaseTest < Minitest::Test
       config.redis_url = "redis://localhost:3333"
     end
   end
+
+  test "redis_url with rediss:// scheme for TLS support" do
+    Coverband::Collectors::Coverage.instance.reset_instance
+    Coverband.configuration.reset
+    # Verify that rediss:// URLs (TLS) can be configured
+    # The Redis gem will automatically enable TLS when it sees the rediss:// scheme
+    Coverband.configure do |config|
+      config.redis_url = "rediss://my-elasticache.example.com:6379"
+    end
+
+    assert_equal "rediss://my-elasticache.example.com:6379", Coverband.configuration.redis_url
+  end
 end

data/test/coverband/mcp/http_handler_test.rb

@@ -37,13 +37,13 @@ if defined?(Coverband::MCP)
       end
     end
 
-    test "handles MCP requests at /mcp endpoint" do
-      # Mock the server to return a simple response
-      server_mock = mock("server")
-      server_mock.expects(:handle_json).returns({"result" => "success"})
+    test "handles MCP POST requests at /mcp endpoint via StreamableHTTPTransport" do
+      # Mock the transport to verify it's called
+      transport_mock = mock("transport")
+      transport_mock.expects(:handle_request).returns([200, {"Content-Type" => "application/json"}, ["{}"]])
 
       handler = Coverband::MCP::HttpHandler.new
-      handler.expects(:mcp_server).returns(server_mock)
+      handler.expects(:transport).returns(transport_mock)
 
       @app = handler
 
@@ -56,12 +56,21 @@ if defined?(Coverband::MCP)
       post "/mcp", json_request, {"CONTENT_TYPE" => "application/json"}
 
       assert_equal 200, last_response.status
-      assert_equal "application/json", last_response.content_type
+    end
 
-      # Check CORS headers
-      assert_equal "*", last_response.headers["Access-Control-Allow-Origin"]
-      assert_equal "POST, OPTIONS", last_response.headers["Access-Control-Allow-Methods"]
-      assert_equal "Content-Type", last_response.headers["Access-Control-Allow-Headers"]
+    test "handles MCP GET requests at /mcp endpoint via StreamableHTTPTransport" do
+      # Mock the transport to verify it's called for GET
+      transport_mock = mock("transport")
+      transport_mock.expects(:handle_request).returns([200, {"Content-Type" => "text/event-stream"}, []])
+
+      handler = Coverband::MCP::HttpHandler.new
+      handler.expects(:transport).returns(transport_mock)
+
+      @app = handler
+
+      get "/mcp", {}, {"ACCEPT" => "text/event-stream"}
+
+      assert_equal 200, last_response.status
     end
 
     test "returns 404 for non-MCP requests when no wrapped app" do
@@ -81,51 +90,49 @@ if defined?(Coverband::MCP)
       assert_equal "wrapped app response", last_response.body
     end
 
-    test "only responds to POST requests for MCP endpoint" do
-      get "/mcp"
+    test "responds to GET, POST, DELETE, OPTIONS for MCP endpoint" do
+      transport_mock = mock("transport")
+      transport_mock.expects(:handle_request).at_least(3).returns([200, {"Content-Type" => "application/json"}, ["{}"]])
 
-      assert_equal 404, last_response.status
-    end
+      handler = Coverband::MCP::HttpHandler.new
+      handler.expects(:transport).at_least(3).returns(transport_mock)
 
-    test "handles invalid JSON gracefully" do
-      post "/mcp", "invalid json", {"CONTENT_TYPE" => "application/json"}
+      @app = handler
 
-      assert_equal 400, last_response.status
-      assert_equal "application/json", last_response.content_type
+      # POST request
+      post "/mcp", "{}", {"CONTENT_TYPE" => "application/json"}
+      assert_equal 200, last_response.status
 
-      response = JSON.parse(last_response.body)
-      assert_includes response["error"], "Invalid JSON"
-    end
+      # GET request
+      get "/mcp", {}, {"ACCEPT" => "text/event-stream"}
+      assert_equal 200, last_response.status
 
-    test "handles server errors gracefully" do
-      # Mock server to raise an error
-      server_mock = mock("server")
-      server_mock.expects(:handle_json).raises(StandardError.new("Test error"))
+      # DELETE request
+      delete "/mcp"
+      assert_equal 200, last_response.status
+    end
 
+    test "handles CORS preflight OPTIONS request" do
       handler = Coverband::MCP::HttpHandler.new
-      handler.expects(:mcp_server).returns(server_mock)
-
       @app = handler
 
-      json_request = {"test" => "request"}.to_json
-      post "/mcp", json_request, {"CONTENT_TYPE" => "application/json"}
-
-      assert_equal 500, last_response.status
+      options "/mcp"
 
-      response = JSON.parse(last_response.body)
-      assert_includes response["error"], "Server error: Test error"
+      assert_equal 204, last_response.status
+      assert_equal "*", last_response.headers["Access-Control-Allow-Origin"]
+      assert_equal "GET, POST, DELETE, OPTIONS", last_response.headers["Access-Control-Allow-Methods"]
     end
 
-    test "mcp_server is lazily initialized" do
-      handler = Coverband::MCP::HttpHandler.new
+    test "delegates non-MCP requests to wrapped app for non-POST" do
+      @app = app_with_wrapped_handler
 
-      # First call creates the server
-      server1 = handler.send(:mcp_server)
-      assert_instance_of Coverband::MCP::Server, server1
+      get "/other-path"
+      assert_equal 200, last_response.status
+      assert_equal "wrapped app response", last_response.body
 
-      # Second call returns the same instance
-      server2 = handler.send(:mcp_server)
-      assert_same server1, server2
+      delete "/other-path"
+      assert_equal 200, last_response.status
+      assert_equal "wrapped app response", last_response.body
     end
 
     test "mcp_request? correctly identifies MCP requests" do
@@ -136,15 +143,20 @@ if defined?(Coverband::MCP)
       request = Rack::Request.new(env)
       assert handler.send(:mcp_request?, request)
 
-      # POST request to /some-path/mcp (ends with /mcp)
-      env = Rack::MockRequest.env_for("/some-path/mcp", method: "POST")
+      # GET request to /mcp
+      env = Rack::MockRequest.env_for("/mcp", method: "GET")
       request = Rack::Request.new(env)
       assert handler.send(:mcp_request?, request)
 
-      # GET request to /mcp
-      env = Rack::MockRequest.env_for("/mcp", method: "GET")
+      # DELETE request to /mcp
+      env = Rack::MockRequest.env_for("/mcp", method: "DELETE")
       request = Rack::Request.new(env)
-      refute handler.send(:mcp_request?, request)
+      assert handler.send(:mcp_request?, request)
+
+      # OPTIONS request to /mcp
+      env = Rack::MockRequest.env_for("/mcp", method: "OPTIONS")
+      request = Rack::Request.new(env)
+      assert handler.send(:mcp_request?, request)
 
       # POST request to /other-path
       env = Rack::MockRequest.env_for("/other-path", method: "POST")

data/test/integration/mcp_integration_test.rb

@@ -84,9 +84,9 @@ if defined?(Coverband::MCP)
     test "HTTP handler integrates with MCP server" do
       handler = Coverband::MCP::HttpHandler.new
 
-      # Verify handler can create and use MCP server
-      server = handler.send(:mcp_server)
-      assert_instance_of Coverband::MCP::Server, server
+      # Verify handler can create and use transport with MCP server
+      transport = handler.send(:transport)
+      assert_instance_of ::MCP::Server::Transports::StreamableHTTPTransport, transport
 
       # Verify handler responds to rack interface
       assert_respond_to handler, :call

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: coverband
 version: !ruby/object:Gem::Version
-  version: 6.2.0
+  version: 6.2.1
 platform: ruby
 authors:
 - Dan Mayer
@@ -446,6 +446,7 @@ files:
 - test/benchmarks/benchmark.rake
 - test/benchmarks/benchmark_delta.rb
 - test/benchmarks/benchmark_file_list.rb
+- test/benchmarks/benchmark_file_list_covered_lines.rb
 - test/benchmarks/benchmark_unused_keys.rb
 - test/benchmarks/coverage_fork.sh
 - test/benchmarks/dog.rb