activesupport-json_logging 1.0.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b542fc320d19a1789f47805250847291ca671676834f66f1b99257d0311706ef
-  data.tar.gz: 8dac946f3ee55c6b22ff4d7996e12c6b6ea220434c7ba4514a7495ce251c7504
+  metadata.gz: c99bef73cc6bf2627075656ee38a3e3b756ac61ef54f2edcc628814b317ac7bf
+  data.tar.gz: c4a0e1ecfd0ae8862db0167cc5507b8da4572e6a58ed4035ec7aa606c3154442
 SHA512:
-  metadata.gz: 82f446cdb9ddc23c91ce99df51f90fd4d6cc2f8eecdaa45276bb8ff8aa074cb1ef07bde42b1ce3e2fc907e34e2e235a544cd54d36a1da5016a0fcf621b8b397b
-  data.tar.gz: 21cc1fe28c94ae215a2293fe5f934bc9f139bba4affd9431b0aa41f0c0620e30ab456c0c43bd4b834e61d4e89a6d2a5876c3fdc47d2ca21b2d4163f4a3327578
+  metadata.gz: 3abb724226828b28519f25dc8edb138c3b4d7dc1a07bf2946b952e46bee4bef5d71149a44df4a52cb12e41f892ca4d2f7147bfdeb9dbd7ad0ca3c4ee3873dddc
+  data.tar.gz: 25b2c9f5ae0c8107e4f5c7385ff96fbb379cbfba851234be9800909978b14d1d81b5fab961a5d72bd1d4ede78c5d1d16eb5ab1534e6ed54d2074e1c21456395c

data/CHANGELOG.md

@@ -1,44 +1,19 @@
-# Changelog
+# CHANGELOG
 
-## 1.0.0 (2024-10-31)
+## 1.2.0 (2025-11-07)
 
-First stable release.
+- Add support for service-specific tagged loggers: create loggers with permanent tags using `logger.tagged("service")` without a block
+- Improve BroadcastLogger compatibility: service-specific loggers work seamlessly with `ActiveSupport::BroadcastLogger`
+- Fix LocalTagStorage implementation to match Rails' TaggedLogging behavior: use `tag_stack` attribute accessor pattern for proper tag isolation
+- Add comprehensive examples in README for service-specific loggers and BroadcastLogger integration
 
-- feat: single-line JSON format compatible with cloud logging services (GCP, AWS, Azure)
-- feat: native tagged logging with `logger.tagged("TAG")` API compatible with Rails
-- feat: thread-safe context via `JsonLogging.with_context` for per-thread fields
-- feat: smart message parsing for hashes, JSON strings, and plain strings
-- feat: inherit all ActiveSupport::Logger features (silence, local_level, etc.)
-- feat: BroadcastLogger compatibility for Rails 7.1+ automatic wrapping
-- feat: timestamp precision in microseconds (iso8601 with 6 decimals)
-- feat: Rails ParameterFilter integration for automatic sensitive data filtering
-- feat: input sanitization removing control characters and truncating long strings
-- feat: sensitive key pattern matching fallback when ParameterFilter unavailable
-- feat: depth and size limits for nested structures to prevent log bloat
-- feat: single-line JSON output to prevent log injection via newlines
-- feat: graceful error handling with fallback entries on serialization errors
-- feat: Rails 6.0, 6.1, 7.0, 7.1, 7.2, 8.0 support
-- feat: IsolatedExecutionState for thread/Fiber isolation (Rails 7.1+)
-- feat: backward compatible fallback to Thread.current for Rails 6-7.0
-- feat: kwargs support in logger initialization for Rails 7+
-- perf: ~0.006ms per log entry overhead (250-400% vs plain text, typical for JSON)
-- perf: memory efficient with ~3KB per entry and zero retained memory
-- feat: performance benchmarks with memory profiling included
-- test: 93.78% code coverage with comprehensive RSpec suite
-- test: BroadcastLogger integration tests
-- test: IsolatedExecutionState thread safety tests
-- test: Appraisals configured for multi-version testing (Rails 6-8)
-- test: GitHub Actions CI workflow
-- docs: complete README with installation, usage, and API docs
-- docs: Rails environment configuration examples (development, production, test)
-- docs: Lograge integration with third-party logger configurations
-- docs: Puma integration example
-- docs: security best practices and ParameterFilter guide
-- docs: inherited Rails logger features documentation
+## 1.1.0 (2025-11-04)
 
