lumberjack_json_device 1.0.0 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '09791e96f24532aeb09e536ed838a28e26d08ed47a868f3f31698b1fefd12c29'
-  data.tar.gz: 4314fc238210e81ffb8743c660bf6cefe2921567e3611dd122b898542fe4578f
+  metadata.gz: 81b9e1a335053608bb8428db2f6828acd748c02ec0610c0c064e060ab94fe36c
+  data.tar.gz: 9a1bf5cb6cce667cde7837624be8db44826976abb4c07c9568481d89efd38c16
 SHA512:
-  metadata.gz: db055ceb22bfca8ebcd2b04454ef2bc4634a48af53d960e64196ff328f06eecee687bab2f8b776a203b3a7f52d3f131e5c2d4a8ff8525930ebfe06010d52ccef
-  data.tar.gz: bee629eeef6c71b6c19c39ec3d4e863baa796f053879202efb460aec88d6649f9127437bd4672a1dafb7a201e6de36f11eaf1e7cfb3f02768687216e77d808d0
+  metadata.gz: 3226afbeeb3c72a0e60b940e26fa47973882d6f5770dff91d0d859087c0399a033c1dd54982da74a03fddd8e8fc7acc2849773b0a20bf362d1c4551314a5ba4e
+  data.tar.gz: 2068343690c36690deda5c7c6b91d9c9f1ba8663ad375f28f064ab88d9acdb9ffdb8912b04611c4898363c024bcc01d9e6fca8ab8293a58db3a72992234ff4b7

data/.github/dependabot.yml

@@ -0,0 +1,12 @@
+# Dependabot update strategy
+version: 2
+updates:
+  - package-ecosystem: bundler
+    directory: "/"
+    schedule:
+      interval: weekly
+    allow:
+      # Automatically keep all runtime dependencies updated
+      - dependency-name: "*"
+        dependency-type: "production"
+    versioning-strategy: lockfile-only

data/.github/workflows/continuous_integration.yml

@@ -0,0 +1,46 @@
+name: Continuous Integration
+
+on:
+  push:
+    branches:
+      - main
+      - actions-*
+    tags:
+      - v*
+  pull_request:
+    branches-ignore:
+      - actions-*
+  workflow_dispatch:
+
+env:
+  BUNDLE_CLEAN: "true"
+  BUNDLE_PATH: vendor/bundle
+  BUNDLE_JOBS: 3
+  BUNDLE_RETRY: 3
+
+jobs:
+  build:
+    name: ${{ matrix.ruby }} build
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        include:
+          - ruby: "ruby"
+            standardrb: true
+          - ruby: "3.0"
+          - ruby: "2.7"
+          - ruby: "2.5"
+    steps:
+    - uses: actions/checkout@v4
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby}}
+    - name: Install gems
+      run: |
+        bundle install
+    - name: Run Tests
+      run: bundle exec rake
+    - name: standardrb
+      if: matrix.standardrb
+      run:  bundle exec standardrb

data/.standard.yml

@@ -0,0 +1,8 @@
+ruby_version: 2.5
+
+format: progress
+
+ignore:
+  - 'spec/**/*':
+    - Lint/UselessAssignment
+    - Lint/Void

data/CHANGE_LOG.md

@@ -1,3 +1,36 @@
-# 1.0.0
+# Changelog
+All notable changes to this project will be documented in this file.
 
-* Initial release
+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
+
+- Tags that contain arrays of hashes are no longer expanded to nested hashes if the hashes in the array use dot nottion in their keys. The hashes in the array will now be included as is in JSON output.
+
+## 2.0.0
+
+### Added
+
+- Field mapping for the JSON can now be set to an array where the first element is the key to map and the second element is a callable object that will transform the value.
+- Output can be set to pretty for better display in development environments.
+- Added post_processor option to allow custom processing of the log entry hash before it is written to the output stream.
+
+### Changed
+
+- Tag structure is now consistently expanded from dot notation into nested hashes in the `tag` field. Previoulsly this was only done when the template copied tags to the root level of the JSON document.
+- The mapping options now supports setting the value to `false` to exclude a field from the JSON output.
+- Tag mapping can now be set to `"*"` to copy all tags into the root of the JSON document.
+
+### Removed
+
+- Remove gem dependency on `multi_json`. The gem now uses the `JSON` code from the Ruby standard library for consistency. `JSON` is also now amoung the fastest JSON libraries available in Ruby so performance is no longer a concern.
+- Removed support for Ruby versions below 2.5.
+
+## 1.0.0
+
+### Added
+
+- Initial release

