lumberjack_capture_device 1.1.1 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f40306e5addb7cd7a23f739e937f26c6f42ab6a7dc2836cf0e9c128fa0835541
-  data.tar.gz: 282b90a7dfe1de511806b0dbf1a8597c6ab7a00a9a031e64f642242fe686b3f1
+  metadata.gz: 633b68181377b77f1940712d6a48261c5c74ed569fdf7d008636691d35add3d2
+  data.tar.gz: c3b73c48ba4d513ef3416676fd38f5ce7877d1e820ba5f4a45ac8b527c468c05
 SHA512:
-  metadata.gz: ddfc01f72e76421232add226ed4d6d8158119883aea02483469d86c8fad428654c576c0df91441acfa3b2332ea3e696419651adfa61549dfd499bda43f7062df
-  data.tar.gz: 8f8b915dfebdb33f58d0f06a143f9a61a919fd503319d2eb74157f221afaba19e30c66884915b682ae772ba6c2fbbea66fabfd3a073c42cde3b57f9398d89589
+  metadata.gz: 1656511eb767a622dec5a5b88500a82471e6c21d1976e7a2124429b117586cec570d27490d44ebdeeb539a99a2ab6dc8b786d886c7cffc46c0705c126412d320
+  data.tar.gz: 6539f93f7a7d9b9d8c4d142dd89385c8143622f281beab396f51dea1706aa9e446653fc07811ae4fa1ade61213fbdb7a7234b7e004add5646c9e373bd583d699

data/CHANGELOG.md

@@ -4,6 +4,13 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## 1.2.0
+
+### Added
+
+- Added support for matching the `progname` of log entries.
+- Added custom RSpec matchers that outputs cleaner messages for failed tests.
+
 ## 1.1.1
 
 ### Fixed
@@ -20,6 +27,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Support for matching tag structures in log entries regardless of if they are specified with dot notation or nested tags. So "foo.bar" will match a tag with the structure `{foo: {bar: "value"}}` or `{"foo.bar" => value}`.
 
+### Changed
+
+- Specifying a tag to match on nil will now match log entries missing the tag rather than matching any value for that tag.
+
 ## 1.0.1
 
 ### Added

data/README.md

@@ -44,7 +44,6 @@ logs = Lumberjack::CaptureDevice.capture(Rails.logger) { do_something }
 assert(logs.include?(level: :info, message: "Something happened"))
 ```
 
-
 You can filter the logs on level, message, and tags.
 
 - The level option can take either a label (i.e. `:warn`) or a constant (i.e. `Logger::WARN`).
@@ -60,6 +59,25 @@ expect(logs).to include(tags: {foo: anything, "count.one" => 1})
 
 You can also use the `Lumberjack::CaptureDevice#extract` method with the same arguments as used by `include?` to extract all log entries that match the filters. You can get all of the log entries with `Lumberjack::CaptureDevice#buffer`.
 
+### RSpec Support
+
+You can include some RSpec syntactic sugar by requiring the rspec file in your test helper.
+
+```ruby
+require "lumberjack/capture_device/rspec"
+```
+
+This will give you a `capture_logger` method and `include_log_entry` matcher. The `include_log_entry` matcher provides a bit cleaner output which can make debugging failing tests a bit easier.
+
+```ruby
+describe MyClass do
+  it "logs information" do
+    logs = capture_logger { MyClass.do_something }
+    expect(logs).to include_log_entry(message: "Something")
+  end
+end
+```
+
 ## Installation
 
 Add this line to your application's Gemfile:

data/VERSION

@@ -1 +1 @@
-1.1.1
+1.2.0