----
+- Move tags to root level of JSON payload instead of nested in context (breaking change: tags now at `payload["tags"]` instead of `payload["context"]["tags"]`)
+- Filter system-controlled keys (severity, timestamp, message, tags, context) from user context to prevent conflicts
+- Prevent nested context objects when user context includes a `context` key
+- Fix pending spec for TimeWithZone objects by requiring ActiveSupport time extensions
 
-## 0.1.0
+## 1.0.0 (2025-10-31)
 
-- feat: initial JSON formatter and logger implementation
-- test: basic RSpec test coverage
+- Initial stable release

data/README.md

@@ -1,6 +1,6 @@
 # activesupport-json_logging
 
-[![Gem Version](https://badge.fury.io/rb/activesupport-json_logging.svg)](https://badge.fury.io/rb/activesupport-json_logging) [![Test Status](https://github.com/amkisko/activesupport-json_logging.rb/actions/workflows/ci.yml/badge.svg)](https://github.com/amkisko/activesupport-json_logging.rb/actions/workflows/ci.yml) [![codecov](https://codecov.io/gh/amkisko/activesupport-json_logging.rb/graph/badge.svg?token=881AFPL643)](https://codecov.io/gh/amkisko/activesupport-json_logging.rb)
+[![Gem Version](https://badge.fury.io/rb/activesupport-json_logging.svg)](https://badge.fury.io/rb/activesupport-json_logging) [![Test Status](https://github.com/amkisko/activesupport-json_logging.rb/actions/workflows/test.yml/badge.svg)](https://github.com/amkisko/activesupport-json_logging.rb/actions/workflows/test.yml) [![codecov](https://codecov.io/gh/amkisko/activesupport-json_logging.rb/graph/badge.svg?token=UX80FTO0Y0)](https://codecov.io/gh/amkisko/activesupport-json_logging.rb)
 
 Structured JSON logging for Rails and ActiveSupport with a safe, single-line formatter.
 No dependencies beyond Rails and Activesupport.
@@ -8,6 +8,11 @@ Supports Rails versions from 6 to 8.
 
 Sponsored by [Kisko Labs](https://www.kiskolabs.com).
 
+<a href="https://www.kiskolabs.com">
+  <img src="kisko.svg" width="200" alt="Sponsored by Kisko Labs" />
+</a>
+
+
 ## Installation
 
 Add to your Gemfile:
@@ -30,22 +35,6 @@ Rails.application.configure do
 end
 ```
 
-### Development: Using from Local Repository
-
-When developing the gem or testing changes in your application, you can point your Gemfile to a local path:
-
-```ruby
-# In your application's Gemfile
-gem "activesupport-json_logging", path: "../activesupport-json_logging.rb"
-```
-
-Then run:
-
-```bash
-bundle install
-```
-
-**Note:** When using `path:` in your Gemfile, Bundler will use the local gem directly. Changes you make to the gem code will be immediately available in your application without needing to rebuild or reinstall the gem. This is ideal for development and testing.
 
 ## What you get
 
@@ -55,6 +44,8 @@ bundle install
 - `JsonLogging.with_context` to attach contextual fields per-thread
 - Smart message parsing (handles hashes, JSON strings, plain strings, and Exception objects)
 - Native `tagged` method support - use it just like Rails' tagged logger
+- Service-specific tagged loggers - create loggers with permanent tags using `logger.tagged("service")` without a block
+- Full compatibility with `ActiveSupport::BroadcastLogger` (Rails 7.1+)
 - Automatic Rails integration via Railtie (auto-requires the gem in Rails apps)
 
 ## Basic usage
@@ -78,6 +69,17 @@ logger.tagged("BCX").info("Stuff")
 logger.tagged("BCX", "Jason").info("Stuff")
 logger.tagged("BCX").tagged("Jason").info("Stuff")
 
+# Create a service-specific logger with permanent tags
+# All logs from this logger will include the "dotenv" tag
+dotenv_logger = logger.tagged("dotenv")
+dotenv_logger.info("Loading environment variables")  # Includes "dotenv" tag
+dotenv_logger.warn("Missing .env file")  # Includes "dotenv" tag
+
+# You can also create service loggers directly
+base_logger = JsonLogging.logger($stdout)
+service_logger = base_logger.tagged("my-service")
+service_logger.info("Service started")  # All logs tagged with "my-service"
+
 # Add context
 JsonLogging.with_context(user_id: 123) do
   logger.warn({event: "slow_query", duration_ms: 250})
@@ -100,6 +102,84 @@ This gem does **not** automatically configure your Rails app. You set it up manu
 - In Rails 7.1+, Rails automatically wraps your logger in `ActiveSupport::BroadcastLogger` to enable writing to multiple destinations (e.g., STDOUT and file simultaneously). This works seamlessly with our logger - your JSON logger will be wrapped and all method calls will delegate correctly. No special handling needed.
 - In Rails 7.1+, tag storage uses `ActiveSupport::IsolatedExecutionState` for improved thread/Fiber safety.
 
+### Service-specific loggers with tags
+
+You can create loggers with permanent tags for specific services or components. This is useful when you want all logs from a particular service to be tagged consistently:
+
+```ruby
+# Create a logger for DotEnv service with "dotenv" tag
+base_logger = JsonLogging.logger($stdout)
+dotenv_logger = base_logger.tagged("dotenv")
+
+# All logs from this logger will include the "dotenv" tag
+dotenv_logger.info("Loading .env file")
+dotenv_logger.warn("Missing .env.local file")
+dotenv_logger.error("Invalid environment variable format")
+
+# Example: Configure Dotenv::Rails to use tagged logger
+if defined?(Dotenv::Rails)
+  Dotenv::Rails.logger = base_logger.tagged("dotenv")
+end
+
+# Example: Create multiple service loggers
+redis_logger = base_logger.tagged("redis")
+sidekiq_logger = base_logger.tagged("sidekiq")
+api_logger = base_logger.tagged("api")
+
+# Each service logger maintains its tag across all log calls
+redis_logger.info("Connected to Redis")  # Tagged with "redis"
+sidekiq_logger.info("Job enqueued")      # Tagged with "sidekiq"
+api_logger.info("Request received")      # Tagged with "api"
+```
+
+### BroadcastLogger integration
+
+`ActiveSupport::BroadcastLogger` (Rails 7.1+) allows writing logs to multiple destinations simultaneously. `JsonLogging` works seamlessly with `BroadcastLogger`:
+
+```ruby
+# Create JSON loggers for different destinations
+stdout_logger = JsonLogging.logger($stdout)
+file_logger = JsonLogging.logger(Rails.root.join("log", "production.log"))
+
+# Wrap in BroadcastLogger to write to both destinations
+broadcast_logger = ActiveSupport::BroadcastLogger.new(stdout_logger)
+broadcast_logger.broadcast_to(file_logger)
+
+# All logging methods work through BroadcastLogger
+broadcast_logger.info("This goes to both STDOUT and file")
+broadcast_logger.warn({event: "warning", message: "Something happened"})
+
+# Tagged logging works through BroadcastLogger
+broadcast_logger.tagged("REQUEST", request_id) do
+  broadcast_logger.info("Processing request")  # Tagged logs go to both destinations
+end
+
+# Service-specific loggers work with BroadcastLogger
+# Note: Create service logger from underlying logger, then wrap in BroadcastLogger
+# (BroadcastLogger.tagged without block returns array due to delegation)
+base_logger = JsonLogging.logger($stdout)
+dotenv_logger = base_logger.tagged("dotenv")
+dotenv_broadcast = ActiveSupport::BroadcastLogger.new(dotenv_logger)
+dotenv_broadcast.broadcast_to(file_logger.tagged("dotenv"))  # Tag second destination too
+dotenv_broadcast.info("Environment loaded")  # Tagged and broadcast to all destinations
+
+# Rails 7.1+ automatically uses BroadcastLogger
+# Your configuration can be simplified:
+Rails.application.configure do
+  # Rails will automatically wrap this in BroadcastLogger
+  base_logger = ActiveSupport::Logger.new($stdout)
+  json_logger = JsonLogging.new(base_logger)
+  config.logger = json_logger  # Rails wraps this in BroadcastLogger automatically
+end
+```
+
+**Key points:**
+- All logger methods (`info`, `warn`, `error`, etc.) work through `BroadcastLogger`
+- Tagged logging (`tagged`) works correctly through `BroadcastLogger`
+- Service-specific tagged loggers work with `BroadcastLogger`
+- Each destination receives properly formatted JSON logs
+- No special configuration needed - just wrap your `JsonLogging` logger in `BroadcastLogger`
+
 ### Basic setup
 
 Create `config/initializers/json_logging.rb`:
@@ -329,10 +409,10 @@ logger.tagged("BCX").tagged("Jason").info("Stuff")
 # Wrap a TaggedLogging logger - works perfectly
 tagged_logger = ActiveSupport::TaggedLogging.new(Logger.new(STDOUT))
 json_logger = JsonLogging.new(tagged_logger)
-json_logger.tagged("TEST") { json_logger.info("message") }  # Tags appear in JSON context
+json_logger.tagged("TEST") { json_logger.info("message") }  # Tags appear at root level in JSON
 ```
 
-**Note:** If you wrap a `JsonLogging` logger with `ActiveSupport::TaggedLogging`, the TaggedLogging's text-based tags will appear as part of the message string in the JSON output, not as structured tags in the context. For best results, wrap loggers with `JsonLogging` last.
+**Note:** If you wrap a `JsonLogging` logger with `ActiveSupport::TaggedLogging`, the TaggedLogging's text-based tags will appear as part of the message string in the JSON output, not as structured tags at the root level. For best results, wrap loggers with `JsonLogging` last.
 
 ### JsonLogging::JsonLogger
 
@@ -359,7 +439,7 @@ formatter.call("INFO", Time.now, nil, "message")
 
 # With tags (useful for Puma or other standalone use cases)
 formatter = JsonLogging::Formatter.new(tags: ["Puma"])
-formatter.call("INFO", Time.now, nil, "message")  # Output includes "Puma" tag in context
+formatter.call("INFO", Time.now, nil, "message")  # Output includes "Puma" tag at root level
 
 # Multiple tags
 formatter = JsonLogging::Formatter.new(tags: ["Puma", "Worker"])
@@ -511,12 +591,13 @@ Rails.application.config.filter_parameters += [
 
 The gem will automatically filter these from all log entries, including context data. Encrypted attributes (using Rails 7+ `encrypts`) are automatically filtered as well.
 
+
 ## Development
 
 ```bash
 # Install dependencies
 bundle install
-bundle exec appraisal install
+bundle exec appraisal generate
 
 # Run tests for current Rails version
 bundle exec rspec
@@ -536,6 +617,47 @@ bundle exec appraisal rails-7.0 rspec
 bundle exec standardrb --fix
 ```
 
+### Development: Using from Local Repository
+
+When developing the gem or testing changes in your application, you can point your Gemfile to a local path:
+
+```ruby
+# In your application's Gemfile
+gem "activesupport-json_logging", path: "../activesupport-json_logging.rb"
+```
+
+Then run:
+
+```bash
+bundle install
+```
+
+**Note:** When using `path:` in your Gemfile, Bundler will use the local gem directly. Changes you make to the gem code will be immediately available in your application without needing to rebuild or reinstall the gem. This is ideal for development and testing.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/amkisko/activesupport-json_logging.rb
+
+Contribution policy:
+- New features are not necessarily added to the gem
+- Pull request should have test coverage for affected parts
+- Pull request should have changelog entry
+
+Review policy:
+- It might take up to 2 calendar weeks to review and merge critical fixes
+- It might take up to 6 calendar months to review and merge pull request
+- It might take up to 1 calendar year to review an issue
+
+
+## Publishing
+
+```sh
+rm activesupport-json_logging-*.gem
+gem build activesupport-json_logging.gemspec
+gem push activesupport-json_logging-*.gem
+```
+
 ## License
 
-MIT
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+

data/lib/activesupport/json_logging.rb

@@ -4,4 +4,3 @@ require "json_logging"
 
 # Ensure Railtie is loaded so Rails auto-discovers it
 require "activesupport/json_logging/railtie" if defined?(Rails)
-

data/lib/json_logging/formatter_with_tags.rb

@@ -8,7 +8,13 @@ module JsonLogging
     end
 
     def current_tags
-      @logger.send(:current_tags)
+      # If LocalTagStorage is extended on this formatter, use its tag_stack
+      # This matches Rails' TaggedLogging behavior where tag_stack attribute shadows the method
+      if respond_to?(:tag_stack, true) && instance_variable_defined?(:@tag_stack)
+        tag_stack.tags
+      else
+        @logger.send(:current_tags)
+      end
     end
 
     def call(severity, timestamp, progname, msg)
@@ -22,18 +28,42 @@ module JsonLogging
       build_fallback_output(severity, timestamp, msg, e)
     end
 
+    def push_tags(*tags)
+      # If LocalTagStorage is present, use it; otherwise use logger's thread-local storage
+      if respond_to?(:tag_stack, true) && instance_variable_defined?(:@tag_stack)
+        tag_stack.push_tags(tags)
+      else
+        @logger.send(:push_tags, tags)
+      end
+    end
+
     # Support tagged blocks for formatter
     def tagged(*tags)
       if block_given?
-        previous = @logger.send(:current_tags).dup
-        @logger.send(:push_tags, tags)
-        begin
-          yield @logger
-        ensure
-          @logger.send(:set_tags, previous)
+        # If LocalTagStorage is present, use it; otherwise use logger's thread-local storage
+        if respond_to?(:tag_stack, true) && instance_variable_defined?(:@tag_stack)
+          previous_count = tag_stack.tags.size
+          tag_stack.push_tags(tags)
+          begin
+            yield @logger
+          ensure
+            tag_stack.pop_tags(tag_stack.tags.size - previous_count)
+          end
+        else
+          previous = @logger.send(:current_tags).dup
+          @logger.send(:push_tags, tags)
+          begin
+            yield @logger
+          ensure
+            @logger.send(:set_tags, previous)
+          end
         end
       else
-        @logger.send(:push_tags, tags)
+        if respond_to?(:tag_stack, true) && instance_variable_defined?(:@tag_stack)
+          tag_stack.push_tags(tags)
+        else
+          @logger.send(:push_tags, tags)
+        end
         self
       end
     end

data/lib/json_logging/json_logger_extension.rb

@@ -75,7 +75,9 @@ module JsonLogging
         # Return a new wrapped logger with tags applied (similar to TaggedLogging)
         logger = JsonLogging.new(self)
         # Extend formatter with LocalTagStorage to preserve current tags when creating nested loggers
+        # This matches Rails' TaggedLogging behavior
         logger.formatter.extend(LocalTagStorage)
+        # Push tags through formatter (matches Rails delegation pattern)
         logger.formatter.push_tags(*formatter.current_tags, *tags)
         logger
       end
@@ -132,7 +134,7 @@ module JsonLogging
       payload = PayloadBuilder.merge_context(
         payload,
         additional_context: JsonLogging.additional_context.compact,
-        tags: current_tags
+        tags: formatter.current_tags
       )
 
       payload.compact
@@ -159,19 +161,37 @@ module JsonLogging
   # Module for preserving current tags when creating nested tagged loggers
   # Similar to ActiveSupport::TaggedLogging::LocalTagStorage
   # When extended on a formatter, stores tags locally instead of using thread-local storage
+  # Uses tag_stack attribute accessor pattern to match Rails' TaggedLogging behavior
   module LocalTagStorage
+    attr_accessor :tag_stack
+
     def self.extended(base)
-      base.instance_variable_set(:@local_tags, [])
+      base.tag_stack = LocalTagStack.new
     end
 
-    def push_tags(*tags)
-      flat = tags.flatten.compact.map(&:to_s).reject(&:empty?)
-      return if flat.empty?
-      @local_tags = (@local_tags || []) + flat
-    end
+    # Simple tag stack implementation for local tag storage
+    # Similar to ActiveSupport::TaggedLogging::TagStack but simplified for JSON logging
+    class LocalTagStack
+      attr_reader :tags
 
-    def current_tags
-      @local_tags || []
+      def initialize
+        @tags = []
+      end
+
+      def push_tags(tags)
+        flat = Array(tags).flatten.compact.map(&:to_s).reject(&:empty?)
+        return [] if flat.empty?
+        @tags.concat(flat)
+        flat
+      end
+
+      def pop_tags(count = 1)
+        @tags.pop(count)
+      end
+
+      def clear
+        @tags.clear
+      end
     end
   end
 end

data/lib/json_logging/payload_builder.rb

@@ -29,14 +29,22 @@ module JsonLogging
         additional_context || {}
       end
 
-      deduped_additional = sanitized_context.reject { |k, _| payload.key?(k) }
+      # Filter out system-controlled keys from user context
+      # These keys should never be set by user context as they're controlled by the logger
+      system_controlled_keys = [:tags, "tags", :severity, "severity", :timestamp, "timestamp", :message, "message", :context, "context"]
+      user_context_filtered = sanitized_context.except(*system_controlled_keys)
+
+      # Also prevent overriding any existing payload keys (additional safety)
+      deduped_additional = user_context_filtered.reject { |k, _| payload.key?(k) }
       merged_context = existing_context.merge(deduped_additional)
 
+      # Put tags at root level, separate from context
+      # Merge with existing tags from payload (e.g., when logging a hash with tags: [...] at root)
       unless tags.empty?
-        existing_tags = Array(merged_context[:tags])
+        existing_tags = Array(payload[:tags] || payload["tags"])
         # Sanitize tag strings (remove control chars, truncate)
         sanitized_tags = tags.map { |tag| Sanitizer.sanitize_string(tag.to_s) }
-        merged_context[:tags] = (existing_tags + sanitized_tags).uniq
+        payload[:tags] = (existing_tags + sanitized_tags).uniq
       end
 
       payload[:context] = merged_context unless merged_context.empty?

data/lib/json_logging/version.rb

@@ -1,3 +1,3 @@
 module JsonLogging
-  VERSION = "1.0.0"
+  VERSION = "1.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activesupport-json_logging
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.2.0
 platform: ruby
 authors:
-- amkisko
+- Andrei Makarov
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-10-31 00:00:00.000000000 Z
+date: 2025-11-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -56,84 +56,140 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.12'
+        version: '3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.12'
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '13.0'
+        version: '13'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '13.0'
+        version: '13'
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.21'
+        version: '0.22'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+- !ruby/object:Gem::Dependency
+  name: rspec_junit_formatter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.21'
+        version: '0.6'
+- !ruby/object:Gem::Dependency
+  name: simplecov-cobertura
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
 - !ruby/object:Gem::Dependency
   name: standard
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '1'
 - !ruby/object:Gem::Dependency
   name: appraisal
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.4'
+        version: '2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.4'
+        version: '2'
 - !ruby/object:Gem::Dependency
   name: memory_profiler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+- !ruby/object:Gem::Dependency
+  name: rbs
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '3'
 description: Lightweight JSON logger and formatter integrating with Rails/ActiveSupport.
   No extra deps beyond Rails/Activesupport. Compatible with Rails 6–8.
 email: