lumberjack_sidekiq 1.0.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5f21585d954b126f9319f5c972734eab302d903e1660ea2e165984eb4719f01b
-  data.tar.gz: b58e262711d98ec50a390f60038869cabe4329ca639405d0b07ba435b7859541
+  metadata.gz: f48f7d5f12c23e6df229a12e1e6906936cf2609f6327e006d1a20613583f3a3c
+  data.tar.gz: af324ef8cd1db551edafa69837e83f596d7aff736747890ee288be7345afce0d
 SHA512:
-  metadata.gz: b34f3b9d671b41c16acbd476725c128f0f01e3f6a6ddad0ee045d2f8102ff9f32146ec2fefccdda25c03fb6b6e51fb1cfca5379b5d58e53e122bfc1d6f4180f1
-  data.tar.gz: 98f05478c1e54a7cb28c276c086d3f2f441ba22278ad926fd140330f7a4db97b8b3b2a6afc1a6dfaaaafc4169cc4646133ac741c8cef1764c8b8f7576238e360
+  metadata.gz: 7caf943f23350cc8357fe3eb685c732adbbe8b794b868533ce8bd91054c5fd27c39fde7e3e135b2a6251b47ab6e9ecf54616b7db4d8c69ff504be0c047a7150b
+  data.tar.gz: ff07e2de83965ec9992e30bd624b07cf0607d7595ebf17f726673bcc0d3f2198aecefbb2e6b6d779fad18909be908ee9464bee2f5f36b8c852dfb7af2101733e

data/.github/workflows/continuous_integration.yml

@@ -5,8 +5,6 @@ on:
     branches:
       - main
       - actions-*
-    tags:
-      - v*
   pull_request:
     branches-ignore:
       - actions-*
@@ -27,6 +25,7 @@ jobs:
         include:
           - ruby: "ruby"
             standardrb: true
+            yard: true
           - ruby: "3.2"
             appraisal: "sidekiq_8"
           - ruby: "2.7"
@@ -50,3 +49,6 @@ jobs:
     - name: standardrb
       if: matrix.standardrb
       run:  bundle exec standardrb
+    - name: yard
+      if: matrix.yard
+      run:  bundle exec yardoc --fail-on-warning

data/CHANGE_LOG.md

@@ -4,6 +4,26 @@ 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.0.0
+
+### Added
+
+- Lumberjack 2 support.
+- Added Lumberjack global context around the job logger.
+
+### Changed
+
+- Attributes are now passed through the logger's attribute formatter before serializing them to JSON for inclusion in job payloads.
+- **Breaking Change** Updated terminology to match Lumberjack 2 change to refer to "attributes" rather than "tags".
+  - Changed config option `log_tag_prefix` to `log_attributes_prefix`
+  - Renamed `Lumberjack::Sidekiq::TagPassthroughMiddleware` to `Lumberjack::Sidekiq::AttributePassthroughMiddleware`.
+
+## 1.0.1
+
+### Changed
+
+- Switched to using the standard `with_level` method for temporarily changing log levels.
+
 ## 1.0.0
 
 ### Added

data/README.md

