lumberjack_capture_device 1.2.2 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9147e66264c0eeebb01f7c04df1b6e18ab64bc4db3337e968d6cd1d2201fef7f
-  data.tar.gz: f01bf2e332024e9ef26ef703b374956e5f17c6bb4f351cb4518b1591b62dd992
+  metadata.gz: 3de3ac7d3bf941c8f6283c70f8bf55163eb36f91bea583836f296e7c5fa2cc3a
+  data.tar.gz: df6a39ef765975ff2f029d99e46aaef435c7675be707ea8effa08fc6a7369308
 SHA512:
-  metadata.gz: 5e5ae9f94313a18f793b299998c9760aaa8d7bf5d8f462f48b4519f83c8844893ff894e5b570e31b15d55dc1ad9d25ee723529dc72e51db83d5060a4bcf1597c
-  data.tar.gz: 06a11ff5e4c5f3afed7cda12fa2f5f9bf94369f6c5b382d7118622136b7f1507d67c1e68ca472c6c38d1bf38cd3aa6db66f4859a145f78b9b69a8f9f4024a634
+  metadata.gz: 8c08cdc46f06da187f942b449a0a15551aefd2c55891cbb93d17ab3b0c8f281e169bddc340bb43a9a6fdfb11aeb6cc43a4a639f3417ab3819bea002d91515e3c
+  data.tar.gz: dfa277bb83a2710a9df87f893a35eaf58c266c8eb1d73e00be6a4f8fb1cf6233f7f552a86329b84e85459de8b87963143197d46e07d47f4136a605f793f0136b

data/CHANGELOG.md

@@ -4,6 +4,44 @@ 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).
 
