lumberjack_capture_device 1.0.1 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 35d8ad5610c0d02fbc90b22a141d58aac09de8f98dcbfa85ed71c69d90e3aae2
-  data.tar.gz: 96657c5cb4a6dfc2431b8fe1689469950f5f144db64f29413df79baa1bf18aeb
+  metadata.gz: f40306e5addb7cd7a23f739e937f26c6f42ab6a7dc2836cf0e9c128fa0835541
+  data.tar.gz: 282b90a7dfe1de511806b0dbf1a8597c6ab7a00a9a031e64f642242fe686b3f1
 SHA512:
-  metadata.gz: f22f7e086c58df3f4fc180b8d84df5bb49c7fc3966f578ae644b8a9c95ca7a143ad71f82f277622af4607377e9ea7219af10f07af6d38bbd07d674a4e3746a9c
-  data.tar.gz: 706cf53df406ca2702b314d89b9f38e9d55c764e667a852a7c2e08fc30e808315a5199e7f603acab6af8748fb15b078da69b9985a10d60c16806b6569e43f48b
+  metadata.gz: ddfc01f72e76421232add226ed4d6d8158119883aea02483469d86c8fad428654c576c0df91441acfa3b2332ea3e696419651adfa61549dfd499bda43f7062df
+  data.tar.gz: 8f8b915dfebdb33f58d0f06a143f9a61a919fd503319d2eb74157f221afaba19e30c66884915b682ae772ba6c2fbbea66fabfd3a073c42cde3b57f9398d89589

data/CHANGELOG.md

@@ -4,10 +4,30 @@ 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.1.1
+
+### Fixed
+
+- Handle tag array comparison when an array contains hashes to consistently convert the hash keys to strings. Otherwise array hashes were being treated differently that other tag structures.
+
+### Changed
+
+- Improved the `inspect` method to provide a clearer representation of captured log entries to make debugging tests easier.
+
+## 1.1.0
+
+### Added
+
+- 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}`.
+
 ## 1.0.1
+
 ### Added
+
 - Ruby 3 compatibility
 
 ## 1.0.0
+
 ### Added
+
 - Initial release.

data/README.md

@@ -1,26 +1,27 @@
+# Lumberjack Capture Device
+
 [![Continuous Integration](https://github.com/bdurand/lumberjack_capture_device/actions/workflows/continuous_integration.yml/badge.svg)](https://github.com/bdurand/lumberjack_capture_device/actions/workflows/continuous_integration.yml)
 [![Ruby Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://github.com/testdouble/standard)
+[![Gem Version](https://badge.fury.io/rb/lumberjack_capture_device.svg)](https://badge.fury.io/rb/lumberjack_capture_device)
 
-# Lumberjack Capture Device
-
-This is a plugin device for the [lumberjack gem](https://github.com/bdurand/lumberjack) that enables capturing log messages in a test suite so that assertions can be made against them. It provides and easy and stable method of testing that specific log messages are being sent to a logger.
+This is a plugin device for the [lumberjack gem](https://github.com/bdurand/lumberjack) that enables capturing log messages in a test suite so that assertions can be made against them. It provides an easy and stable method of testing that specific log messages are being sent to a logger.
 
-Using mocks and stubs on a logger to test that it receives messages can make for a brittle test suite since there can a wide variety of code writing messages to logs and your test suite may have a higher log level turned on causing it skip messages at a lower level.
+Using mocks and stubs on a logger to test that it receives messages can make for a brittle test suite since there can be a wide variety of code writing messages to logs and your test suite may have a higher log level turned on causing it to skip messages at a lower level.
 
-For instance, this rspec code can break if any of the code called by the `do_something` writes a different info log message:
+For instance, this RSpec code can break if any of the code called by `do_something` writes a different info log message:
 
 ```ruby
 do_something