@@ -8,9 +8,9 @@ This gem provides an enhanced logging setup for [Sidekiq](https://github.com/mpe
 
 **Key Features:**
 
-- **Structured Job Logging**: Automatically adds structured tags for job metadata (class, job ID, queue, duration, etc.)
-- **Context Propagation**: Pass log tags from client to server to maintain request context across job execution
-- **Flexible Configuration**: Control logging behavior per job with options for log levels, argument filtering, and custom tags
+- **Structured Job Logging**: Automatically adds structured attributes for job metadata (class, job ID, queue, duration, etc.)
+- **Context Propagation**: Pass log attributes from client to server to maintain request context across job execution
+- **Flexible Configuration**: Control logging behavior per job with options for log levels, argument filtering, and custom attributes
 - **Performance Tracking**: Automatic timing of job execution and queue wait times
 
 ## Usage
@@ -24,7 +24,7 @@ To use it, configure Sidekiq to use the Lumberjack job logger:
 ```ruby
 require 'lumberjack_sidekiq'
 
-# Firat you'll need a Lumberjack logger instance
+# First you'll need a Lumberjack logger instance
 logger = Lumberjack::Logger.new(STDOUT)
 
 # Configure Sidekiq to use Lumberjack
@@ -34,7 +34,7 @@ Sidekiq.configure_server do |config|
 end
 ```
 
-The job logger automatically adds structured tags to your log entries:
+The job logger automatically adds structured attributes to your log entries:
 
 - `class` - The worker class name
 - `jid` - The job ID
@@ -43,32 +43,32 @@ The job logger automatically adds structured tags to your log entries:
 - `duration` - Job execution time in seconds
 - `enqueued_ms` - Time the job was queued before execution
 - `retry_count` - Number of retries (if > 0)
-- `tags` - Any custom Sidekiq tags
+- `attributes` - Any custom Sidekiq attributes
 
-You can add an optional prefix to all tags:
+You can add an optional prefix to all attributes:
 
 ```ruby
 Sidekiq.configure_server do |config|
-  config[:log_tag_prefix] = "sidekiq."
+  config[:log_attribute_prefix] = "sidekiq."
 end
 ```
 
-### Tag Passthrough Middleware
+### Attribute Passthrough Middleware
 
-The `Lumberjack::Sidekiq::TagPassthroughMiddleware` allows you to pass log tags from the client (where jobs are enqueued) to the server (where jobs are executed). This is useful for maintaining context like user IDs or request IDs across the job execution.
+The `Lumberjack::Sidekiq::AttributePassthroughMiddleware` allows you to pass log attributes from the client (where jobs are enqueued) to the server (where jobs are executed). This is useful for maintaining context like user IDs or request IDs across the job execution.
 
 Configure the middleware on the client side:
 
 ```ruby
 Sidekiq.configure_client do |config|
   config.client_middleware do |chain|
-    # Pass through :user_id and :request_id tags to the job logger
-    chain.add(Lumberjack::Sidekiq::TagPassthroughMiddleware, :user_id, :request_id)
+    # Pass through :user_id and :request_id attributes to the job logger
+    chain.add(Lumberjack::Sidekiq::AttributePassthroughMiddleware, :user_id, :request_id)
   end
 end
 ```
 
-Now when you enqueue a job with those tags in the current logging context, they will be propagated to the logs when the job runs.
+Now when you enqueue a job with those attributes in the current logging context, they will be propagated to the logs when the job runs.
 
 ```ruby
 logger.tag(user_id: 123, request_id: "abc-def") do
@@ -78,9 +78,9 @@ end
 
 ### Adding Additional Metadata
 
-You can add additional metadata to your job logs by adding your own server middleware. Job logging sets up a tag context so any tags you add in your middleware will be included in the job log when it finishes.
+You can add additional metadata to your job logs by adding your own server middleware. Job logging sets up an attribute context so any attributes you add in your middleware will be included in the job log when it finishes.
 
-Tags added before the `yield` in your middleware will be included in all logs for the job processing. Tags added after the `yield` will only be included in the final final job lifecycle event log.
+Attributes added before the `yield` in your middleware will be included in all logs for the job processing. Attributes added after the `yield` will only be included in the final job lifecycle event log.
 
 ```ruby
 class MyLogTaggingMiddleware
@@ -92,7 +92,7 @@ class MyLogTaggingMiddleware
 
     yield
 
-    # Add tag_2 only to the final job log only.
+    # Add tag_2 to the final job log only.
     Sidekiq.logger.tag(tag_2: job["value_2"]) if Sidekiq.logger.is_a?(Lumberjack::Logger)
   end
 end
@@ -117,7 +117,7 @@ class MyWorker
     skip: false,             # Skip logging lifecycle events for this job
     skip_start: true,        # Skip the "Start job" lifecycle log message
     args: ["param1"],        # Only log specific arguments by name; can specify false to omit all args
-    tags: {custom: "value"}  # Add custom tags to job logs
+    attributes: {custom: "value"}  # Add custom attributes to job logs
   }
 
   def perform(param1, param2)