+## 2.1.0
+
+### Changed
+
+- `include?` now symbolizes filter keys and raises an `ArgumentError` on unrecognized filter keys. Previously filters with string keys or misspelled keys were silently ignored, causing the method to match any captured entry.
+- `write_to_underlying_device` accepts an optional `attributes` keyword argument to add attributes to each entry as it is written.
+- The `include_log_entry` matcher failure message now shows a diff of the closest matching entry against the expectation instead of just printing the entry. Severity, message, progname, and each attribute are shown with the expected value on a `-` line and the logged value on a `+` line so it is obvious which ones prevented the match. The comparison is done with `Lumberjack::LogEntryMatcher#diff` using the device's entry formatter, so the diff always agrees with the match. The diff is also available directly from `Lumberjack::CaptureDevice::IncludeLogEntryMatcher#entry_diff`.
+
+### Fixed
+
+- `extract` now matches filters with the device `entry_formatter` like `include?`, `match`, and `closest_match` do. Previously filter values were only compared to the formatted values captured on the entries, so unformatted values in the filters did not match.
+- `capture_logger_around_example` now correctly adds the rspec metadata attributes to entries written to the underlying device when an example fails. Previously the attributes were silently dropped and building them raised a `NoMethodError` since `RSpec::Core::Example` does not have a `source_location` method; the example location is now recorded in the `rspec.location` attribute.
+- The `max_entries` option is no longer ignored when initializing a `Lumberjack::CaptureDevice`.
+- Fixed missing line break after "Closest match found:" in RSpec matcher failure messages.
+- The `include_log_entry` matcher description no longer omits the expected attributes when a matcher (i.e. RSpec's `hash_including`) is passed as the `attributes` option instead of a hash. Matcher objects are now rendered with their description rather than by inspecting them.
+- `each` and `length` now read from a thread safe copy of the entries buffer.
+
+### Removed
+
+- Removed the deprecated `:level` and `:tags` options from the matching methods (`include?`, `match`, `closest_match`, and `extract`) and from the `include_log_entry` RSpec matcher. Use `:severity` and `:attributes` instead.
+- Removed the `match` and `closest_match` methods. They only existed to translate the deprecated options and are now inherited unchanged from `Lumberjack::Device::Test`.
+- Removed unused internal `Lumberjack::CaptureDevice::EntryScore` class. It was never loaded and was replaced by the scoring logic in the lumberjack gem.
+
+## 2.0.0
+
+### Added
+
+- Captured log entries are now passed through to the underlying logging device when the capture block is finished. This can be disabled by passing `write_to_original: false` to the `capture` method. You can then write the captured entries to the underlying device manually by calling `write_to_underlying_device`.
+- Added `capture_logger_around_example` RSpec helper method to simplify capturing log entries in an `around` hook.
+
+### Changed
+
+- Depends on `lumberjack` 2.0 or greater.
+
+### Deprecated
+
+- The `:level` and `:tags` options on the matching methods (`include?`, `match`, `closest_match`, and `extract`) have been deprecated in favor of `:severity` and `:attributes`.
+
 ## 1.2.2
 
 ### Changed

data/README.md

@@ -26,7 +26,7 @@ You can use the `include?` method on the log device to determine if specific log
 ```ruby
 Lumberjack::CaptureDevice.capture(Rails.logger) do |logs|
   do_something
-  expect(logs).to include(level: :info, message: "Something happened")
+  expect(logs).to include(severity: :info, message: "Something happened")
 end
 ```
 
@@ -34,30 +34,30 @@ You can also write that same test as:
 
 ```ruby
 logs = Lumberjack::CaptureDevice.capture(Rails.logger) { do_something }
-expect(logs).to include(level: :info, message: "Something happened")
+expect(logs).to include(severity: :info, message: "Something happened")
 ```
 
 For MiniTest, you could assert:
 
 ```ruby
 logs = Lumberjack::CaptureDevice.capture(Rails.logger) { do_something }
-assert(logs.include?(level: :info, message: "Something happened"))
+assert(logs.include?(severity: :info, message: "Something happened"))
 ```
 
-You can filter the logs on level, message, and tags.
+You can filter the logs on severity, message, progname, and attributes.
 
-- The level option can take either a label (i.e. `:warn`) or a constant (i.e. `Logger::WARN`).
+- The severity option can take either a label (i.e. `:warn`) or a constant (i.e. `Logger::WARN`).
 - The message filter can be either an exact string or a regular expression, or any matcher supported by your test library.
-- The tags argument can match tags with a Hash mapping tag names to the matcher values. If tags are nested, you can use dot notation on tag names to reference nested tags.
+- The attributes argument can match attributes with a Hash mapping attribute names to the matcher values. If attributes are nested, you can use dot notation on attribute names to reference nested attributes.
 
 ```ruby
-expect(logs).to include(level: :info, message: /something/i)
-expect(logs).to include(level: Logger::INFO, tags: {foo: "bar"})
-expect(logs).to include(tags: {foo: anything, count: {one: 1}})
-expect(logs).to include(tags: {foo: anything, "count.one" => 1})
+expect(logs).to include(severity: :info, message: /something/i)
+expect(logs).to include(severity: Logger::INFO, attributes: {foo: "bar"})
+expect(logs).to include(attributes: {foo: anything, count: {one: 1}})
+expect(logs).to include(attributes: {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`.
+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#entries`.
 
 ### RSpec Support
 
@@ -72,12 +72,52 @@ This will give you a `capture_logger` method and `include_log_entry` matcher. Th
 ```ruby
 describe MyClass do
   it "logs information" do
-    logs = capture_logger { MyClass.do_something }
+    logs = capture_logger(Rails.logger) { MyClass.do_something }
     expect(logs).to include_log_entry(message: "Something")
   end
 end
 ```
 
+When the matcher fails, the failure message includes a diff between the expectation and the closest matching entry so you can see exactly which fields and attributes are off. Lines prefixed with `-` show what was expected and lines prefixed with `+` show what was actually logged.
+
+```
+expected logs to include entry:
+  severity: WARN
+  message: User logged out
+  attributes: request_id: "abc"
+              user.role: "admin"
+
+Closest match found (- expected, + actual):
+  - severity: WARN
+  + severity: INFO
+    message: "User logged out"
+  - attributes.user.role: "admin"
+  + attributes.user.role: "guest"
+    attributes.duration: 1.5
+  - attributes.request_id: "abc"
+  + attributes.request_id: (not set)
+```
+
+You can also set up log capturing around each example with the `capture_logger_around_example` method.
+
+```ruby
+describe MyClass do
+  around do |example|
+    capture_logger_around_example(Rails.logger, example)
+  end
+
+  it "logs information" do
+    MyClass.do_something
+    expect(Rails.logger).to include_log_entry(message: "Something")
+  end
+end
+```
+
+> [!TIP]
+> Add `capture_logger_around_example` as a global `around` hook in your RSpec configuration to automatically capture log entries for every example.
+>
+> This will also suppress all log output during tests unless an example fails which can reduce noise in the logs from tests that don't fail. This is especially useful in CI environments where you can save the logs as an artifact for failed test runs.
+
 ## Installation
 
 Add this line to your application's Gemfile:

data/VERSION

@@ -1 +1 @@
-1.2.2
+2.1.0

data/lib/lumberjack/capture_device/include_log_entry_matcher.rb

@@ -2,92 +2,287 @@
 
 # RSpec matcher for checking captured logs for specific entries.
 class Lumberjack::CaptureDevice::IncludeLogEntryMatcher
+  # Displayed as the actual value for an expected attribute that the log entry does not have.
+  MISSING_VALUE = "(not set)"
+
+  private_constant :MISSING_VALUE
+
+  # Initialize the matcher with expected log entry attributes.
+  #
+  # @param expected_hash [Hash] Expected log entry attributes to match against.
   def initialize(expected_hash)
+    # The keys are symbolized so the hash can be passed to any Lumberjack::Device::Test device.
     @expected_hash = expected_hash.transform_keys(&:to_sym)
-    @captured_logger = nil
+    @logger = nil
   end
 
+  # Check if the logger contains a log entry matching the expected attributes.
+  #
+  # @param actual [Lumberjack::Logger, Lumberjack::ForkedLogger] The logger to check. The logger must be using
+  #   a Lumberjack::Device::Test device.
+  # @return [Boolean] True if a matching log entry is found.
   def matches?(actual)
-    @captured_logger = actual
-    return false unless valid_captured_logger?
+    @logger = actual
+    return false unless valid_logger?
 
-    @captured_logger.include?(@expected_hash)
+    device.include?(@expected_hash)
   end
 
+  # Generate a failure message when the matcher fails.
+  #
+  # @return [String] A formatted failure message.
   def failure_message
-    if valid_captured_logger?
-      formatted_failure_message(@captured_logger, @expected_hash)
+    if valid_logger?
+      formatted_failure_message(@expected_hash)
     else
-      wrong_object_type_message(@captured_logger)
+      wrong_object_type_message(@logger)
     end
   end
 
+  # Generate a failure message when the negated matcher fails.
+  #
+  # @return [String] A formatted failure message for negated expectations.
   def failure_message_when_negated
-    if valid_captured_logger?
-      formatted_negated_failure_message(@captured_logger, @expected_hash)
+    if valid_logger?
+      formatted_negated_failure_message(@expected_hash)
     else
-      wrong_object_type_message(@captured_logger)
+      wrong_object_type_message(@logger)
     end
   end
 
+  # Provide a description of what this matcher checks.
+  #
+  # @return [String] A human-readable description of the matcher.
   def description
     "have logged entry with #{expectation_description(@expected_hash)}"
   end
 
+  # Generate a diff between a log entry and the expected log entry values. The severity,
+  # message, progname, and attributes of the entry are listed. Values that don't match the
+  # expectation are shown on a pair of lines with the expected value prefixed with "-" and
+  # the value from the log entry prefixed with "+". This is intended to make it easy to spot
+  # exactly which fields kept an entry from matching.
+  #
+  # The comparison is done by Lumberjack::LogEntryMatcher#diff so the diff always agrees
+  # with the result of the match.
+  #
+  # @param entry [Lumberjack::LogEntry] The log entry to compare to the expectation.
+  # @param indent [Integer] The number of spaces to indent each line.
+  # @return [String] A formatted diff of the entry and the expectation.
+  def entry_diff(entry, indent: 2)
+    indent_str = " " * indent
+
+    entry_differences(entry).collect do |name, expected, actual, matched|
+      if matched
+        "#{indent_str}  #{name}: #{actual}"
+      else
+        "#{indent_str}- #{name}: #{expected}#{Lumberjack::LINE_SEPARATOR}#{indent_str}+ #{name}: #{actual}"
+      end
+    end.join(Lumberjack::LINE_SEPARATOR)
+  end
+
   private
 
-  def valid_captured_logger?
-    @captured_logger.is_a?(Lumberjack::CaptureDevice)
+  # Check if the logger is using a valid Lumberjack::Device::Test device.
+  #
+  # @return [Boolean] True if the logger is a Lumberjack::Device::Test.
+  def valid_logger?
+    return true if @logger.is_a?(Lumberjack::Device::Test)
+    return false unless @logger.respond_to?(:device)
+
+    @logger.device.is_a?(Lumberjack::Device::Test)
   end
 
-  def wrong_object_type_message(captured_logger)
-    "Expected a Lumberjack::CaptureDevice object, but received a #{captured_logger.class}."
+  # Generate an error message for wrong object type.
+  #
+  # @param logger [Object] The object that was passed instead of a Lumberjack::Device::Test.
+  # @return [String] An error message describing the type mismatch.
+  def wrong_object_type_message(logger)
+    unless logger.respond_to?(:device)
+      return "Expected a Lumberjack::Logger object, but received a #{logger.class}."
+    end
+
+    device = logger.device
+    "Expected logger device to be a Lumberjack::Device::Test, but it is a #{device.class}."
   end
 
-  def formatted_failure_message(captured_logger, expected_hash)
+  # Generate a detailed failure message showing expected vs actual logs.
+  #
+  # @param expected_hash [Hash] The expected log entry attributes.
+  # @return [String] A formatted failure message with context.
+  def formatted_failure_message(expected_hash)
     message = +"expected logs to include entry:\n" \
-      "#{Lumberjack::CaptureDevice.formatted_expectation(expected_hash, indent: 2)}\n\n" \
-      "Captured #{captured_logger.length} log #{(captured_logger.length == 1) ? "entry" : "entries"}"
+      "#{Lumberjack::Device::Test.formatted_expectation(expected_hash, indent: 2)}"
 
-    if captured_logger.length > 0
-      message << "\n----------------------\n"
-      captured_logger.each do |entry|
-        message << "#{Lumberjack::CaptureDevice.formatted_entry(entry)}\n"
-      end
+    closest_match = device.closest_match(**expected_hash)
+    if closest_match
+      message << "\n\nClosest match found (- expected, + actual):\n" \
+        "#{entry_diff(closest_match, indent: 2)}"
     end
 
-    closest_match = captured_logger.closest_match(**expected_hash)
-    if closest_match
-      message = "#{message}\n\nClosest match found:" \
-        "#{Lumberjack::CaptureDevice.formatted_expectation(closest_match, indent: 2)}"
+    entries = device.entries
+    message << "\n\nLogged #{entries.length} #{(entries.length == 1) ? "entry" : "entries"}"
+    if entries.length > 0
+      message << "\n----------------------\n"
+      template = Lumberjack::LocalLogTemplate.new
+      entries.each do |entry|
+        message << "#{template.call(entry)}\n"
+      end
     end
 
     message
   end
 
-  def formatted_negated_failure_message(captured_logger, expected_hash)
+  # Generate a failure message for negated expectations.
+  #
+  # @param expected_hash [Hash] The expected log entry attributes that should not be present.
+  # @return [String] A formatted failure message for negated expectations.
+  def formatted_negated_failure_message(expected_hash)
     message = "expected logs not to include entry:\n" \
-      "#{Lumberjack::CaptureDevice.formatted_expectation(expected_hash, indent: 2)}"
+      "#{Lumberjack::Device::Test.formatted_expectation(expected_hash, indent: 2)}"
 
-    match = captured_logger.match(**expected_hash)
+    match = device.match(**expected_hash)
     if match
       message = "#{message}\n\nFound entry:\n" \
-        "#{Lumberjack::CaptureDevice.formatted_expectation(match, indent: 2)}"
+        "#{Lumberjack::Device::Test.formatted_expectation(match, indent: 2)}"
     end
 
     message
   end
 
+  # Create a human-readable description of the expected log entry attributes.
+  #
+  # @param expected_hash [Hash] The expected log entry attributes.
+  # @return [String] A formatted description of the expected attributes.
   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}"