data/lib/lumberjack/capture_device/entry_score.rb

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+# Class responsible for scoring and matching log entries against filters
+class Lumberjack::CaptureDevice::EntryScore
+  # Minimum score threshold for considering a match (30% match)
+  MIN_SCORE_THRESHOLD = 0.3
+
+  class << self
+    # Calculate the overall match score for an entry against all provided filters
+    # Returns a score between 0.0 and 1.0
+    def calculate_match_score(entry, message_filter, level_filter, tags_filter, progname_filter)
+      scores = []
+      weights = []
+
+      # Check message match
+      if message_filter
+        message_score = calculate_field_score(entry.message, message_filter)
+        scores << message_score
+        weights << 0.4  # Weight message matching highly
+      end
+
+      # Check level match
+      if level_filter
+        level_score = if entry.severity == level_filter
+          1.0  # Exact level match
+        else
+          level_proximity_score(entry.severity, level_filter)  # Partial level match
+        end
+        scores << level_score
+        weights << 0.3
+      end
+
+      # Check progname match
+      if progname_filter
+        progname_score = calculate_field_score(entry.progname, progname_filter)
+        scores << progname_score
+        weights << 0.2
+      end
+
+      # Check tags match
+      if tags_filter.is_a?(Hash) && !tags_filter.empty?
+        tags_score = calculate_tags_score(entry.tags, tags_filter)
+        scores << tags_score
+        weights << 0.3
+      end
+
+      # Return 0 if no criteria were provided
+      return 0.0 if scores.empty?
+
+      # Calculate weighted average, but apply a penalty if any score is 0
+      # This ensures that completely failed criteria significantly impact the result
+      total_weighted_score = scores.zip(weights).map { |score, weight| score * weight }.sum
+      total_weight = weights.sum
+      base_score = total_weighted_score / total_weight
+
+      # Apply penalty for zero scores: reduce the score based on how many criteria completely failed
+      zero_scores = scores.count(0.0)
+      if zero_scores > 0
+        penalty_factor = 1.0 - (zero_scores.to_f / scores.length * 0.5)  # Up to 50% penalty
+        base_score *= penalty_factor
+      end
+
+      base_score
+    end
+
+    # Calculate score for any field value against a filter
+    # Returns a score between 0.0 and 1.0 based on how well the value matches the filter
+    def calculate_field_score(value, filter)
+      return 0.0 unless value && filter
+
+      case filter
+      when String
+        value_str = value.to_s
+        if value_str == filter
+          1.0
+        elsif value_str.include?(filter)
+          0.7
+        else
+          # Use string similarity for partial matching
+          similarity = string_similarity(value_str, filter)
+          (similarity > 0.5) ? similarity * 0.6 : 0.0
+        end
+      when Regexp
+        filter.match?(value.to_s) ? 1.0 : 0.0
+      else
+        # For other matchers (like RSpec matchers), try to use === operator
+        begin
+          (filter === value) ? 1.0 : 0.0
+        rescue
+          0.0
+        end
+      end
+    end
+
+    # Calculate proximity score based on log level distance
+    def level_proximity_score(entry_level, filter_level)
+      level_diff = (entry_level - filter_level).abs
+      case level_diff
+      when 0 then 1.0
+      when 1 then 0.7
+      when 2 then 0.4
+      else 0.0
+      end
+    end
+
+    # Calculate score for tag matching
+    def calculate_tags_score(entry_tags, tags_filter)
+      return 0.0 unless entry_tags && tags_filter.is_a?(Hash)
+
+      tags_filter = deep_stringify_keys(Lumberjack::Utils.expand_tags(tags_filter))
+      tags = deep_stringify_keys(Lumberjack::Utils.expand_tags(entry_tags))
+
+      total_tag_filters = count_tag_filters(tags_filter)
+      return 0.0 if total_tag_filters == 0
+
+      matched_tags = count_matched_tags(tags, tags_filter)
+      matched_tags.to_f / total_tag_filters
+    end
+
+    private
+
+    # Calculate string similarity using a simple Levenshtein distance-based approach
+    # Returns a score between 0.0 and 1.0 where 1.0 is an exact match
+    def string_similarity(str1, str2)
+      return 1.0 if str1 == str2
+      return 0.0 if str1.nil? || str2.nil? || str1.empty? || str2.empty?
+
+      # Convert to lowercase for case-insensitive comparison
+      s1 = str1.downcase
+      s2 = str2.downcase
+
+      # If one string contains the other, give it a good score
+      if s1.include?(s2) || s2.include?(s1)
+        shorter = [s1.length, s2.length].min
+        longer = [s1.length, s2.length].max
+        return shorter.to_f / longer * 0.8 + 0.2  # Boost score for containment
+      end
+
+      # Calculate Levenshtein distance
+      distance = levenshtein_distance(s1, s2)
+      max_length = [s1.length, s2.length].max
+
+      # Convert distance to similarity score
+      return 0.0 if max_length == 0
+      1.0 - (distance.to_f / max_length)
+    end
+
+    # Simple Levenshtein distance implementation
+    def levenshtein_distance(str1, str2)
+      return str2.length if str1.empty?
+      return str1.length if str2.empty?
+
+      matrix = Array.new(str1.length + 1) { Array.new(str2.length + 1, 0) }
+
+      # Initialize first row and column
+      (0..str1.length).each { |i| matrix[i][0] = i }
+      (0..str2.length).each { |j| matrix[0][j] = j }
+
+      # Fill the matrix
+      (1..str1.length).each do |i|
+        (1..str2.length).each do |j|
+          cost = (str1[i - 1] == str2[j - 1]) ? 0 : 1
+          matrix[i][j] = [
+            matrix[i - 1][j] + 1,     # deletion
+            matrix[i][j - 1] + 1,     # insertion
+            matrix[i - 1][j - 1] + cost # substitution
+          ].min
+        end
+      end
+
+      matrix[str1.length][str2.length]
+    end
+
+    def count_tag_filters(tags_filter, count = 0)
+      tags_filter.each do |_name, value_filter|
+        if value_filter.is_a?(Hash)
+          count = count_tag_filters(value_filter, count)
+        else
+          count += 1
+        end
+      end
+      count
+    end
+
+    def count_matched_tags(tags, tags_filter, count = 0)
+      return count unless tags && tags_filter
+
+      tags_filter.each do |name, value_filter|
+        name = name.to_s
+        tag_values = tags[name]
+
+        if value_filter.is_a?(Hash) && tag_values.is_a?(Hash)
+          count = count_matched_tags(tag_values, value_filter, count)
+        elsif tags.include?(name) && exact_match?(tag_values, value_filter)
+          count += 1
+        end
+      end
+      count
+    end
+
+    def exact_match?(value, filter)
+      return true unless filter
+      filter === value
+    end
+
+    def deep_stringify_keys(hash)
+      if hash.is_a?(Hash)
+        hash.each_with_object({}) do |(key, value), result|
+          new_key = key.to_s
+          new_value = deep_stringify_keys(value)
+          result[new_key] = new_value
+        end
+      elsif hash.is_a?(Enumerable)
+        hash.collect { |item| deep_stringify_keys(item) }
+      else
+        hash
+      end
+    end
+  end
+end