@@ -136,11 +136,11 @@ Sidekiq.configure_server do |config|
 end
 ```
 
-You can add a prefix to all automatically generated log tags by setting `:log_tag_prefix`.
+You can add a prefix to all automatically generated log attributes by setting `:log_attribute_prefix`.
 
 ```ruby
 Sidekiq.configure_server do |config|
-  config[:log_tag_prefix] = "sidekiq."
+  config[:log_attribute_prefix] = "sidekiq."
 end
 ```
 
@@ -160,7 +160,7 @@ Sidekiq.configure_server do |config|
 end
 ```
 
-You can customize the message format by implementing your own `Lumberjack::Sidekiq::MessageFormatter` and setting it in the configuration. You can use this if you existing log processing pipeline is expecting specific message formats.
+You can customize the message format by implementing your own `Lumberjack::Sidekiq::MessageFormatter` and setting it in the configuration. You can use this if your existing log processing pipeline is expecting specific message formats.
 
 ```ruby
 Sidekiq.configure_server do |config|

data/VERSION

@@ -1 +1 @@
-1.0.1
+2.0.0

data/lib/lumberjack/sidekiq/attribute_passthrough_middleware.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "json"
+
+# Sidekiq client middleware that can pass through log attributes from the current Lumberjack
+# logger to job logger when the job is executed on the Sidekiq server. This can be
+# useful to maintain context in logs when a job is executed.
+#
+# @example Adding middleware to pass through attributes
+#   Sidekiq.configure_client do |config|
+#     config.client_middleware do |chain|
+#       # Pass through :user_id and :request_id attributes to the job logger.
+#       chain.add(Lumberjack::Sidekiq::AttributePassthroughMiddleware, :user_id, :request_id)
+#     end
+#   end
+class Lumberjack::Sidekiq::AttributePassthroughMiddleware
+  include ::Sidekiq::ClientMiddleware
+
+  # Types that can be safely serialized to JSON without losing information
+  JSON_SAFE_TYPES = [String, Integer, Float, TrueClass, FalseClass].freeze
+
+  # @param pass_through_attributes [Array<String, Symbol>] Log attributes to pass through to the job logger when the job is executed.
+  def initialize(*pass_through_attributes)
+    @pass_through_attributes = pass_through_attributes.flatten.map(&:to_s)
+  end
+
+  # Sidekiq client middleware hook that adds configured log attributes to the job data
+  # so they can be used by the job logger when the job is executed.
+  #
+  # @param job_class_or_string [String, Class] The worker class or class name
+  # @param job [Hash] The job hash containing job data
+  # @param queue [String] The queue name
+  # @param redis_pool [ConnectionPool] The Redis connection pool
+  # @yield The next middleware in the chain
+  # @return [void]
+  def call(job_class_or_string, job, queue, redis_pool)
+    return yield unless Sidekiq.logger.is_a?(Lumberjack::Logger)
+
+    job["logging"] ||= {}
+    attributes = job["logging"]["attributes"] || {}
+
+    unless @pass_through_attributes.empty?
+      logger_attributes = logger_attributes_helper
+      @pass_through_attributes.each do |attribute|
+        value = json_value(logger_attributes[attribute])
+        attributes[attribute] = value unless value.nil?
+      end
+    end
+
+    job["logging"]["attributes"] = attributes unless attributes.empty?
+
+    yield
+  end
+
+  private
+
+  # Gets logger attributes helper for extracting formatted attributes.
+  #
+  # @return [Lumberjack::AttributesHelper] Helper for accessing formatted attributes
+  def logger_attributes_helper
+    attributes = Sidekiq.logger.attributes
+    formatter = Sidekiq.logger.attribute_formatter
+    if formatter
+      attributes = formatter.format(attributes)
+    end
+    Lumberjack::AttributesHelper.new(attributes)
+  end
+
+  # Converts a value to a JSON-safe format.
+  #
+  # @param value [Object] The value to convert
+  # @return [Object, nil] JSON-safe value or nil if conversion fails
+  def json_value(value)
+    return nil if value.nil?
+    return value if JSON_SAFE_TYPES.include?(value.class)
+
+    begin
+      JSON.parse(JSON.generate(value))
+    rescue JSON::JSONError
+      nil
+    end
+  end
+end

data/lib/lumberjack/sidekiq/job_logger.rb

@@ -2,7 +2,7 @@
 
 # This is a replacement for Sidekiq's built in JobLogger. Like the built in JobLogger, it
 # will log job lifecycle events (start, end, failure) with timing information and job metadata.
-# It the standard metadata for jobs:
+# It will include the standard metadata for jobs:
 # - Job class name
 # - Job ID
 # - Duration of job execution
@@ -13,7 +13,7 @@
 # - Retry count
 # - Enqueued time in milliseconds (if available)
 #
-# Log messages will also include more information to be human readable include the jog arguments:
+# Log messages will also include more information to be human readable including the job arguments:
 #
 #   Finished Sidekiq job MyWorker.perform("foo", 12)`
 #
