lumberjack_sidekiq 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: af05f3d7358c3375820ed3e3d4b09ea6830de363c6ce38600236a873002d297d
+  data.tar.gz: 69e09c53f370c63009e5612add2d3f471ac1e3bb134dbd94e35a2580f36a3bf8
+SHA512:
+  metadata.gz: 4ae4f2b993a862c4eca32d4634412fdd9c6178d06698d67fd29038de73ca623528053aad65a04e6407196bb2cc120b65aa23620cceb1a070d14547bbc97b33cb
+  data.tar.gz: 92392ec7a0b70eaac5cd20b8bc71c864dd517c49ee91d0dbaf3890dae58f42c2bef06668b883a1add2f98e221bc7282c0b868f0e72d04649168b057eb1f4b531

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,47 @@
+name: Continuous Integration
+
+on:
+  push:
+    branches:
+      - master
+      - 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"
+            appraisal: "sidekiq_8"
+          - ruby: "2.7"
+            appraisal: "sidekiq_7"
+    steps:
+    - uses: actions/checkout@v2
+    - 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.7
+
+format: progress
+
+ignore:
+  - 'spec/**/*':
+    - Lint/UselessAssignment
+    - Lint/Void

data/CHANGE_LOG.md

@@ -0,0 +1,11 @@
+# Changelog
+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.0.0
+
+### Added
+
+- Initial release