-expect(Rail.logger).to receive(:info).with("Something happened")
+expect(Rails.logger).to receive(:info).with("Something happened")
 ```
 
 It will also break if the test suite logger has the log level set to `warn` or higher since it will then skip all info and debug messages.
 
 ## Usage
 
-You can call the `Lumberjack::CaptureDevice.capture` method to override a logger so that it will capture log entries within a block to an in memory buffer. This method will yield the capturing log device as well as return it as the result of the method. The log level will also be temporarily set to debug within the block, so you can capture all log messages without having to change the log level for the entire test suite.
+You can call the `Lumberjack::CaptureDevice.capture` method to temporarily override a logger so that it will capture log entries within a block to an in-memory buffer. This method will yield the capturing log device and also return it as the result of the method. The log level will also be temporarily set to debug within the block, so you can capture all log messages without having to change the log level for the entire test suite.
 
-You can use the `include?` method on the log device to determine if specific log entries were made. This would be the equivalent code to the above rspec test, but without the brittleness of mocking method calls:
+You can use the `include?` method on the log device to determine if specific log entries were made. This would be the equivalent code to the above RSpec test, but without the brittleness of mocking method calls:
 
 ```ruby
 Lumberjack::CaptureDevice.capture(Rails.logger) do |logs|
@@ -44,12 +45,47 @@ 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`). 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.
+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`).
+- 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.
 
 ```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})
+```
+
+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`.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'lumberjack_capture_device'
 ```
 
-You can also use the `Lumberjack::CaptureDevice#extract` method with the same arguments as used by `include?` to grab all lines that match the filters. And finally, you can access all the log entries with `Lumberjack::CaptureDevice#buffer`.
+And then execute:
+
+```bash
+$ bundle install
+```
+
+Or install it yourself as:
+
+```bash
+$ gem install lumberjack_capture_device
+```
+
+## Contributing
+
+Open a pull request on GitHub.
+
+Please use the [standardrb](https://github.com/testdouble/standard) syntax and lint your code with `standardrb --fix` before submitting.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/VERSION

@@ -1 +1 @@
-1.0.1
+1.1.1

data/lib/lumberjack_capture_device.rb

@@ -14,6 +14,20 @@ module Lumberjack
       # 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
@@ -64,14 +78,32 @@ module Lumberjack
     # ```
     # 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))
@@ -82,13 +114,33 @@ module Lumberjack
           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)
-      match?(entry.message, message_filter) && match?(entry.severity, level_filter) && match_tags?(entry.tags, 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)
@@ -99,21 +151,51 @@ module Lumberjack
     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?(Lumberjack::Tags.stringify_keys(tag_values), value_filter)
+            match_tags?(tag_values, value_filter)
           else
             false
           end
-        elsif tag_values || tags.include?(name)
+        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

data/lumberjack_capture_device.gemspec

@@ -8,6 +8,12 @@ Gem::Specification.new do |spec|
   spec.homepage = "https://github.com/bdurand/lumberjack_capture_device"
   spec.license = "MIT"
 
+  spec.metadata = {
+    "homepage_uri" => spec.homepage,
+    "source_code_uri" => spec.homepage,
+    "changelog_uri" => "#{spec.homepage}/blob/main/CHANGELOG.md"
+  }
+
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
   ignore_files = %w[
@@ -25,8 +31,8 @@ Gem::Specification.new do |spec|
 
   spec.require_paths = ["lib"]
 
-  spec.required_ruby_version = ">= 2.4.0"
+  spec.required_ruby_version = ">= 2.5"
 
-  spec.add_dependency "lumberjack", ">=1.1.0"
+  spec.add_dependency "lumberjack", ">=1.3.3"
   spec.add_development_dependency "bundler"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lumberjack_capture_device
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.1.1
 platform: ruby
 authors:
 - Brian Durand
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-09-25 00:00:00.000000000 Z
+date: 2025-07-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lumberjack
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.1.0
+        version: 1.3.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.1.0
+        version: 1.3.3
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -38,7 +38,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: 
+description:
 email:
 - bbdurand@gmail.com
 executables: []
@@ -54,8 +54,11 @@ files:
 homepage: https://github.com/bdurand/lumberjack_capture_device
 licenses:
 - MIT
-metadata: {}
-post_install_message: 
+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
@@ -63,15 +66,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.4.0
+      version: '2.5'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.4.10
+signing_key:
 specification_version: 4
 summary: Testing device for the lumberjack gem that can be used for asserting messages
   have been logged in a test suite.