+    info << "severity: #{formatted_value(expected_hash[:severity])}" unless expected_hash[:severity].nil?
+    info << "message: #{formatted_value(expected_hash[:message])}" unless expected_hash[:message].nil?
+    info << "progname: #{formatted_value(expected_hash[:progname])}" unless expected_hash[:progname].nil?
+
+    expected_attributes = expected_hash[:attributes]
+    if expected_attributes.is_a?(Hash)
+      unless expected_attributes.empty?
+        attributes = Lumberjack::Utils.flatten_attributes(expected_attributes)
+        attributes_info = attributes.collect { |name, value| "#{name}=#{formatted_value(value)}" }.join(", ")
+        info << "attributes: #{attributes_info}"
+      end
+    elsif expected_attributes
+      # Matchers like RSpec's hash_including are matched against the attributes hash as a whole.
+      info << "attributes: #{formatted_value(expected_attributes)}"
     end
+
     info.join(", ")
   end
+
+  # Build the matcher used to compare log entries to the expectation. The entry formatter
+  # from the device is used so filter values are matched the same way they are by the
+  # device itself.
+  #
+  # @return [Lumberjack::LogEntryMatcher] The matcher for the expected values.
+  def log_entry_matcher
+    Lumberjack::LogEntryMatcher.new(
+      message: @expected_hash[:message],
+      severity: @expected_hash[:severity],
+      progname: @expected_hash[:progname],
+      attributes: @expected_hash[:attributes],
+      formatter: device&.entry_formatter
+    )
+  end
+
+  # Compare a log entry to the expected values one field at a time. The comparison itself is
+  # done by Lumberjack::LogEntryMatcher#diff which reports only the mismatched fields; the
+  # rest of the entry is filled in from the entry so it can be seen in full.
+  #
+  # @param entry [Lumberjack::LogEntry] The log entry to compare to the expectation.
+  # @return [Array<Array>] An array of [name, expected value, actual value, matched] tuples
+  #   in the order they should be displayed. The values are already formatted for display.
+  def entry_differences(entry)
+    diff = log_entry_matcher.diff(entry)
+    differences = []
+
+    mismatch = diff["severity"]
+    differences << if mismatch
+      # Severities are already reported as labels by the diff.
+      ["severity", mismatch[:expected].to_s, mismatch[:actual].to_s, false]
+    else
+      ["severity", nil, entry.severity_label, true]
+    end
+
+    differences << field_difference("message", diff["message"], entry.message)
+
+    unless diff["progname"].nil? && entry.progname.nil?
+      differences << field_difference("progname", diff["progname"], entry.progname)
+    end
+
+    differences.concat(attribute_differences(entry, diff["attributes"]))
+  end
+
+  # Build the display tuple for a single log entry field.
+  #
+  # @param name [String] The name of the field.
+  # @param mismatch [Hash, nil] The expected and actual values reported by the diff, or nil
+  #   if the field matched the expectation.
+  # @param value [Object] The value from the log entry, used when the field matched.
+  # @return [Array] A [name, expected value, actual value, matched] tuple.
+  def field_difference(name, mismatch, value)
+    if mismatch
+      [name, formatted_value(mismatch[:expected]), formatted_value(mismatch[:actual]), false]
+    else
+      [name, nil, formatted_value(value), true]
+    end
+  end
+
+  # Build the display tuples for the attributes of a log entry. Mismatches are reported by
+  # the diff per attribute using dot notation names. The remaining attributes on the entry
+  # are listed as well, followed by any expected attributes the entry does not have.
+  #
+  # @param entry [Lumberjack::LogEntry] The log entry being compared to the expectation.
+  # @param mismatches [Hash, nil] The attribute mismatches reported by the diff.
+  # @return [Array<Array>] An array of [name, expected value, actual value, matched] tuples.
+  def attribute_differences(entry, mismatches)
+    mismatches ||= {}
+
+    if mismatches.include?(:expected)
+      # Matchers like RSpec's hash_including are matched against the attributes hash as a whole.
+      return [field_difference("attributes", mismatches, nil)]
+    end
+
+    entry_attributes = Lumberjack::Utils.flatten_attributes(entry.attributes || {})
+
+    differences = entry_attributes.collect do |name, value|
+      field_difference("attributes.#{name}", mismatches[name], value)
+    end
+
+    (mismatches.keys - entry_attributes.keys).each do |name|
+      mismatch = mismatches[name]
+      actual = mismatch[:actual].nil? ? MISSING_VALUE : formatted_value(mismatch[:actual])
+      differences << ["attributes.#{name}", formatted_value(mismatch[:expected]), actual, false]
+    end
+
+    differences
+  end
+
+  # The Lumberjack::Device::Test the entries are being matched against.
+  #
+  # @return [Lumberjack::Device::Test, nil] The device, or nil if the logger is not valid.
+  def device
+    return nil unless valid_logger?
+
+    @logger.is_a?(Lumberjack::Device::Test) ? @logger : @logger.device
+  end
+
+  # Format a value for display in a description. Matcher objects (i.e. RSpec matchers)
+  # that implement a +description+ method are displayed using that description since
+  # inspecting them is not very informative.
+  #
+  # @param value [Object] The value to format.
+  # @return [String] The formatted value.
+  def formatted_value(value)
+    if value.respond_to?(:description) && !value.is_a?(Module)
+      value.description.to_s
+    else
+      value.inspect
+    end
+  end
 end