data/MIT_LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2025 Brian Durand
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,197 @@
+# Lumberjack Sidekiq
+
+[![Continuous Integration](https://github.com/bdurand/lumberjack_sidekiq/actions/workflows/continuous_integration.yml/badge.svg)](https://github.com/bdurand/lumberjack_sidekiq/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_sidekiq.svg)](https://badge.fury.io/rb/lumberjack_sidekiq)
+
+This gem provides an enhanced logging setup for [Sidekiq](https://github.com/mperham/sidekiq) using the [lumberjack](https://github.com/bdurand/lumberjack) structured logging framework. It replaces Sidekiq's default job logging behavior with one that provides rich structured logging with automatic tagging, timing information, and context propagation.
+
+**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
+- **Performance Tracking**: Automatic timing of job execution and queue wait times
+
+## Usage
+
+### Job Logger
+
+The `Lumberjack::Sidekiq::JobLogger` provides structured logging for Sidekiq jobs with automatic tagging and timing information.
+
+To use it, configure Sidekiq to use the Lumberjack job logger:
+
+```ruby
+require 'lumberjack_sidekiq'
+
+# Firat you'll need a Lumberjack logger instance
+logger = Lumberjack::Logger.new(STDOUT)
+
+# Configure Sidekiq to use Lumberjack
+Sidekiq.configure_server do |config|
+  config.logger = logger
+  config[:job_logger] = Lumberjack::Sidekiq::JobLogger
+end
+```
+
+The job logger automatically adds structured tags to your log entries:
+
+- `class` - The worker class name
+- `jid` - The job ID
+- `bid` - The batch ID (if using Sidekiq batch)
+- `queue` - The queue name
+- `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
+
+You can add an optional prefix to all tags:
+
+```ruby
+Sidekiq.configure_server do |config|
+  config[:log_tag_prefix] = "sidekiq."
+end
+```
+
+### Tag 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.
+
+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)
+  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.
+
+```ruby
+logger.tag(user_id: 123, request_id: "abc-def") do
+  MyWorker.perform_async(params)
+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.
+
+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.
+
+```ruby
+class MyLogTaggingMiddleware
+  include Sidekiq::ServerMiddleware
+
+  def call(worker, job, queue)
+    # Add tag_1 to all logs for this job.
+    Sidekiq.logger.tag(tag_1: job["value_1"]) if Sidekiq.logger.is_a?(Lumberjack::Logger)
+
+    yield
+
+    # Add tag_2 only to the final job log only.
+    Sidekiq.logger.tag(tag_2: job["value_2"]) if Sidekiq.logger.is_a?(Lumberjack::Logger)
+  end
+end
+
+Sidekiq.configure_server do |config|
+  config.server_middleware do |chain|
+    chain.add MyLogTaggingMiddleware
+  end
+end
+```
+
+### Job-Level Logging Options
+
+You can control logging behavior on a per-job basis by setting logging options:
+
+```ruby
+class MyWorker
+  include Sidekiq::Worker
+
+  sidekiq_options logging: {
+    level: "warn",           # Set log level for this job
+    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
+  }
+
+  def perform(param1, param2)
+    # Your job logic here
+  end
+end
+```
+
+### Configuration Options
+
+You can globally disable logging job start events by setting `:skip_start_job_logging` to `true` in the Sidekiq configuration.
+
+```ruby
+Sidekiq.configure_server do |config|
+  config[:skip_start_job_logging] = true
+end
+```
+
+You can add a prefix to all automatically generated log tags by setting `:log_tag_prefix`.
+
+```ruby
+Sidekiq.configure_server do |config|
+  config[:log_tag_prefix] = "sidekiq."
+end
+```
+
+You can disable logging the enqueued time by setting `:skip_enqueued_time_logging` to `true`.
+
+```ruby
+Sidekiq.configure_server do |config|
+  config[:skip_enqueued_time_logging] = true
+end
+```
+
+You can disable logging any job arguments by setting `:skip_logging_job_arguments` to `true`.
+
+```ruby
+Sidekiq.configure_server do |config|
+  config[:skip_logging_job_arguments] = true
+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.
+
+```ruby
+Sidekiq.configure_server do |config|
+  config[:job_logger_message_formatter] = MyCustomMessageFormatter.new(config)
+end
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "lumberjack_sidekiq"
+```
+
+And then execute:
+```bash
+$ bundle install
+```
+
+Or install it yourself as:
+```bash
+$ gem install lumberjack_sidekiq
+```
+
+## 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

@@ -0,0 +1 @@
+1.0.0

data/lib/lumberjack/sidekiq/job_logger.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+# 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:
+# - Job class name
+# - Job ID
+# - Duration of job execution
+# - Tags from the current Sidekiq context
+#
+# It will also include additional metadata:
+# - Queue name
+# - Retry count
+# - Enqueued time in milliseconds (if available)
+#
+# Log messages will also include more information to be human readable include the jog arguments:
+#
+#   Finished Sidekiq job MyWorker.perform("foo", 12)`
+#
+# You can specify at the worker level if you want to suppress arguments with the `logging => args` option:
+#
+#   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
+class Lumberjack::Sidekiq::JobLogger
+  def initialize(config)
+    @config = config
+    @logger = @config.logger
+    @prefix = @config[:log_tag_prefix] || ""
+    @message_formatter = @config[:job_logger_message_formatter] || Lumberjack::Sidekiq::MessageFormatter.new(@config)
+  end
+
+  def call(job, _queue)
+    enqueued_time = enqueued_time_ms(job) unless skip_enqueued_time_logging?
+    begin
+      start = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+      log_start_job(job) unless skip_start_job_logging?(job)
+
+      yield
+
+      log_end_job(job, start, enqueued_time) unless skip_logging?(job)
+    rescue Exception => err # rubocop:disable Lint/RescueException
+      log_failed_job(job, err, start, enqueued_time) unless skip_logging?(job)
+
+      raise
+    end
+  end
+
+  # If true don't log the start of the job.
+  def skip_start_job_logging?(job)
+    return true if @config[:skip_start_job_logging]
+    return true if skip_logging?(job)
+
+    logging_options = job["logging"]
+    return false unless logging_options.is_a?(Hash)
+
+    !!logging_options["skip_start"]
+  end
+
+  def skip_logging?(job)
+    logging_options = job["logging"]
+    return false unless logging_options.is_a?(Hash)
+
+    !!logging_options["skip"]
+  end
+
+  def skip_enqueued_time_logging?
+    @config[:skip_enqueued_time_logging] || false
+  end
+
+  def prepare(job, &block)
+    return yield unless @logger.is_a?(Lumberjack::Logger)
+
+    tags = {
+      "#{@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.silence(level, &block)
+      else
+        yield
+      end
+    end
+  end
+
+  private
+
+  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)
+    else
+      @logger.info(message)
+    end
+  end
+
+  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)
+    else
+      @logger.info(message)
+    end
+  end
+
+  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)
+    else
+      @logger.error(message)
+    end
+  end
+
+  def elapsed_time(start)
+    (::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - start).round(6)
+  end
+
+  def enqueued_time_ms(job)
+    enqueued_at = job["enqueued_at"]
+    return nil unless enqueued_at.is_a?(Numeric)
+
+    # Older versions of Sidekiq stored the time as the number of seconds in a float.
+    # As of Sidekiq 8 it is stored as an integer in milliseconds.
+    enqueued_at = (enqueued_at * 1000).round if enqueued_at.is_a?(Float)
+    enqueued_ms = ((Time.now.to_f * 1000) - enqueued_at).round
+    enqueued_ms = 0 if enqueued_ms < 0
+    enqueued_ms
+  end
+
+  def job_tags(job)
+    tags = {}
+
+    retry_count = job["retry_count"]
+    tags["#{@prefix}retry_count"] = retry_count if retry_count && retry_count > 0
+
+    tags["#{@prefix}queue"] = job["queue"] if job["queue"]
+
+    ::Sidekiq::Context.current&.each do |tag, value|
+      tags["#{@prefix}#{tag}"] = value
+    end
+
+    tags
+  end
+
+  def worker_class(job)
+    job["display_class"] || job["wrapped"] || job["class"]
+  end
+
+  def passthrough_tags(job)
+    job.dig("logging", "tags")
+  end
+end

data/lib/lumberjack/sidekiq/message_formatter.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module Lumberjack::Sidekiq
+  # This class formats log messages for Sidekiq jobs. Out of the box it will log messages like these:
+  #
+  # - Start Sidekiq job MyWorker.perform("foo", 12)
+  # - Finished Sidekiq job MyWorker.perform("foo", 12) in 123.4ms
+  # - Failed Sidekiq job MyWorker.perform("foo", 12) due to RuntimeError in 123.4ms
+  #
+  # You can control the arguments that are logged by setting the `logging.args` option in your worker:
+  #
+  #   sidekiq_options logging: {args: [:arg1]} # only `arg1` will appear in the logs
+  #   sidekiq_options logging: {args: false} # no arguments will appear in the logs
+  #
+  # Argument logging can be disabled globally by setting the `skip_logging_job_arguments` option in your
+  # Sidekiq configuration.
+  #
+  # You can override this class or provide your own implementation that implements the `start_job`,
+  # `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)
+  #   end
+  class MessageFormatter
+    # @param config [::Sidekiq::Config] The Sidekiq configuration.
+    def initialize(config)
+      @config = config
+    end
+
+    # Formats the start job message.
+    #
+    # @param job [Hash] The job data.
+    # @return [String] The formatted start job message.
+    def start_job(job)
+      "Start Sidekiq job #{job_info(job)}"
+    end
+
+    # Formats the end job message.
+    #
+    # @param job [Hash] The job data.
+    # @param elapsed_time [Float] The elapsed time in seconds.
+    # @return [String] The formatted end job message.
+    def end_job(job, elapsed_time)
+      "Finished Sidekiq job #{job_info(job)} in #{(elapsed_time * 1000).round(1)}ms"
+    end
+
+    # Formats the failed job message.
+    #
+    # @param job [Hash] The job data.
+    # @param error [Exception] The exception that was raised.
+    # @param elapsed_time [Float] The elapsed time in seconds.
+    # @return [String] The formatted failed job message.
+    def failed_job(job, error, elapsed_time)
+      "Failed Sidekiq job #{job_info(job)} due to #{error.class.name} in #{(elapsed_time * 1000).round(1)}ms"
+    end
+
+    # Helper method to get the method called on the job worker and format the arguments.
+    #
+    # @param job [Hash] The job data.
+    # @return [String] The formatted job information.
+    # @note If `skip_logging_job_arguments?` is true, it will only return the worker class name.
+    def job_info(job)
+      return worker_class(job) if skip_logging_job_arguments?
+
+      display_args = job_display_args(job)
+      "#{worker_class(job)}.perform(#{display_args.join(", ")})"
+    end
+
+    # Helper method to get the job arguments for logging. The return value is an array
+    # of strings representing the inspect of each argument (i.e. `["foo", 12]` will be
+    # returned as `['"foo"'', '12']`).
+    #
+    # Arguments can be filtered by the `logging.args` option in the worker sidekiq options.
+    #
+    # @param job [Hash] The job data.
+    # @return [Array<String>] The formatted job arguments.
+    def job_display_args(job)
+      logger_options = job["logging"] || {}
+      args_filter = logger_options["args"]
+      args = job["args"]
+      return [] if args.nil?
+      return args.collect(&:inspect) if args_filter == true || args_filter.nil?
+
+      if args_filter == false
+        ["..."]
+      else
+        args_filter = Array(args_filter)
+        filtered_args(job, args, args_filter)
+      end
+    end
+
+    # Returns true of job arguments should never be logged.
+    #
+    # @return [Boolean] True if job arguments should not be logged.
+    def skip_logging_job_arguments?
+      @config[:skip_logging_job_arguments] || false
+    end
+
+    # 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)
+      job["display_class"] || job["wrapped"] || job["class"]
+    end
+
+    private
+
+    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)
+      return ["..."] unless klass.is_a?(Class)
+      return ["..."] unless klass.instance_methods.include?(:perform)
+
+      perform_args = klass.instance_method(:perform).parameters
+      args.each_with_index.map do |arg, index|
+        arg_name = perform_args[index][1] if perform_args[index]
+        if args_filter.include?(arg_name.to_s)
+          arg.inspect
+        else
+          "-"
+        end
+      end
+    end
+  end
+end