data/lib/lumberjack/capture_device/include_log_entry_matcher.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+# RSpec matcher for checking captured logs for specific entries.
+class Lumberjack::CaptureDevice::IncludeLogEntryMatcher
+  def initialize(expected_hash)
+    @expected_hash = expected_hash.transform_keys(&:to_sym)
+    @captured_logger = nil
+  end
+
+  def matches?(actual)
+    @captured_logger = actual
+    return false unless valid_captured_logger?
+
+    @captured_logger.include?(@expected_hash)
+  end
+
+  def failure_message
+    if valid_captured_logger?
+      formatted_failure_message(@captured_logger, @expected_hash, negated: false)
+    else
+      wrong_object_type_message(@captured_logger)
+    end
+  end
+
+  def failure_message_when_negated
+    if valid_captured_logger?
+      formatted_failure_message(@captured_logger, @expected_hash, negated: true)
+    else
+      wrong_object_type_message(@captured_logger)
+    end
+  end
+
+  def description
+    "have logged entry with #{expectation_description(@expected_hash)}"
+  end
+
+  private
+
+  def valid_captured_logger?
+    @captured_logger.is_a?(Lumberjack::CaptureDevice)
+  end
+
+  def wrong_object_type_message(captured_logger)
+    "Expected a Lumberjack::CaptureDevice object, but received a #{captured_logger.class}."
+  end
+
+  def formatted_failure_message(captured_logger, expected_hash, negated:)
+    closest_match = captured_logger.closest_match(**expected_hash)
+    message = "expected logs did not include expected entry.\n\n" \
+      "Expected entry:\n-----------\n#{Lumberjack::CaptureDevice.formatted_expectation(expected_hash)}\n\n" \
+      "Captured logs:\n-----------\n#{captured_logger.inspect}"
+
+    if closest_match
+      # Convert the entry to a hash format for formatted_expectation
+      closest_match_hash = {
+        level: closest_match.severity_label,
+        message: closest_match.message,
+        progname: closest_match.progname,
+        tags: closest_match.tags
+      }.compact
+
+      message = "#{message}\n\nClosest match found:\n-----------\n" \
+        "#{Lumberjack::CaptureDevice.formatted_expectation(closest_match_hash)}"
+    end
+
+    message
+  end
+
+  def expectation_description(expected_hash)
+    info = []
+    info << "level: #{expected_hash[:level].inspect}" unless expected_hash[:level].nil?
+    info << "message: #{expected_hash[:message].inspect}" unless expected_hash[:message].nil?
+    info << "progname: #{expected_hash[:progname].inspect}" unless expected_hash[:progname].nil?
+    if expected_hash[:tags].is_a?(Hash) && !expected_hash[:tags].empty?
+      tags = Lumberjack::Utils.flatten_tags(expected_hash[:tags])
+      tags_info = tags.collect { |name, value| "#{name}=#{value.inspect}" }.join(", ")
+      info << "tags: #{tags_info}"
+    end
+    info.join(", ")
+  end
+end