data/lib/lumberjack/capture_device/rspec.rb

@@ -3,13 +3,68 @@
 require_relative "../capture_device"
 require "rspec"
 
+# RSpec helper methods for working with CaptureDevice.
 module Lumberjack::CaptureDevice::RSpec
+  # Create a matcher for checking if a log entry is included in the captured logs.
+  # This matcher provides better error messages than using the include? method directly.
+  #
+  # @param expected_hash [Hash] The expected log entry attributes to match.
+  # @option expected_hash [String, Symbol, Integer] :severity The expected log severity.
+  # @option expected_hash [String, Regexp] :message The expected message content.
+  # @option expected_hash [Hash] :attributes Expected log entry attributes.
+  # @option expected_hash [String] :progname Expected program name.
+  # @return [Lumberjack::CaptureDevice::IncludeLogEntryMatcher] A matcher for the expected log entry.
+  # @example
+  #   expect(logs).to include_log_entry(severity: :info, message: "User logged in")
+  # @example
+  #   expect(logs).to include_log_entry(message: /error/i, attributes: {user_id: 123})
   def include_log_entry(expected_hash)
     Lumberjack::CaptureDevice::IncludeLogEntryMatcher.new(expected_hash)
   end
 
-  def capture_logger(logger, &block)
-    Lumberjack::CaptureDevice.capture(logger, &block)
+  # Capture log entries from a logger within a block. This method temporarily
+  # replaces the logger's device with a CaptureDevice and sets the log level to debug.
+  # The logger's formatters remain active, so captured entries contain the same
+  # formatted values that would have been logged.
+  #
+  # @param logger [Lumberjack::Logger] The logger to capture entries from.
+  # @yield [device] The block to execute while capturing log entries.
+  # @yieldparam device [Lumberjack::CaptureDevice] The device that will capture the log entries.
+  # @return [Lumberjack::CaptureDevice] The device that captured the log entries.
+  # @example
+  #   logs = capture_logger(Rails.logger) do
+  #     Rails.logger.info("Test message")
+  #   end
+  #   expect(logs).to include_log_entry(severity: :info, message: "Test message")
+  def capture_logger(logger, write_to_original: true, &block)
+    Lumberjack::CaptureDevice.capture(logger, write_to_original: write_to_original, &block)
+  end
+
+  # RSpec around hook to automatically capture logs for each example. The captured logs are only
+  # written to the original logger if the example fails. This helps keep the logs more usable for
+  # debugging test failures since it removes all the noise from passing tests.
+  #
+  # This is designed for CI environments where you can save the logs as artifacts of the test run.
+  #
+  # @param logger [Lumberjack::Logger] The logger to capture entries for.
+  # @param example [RSpec::Core::Example] The current RSpec example.
+  #
+  # @example Capture logs for a Rails application
+  #  # In your spec_helper.rb or rails_helper.rb
+  #  RSpec.configure do |config|
+  #    config.around do |example|
+  #      capture_logger_around_example(Rails.logger, example)
+  #    end
+  #  end
+  def capture_logger_around_example(logger, example)
+    capture_logger(logger, write_to_original: false) do |captured_device|
+      example.run
+
+      if example.exception
+        rspec_attributes = {rspec: {location: example.location, description: example.metadata[:description]}}
+        captured_device.write_to_underlying_device(attributes: rspec_attributes)
+      end
+    end
   end
 end
 