data/README.md

@@ -1,13 +1,27 @@
 # Lumberjack JSON Device
 
-[![Build Status](https://travis-ci.org/bdurand/lumberjack_json_device.svg?branch=master)](https://travis-ci.org/bdurand/lumberjack_json_device)
-[![Maintainability](https://api.codeclimate.com/v1/badges/c62cb886b86381560810/maintainability)](https://codeclimate.com/github/bdurand/lumberjack_json_device/maintainability)
+[![Continuous Integration](https://github.com/bdurand/lumberjack_json_device/actions/workflows/continuous_integration.yml/badge.svg)](https://github.com/bdurand/lumberjack_json_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_json_device.svg)](https://badge.fury.io/rb/lumberjack_json_device)
 
-This gem provides a logging device for the [lumberjack](https://github.com/bdurand/lumberjack) gem that will log JSON formatted output to a stream with one JSON document per line. This can be used as part of a log processing pipeline to ship the log to a structured data store or logging service.
+This gem provides a logging device for the [lumberjack](https://github.com/bdurand/lumberjack) gem that outputs JSON formatted log entries to a stream with one JSON document per line. This format is ideal for structured logging pipelines and can be easily consumed by log aggregation services, search engines, and monitoring tools.
 
-## Destination
+## Quick Start
 
-You can send the JSON output either to a stream or to another Lumberjack device.
+```ruby
+require 'lumberjack_json_device'
+
+# Create a logger with JSON output to STDOUT
+logger = Lumberjack::Logger.new(Lumberjack::JsonDevice.new(STDOUT))
+
+# Log a message with tags
+logger.info("User logged in", user_id: 123, session_id: "abc")
+# Output: {"time":"2020-01-02T19:47:45.123455-0800","severity":"INFO","progname":null,"pid":12345,"message":"User logged in","tags":{"user_id":123,"session_id":"abc"}}
+```
+
+## Output Destinations
+
+You can send the JSON output to either a stream or to another Lumberjack device.
 
 ```ruby
 # Send to STDOUT
@@ -20,17 +34,23 @@ device = Lumberjack::JsonDevice.new(log_file)
 
 ## JSON Structure
 
-By default, the JSON document will map to the `Lumberjack::LogEntry` data structure.
+By default, the JSON document maps to the `Lumberjack::LogEntry` data structure and includes all standard fields:
 
 ```json
-{"timestamp": "2020-01-02T19:47:45.123455", "severity": "INFO", "progname": "web", "pid": 101, "message": "test", "tags": {"foo": "bar"}}
+{"time": "2020-01-02T19:47:45.123455-0800", "severity": "INFO", "progname": "web", "pid": 101, "message": "test", "tags": {"foo": "bar"}}
 ```
 
-You can specify a mapping to the device to customize the JSON document data structure. You can map the standard field names (time, severity, progname, pid, message, and tags) to custom field names.
+### Custom Field Mapping
+
+You can customize the JSON document structure by providing a mapping that specifies how log entry fields should be transformed. The mapping supports several different value types:
 
-If you map a field to an array, it will be mapped into a nested hash in the JSON document.
+- **String**: Maps the field to a custom JSON key name
+- **Array**: Creates nested JSON structures
+- **`true`**: Maps the field to the same name as the key
+- **`false`**: Excludes the field from the JSON output
+- **Callable**: Transforms the value using custom logic
 
-Any keys beyond the standard field names will be populated by a tag with the same name. These tags will not be included with the rest of the tags.
+You can map the standard field names (`time`, `severity`, `progname`, `pid`, `message`, and `tags`) as well as extract specific tags by name.
 
 ```ruby
 device = Lumberjack::JsonDevice.new(STDOUT, mapping: {
@@ -39,36 +59,41 @@ device = Lumberjack::JsonDevice.new(STDOUT, mapping: {
   progname: ["app", "name"],
   pid: ["app", "pid"],
   message: "message",
-  duration: "duration",
+  duration: "duration",  # Extracts the "duration" tag
   tags: "tags"
 })
 ```
 
 ```json
-{"timestamp": "2020-01-02T19:47:45.123455", "level": "INFO", "app": {"name": "web", "pid": 101}, "message": "test", "duration": 5, "tags": {"foo": "bar"}}
+{"timestamp": "2020-01-02T19:47:45.123455-0800", "level": "INFO", "app": {"name": "web", "pid": 101}, "message": "test", "duration": 5, "tags": {"foo": "bar"}}
 ```
 
-If you omit any fields in the mapping, they will not appear in the JSON document.
+### Excluding Fields
+
+If you omit fields from the mapping or set them to `false`, they will not appear in the JSON output:
 
 ```ruby
 device = Lumberjack::JsonDevice.new(STDOUT, mapping: {
   time: "timestamp",
   severity: "level",
   message: "message",
+  pid: false  # Exclude PID from output
 })
 ```
 
 ```json
-{"timestamp": "2020-01-02T19:47:45.123455", "level": "INFO", "message": "test"}
+{"timestamp": "2020-01-02T19:47:45.123455-0800", "level": "INFO", "message": "test"}
 ```
 
-You can also provide a block or any object that responds to `call` in a mapping. The block will be called with the value and should emit a hash that will be merged into the JSON document.
+### Custom Transformations
+
+You can provide a callable object (proc, lambda, or any object responding to `call`) to transform field values. The callable receives the original value and should return a hash that will be merged into the JSON document:
 
 ```ruby
 device = Lumberjack::JsonDevice.new(STDOUT, mapping: {
-  time: lambda { |val| (timestamp: val.to_f * 1000).round} },
+  time: lambda { |val| {timestamp: (val.to_f * 1000).round} },
   severity: "level",
-  message: "test",
+  message: "message",
 })
 ```
 
@@ -76,35 +101,157 @@ device = Lumberjack::JsonDevice.new(STDOUT, mapping: {
 {"timestamp": 1578125375588, "level": "INFO", "message": "test"}
 ```
 
-Finally, you can specify `true` in the mapping as a short cut to map the field to the same name. If the field name contains periods, it will be mapped to a nested structure.
+### Shortcut Mapping
+
+Use `true` as a shortcut to map a field to the same name:
+
+```ruby
+device = Lumberjack::JsonDevice.new(STDOUT, mapping: {
+  time: "timestamp",
+  severity: true,      # Maps to "severity"
+  progname: true,      # Maps to "progname"
+  pid: false,          # Excluded from output
+  message: "message",
+  tags: true          # Maps to "tags"
+})
+```
+
+### Tag Extraction and Dot Notation
+
+You can extract specific tags from the log entry and map them to custom locations in the JSON. Tags with dot notation in their names are automatically expanded into nested structures:
 
 ```ruby
 device = Lumberjack::JsonDevice.new(STDOUT, mapping: {
   "message" => true,
-  "http.status" => true,
-  "http.method" => true,
-  "http.path" => true
+  "http.status" => true,    # Extracts "http.status" tag
+  "http.method" => true,    # Extracts "http.method" tag
+  "http.path" => true,      # Extracts "http.path" tag
+  "tags" => true
 })
 ```
 
 ```json
-{"message": "test", "http": {"status": 200, "method": "GET", "path": "/resource"}}
+{"message": "test", "http": {"status": 200, "method": "GET", "path": "/resource"}, "tags": {"other": "values"}}
 ```
 
+**Important**: All tags are automatically expanded from dot notation into nested hash structures, not just extracted tags. For example, if you have a tag named `"user.profile.name"`, it will automatically become `{"user": {"profile": {"name": "value"}}}` in the tags section.
+
+### Flattening Tags to Root Level
+
+Use `"*"` as the tags mapping value to copy all remaining tags directly to the root level of the JSON document:
+
+```ruby
+device = Lumberjack::JsonDevice.new(STDOUT, mapping: {
+  "message" => true,
+  "tags" => "*"
+})
+```
+
+```json
+{"message": "test", "tag1": "value", "tag2": "value"}
+```
 
 ## Data Formatting
 
-The device will have a `Lumberjack::Formatter` that will be used to format objects before serializing them as JSON. You can add additional formatters for classes to the default formatter, or supply a custom one when creating the device.
+The device includes a `Lumberjack::Formatter` that formats objects before serializing them as JSON. You can add custom formatters for specific classes or supply your own formatter when creating the device.
 
 ```ruby
-device.formatter.add(Exception, LumberjacK::Formatter::InspectFormatter.new)
-device.formatter.add(ActiveRecord::Base, LumberjacK::Formatter::IdFormatter.new)
+device.formatter.add(Exception, Lumberjack::Formatter::InspectFormatter.new)
+device.formatter.add(ActiveRecord::Base, Lumberjack::Formatter::IdFormatter.new)
 ```
 
-You can also specify the `datetime_format` that will be used to serialize Time and DateTime objects.
+### Dynamic Mapping
+
+You can incrementally add field mappings after creating the device using the `map` method:
+
+```ruby
+device.map(duration: "response_time", user_id: ["user", "id"])
+```
+
+### DateTime Formatting
+
+You can specify the `datetime_format` that will be used to serialize Time and DateTime objects:
 
 ```ruby
 device.datetime_format = "%Y-%m-%dT%H:%M:%S.%3N"
 ```
 
-Log entries with no message will not be written to the log.
+### Post Processing
+
+You can provide a post processor that will be called on the hash before it is serialized to JSON. This allows you to modify any aspect of the log entry:
+
+```ruby
+# Filter out sensitive elements using Rails parameter filter
+param_filter = ActiveSupport::ParameterFilter.new(Rails.application.config.filter_parameters)
+device = Lumberjack::JsonDevice.new(STDOUT, post_processor: ->(data) { param_filter.filter(data) }
+```
+
+Note that all hash keys will be strings.If the post processor does not return a hash, it will be ignored.
+
+### Pretty Printing
+
+For development or debugging, you can format the JSON output with indentation and newlines by setting the `pretty` option to `true`:
+
+```ruby
+device = Lumberjack::JsonDevice.new(STDOUT, pretty: true)
+```
+
+This will format each log entry as multi-line JSON instead of single-line output. You can check if pretty formatting is enabled using the `pretty?` method:
+
+```ruby
+device.pretty?  # => true or false
+```
+
+### Empty Messages
+
+Log entries with empty or nil messages will not be written to the output.
+
+## Configuration Options
+
+The `JsonDevice` constructor accepts the following options:
+
+- **`mapping`**: Hash defining how log fields should be mapped to JSON (default: maps all standard fields)
+- **`formatter`**: Custom `Lumberjack::Formatter` instance for formatting values before JSON serialization
+- **`datetime_format`**: String format for Time/DateTime objects (default: `"%Y-%m-%dT%H:%M:%S.%6N%z"`)
+- **`post_processor`**: Callable that receives and can modify the final hash before JSON serialization
+- **`pretty`**: Boolean to enable pretty-printed JSON output (default: `false`)
+
+```ruby
+device = Lumberjack::JsonDevice.new(
+  STDOUT,
+  mapping: { time: "timestamp", message: true, tags: "*" },
+  datetime_format: "%Y-%m-%d %H:%M:%S",
+  pretty: true,
+  post_processor: lambda { |data| data.merge(app: "myapp") }
+)
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "lumberjack_json_device"
+```
+
+And then execute:
+
+```bash
+bundle install
+```
+
+Or install it yourself as:
+
+```bash
+gem install lumberjack_json_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.0
+2.1.0

data/lib/lumberjack_json_device.rb

@@ -1,8 +1,7 @@
 # frozen_string_literal: true
 
-require 'lumberjack'
-require 'multi_json'
-require 'thread'
+require "lumberjack"
+require "json"
 
 module Lumberjack
   # This Lumberjack device logs output to another device as JSON formatted text with one document per line.
@@ -24,7 +23,6 @@ module Lumberjack
   #
   # You can create a nested JSON structure by specifying an array as the JSON key.
   class JsonDevice < Device
-
     DEFAULT_MAPPING = {
       time: true,
       severity: true,
@@ -37,15 +35,32 @@ module Lumberjack
     DEFAULT_TIME_FORMAT = "%Y-%m-%dT%H:%M:%S.%6N%z"
 
     attr_accessor :formatter
+    attr_accessor :post_processor
+    attr_writer :pretty
     attr_reader :mapping
 
-    def initialize(stream_or_device, mapping: DEFAULT_MAPPING, formatter: nil, datetime_format: nil)
+    # @param stream_or_device [IO, Lumberjack::Device] The output stream or Lumberjack device to write
+    #  the JSON formatted log entries to.
+    # @param mapping [Hash] A hash where the key is the log entry field name and the value indicates how
+    #   to map the field if it exists. If the value is `true`, the field will be mapped to the same name.
+    #   If the value is an array, it will be mapped to a nested structure that follows the array elements.
+    #   If the value is a callable object, it will be called with the value and is expected to return
+    #   a hash that will be merged into the JSON document.
+    #   If the value is `false`, the field will not be included in the JSON output.
+    # @param formatter [Lumberjack::Formatter] An optional formatter to use for formatting the log entry data.
+    # @param datetime_format [String] An optional datetime format string to use for formatting the log timestamp.
+    # @param post_processor [Proc] An optional callable object that will be called with the log entry hash
+    #   before it is written to the output stream. This can be used to modify the log entry data
+    #   before it is serialized to JSON.
+    # @param pretty [Boolean] If true, the output will be formatted as pretty JSON with indentation and newlines.
+    #   The default is false, which writes each log entry as a single line JSON document.
+    def initialize(stream_or_device, mapping: DEFAULT_MAPPING, formatter: nil, datetime_format: nil, post_processor: nil, pretty: false)
       @mutex = Mutex.new
 
-      if stream_or_device.is_a?(Device)
-        @device = stream_or_device
+      @device = if stream_or_device.is_a?(Device)
+        stream_or_device
       else
-        @device = Writer.new(stream_or_device)
+        Lumberjack::Device::Writer.new(stream_or_device)
       end
 
       self.mapping = mapping
@@ -57,12 +72,17 @@ module Lumberjack
         datetime_format = DEFAULT_TIME_FORMAT if datetime_format.nil?
       end
       add_datetime_formatter!(datetime_format) unless datetime_format.nil?
+
+      @post_processor = post_processor
+
+      @pretty = !!pretty
     end
 
     def write(entry)
-      return if entry.message.nil? || entry.message == ""
+      return if entry.empty?
+
       data = entry_as_json(entry)
-      json = MultiJson.dump(data)
+      json = @pretty ? JSON.pretty_generate(data) : JSON.generate(data)
       @device.write(json)
     end
 
@@ -70,16 +90,31 @@ module Lumberjack
       @device.flush
     end
 
-    def datetime_format
-      @datetime_format
-    end
+    attr_reader :datetime_format
 
     # Set the datetime format for the log timestamp.
+    #
+    # @param format [String] The datetime format string to use for formatting the log timestamp.
     def datetime_format=(format)
       add_datetime_formatter!(format)
     end
 
+    # Return true if the output is written in a multi-line pretty format. The default is to write each
+    # log entry as a single line JSON document.
+    #
+    # @return [Boolean]
+    def pretty?
+      !!@pretty
+    end
+
     # Set the mapping for how to map an entry to a JSON object.
+    #
+    # @param mapping [Hash] A hash where the key is the log entry field name and the value is the JSON key.
+    #   If the value is `true`, the field will be mapped to the same name
+    #   If the value is an array, it will be mapped to a nested structure.
+    #   If the value is a callable object, it will be called with the value and should return a hash that will be merged into the JSON document.
+    #   If the value is `false`, the field will not be included in the JSON output.
+    # @return [void]
     def mapping=(mapping)
       @mutex.synchronize do
         keys = {}
@@ -97,48 +132,110 @@ module Lumberjack
         @pid_key = keys.delete(:pid)
         @message_key = keys.delete(:message)
         @tags_key = keys.delete(:tags)
-        @custom_keys = keys
+        @custom_keys = keys.map do |name, key|
+          [name.to_s.split("."), key]
+        end.to_h
         @mapping = mapping
       end
-      nil
     end
 
+    # Add a field mapping to the existing mappings.
+    #
+    # @param field_mapping [Hash] A hash where the key is the log entry field name and the value is the JSON key.
+    #   If the value is `true`, the field will be mapped to the same name
+    #   If the value is an array, it will be mapped to a nested structure.
+    #   If the value is a callable object, it will be called with the value and should return a hash that will be merged into the JSON document.
+    #   If the value is `false`, the field will not be included in the JSON output.
+    # @return [void]
     def map(field_mapping)
-      new_mapping = {}
-      field_mapping.each do |key, value|
-        new_mapping[key.to_sym] = value
-      end
+      new_mapping = field_mapping.transform_keys(&:to_sym)
       self.mapping = mapping.merge(new_mapping)
     end
 
     # Convert a Lumberjack::LogEntry to a Hash using the specified field mapping.
+    #
+    # @param entry [Lumberjack::LogEntry] The log entry to convert.
+    # @return [Hash] A hash representing the log entry in JSON format.
     def entry_as_json(entry)
       data = {}
-      set_attribute(data, @time_key, entry.time) unless @time_key.nil?
-      set_attribute(data, @severity_key, entry.severity_label) unless @severity_key.nil?
-      set_attribute(data, @progname_key, entry.progname) unless @progname_key.nil?
-      set_attribute(data, @pid_key, entry.pid) unless @pid_key.nil?
-      set_attribute(data, @message_key, entry.message) unless @message_key.nil?
-
-      tags = entry.tags
-      if @custom_keys.size > 0
-        tags = (tags.nil? ? {} : tags.dup)
+      set_attribute(data, @time_key, entry.time) if @time_key
+      set_attribute(data, @severity_key, entry.severity_label) if @severity_key
+      set_attribute(data, @message_key, entry.message) if @message_key
+      set_attribute(data, @progname_key, entry.progname) if @progname_key
+      set_attribute(data, @pid_key, entry.pid) if @pid_key
+
+      tags = Lumberjack::Utils.expand_tags(entry.tags) if entry.tags
+      extracted_tags = nil
+      if @custom_keys.size > 0 && !tags&.empty?
+        extracted_tags = []
         @custom_keys.each do |name, key|
-          set_attribute(data, key, tags.delete(name.to_s))
+          set_attribute(data, key, tag_value(tags, name))
+          extracted_tags << name
+        end
+
+        extracted_tags.each do |path|
+          tags = deep_remove_tag(tags, path, entry.tags)
         end
       end
 
-      unless @tags_key.nil?
+      if @tags_key
         tags ||= {}
-        set_attribute(data, @tags_key, tags)
+        if @tags_key == "*"
+          data = tags.merge(data) unless tags.empty?
+        else
+          set_attribute(data, @tags_key, tags)
+        end
       end
 
       data = @formatter.format(data) if @formatter
+      if @post_processor
+        processed_result = @post_processor.call(data)
+        data = processed_result if processed_result.is_a?(Hash)
+      end
+
       data
     end
 
     private
 
+    def tag_value(tags, name)
+      return nil if tags.nil?
+      return tags[name] unless name.is_a?(Array)
+
+      val = tags[name.first]
+      return val if name.length == 1
+      return nil unless val.is_a?(Hash)
+
+      tag_value(val, name[1, name.length])
+    end
+
+    def deep_remove_tag(tags, path, original_tags)
+      return nil if tags.nil?
+
+      dup_needed = tags.equal?(original_tags)
+      key = path.first
+      val = tags[key] if path.length > 1
+      unless val.is_a?(Hash)
+        if tags.include?(key)
+          tags = tags.dup if dup_needed
+          tags.delete(key)
+        end
+        return tags
+      end
+
+      new_val = deep_remove_tag(val, path[1, path.length], original_tags[key])
+      if new_val.empty? || !new_val.equal?(val)
+        tags = tags.dup if dup_needed
+        if new_val.empty?
+          tags.delete(key)
+        else
+          tags[key] = new_val
+        end
+      end
+
+      tags
+    end
+
     def set_attribute(data, key, value)
       return if value.nil?
 
@@ -191,13 +288,12 @@ module Lumberjack
       hash.merge!(other_hash) do |key, this_val, other_val|
         if this_val.is_a?(Hash) && other_val.is_a?(Hash)
           deep_merge!(this_val, other_val, &block)
-        elsif block_given?
+        elsif block
           block.call(key, this_val, other_val)
         else
           other_val
         end
       end
     end
-
   end
 end

data/lumberjack_json_device.gemspec

@@ -1,16 +1,16 @@
 Gem::Specification.new do |spec|
-  spec.name = 'lumberjack_json_device'
-  spec.version = File.read(File.expand_path("../VERSION", __FILE__)).strip
-  spec.authors = ['Brian Durand']
-  spec.email = ['bbdurand@gmail.com']
+  spec.name = "lumberjack_json_device"
+  spec.version = File.read(File.join(__dir__, "VERSION")).strip
+  spec.authors = ["Brian Durand"]
+  spec.email = ["bbdurand@gmail.com"]
 
-  spec.summary = "A logging device for the lumberjack gem that writes log entries as JSON documentspec."
+  spec.summary = "A logging device for the lumberjack gem that writes log entries as JSON documents for use with structured logging."
   spec.homepage = "https://github.com/bdurand/lumberjack_json_device"
   spec.license = "MIT"
 
   # 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(
+  ignore_files = %w[
     .gitignore
     .travis.yml
     Appraisals
@@ -19,16 +19,14 @@ Gem::Specification.new do |spec|
     Rakefile
     gemfiles/
     spec/
-  )
-  spec.files = Dir.chdir(File.expand_path('..', __FILE__)) do
-    `git ls-files -z`.split("\x0").reject{ |f| ignore_files.any?{ |path| f.start_with?(path) } }
+  ]
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject { |f| ignore_files.any? { |path| f.start_with?(path) } }
   end
 
-  spec.require_paths = ['lib']
+  spec.require_paths = ["lib"]
 
-  spec.add_dependency "lumberjack", ">=1.2"
-  spec.add_dependency "multi_json"
+  spec.required_ruby_version = ">= 2.5"
 
-  spec.add_development_dependency("rspec", ["~> 3.0"])
-  spec.add_development_dependency "rake"
+  spec.add_dependency "lumberjack", ">=1.3.3"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lumberjack_json_device
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 2.1.0
 platform: ruby
 authors:
 - Brian Durand
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-01-20 00:00:00.000000000 Z
+date: 2025-07-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lumberjack
@@ -16,65 +16,26 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: 1.3.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '1.2'
-- !ruby/object:Gem::Dependency
-  name: multi_json
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
-- !ruby/object:Gem::Dependency
-  name: rake
-  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: 1.3.3
+description:
 email:
 - bbdurand@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/dependabot.yml"
+- ".github/workflows/continuous_integration.yml"
+- ".standard.yml"
 - CHANGE_LOG.md
-- MIT_LICENSE
+- MIT_LICENSE.txt
 - README.md
 - VERSION
 - lib/lumberjack_json_device.rb
@@ -83,7 +44,7 @@ homepage: https://github.com/bdurand/lumberjack_json_device
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -91,15 +52,16 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '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: A logging device for the lumberjack gem that writes log entries as JSON documentspec.
+summary: A logging device for the lumberjack gem that writes log entries as JSON documents
+  for use with structured logging.
 test_files: []