@@ -21,18 +21,29 @@
 #
 #   sidekiq_options logging: {args: [:arg1]} # only `arg1` will appear in the logs
 #
-# @example
-# Sidekiq.configure_server do |config|
-#   config.logger = Lumberjack::Sidekiq::JobLogger.new(config)
-# end
+# @example Setting up the job logger
+#   Sidekiq.configure_server do |config|
+#     config.logger = Lumberjack::Logger.new(STDOUT)
+#     config[:job_logger] = Lumberjack::Sidekiq::JobLogger
+#   end
 class Lumberjack::Sidekiq::JobLogger
+  # Creates a new JobLogger instance.
+  #
+  # @param config [Sidekiq::Config] The Sidekiq configuration object
   def initialize(config)
     @config = config
     @logger = @config.logger
-    @prefix = @config[:log_tag_prefix] || ""
+    @prefix = @config[:log_attribute_prefix] || ""
     @message_formatter = @config[:job_logger_message_formatter] || Lumberjack::Sidekiq::MessageFormatter.new(@config)
   end
 
+  # Sidekiq server middleware hook that logs job lifecycle events (start, completion, failure)
+  # with timing information and job metadata.
+  #
+  # @param job [Hash] The job hash containing job data
+  # @param _queue [String] The queue name (unused)
+  # @yield The job execution block
+  # @return [void]
   def call(job, _queue)
     enqueued_time = enqueued_time_ms(job) unless skip_enqueued_time_logging?
     begin
@@ -49,7 +60,10 @@ class Lumberjack::Sidekiq::JobLogger
     end
   end
 
-  # If true don't log the start of the job.
+  # Determines if start job logging should be skipped for the given job.
+  #
+  # @param job [Hash] The job hash containing job data
+  # @return [Boolean] true if start logging should be skipped
   def skip_start_job_logging?(job)
     return true if @config[:skip_start_job_logging]
     return true if skip_logging?(job)
@@ -60,6 +74,10 @@ class Lumberjack::Sidekiq::JobLogger
     !!logging_options["skip_start"]
   end
 
+  # Determines if logging should be skipped entirely for the given job.
+  #
+  # @param job [Hash] The job hash containing job data
+  # @return [Boolean] true if logging should be skipped
   def skip_logging?(job)
     logging_options = job["logging"]
     return false unless logging_options.is_a?(Hash)
@@ -67,73 +85,107 @@ class Lumberjack::Sidekiq::JobLogger
     !!logging_options["skip"]
   end
 
+  # Determines if enqueued time logging should be skipped globally.
+  #
+  # @return [Boolean] true if enqueued time logging should be skipped
   def skip_enqueued_time_logging?
     @config[:skip_enqueued_time_logging] || false
   end
 
+  # Prepares the logging context for a job by setting up Lumberjack attributes and
+  # executing the block within that context. This includes job metadata like class name,
+  # job ID, and any attributes passed through from the client.
+  #
+  # @param job [Hash] The job hash containing job data
+  # @yield The block to execute within the logging context
+  # @return [void]
   def prepare(job, &block)
     return yield unless @logger.is_a?(Lumberjack::Logger)
 