data/lib/lumberjack/capture_device.rb

@@ -5,304 +5,213 @@ 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"))
+  class CaptureDevice < Lumberjack::Device::Test
+    VERSION = ::File.read(::File.join(__dir__, "..", "..", "VERSION")).strip.freeze
+
+    require_relative "capture_device/include_log_entry_matcher"
 
     include Enumerable
 
-    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.
+      # the logger. In addition, the log level will be set to debug. The logger's formatters
+      # remain active, so captured entries contain the same formatted values that would have
+      # been logged. The device being written to be both yielded to the block as well as
+      # returned by the method call.
+      #
+      # This method is not thread safe. It swaps the device and log level on the logger
+      # itself, so concurrent calls on the same logger will interfere with each other and
+      # entries logged by other threads during the block will be captured as well. The log
+      # level is set on the current context, so threads spawned within the block may not
+      # log at the debug level.
       #
       # @param logger [Lumberjack::Logger] The logger to capture entries from.
+      # @param write_to_original [Boolean] If true (the default) the captured entries will be written
+      #   back to the original device when the block completes. If false, the captured entries
+      #   will not be written back.
       # @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")
+      #     expect(logs).to include(severity: :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
+      #   expect(logs).to include(severity: :info, message: "This will be captured")
+      def capture(logger, write_to_original: true)
         save_device = logger.device
         save_level = logger.level