data/lib/lumberjack/capture_device/rspec.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative "../capture_device"
+require "rspec"
+
+module Lumberjack::CaptureDevice::RSpec
+  def include_log_entry(expected_hash)
+    Lumberjack::CaptureDevice::IncludeLogEntryMatcher.new(expected_hash)
+  end
+
+  def capture_logger(logger, &block)
+    Lumberjack::CaptureDevice.capture(logger, &block)
+  end
+end
+
+RSpec.configure do |config|
+  config.include Lumberjack::CaptureDevice::RSpec
+end

data/lib/lumberjack/capture_device.rb

@@ -0,0 +1,262 @@
+# frozen_string_literal: true
+
+require "lumberjack"
+
+module Lumberjack
+  # Lumberjack device for capturing log entries into memory to allow them to be inspected
+  # for testing purposes.
+  class CaptureDevice < Lumberjack::Device
+    VERSION = File.read(File.join(__dir__, "..", "..", "VERSION"))
+
+    attr_reader :buffer
+
+    class << self
+      # Capture the entries written by the logger within a block. Within the block all log
+      # entries will be written to a CaptureDevice rather than to the normal output for
+      # the logger. In addition, all formatters will be removed and the log level will be set
+      # to debug. The device being written to be both yielded to the block as well as returned
+      # by the method call.
+      #
+      # @param logger [Lumberjack::Logger] The logger to capture entries from.
+      # @yield [device] The block to execute while capturing log entries.
+      # @return [Lumberjack::CaptureDevice] The device that captured the log entries.
+      # @yieldparam device [Lumberjack::CaptureDevice] The device that will capture the log entries.
+      # @example
+      #   Lumberjack::CaptureDevice.capture(logger) do |logs|
+      #     logger.info("This will be captured")
+      #     expect(logs).to include(level: :info, message: "This will be captured")
+      #   end
+      #
+      # @example
+      #   logs = Lumberjack::CaptureDevice.capture(logger) { logger.info("This will be captured") }
+      #   expect(logs).to include(level: :info, message: "This will be captured")
+      def capture(logger)
+        device = new
+        save_device = logger.device
+        save_level = logger.level
+        save_formatter = logger.formatter
+        begin
+          logger.device = device
+          logger.level = :debug
+          logger.formatter = Lumberjack::Formatter.empty
+          yield device
+        ensure
+          logger.device = save_device
+          logger.level = save_level
+          logger.formatter = save_formatter
+        end
+        device
+      end
+
+      def formatted_expectation(expectation)
+        expectation = expectation.transform_keys(&:to_s).compact
+        message = []
+        message << "level: #{expectation["level"].inspect}"
+        message << "message: #{expectation["message"].inspect}"
+        message << "progname: #{expectation["progname"].inspect}"
+        if expectation["tags"].is_a?(Hash) && !expectation["tags"].empty?
+          tags = Lumberjack::Utils.flatten_tags(expectation["tags"])
+          prefix = "tags: "
+          tags.each do |name, value|
+            message << "#{prefix} #{name}: #{value.inspect}"
+            prefix = "      "
+          end
+        end
+        message.join("\n")
+      end
+    end
+
+    def initialize
+      @buffer = []
+    end
+
+    def write(entry)
+      @buffer << entry
+    end
+
+    # Clear all entries that have been written to the buffer.
+    def clear
+      @buffer.clear
+    end
+
+    # Return true if the captured log entries match the specified level, message, and tags.
+    #
+    # For level, you can specified either a numeric constant (i.e. `Logger::WARN`) or a symbol
+    # (i.e. `:warn`).
+    #
+    # For message you can specify a string to perform an exact match or a regular expression
+    # to perform a partial or pattern match. You can also supply any matcher value available
+    # in your test library (i.e. in rspec you could use `anything` or `instance_of(Error)`, etc.).
+    #
+    # For tags, you can specify a hash of tag names to values to match. You can use
+    # regular expression or matchers as the values here as well. Tags can also be nested to match
+    # nested tags.
+    #
+    # Example:
+    #
+    # ```
+    # logs.include(level: :warn, message: /something happened/, tags: {duration: instance_of(Float)})
+    # ```
+    #
+    # @param args [Hash] The filters to apply to the captured entries.
+    # @option args [String, Regexp] :message The message to match against the log entries.
+    # @option args [String, Symbol, Integer] :level The log level to match against the log entries.
+    # @option args [Hash] :tags A hash of tag names to values to match against the log entries. The tags
+    #   will match nested tags using dot notation (e.g. `foo.bar` will match a tag with the structure
+    #   `{foo: {bar: "value"}}`).
+    # @option args [String] :progname The program name to match against the log entries.
+    # @return [Boolean] True if any entries match the specified filters, false otherwise.
+    def include?(args)
+      !extract(**args.merge(limit: 1)).empty?
+    end
+
+    # Return all the captured entries that match the specified filters. These filters are
+    # the same as described in the `include?` method.
+    #
+    # @param message [String, Regexp, nil] The message to match against the log entries.
+    # @param level [String, Symbol, Integer, nil] The log level to match against the log entries.
+    # @param tags [Hash, nil] A hash of tag names to values to match against the log entries. The tags
+    #   will match nested tags using dot notation (e.g. `foo.bar` will match a tag with the structure
+    #   `{foo: {bar: "value"}}`).
+    # @param limit [Integer, nil] The maximum number of entries to return. If nil, all matching entries
+    #   will be returned.
+    # @return [Array<Lumberjack::Entry>] An array of log entries that match the specified filters.
+    def extract(message: nil, level: nil, tags: nil, limit: nil, progname: nil)
+      matches = []
+
+      if level
+        # Normalize the level filter to numeric values.
+        level = (level.is_a?(Integer) ? level : Lumberjack::Severity.label_to_level(level))
+      end
+
+      @buffer.each do |entry|
+        if matched?(entry, message, level, tags, progname)
+          matches << entry
+          break if limit && matches.size >= limit
+        end
+      end
+
+      matches
+    end
+
+    # Return the log entry that most closely matches the specified filters. This method
+    # uses fuzzy matching logic to find the best match when no exact match exists.
+    # The matching score is calculated based on how many criteria are met and how closely
+    # they match. Returns nil if no entry meets the minimum matching criteria.
+    #
+    # @param message [String, Regexp, nil] The message to match against the log entries.
+    # @param level [String, Symbol, Integer, nil] The log level to match against the log entries.
+    # @param tags [Hash, nil] A hash of tag names to values to match against the log entries.
+    # @param progname [String, nil] The program name to match against the log entries.
+    # @return [Lumberjack::Entry, nil] The log entry that most closely matches the filters, or nil if no entry meets minimum criteria.
+    def closest_match(message: nil, level: nil, tags: nil, progname: nil)
+      return nil if @buffer.empty?
+
+      # Normalize level filter
+      if level
+        level = (level.is_a?(Integer) ? level : Lumberjack::Severity.label_to_level(level))
+      end
+
+      best_entry = nil
+      best_score = 0
+
+      @buffer.each do |entry|
+        score = Lumberjack::CaptureDevice::EntryScore.calculate_match_score(entry, message, level, tags, progname)
+        if score > best_score && score >= Lumberjack::CaptureDevice::EntryScore::MIN_SCORE_THRESHOLD
+          best_score = score
+          best_entry = entry
+        end
+      end
+
+      best_entry
+    end
+
+    def inspect
+      message = +"<##{self.class.name} #{@buffer.size} #{(@buffer.size == 1) ? "entry" : "entries"} captured:"
+      @buffer.each do |entry|
+        message << "\n  #{formatted_entry(entry)}"
+      end
+      message << "\n>"
+      message
+    end
+
+    def to_s
+      "<##{self.class.name} #{@buffer.size} #{(@buffer.size == 1) ? "entry" : "entries"} captured>"
+    end
+
+    private
+
+    def matched?(entry, message_filter, level_filter, tags_filter, progname_filter)
+      return false unless match?(entry.message, message_filter)
+      return false unless match?(entry.severity, level_filter)
+      return false unless match?(entry.progname, progname_filter)
+
+      if tags_filter.is_a?(Hash)
+        tags_filter = deep_stringify_keys(Lumberjack::Utils.expand_tags(tags_filter))
+      end
+      tags = deep_stringify_keys(Lumberjack::Utils.expand_tags(entry.tags))
+
+      return false unless match_tags?(tags, tags_filter)
+
+      true
+    end
+
+    def match?(value, filter)
+      return true unless filter
+
+      filter === value
+    end
+
+    def match_tags?(tags, filter)
+      return true unless filter
+      return false unless tags
+
+      filter.all? do |name, value_filter|
+        name = name.to_s
+        tag_values = tags[name]
+        if tag_values.is_a?(Hash)
+          if value_filter.is_a?(Hash)
+            match_tags?(tag_values, value_filter)
+          else
+            false
+          end
+        elsif value_filter.nil? || (value_filter.is_a?(Enumerable) && value_filter.empty?)
+          tag_values.nil? || (tag_values.is_a?(Array) && tag_values.empty?)
+        elsif tags.include?(name)
+          match?(tag_values, value_filter)
+        else
+          false
+        end
+      end
+    end
+
+    def deep_stringify_keys(hash)
+      if hash.is_a?(Hash)
+        hash.each_with_object({}) do |(key, value), result|
+          new_key = key.to_s
+          new_value = deep_stringify_keys(value)
+          result[new_key] = new_value
+        end
+      elsif hash.is_a?(Enumerable)
+        hash.collect { |item| deep_stringify_keys(item) }
+      else
+        hash
+      end
+    end
+
+    def formatted_entry(entry)
+      timestamp = entry.time.strftime("%Y-%m-%d %H:%M:%S")
+      formatted = +"#{timestamp} #{entry.severity_label}: #{entry.message}"
+      formatted << "\n    progname: #{entry.progname}" if entry.progname.to_s != ""
+      if entry.tags && !entry.tags.empty?
+        Lumberjack::Utils.flatten_tags(entry.tags).to_a.sort_by(&:first).each do |name, value|
+          formatted << "\n    #{name}: #{value}"
+        end
+      end
+      formatted
+    end
+  end
+end
+
+require_relative "capture_device/entry_score"
+require_relative "capture_device/include_log_entry_matcher"