-    tags = {
+    attributes = {
       "#{@prefix}class" => worker_class(job),
       "#{@prefix}jid" => job["jid"]
     }
-    tags["#{@prefix}bid"] = job["bid"] if job.include?("bid")
-    tags["#{@prefix}tags"] = job["tags"] if job.include?("tags")
-
-    persisted_tags = passthrough_tags(job)
-    tags.merge!(persisted_tags) if persisted_tags.is_a?(Hash)
-
-    @logger.tag(tags) do
-      level = job.dig("logging", "level") || job["log_level"]
-      if level
-        @logger.with_level(level, &block)
-      else
-        yield
+    attributes["#{@prefix}bid"] = job["bid"] if job.include?("bid")
+    attributes["#{@prefix}attributes"] = job["attributes"] if job.include?("attributes")
+
+    persisted_attributes = passthrough_attributes(job)
+    attributes.merge!(persisted_attributes) if persisted_attributes.is_a?(Hash)
+
+    Lumberjack.context do
+      @logger.tag(attributes) do
+        level = job.dig("logging", "level") || job["log_level"]
+        if level
+          @logger.with_level(level, &block)
+        else
+          yield
+        end
       end
     end
   end
 
   private
 
+  # Logs the start of a job.
+  #
+  # @param job [Hash] The job hash containing job data
   def log_start_job(job)
     message = @message_formatter.start_job(job)
     if @logger.is_a?(Lumberjack::Logger)
-      tags = job_tags(job)
-      @logger.info(message, tags)
+      attributes = job_attributes(job)
+      @logger.info(message, attributes)
     else
       @logger.info(message)
     end
   end
 
+  # Logs the successful completion of a job.
+  #
+  # @param job [Hash] The job hash containing job data
+  # @param start [Float] The start time from Process.clock_gettime
+  # @param enqueued_time [Integer, nil] The enqueued time in milliseconds
   def log_end_job(job, start, enqueued_time)
     message = @message_formatter.end_job(job, elapsed_time(start))
     if @logger.is_a?(Lumberjack::Logger)
-      tags = job_tags(job)
-      tags["#{@prefix}duration"] = elapsed_time(start)
-      tags["#{@prefix}enqueued_ms"] = enqueued_time if enqueued_time
-      @logger.info(message, tags)
+      attributes = job_attributes(job)
+      attributes["#{@prefix}duration"] = elapsed_time(start)
+      attributes["#{@prefix}enqueued_ms"] = enqueued_time if enqueued_time
+      @logger.info(message, attributes)
     else
       @logger.info(message)
     end
   end
 
+  # Logs the failure of a job.
+  #
+  # @param job [Hash] The job hash containing job data
+  # @param err [Exception] The exception that caused the failure
+  # @param start [Float] The start time from Process.clock_gettime
+  # @param enqueued_time [Integer, nil] The enqueued time in milliseconds
   def log_failed_job(job, err, start, enqueued_time)
     message = @message_formatter.failed_job(job, err, elapsed_time(start))
     if @logger.is_a?(Lumberjack::Logger)
-      tags = job_tags(job)
-      tags["#{@prefix}duration"] = elapsed_time(start)
-      tags["#{@prefix}enqueued_ms"] = enqueued_time if enqueued_time
-      @logger.error(message, tags)
+      attributes = job_attributes(job)
+      attributes["#{@prefix}duration"] = elapsed_time(start)
+      attributes["#{@prefix}enqueued_ms"] = enqueued_time if enqueued_time
+      @logger.error(message, attributes)
     else
       @logger.error(message)
     end
   end
 
+  # Calculates the elapsed time since start.
+  #
+  # @param start [Float] The start time from Process.clock_gettime
+  # @return [Float] The elapsed time in seconds
   def elapsed_time(start)
     (::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - start).round(6)
   end
 
+  # Calculates the enqueued time in milliseconds.
+  #
+  # @param job [Hash] The job hash containing job data
+  # @return [Integer, nil] The enqueued time in milliseconds or nil if not available
   def enqueued_time_ms(job)
     enqueued_at = job["enqueued_at"]
     return nil unless enqueued_at.is_a?(Numeric)
@@ -146,26 +198,38 @@ class Lumberjack::Sidekiq::JobLogger
     enqueued_ms
   end
 
-  def job_tags(job)
-    tags = {}
+  # Builds job attributes hash for logging.
+  #
+  # @param job [Hash] The job hash containing job data
+  # @return [Hash] Hash of attributes to add to the log entry
+  def job_attributes(job)
+    attributes = {}
 
     retry_count = job["retry_count"]
-    tags["#{@prefix}retry_count"] = retry_count if retry_count && retry_count > 0
+    attributes["#{@prefix}retry_count"] = retry_count if retry_count && retry_count > 0
 
-    tags["#{@prefix}queue"] = job["queue"] if job["queue"]
+    attributes["#{@prefix}queue"] = job["queue"] if job["queue"]
 
-    ::Sidekiq::Context.current&.each do |tag, value|
-      tags["#{@prefix}#{tag}"] = value
+    ::Sidekiq::Context.current&.each do |attribute, value|
+      attributes["#{@prefix}#{attribute}"] = value
     end
 
-    tags
+    attributes
   end
 
+  # Extracts the worker class name from job data.
+  #
+  # @param job [Hash] The job hash containing job data
+  # @return [String] The worker class name
   def worker_class(job)
     job["display_class"] || job["wrapped"] || job["class"]
   end
 
-  def passthrough_tags(job)
-    job.dig("logging", "tags")
+  # Extracts passthrough attributes from job logging configuration.
+  #
+  # @param job [Hash] The job hash containing job data
+  # @return [Hash, nil] The passthrough attributes or nil if none
+  def passthrough_attributes(job)
+    job.dig("logging", "attributes")
   end
 end

data/lib/lumberjack/sidekiq/message_formatter.rb

@@ -19,7 +19,7 @@ module Lumberjack::Sidekiq
   # `end_job`, and `failed_job` methods and set it in your Sidekiq configuration:
   #
   #   Sidekiq.configure_server do |config|
-  #     config.job_logger_message_formatter = MyCustomFormatter.new(config)
+  #     config[:job_logger_message_formatter] = MyCustomFormatter.new(config)
   #   end
   class MessageFormatter
     # @param config [::Sidekiq::Config] The Sidekiq configuration.
@@ -89,7 +89,7 @@ module Lumberjack::Sidekiq
       end
     end
 
-    # Returns true of job arguments should never be logged.
+    # Returns true if job arguments should never be logged.
     #
     # @return [Boolean] True if job arguments should not be logged.
     def skip_logging_job_arguments?
@@ -98,7 +98,7 @@ module Lumberjack::Sidekiq
 
     # Helper method to get the job worker class name. If the job has a `display_class` or `wrapped` key,
     # it will return that value for logging purposes.
-    #     #
+    #
     # @param job [Hash] The job data.
     # @return [String] The worker class name.
     def worker_class(job)
@@ -107,6 +107,12 @@ module Lumberjack::Sidekiq
 
     private
 
+    # Filters job arguments based on the args filter configuration.
+    #
+    # @param job [Hash] The job data
+    # @param args [Array] The job arguments
+    # @param args_filter [Array] The list of argument names to include
+    # @return [Array<String>] The filtered arguments for display
     def filtered_args(job, args, args_filter)
       class_name = job["wrapped"] || job["class"]
       klass = Object.const_get(class_name) if class_name && Object.const_defined?(class_name)

data/lib/lumberjack/sidekiq.rb

@@ -3,9 +3,12 @@
 require "lumberjack"
 require "sidekiq"
 
+# Lumberjack Sidekiq integration module that provides enhanced logging capabilities
+# for Sidekiq jobs with support for structured logging and attribute passthrough.
 module Lumberjack::Sidekiq
+  VERSION = File.read(File.expand_path("../../../VERSION", __FILE__)).strip.freeze
 end
 
 require_relative "sidekiq/job_logger"
 require_relative "sidekiq/message_formatter"
-require_relative "sidekiq/tag_passthrough_middleware"
+require_relative "sidekiq/attribute_passthrough_middleware"

data/lumberjack_sidekiq.gemspec

@@ -4,7 +4,7 @@ Gem::Specification.new do |spec|
   spec.authors = ["Brian Durand"]
   spec.email = ["bbdurand@gmail.com"]
 
-  spec.summary = "Structured logging for Sidekiq jobs using the Lumberjack framework with automatic tagging, timing, and context propagation."
+  spec.summary = "Structured logging for Sidekiq jobs using the Lumberjack framework with automatic attributeging, timing, and context propagation."
   spec.homepage = "https://github.com/bdurand/lumberjack_sidekiq"
   spec.license = "MIT"
 
@@ -28,6 +28,6 @@ Gem::Specification.new do |spec|
 
   spec.required_ruby_version = ">= 2.7"
 
-  spec.add_dependency "lumberjack", ">=1.3"
+  spec.add_dependency "lumberjack", ">=2.0"
   spec.add_dependency "sidekiq", ">=7.0"
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: lumberjack_sidekiq
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 2.0.0
 platform: ruby
 authors:
 - Brian Durand
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-08-18 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lumberjack
@@ -16,14 +15,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '2.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: sidekiq
   requirement: !ruby/object:Gem::Requirement
@@ -38,7 +37,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '7.0'
-description:
 email:
 - bbdurand@gmail.com
 executables: []
@@ -53,16 +51,15 @@ files:
 - README.md
 - VERSION
 - lib/lumberjack/sidekiq.rb
+- lib/lumberjack/sidekiq/attribute_passthrough_middleware.rb
 - lib/lumberjack/sidekiq/job_logger.rb
 - lib/lumberjack/sidekiq/message_formatter.rb
-- lib/lumberjack/sidekiq/tag_passthrough_middleware.rb
 - lib/lumberjack_sidekiq.rb
 - lumberjack_sidekiq.gemspec
 homepage: https://github.com/bdurand/lumberjack_sidekiq
 licenses:
 - MIT
 metadata: {}
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -77,9 +74,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
-signing_key:
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Structured logging for Sidekiq jobs using the Lumberjack framework with automatic
-  tagging, timing, and context propagation.
+  attributeging, timing, and context propagation.
 test_files: []

data/lib/lumberjack/sidekiq/tag_passthrough_middleware.rb

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-
-# Sidekiq client middleware that can pass through log tags from the current Lumberjack
-# logger to job logger when the job is executed on the Sidekiq server. This can be
-# useful to maintain context in logs when a job is executed.
-#
-# @example
-# Sidekiq.configure_client do |config|
-#   config.client_middleware do |chain|
-#     # Pass through :user_id and :request_id tags to the job logger.
-#     chain.add(Lumberjack::Sidekiq::TagPassthroughMiddleware, :user_id, :request_id)
-#   end
-# end
-class Lumberjack::Sidekiq::TagPassthroughMiddleware
-  include ::Sidekiq::ClientMiddleware
-
-  JSON_SAFE_TYPES = [String, Integer, Float, TrueClass, FalseClass].freeze
-
-  # @param pass_through_tags [Array<String, Symbol>] Log tags to pass through to the job logger when the job is executed.
-  def initialize(*pass_through_tags)
-    @pass_through_tags = pass_through_tags.flatten.map(&:to_s)
-  end
-
-  def call(job_class_or_string, job, queue, redis_pool)
-    return yield unless Sidekiq.logger.is_a?(Lumberjack::Logger)
-
-    job["logging"] ||= {}
-    tags = job["logging"]["tags"] || {}
-
-    @pass_through_tags.each do |tag|
-      value = json_value(Sidekiq.logger.tag_value(tag))
-      tags[tag] = value unless value.nil?
-    end
-
-    job["logging"]["tags"] = tags unless tags.empty?
-
-    yield
-  end
-
-  private
-
-  def json_value(value)
-    return nil if value.nil?
-    return value if JSON_SAFE_TYPES.include?(value.class)
-
-    begin
-      JSON.parse(JSON.generate(value))
-    rescue JSON::JSONError
-      nil
-    end
-  end
-end