-        save_formatter = logger.formatter
+        device = new(underlying_device: save_device)
+
         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
-
-      # Helper method to format a log entry for display.
-      #
-      # @param entry [Lumberjack::LogEntry] The log entry to format.
-      # @param indent [Integer] The indentation to prefix on every line.
-      # @return [String] The formatted log entry.
-      def formatted_entry(entry, indent: 0)
-        indent_str = " " * indent
-        timestamp = entry.time.strftime("%Y-%m-%d %H:%M:%S")
-        formatted = +"#{indent_str}#{timestamp} #{entry.severity_label}: #{entry.message}"
-        formatted << "\n#{indent_str}  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#{indent_str}  #{name}: #{value}"
-          end
+          device.write_to_underlying_device if write_to_original
         end
-        formatted
-      end
 
-      # Format a log entry or expectation hash into a more human readable format.
-      #
-      # @param expectation [Hash, Lumberjack::LogEntry] The expectation or log entry to format.
-      # @return [String] A formatted string representation of the expectation or log entry.
-      def formatted_expectation(expectation, indent: 0)
-        if expectation.is_a?(Lumberjack::LogEntry)
-          expectation = {
-            "level" => expectation.severity_label,
-            "message" => expectation.message,
-            "progname" => expectation.progname,
-            "tags" => expectation.tags
-          }
-        end
-
-        expectation = expectation.transform_keys(&:to_s).compact
-
-        message = []
-        indent_str = " " * indent
-        message << "#{indent_str}level: #{expectation["level"].inspect}" if expectation.include?("level")
-        message << "#{indent_str}message: #{expectation["message"].inspect}" if expectation.include?("message")
-        message << "#{indent_str}progname: #{expectation["progname"].inspect}" if expectation.include?("progname")
-        if expectation["tags"].is_a?(Hash) && !expectation["tags"].empty?
-          tags = Lumberjack::Utils.flatten_tags(expectation["tags"])
-          prefix = "tags: "
-          tags.sort_by(&:first).each do |name, value|
-            message << "#{prefix} #{name}: #{value.inspect}"
-            prefix = "#{indent_str}      "
-          end
-        end
-        message.join("\n")
+        device
       end
     end
 