data/lib/lumberjack_capture_device.rb

@@ -1,201 +1,3 @@
 # frozen_string_literal: true
 
-require "lumberjack"
-
-module Lumberjack
-  # Lumberjack device for capturing log entries into memory to allow them to be inspected
-  # for testing purposes.
-  class CaptureDevice < Lumberjack::Device
-    attr_reader :buffer
-
-    class << self
-      # Capture the entries written by the logger within a block. Within the block all log
-      # entries will be written to a CaptureDevice rather than to the normal output for
-      # the logger. In addition, all formatters will be removed and the log level will be set
-      # to debug. The device being written to be both yielded to the block as well as returned
-      # by the method call.
-      #
-      # @param logger [Lumberjack::Logger] The logger to capture entries from.
-      # @yield [device] The block to execute while capturing log entries.
-      # @return [Lumberjack::CaptureDevice] The device that captured the log entries.
-      # @yieldparam device [Lumberjack::CaptureDevice] The device that will capture the log entries.
-      # @example
-      #   Lumberjack::CaptureDevice.capture(logger) do |logs|
-      #     logger.info("This will be captured")
-      #     expect(logs).to include(level: :info, message: "This will be captured")
-      #   end
-      #
-      # @example
-      #   logs = Lumberjack::CaptureDevice.capture(logger) { logger.info("This will be captured") }
-      #   expect(logs).to include(level: :info, message: "This will be captured")
-      def capture(logger)
-        device = new
-        save_device = logger.device
-        save_level = logger.level
-        save_formatter = logger.formatter
-        begin
-          logger.device = device
-          logger.level = :debug
-          logger.formatter = Lumberjack::Formatter.empty
-          yield device
-        ensure
-          logger.device = save_device
-          logger.level = save_level
-          logger.formatter = save_formatter
-        end
-        device
-      end
-    end
-
-    def initialize
-      @buffer = []
-    end
-
-    def write(entry)
-      @buffer << entry
-    end
-
-    # Clear all entries that have been written to the buffer.
-    def clear
-      @buffer.clear
-    end
-
-    # Return true if the captured log entries match the specified level, message, and tags.
-    #
-    # For level, you can specified either a numeric constant (i.e. `Logger::WARN`) or a symbol
-    # (i.e. `:warn`).
-    #
-    # For message you can specify a string to perform an exact match or a regular expression
-    # to perform a partial or pattern match. You can also supply any matcher value available
-    # in your test library (i.e. in rspec you could use `anything` or `instance_of(Error)`, etc.).
-    #
-    # For tags, you can specify a hash of tag names to values to match. You can use
-    # regular expression or matchers as the values here as well. Tags can also be nested to match
-    # nested tags.
-    #
-    # Example:
-    #
-    # ```
-    # logs.include(level: :warn, message: /something happened/, tags: {duration: instance_of(Float)})
-    # ```
-    #
-    # @param args [Hash] The filters to apply to the captured entries.
-    # @option args [String, Regexp] :message The message to match against the log entries.
-    # @option args [String, Symbol, Integer] :level The log level to match against the log entries.
-    # @option args [Hash] :tags A hash of tag names to values to match against the log entries. The tags
-    #   will match nested tags using dot notation (e.g. `foo.bar` will match a tag with the structure
-    #   `{foo: {bar: "value"}}`).
-    # @return [Boolean] True if any entries match the specified filters, false otherwise.
-    def include?(args)
-      !extract(**args.merge(limit: 1)).empty?
-    end
-
-    # Return all the captured entries that match the specified filters. These filters are
-    # the same as described in the `include?` method.
-    #
-    # @param message [String, Regexp, nil] The message to match against the log entries.
-    # @param level [String, Symbol, Integer, nil] The log level to match against the log entries.
-    # @param tags [Hash, nil] A hash of tag names to values to match against the log entries. The tags
-    #   will match nested tags using dot notation (e.g. `foo.bar` will match a tag with the structure
-    #   `{foo: {bar: "value"}}`).
-    # @param limit [Integer, nil] The maximum number of entries to return. If nil, all matching entries
-    #   will be returned.
-    # @return [Array<Lumberjack::Entry>] An array of log entries that match the specified filters.
-    def extract(message: nil, level: nil, tags: nil, limit: nil)
-      matches = []
-
-      if level
-        # Normalize the level filter to numeric values.
-        level = (level.is_a?(Integer) ? level : Lumberjack::Severity.label_to_level(level))
-      end
-      @buffer.each do |entry|
-        if matched?(entry, message, level, tags)
-          matches << entry
-          break if limit && matches.size >= limit
-        end
-      end
-
-      matches
-    end
-
-    def inspect
-      message = +"<##{self.class.name} #{@buffer.size} #{(@buffer.size == 1) ? "entry" : "entries"} captured:"
-      @buffer.each do |entry|
-        message << "\n  #{formatted_entry(entry)}"
-      end
-      message << "\n>"
-      message
-    end
-
-    private
-
-    def matched?(entry, message_filter, level_filter, tags_filter)
-      return false unless match?(entry.message, message_filter)
-      return false unless match?(entry.severity, level_filter)
-
-      if tags_filter.is_a?(Hash)
-        tags_filter = deep_stringify_keys(Lumberjack::Utils.expand_tags(tags_filter))
-      end
-      tags = deep_stringify_keys(Lumberjack::Utils.expand_tags(entry.tags))
-
-      return false unless match_tags?(tags, tags_filter)
-
-      true
-    end
-
-    def match?(value, filter)
-      return true unless filter
-      filter === value
-    end
-
-    def match_tags?(tags, filter)
-      return true unless filter
-      return false unless tags
-
-      filter.all? do |name, value_filter|
-        name = name.to_s
-        tag_values = tags[name]
-        if tag_values.is_a?(Hash)
-          if value_filter.is_a?(Hash)
-            match_tags?(tag_values, value_filter)
-          else
-            false
-          end
-        elsif value_filter.nil? || (value_filter.is_a?(Enumerable) && value_filter.empty?)
-          tag_values.nil? || (tag_values.is_a?(Array) && tag_values.empty?)
-        elsif tags.include?(name)
-          match?(tag_values, value_filter)
-        else
-          false
-        end
-      end
-    end
-
-    def deep_stringify_keys(hash)
-      if hash.is_a?(Hash)
-        hash.each_with_object({}) do |(key, value), result|
-          new_key = key.to_s
-          new_value = deep_stringify_keys(value)
-          result[new_key] = new_value
-        end
-      elsif hash.is_a?(Enumerable)
-        hash.collect { |item| deep_stringify_keys(item) }
-      else
-        hash
-      end
-    end
-
-    def formatted_entry(entry)
-      timestamp = entry.time.strftime("%Y-%m-%d %H:%M:%S")
-      formatted = +"#{timestamp} #{entry.severity_label}: #{entry.message}"
-      formatted << "\n    progname: #{entry.progname}" if entry.progname.to_s != ""
-      formatted << "\n    pid: #{entry.pid}" if entry.pid
-      if entry.tags && !entry.tags.empty?
-        Lumberjack::Utils.flatten_tags(entry.tags).to_a.sort_by(&:first).each do |name, value|
-          formatted << "\n    #{name}: #{value}"
-        end
-      end
-      formatted
-    end
-  end
-end
+require_relative "lumberjack/capture_device"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lumberjack_capture_device
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 1.2.0
 platform: ruby
 authors:
 - Brian Durand
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-07-24 00:00:00.000000000 Z
+date: 2025-07-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lumberjack
@@ -49,6 +49,10 @@ files:
 - MIT_LICENSE.txt
 - README.md
 - VERSION
+- lib/lumberjack/capture_device.rb
+- lib/lumberjack/capture_device/entry_score.rb
+- lib/lumberjack/capture_device/include_log_entry_matcher.rb
+- lib/lumberjack/capture_device/rspec.rb
 - lib/lumberjack_capture_device.rb
 - lumberjack_capture_device.gemspec
 homepage: https://github.com/bdurand/lumberjack_capture_device