data/lib/lumberjack/sidekiq/tag_passthrough_middleware.rb

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

data/lib/lumberjack/sidekiq.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "lumberjack"
+require "sidekiq"
+
+module Lumberjack::Sidekiq
+end
+
+require_relative "sidekiq/job_logger"
+require_relative "sidekiq/message_formatter"
+require_relative "sidekiq/tag_passthrough_middleware"

data/lib/lumberjack_sidekiq.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "lumberjack/sidekiq"

data/lumberjack_sidekiq.gemspec

@@ -0,0 +1,33 @@
+Gem::Specification.new do |spec|
+  spec.name = "lumberjack_sidekiq"
+  spec.version = File.read(File.join(__dir__, "VERSION")).strip
+  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.homepage = "https://github.com/bdurand/lumberjack_sidekiq"
+  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[
+    .gitignore
+    .travis.yml
+    Appraisals
+    Gemfile
+    Gemfile.lock
+    Rakefile
+    gemfiles/
+    spec/
+  ]
+  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.required_ruby_version = ">= 2.7"
+
+  spec.add_dependency "lumberjack", ">=1.3"
+  spec.add_dependency "sidekiq", ">=7.0"
+end

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification
+name: lumberjack_sidekiq
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Brian Durand
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-07-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: lumberjack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: sidekiq
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+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.txt
+- README.md
+- VERSION
+- lib/lumberjack/sidekiq.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
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.7'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.10
+signing_key:
+specification_version: 4
+summary: Structured logging for Sidekiq jobs using the Lumberjack framework with automatic
+  tagging, timing, and context propagation.
+test_files: []