-    def initialize
-      @buffer = []
-    end
-
-    def write(entry)
-      @buffer << entry
-    end
+    # The original device from the logger before capture started.
+    #
+    # @return [Lumberjack::Device, nil] The original device, or nil if none was set.
+    attr_reader :underlying_device
 
-    # Clear all entries that have been written to the buffer.
-    def clear
-      @buffer.clear
+    # Initialize a new CaptureDevice.
+    #
+    # @param options [Hash] Options to pass to the parent Test device.
+    def initialize(options = {})
+      @underlying_device = options[:underlying_device]
+      super({max_entries: 1_000_000}.merge(options))
     end
 
-    # Return true if the captured log entries match the specified level, message, and tags.
+    # Return all the captured entries that match the specified filters. The device
+    # `entry_formatter` is used to match the filters, so unformatted values can be used in
+    # the filters if it is set.
     #
-    # For level, you can specified either a numeric constant (i.e. `Logger::WARN`) or a symbol
+    # For severity, you can specify 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)
-      !!match(**args)
-    end
-
-    # Return all the captured entries that match the specified filters. These filters are
-    # the same as described in the `include?` method.
+    # For message and progname 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.).
     #
     # @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 severity [String, Symbol, Integer, nil] The severity to match against the log entries.
+    # @param attributes [Hash, nil] A hash of attribute names to values to match against the log entries. The attributes
+    #   will match nested attributes using dot notation (e.g. `foo.bar` will match an attribute with the structure
+    #   +{foo: {bar: "value"}}+).
+    # @param progname [String, nil] The program name to match against the log entries.
     # @param limit [Integer, nil] The maximum number of entries to return. If nil, all matching entries
     #   will be returned.
     # @return [Array<Lumberjack::LogEntry>] An array of log entries that match the specified filters.
-    def extract(message: nil, level: nil, tags: nil, progname: 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))
+    # @example
+    #   logs.extract(severity: :warn, message: /something happened/, attributes: {user: "john"})
+    def extract(message: nil, severity: nil, attributes: nil, progname: nil, limit: nil)
+      matched = []
+
+      matcher = LogEntryMatcher.new(
+        message: message,
+        severity: severity,
+        attributes: attributes,
+        progname: progname,
+        formatter: entry_formatter
+      )
+
+      entries.each do |entry|
+        matched << entry if matcher.match?(entry)
+        break if limit && matched.size >= limit
       end
 
-      @buffer.each do |entry|
-        if matched?(entry, message, level, tags, progname)
-          matches << entry
-          break if limit && matches.size >= limit
-        end
-      end
-
-      matches
+      matched
     end
 
-    # Return the first entry that matches the specified filters.
+    # Return true if the captured log entries match the specified filters. The filters are the
+    # same as the ones used by the `extract` 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.
-    # @param progname [String, nil] The program name to match against the log entries.
-    # @return [Lumberjack::LogEntry, nil] The log entry that most closely matches the filters, or nil if no entry meets minimum criteria.
-    def match(message: nil, level: nil, tags: nil, progname: nil)
-      extract(message: message, level: level, tags: tags, progname: progname, limit: 1).first
-    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.
+    # This must be redefined here because Enumerable#include? would otherwise shadow the
+    # implementation inherited from Lumberjack::Device::Test.
     #
-    # @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::LogEntry, 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?
-
-      exact_match = match(message: message, level: level, tags: tags, progname: progname)
-      return exact_match if exact_match
-
-      # Normalize level filter
-      if level
-        level = (level.is_a?(Integer) ? level : Lumberjack::Severity.label_to_level(level))
+    # @example
+    #   logs.include?(severity: :warn, message: /something happened/, attributes: {user: "john"})
+    #
+    # @param filters [Hash] The filters to apply to the captured entries.
+    # @option filters [String, Regexp] :message The message to match against the log entries.
+    # @option filters [String, Symbol, Integer] :severity The severity to match against the log entries.
+    # @option filters [Hash] :attributes A hash of attribute names to values to match against the log entries. The attributes
+    #   will match nested attributes using dot notation (e.g. `foo.bar` will match an attribute with the structure
+    #   +{foo: {bar: "value"}}+).
+    # @option filters [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?(filters)
+      filters = filters.transform_keys(&:to_sym)
+      unknown_keys = filters.keys - [:message, :severity, :attributes, :progname]
+      unless unknown_keys.empty?
+        raise ArgumentError, "unknown log filters: #{unknown_keys.map(&:inspect).join(", ")}"
       end
 
-      best_entry = nil
-      best_score = 0
+      !!match(**filters)
+    end
 
-      @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
+    # Write the captured log entries to the underlying device.
+    #
+    # @param attributes [Hash, nil] Additional attributes to add to each entry as it is
+    #   written. Attributes already set on an entry take precedence over these values.
+    # @return [void]
+    def write_to_underlying_device(attributes: nil)
+      return unless @underlying_device
+
+      if attributes.nil? || attributes.empty?
+        write_to(@underlying_device)
+      else
+        extra_attributes = Lumberjack::Utils.expand_attributes(attributes)
+        entries.each do |entry|
+          copy = entry.dup
+          copy.attributes = extra_attributes.merge(Lumberjack::Utils.expand_attributes(entry.attributes || {}))
+          @underlying_device.write(copy)
         end
       end
 
-      best_entry
+      nil
     end
 
+    # Provide a detailed string representation showing all captured entries.
+    #
+    # @return [String] A formatted string showing all captured log entries.
     def inspect
-      message = +"<##{self.class.name} #{@buffer.size} #{(@buffer.size == 1) ? "entry" : "entries"} captured:"
-      @buffer.each do |entry|
-        message << "\n  #{Lumberjack::CaptureDevice.formatted_entry(entry)}"
+      message = +"<##{self.class.name} #{length} #{(length == 1) ? "entry" : "entries"} captured:\n"
+      template = Lumberjack::LocalLogTemplate.new
+      entries.each do |entry|
+        formatted = template.call(entry).split("\n").collect { |line| "  #{line}" }.join("\n")
+        message << formatted
+        message << "\n"
       end
-      message << "\n>"
+      message << ">"
       message
     end
 
+    # Provide a simple string representation showing the count of captured entries.
+    #
+    # @return [String] A brief description of the captured entries count.
     def to_s
-      "<##{self.class.name} #{@buffer.size} #{(@buffer.size == 1) ? "entry" : "entries"} captured>"
+      "<##{self.class.name} #{length} #{(length == 1) ? "entry" : "entries"} captured>"
     end
 
+    # Return a thread-safe copy of all captured log entries. This must be redefined here
+    # because Enumerable#entries would otherwise shadow the thread-safe implementation
+    # inherited from Lumberjack::Device::Test.
+    #
+    # @return [Array<Lumberjack::LogEntry>] A copy of all captured log entries.
+    def entries
+      @lock.synchronize { @buffer.dup }
+    end
+
+    # Return the number of captured log entries.
+    #
+    # @return [Integer] The number of captured entries.
     def length
-      @buffer.length
+      entries.length
     end
 
     alias_method :size, :length
 
+    # Iterate over each captured log entry.
+    #
+    # @yield [entry] Block to execute for each captured entry.
+    # @yieldparam entry [Lumberjack::LogEntry] A captured log entry.
+    # @return [Array<Lumberjack::LogEntry>] The captured entries (when no block given).
     def each(&block)
-      @buffer.each(&block)
-    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
+      entries.each(&block)
     end
   end
 end
-
-require_relative "capture_device/entry_score"
-require_relative "capture_device/include_log_entry_matcher"

data/lumberjack_capture_device.gemspec

@@ -31,8 +31,7 @@ Gem::Specification.new do |spec|
 
   spec.require_paths = ["lib"]
 
-  spec.required_ruby_version = ">= 2.5"
+  spec.required_ruby_version = ">= 2.7"
 
-  spec.add_dependency "lumberjack", ">=1.3.3"
-  spec.add_development_dependency "bundler"
+  spec.add_dependency "lumberjack", ">= 2.1.0"
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: lumberjack_capture_device
 version: !ruby/object:Gem::Version
-  version: 1.2.2
+  version: 2.1.0
 platform: ruby
 authors:
 - Brian Durand
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-08-09 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lumberjack
@@ -16,29 +15,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.3.3
+        version: 2.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.3.3
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-description:
+        version: 2.1.0
 email:
 - bbdurand@gmail.com
 executables: []
@@ -50,7 +34,6 @@ files:
 - 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
@@ -62,7 +45,6 @@ metadata:
   homepage_uri: https://github.com/bdurand/lumberjack_capture_device
   source_code_uri: https://github.com/bdurand/lumberjack_capture_device
   changelog_uri: https://github.com/bdurand/lumberjack_capture_device/blob/main/CHANGELOG.md
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -70,15 +52,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.5'
+      version: '2.7'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
-signing_key:
+rubygems_version: 4.0.3
 specification_version: 4
 summary: Testing device for the lumberjack gem that can be used for asserting messages
   have been logged in a test suite.

data/lib/lumberjack/capture_device/entry_score.rb

@@ -1,220 +0,0 @@
-# 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