sidekiq-memory_logger 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d0d86186cadbe56a86c0d9f503f95bffe809038454a011ebe2878a7caf9190cc
+  data.tar.gz: 74d82b63659d8562d314bd0c62eb75d54a1e58933ad37894b6335882d7a2713c
+SHA512:
+  metadata.gz: 03b7ae7daf959020bf30ea8dfafb7d77b4f2cf34ea32099c3954f8a811defec17ba2ab6db8f7cdc39615bf6b88ef5598d136677ab9c6d52e27e64af34975c7ca
+  data.tar.gz: 7daa948bfdf7310df265b7174aad891ba0cdc7af27c5f9015602ded35971cd0df3c127ad5c5c34d120ab94ca633cc191b4c2396a227b61c08cf7703616ffe3d9

data/.custom_rubocop.yml

@@ -0,0 +1,9 @@
+require:
+  - ./lib/rubocop/cop/sidekiq_memory_logger
+
+SidekiqMemoryLogger/NoConfigureInTests:
+  Enabled: true
+  Include:
+    - 'test/**/*.rb'
+  Exclude:
+    - test/sidekiq/memory_logger/configure_method_test.rb

data/.github/workflows/benchmark.yml

@@ -0,0 +1,154 @@
+name: Benchmark
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+  workflow_dispatch:
+
+jobs:
+  benchmark:
+    runs-on: ubuntu-latest
+
+    services:
+      redis:
+        image: redis:7.0
+        ports:
+          - 6379:6379
+        options: >-
+          --health-cmd "redis-cli ping"
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+
+    strategy:
+      matrix:
+        ruby-version: ['3.4']
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Set up Ruby ${{ matrix.ruby-version }}
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby-version }}
+        bundler-cache: true
+
+    - name: Cache Redis CLI
+      uses: actions/cache@v4
+      id: cache-redis-tools
+      with:
+        path: /usr/bin/redis-cli
+        key: redis-tools-${{ runner.os }}
+
+    - name: Install Redis CLI
+      if: steps.cache-redis-tools.outputs.cache-hit != 'true'
+      run: sudo apt-get update && sudo apt-get install -y redis-tools
+
+    - name: Wait for Redis
+      run: |
+        until redis-cli ping; do
+          echo "Waiting for Redis..."
+          sleep 1
+        done
+
+    - name: Run benchmark without memory logger
+      id: benchmark_without
+      run: |
+        echo "Running benchmark WITHOUT memory logger..."
+        output=$(ITER=50 timeout 120 bundle exec bin/sidekiqload 2>&1 || true)
+        echo "$output"
+        
+        # Extract performance metrics
+        jobs_per_sec=$(echo "$output" | grep -oE '[0-9]+ jobs/sec' | grep -oE '[0-9]+' | head -1 || echo "0")
+        ending_rss=$(echo "$output" | grep 'Ending RSS:' | grep -oE '[0-9]+' | head -1 || echo "0")
+        
+        echo "without_jobs_per_sec=$jobs_per_sec" >> $GITHUB_OUTPUT
+        echo "without_ending_rss=$ending_rss" >> $GITHUB_OUTPUT
+        
+        # Save full output for comparison
+        echo "WITHOUT_OUTPUT<<EOF" >> $GITHUB_ENV
+        echo "$output" >> $GITHUB_ENV
+        echo "EOF" >> $GITHUB_ENV
+
+    - name: Run benchmark with memory logger
+      id: benchmark_with
+      run: |
+        echo "Running benchmark WITH memory logger..."
+        output=$(MEMORY_LOGGER=1 ITER=50 timeout 120 bundle exec bin/sidekiqload 2>&1 || true)
+        echo "$output"
+        
+        # Extract performance metrics
+        jobs_per_sec=$(echo "$output" | grep -oE '[0-9]+ jobs/sec' | grep -oE '[0-9]+' | head -1 || echo "0")
+        ending_rss=$(echo "$output" | grep 'Ending RSS:' | grep -oE '[0-9]+' | head -1 || echo "0")
+        
+        echo "with_jobs_per_sec=$jobs_per_sec" >> $GITHUB_OUTPUT
+        echo "with_ending_rss=$ending_rss" >> $GITHUB_OUTPUT
+        
+        # Save full output for comparison
+        echo "WITH_OUTPUT<<EOF" >> $GITHUB_ENV
+        echo "$output" >> $GITHUB_ENV
+        echo "EOF" >> $GITHUB_ENV
+
+    - name: Compare results
+      run: |
+        echo "## Benchmark Results Comparison" >> $GITHUB_STEP_SUMMARY
+        echo "" >> $GITHUB_STEP_SUMMARY
+        
+        echo "### Without Memory Logger" >> $GITHUB_STEP_SUMMARY
+        echo '```' >> $GITHUB_STEP_SUMMARY
+        echo "$WITHOUT_OUTPUT" >> $GITHUB_STEP_SUMMARY
+        echo '```' >> $GITHUB_STEP_SUMMARY
+        echo "" >> $GITHUB_STEP_SUMMARY
+        
+        echo "### With Memory Logger" >> $GITHUB_STEP_SUMMARY
+        echo '```' >> $GITHUB_STEP_SUMMARY
+        echo "$WITH_OUTPUT" >> $GITHUB_STEP_SUMMARY
+        echo '```' >> $GITHUB_STEP_SUMMARY
+        echo "" >> $GITHUB_STEP_SUMMARY
+        
+        # Performance comparison
+        without_jps=${{ steps.benchmark_without.outputs.without_jobs_per_sec }}
+        with_jps=${{ steps.benchmark_with.outputs.with_jobs_per_sec }}
+        
+        echo "### Performance Metrics" >> $GITHUB_STEP_SUMMARY
+        echo "| Metric | Without Logger | With Logger | Difference |" >> $GITHUB_STEP_SUMMARY
+        echo "|--------|----------------|-------------|------------|" >> $GITHUB_STEP_SUMMARY
+        echo "| Jobs/sec | $without_jps | $with_jps | $(($with_jps - $without_jps)) |" >> $GITHUB_STEP_SUMMARY
+        
+        # Calculate milliseconds per job
+        if [ "$without_jps" -gt 0 ] && [ "$with_jps" -gt 0 ]; then
+          without_ms_per_job=$(echo "scale=3; 1000.0 / $without_jps" | bc -l)
+          with_ms_per_job=$(echo "scale=3; 1000.0 / $with_jps" | bc -l)
+          ms_per_job_diff=$(echo "scale=3; $with_ms_per_job - $without_ms_per_job" | bc -l)
+          echo "| Milliseconds per job | $without_ms_per_job | $with_ms_per_job | $ms_per_job_diff |" >> $GITHUB_STEP_SUMMARY
+        fi
+
+    - name: Output results to console
+      run: |
+        echo "=== BENCHMARK RESULTS ==="
+        echo "Without Memory Logger:"
+        echo "  Jobs/sec: ${{ steps.benchmark_without.outputs.without_jobs_per_sec }}"
+        echo "  Ending RSS: ${{ steps.benchmark_without.outputs.without_ending_rss }} KB"
+        echo ""
+        echo "With Memory Logger:"
+        echo "  Jobs/sec: ${{ steps.benchmark_with.outputs.with_jobs_per_sec }}"
+        echo "  Ending RSS: ${{ steps.benchmark_with.outputs.with_ending_rss }} KB"
+        echo ""
+        echo "Differences:"
+        echo "  Jobs/sec difference: $((${{ steps.benchmark_with.outputs.with_jobs_per_sec }} - ${{ steps.benchmark_without.outputs.without_jobs_per_sec }}))"
+        echo "  RSS difference: $((${{ steps.benchmark_with.outputs.with_ending_rss }} - ${{ steps.benchmark_without.outputs.without_ending_rss }})) KB"
+        echo ""
+        
+        # Calculate absolute latency added per job
+        without_jps=${{ steps.benchmark_without.outputs.without_jobs_per_sec }}
+        with_jps=${{ steps.benchmark_with.outputs.with_jobs_per_sec }}
+        
+        if [ "$without_jps" -gt 0 ] && [ "$with_jps" -gt 0 ]; then
+          # Convert jobs/sec to milliseconds per job, then calculate difference
+          without_ms_per_job=$(echo "scale=6; 1000.0 / $without_jps" | bc -l)
+          with_ms_per_job=$(echo "scale=6; 1000.0 / $with_jps" | bc -l)
+          latency_added=$(echo "scale=3; $with_ms_per_job - $without_ms_per_job" | bc -l)
+          echo "Memory logger adds $latency_added milliseconds per job"
+        fi

data/.github/workflows/test.yml

@@ -0,0 +1,26 @@
+name: Test
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        ruby-version: ['2.7', '3.0', '3.1', '3.2', '3.3', '3.4']
+
+    steps:
+    - uses: actions/checkout@v4
+    
+    - name: Set up Ruby ${{ matrix.ruby-version }}
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby-version }}
+        bundler-cache: true
+    
+    - name: Run tests
+      run: bundle exec rake

data/.standard.yml

@@ -0,0 +1,5 @@
+ignore:
+  - 'bin/**/*'
+extend_config:
+  - .custom_rubocop.yml
+ruby_version: 2.7

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Nate Berkopec
+
+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,125 @@
+# Sidekiq Memory Logger
+
+Have you ever seen massive memory increases in your Sidekiq workers? Well, this gem helps you figure out which job is causing it.
+
+![memory](https://github.com/user-attachments/assets/6084306f-1f3e-4fdb-9c4a-fccc63a2942f)
+
+## How it works
+
+Memory measurement is handled by the [get_process_mem](https://github.com/zombocom/get_process_mem) gem, which works across all platforms (Windows, macOS, Linux) and both inside and outside of containers. Object allocation tracking uses Ruby's built-in `GC.stat[:total_allocated_objects]`.
+
+By default, this gem just logs at `info` level for every job:
+```
+[MemoryLogger] job=MyJob queue=default memory_mb=15.2 objects=12345
+```
+
+You can also parse this log and create a metric (e.g. with Sumo or Datadog) or change the callback we use (see Configuration below) to create metrics.
+
+> [!WARNING]
+> Each job runs on its own thread, but all threads share the same process heap. Since memory measurement is performed at the process level, concurrent job execution can lead to inaccurate memory attribution, since the measured memory usage will include memory increases from other jobs running simultaneously. For example, two jobs running at the same time will report the same memory increase, although only one of those jobs may have allocated any memory at all.
+>
+> **Workaround:** To work around this limitation, collect a large enough sample size and use 95th percentile or maximum metrics along with detailed logging to identify which job classes _consistently_ reproduce memory issues. This statistical approach will help you identify problematic jobs despite the measurement noise from concurrent execution.
+
+## Installation
+
+```ruby
+gem 'sidekiq-memory_logger'
+```
+
+## Usage
+
+### Basic Setup
+
+You must add the middleware to your Sidekiq server configuration:
+
+```ruby
+# config/initializers/sidekiq.rb or similar
+Sidekiq.configure_server do |config|
+  config.server_middleware do |chain|
+    chain.add Sidekiq::MemoryLogger::Middleware
+  end
+end
+```
+
+You're now ready to go.
+
+### Configuration
+
+It will just work out of the box, but you can change some of your behavior if you like.
+
+```ruby
+# config/initializers/sidekiq_memory_logger.rb or similar
+Sidekiq::MemoryLogger.configure do |config|
+  # Change the logger (default uses Rails.logger if available, otherwise stdout)
+  config.logger = MyCustomLogger.new
+
+  # Specify which queues to monitor (empty array monitors all queues)
+  config.queues = ["critical", "mailers"]  # Only monitor these queues
+  # config.queues = []  # Monitor all queues (default)
+
+  # Replace the default logging callback with custom behavior
+  # The callback now receives job arguments as the 5th parameter
+  config.callback = ->(job_class, queue, memory_diff_mb, objects_diff, args) do
+    # Example: Extract company_id from job arguments
+    # Assuming your job is called like: ProcessCompanyDataJob.perform_async(company_id, other_params)
+    company_id = args&.first
+
+    # StatsD example with company_id
+    StatsD.histogram('sidekiq.memory_usage', memory_diff_mb, tags: {
+      job_class: job_class,
+      queue: queue,
+      company_id: company_id
+    })
+
+    # Log with company context
+    Rails.logger.info "Job #{job_class} for company #{company_id} on queue #{queue} used #{memory_diff_mb} MB"
+
+    # Dogstatsd example
+    # $dogstatsd.histogram('sidekiq.memory_usage', memory_diff_mb, tags: [
+    #   "job_class:#{job_class}",
+    #   "queue:#{queue}",
+    #   "company_id:#{company_id}"
+    # ])
+
+    # New Relic example
+    # NewRelic::Agent.record_metric("Custom/Sidekiq/MemoryUsage/#{queue}/#{job_class}", memory_diff_mb)
+    # NewRelic::Agent.add_custom_attributes({
+    #   'sidekiq.job_class' => job_class,
+    #   'sidekiq.queue' => queue,
+    #   'sidekiq.company_id' => company_id
+    # })
+
+    # Datadog tracing example - add attributes to current span
+    # span = Datadog::Tracing.active_span
+    # if span
+    #   span.set_tag('sidekiq.memory_usage_mb', memory_diff_mb)
+    #   span.set_tag('sidekiq.job_class', job_class)
+    #   span.set_tag('sidekiq.queue', queue)
+    #   span.set_tag('sidekiq.company_id', company_id)
+    # end
+  end
+
+  # The default callback logs memory usage like this:
+  # config.callback = ->(job_class, queue, memory_diff_mb, objects_diff, args) do
+  #   config.logger.info("[MemoryLogger] job=#{job_class} queue=#{queue} memory_mb=#{memory_diff_mb}")
+  # end
+
+  # If you want custom metrics AND logging, include both in your callback:
+  config.callback = ->(job_class, queue, memory_diff_mb, objects_diff, args) do
+    # Your custom metrics collection
+    StatsD.histogram('sidekiq.memory_usage', memory_diff_mb, tags: {
+      job_class: job_class,
+      queue: queue
+    })
+
+    # Include logging if you still want it
+    Rails.logger.info "Job #{job_class} on queue #{queue} used #{memory_diff_mb} MB"
+  end
+end
+```
+
+## Performance Overhead
+
+The memory logger middleware introduces some performance overhead due to memory measurement and callback execution. We continuously benchmark this overhead using the official `sidekiqload` tool.
+
+According to our benchmarks running in Github Actions ([view workflow](https://github.com/speedshop/sidekiq-memory_logger/actions/workflows/benchmark.yml)), the middleware **adds ~0.16ms of latency per job**. The memory footprint increase is negligible. Consider this overhead when deciding whether to enable the middleware in high-throughput production environments. Use the `queues` config setting to limit this middleware to only the queues you're trying to debug.

data/Rakefile

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+require "standard/rake"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task default: %i[standard test]

data/lib/rubocop/cop/sidekiq_memory_logger/no_configure_in_tests.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module SidekiqMemoryLogger
+      class NoConfigureInTests < Base
+        MSG = "Do not use Sidekiq::MemoryLogger.configure in test files. Use Configuration objects instead."
+
+        def on_send(node)
+          if sidekiq_memory_logger_configure?(node)
+            add_offense(node)
+          end
+        end
+
+        private
+
+        def sidekiq_memory_logger_configure?(node)
+          node.send_type? &&
+            node.receiver&.const_type? &&
+            node.receiver.const_name == "Sidekiq::MemoryLogger" &&
+            node.method_name == :configure
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/sidekiq_memory_logger.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "sidekiq_memory_logger/no_configure_in_tests"

data/lib/sidekiq/memory_logger/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Sidekiq
+  module MemoryLogger
+    VERSION = "0.1.1"
+  end
+end

data/lib/sidekiq/memory_logger.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require "get_process_mem"
+require "sidekiq"
+require_relative "memory_logger/version"
+
+module Sidekiq
+  module MemoryLogger
+    class Error < StandardError; end
+
+    class Configuration
+      attr_accessor :logger, :callback, :queues
+
+      def initialize
+        @logger = default_logger
+        @callback = default_callback
+        @queues = []
+      end
+
+      private
+
+      def default_logger
+        rails_logger = defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger
+        rails_logger || fallback_logger
+      end
+
+      def fallback_logger
+        require "logger"
+        ::Logger.new($stdout)
+      end
+
+      def default_callback
+        ->(job_class, queue, memory_diff_mb, objects_diff, args) do
+          @logger.info("[MemoryLogger] job=#{job_class} queue=#{queue} memory_mb=#{memory_diff_mb} objects=#{objects_diff}")
+        end
+      end
+    end
+
+    class << self
+      def configuration
+        @configuration ||= Configuration.new
+      end
+
+      def configure
+        yield configuration
+      end
+    end
+
+    class Middleware
+      include Sidekiq::ServerMiddleware
+
+      def initialize(config = nil)
+        @memory_logger_config = config || MemoryLogger.configuration
+      end
+
+      def call(worker_instance, job, queue)
+        return yield if should_skip_queue?(queue)
+
+        start_mem = GetProcessMem.new.mb
+        start_objects = GC.stat[:total_allocated_objects]
+
+        begin
+          yield
+        ensure
+          end_mem = GetProcessMem.new.mb
+          end_objects = GC.stat[:total_allocated_objects]
+          memory_diff = end_mem - start_mem
+          objects_diff = end_objects - start_objects
+
+          begin
+            @memory_logger_config.callback.call(job["class"], queue, memory_diff, objects_diff, job["args"])
+          rescue => e
+            @memory_logger_config.logger.error("Sidekiq memory logger callback failed: #{e.message}")
+          end
+        end
+      end
+
+      private
+
+      def should_skip_queue?(queue)
+        return false if @memory_logger_config.queues.empty?
+        !@memory_logger_config.queues.include?(queue)
+      end
+    end
+  end
+end

data/lib/sidekiq-memory_logger.rb

@@ -0,0 +1 @@
+require "sidekiq/memory_logger"

data/test/sidekiq/memory_logger/configuration_test.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class TestSidekiqMemoryLoggerConfiguration < Minitest::Test
+  def setup
+    @config = Sidekiq::MemoryLogger::Configuration.new
+  end
+
+  def test_default_values
+    refute_nil @config.logger
+    assert_kind_of Logger, @config.logger
+    refute_nil @config.callback
+    assert_kind_of Proc, @config.callback
+  end
+
+  def test_setting_logger
+    logger = "test_logger"
+    @config.logger = logger
+    assert_equal logger, @config.logger
+  end
+
+  def test_setting_callback
+    callback = ->(job, queue, memory) { "test" }
+    @config.callback = callback
+    assert_equal callback, @config.callback
+  end
+end

data/test/sidekiq/memory_logger/configure_method_test.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class TestSidekiqMemoryLoggerConfigureMethod < Minitest::Test
+  def teardown
+    Sidekiq::MemoryLogger.instance_variable_set(:@configuration, nil)
+  end
+
+  def test_configuration
+    Sidekiq::MemoryLogger.configure do |config|
+      config.logger = "test_logger"
+      config.callback = "test_callback"
+    end
+
+    assert_equal "test_logger", Sidekiq::MemoryLogger.configuration.logger
+    assert_equal "test_callback", Sidekiq::MemoryLogger.configuration.callback
+  end
+
+  def test_configuration_object
+    config = Sidekiq::MemoryLogger.configuration
+    assert_instance_of Sidekiq::MemoryLogger::Configuration, config
+  end
+
+  def test_configuration_is_singleton
+    config1 = Sidekiq::MemoryLogger.configuration
+    config2 = Sidekiq::MemoryLogger.configuration
+    assert_same config1, config2
+  end
+
+  def test_direct_configuration_access
+    Sidekiq::MemoryLogger.configuration.logger = "direct_logger"
+    assert_equal "direct_logger", Sidekiq::MemoryLogger.configuration.logger
+
+    callback = ->(job, queue, memory) { "test" }
+    Sidekiq::MemoryLogger.configuration.callback = callback
+    assert_equal callback, Sidekiq::MemoryLogger.configuration.callback
+  end
+end

data/test/sidekiq/memory_logger/memory_logger_test.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class TestSidekiqMemoryLogger < Minitest::Test
+  def test_that_it_has_a_version_number
+    refute_nil ::Sidekiq::MemoryLogger::VERSION
+  end
+end

data/test/sidekiq/memory_logger/middleware_test.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class TestSidekiqMemoryLoggerMiddleware < Minitest::Test
+  def setup
+    @job = {"class" => "TestJob", "args" => [123, "test_arg"]}
+    @queue = "test_queue"
+  end
+
+  def test_middleware_calls_callback_when_configured
+    callback_calls = []
+    config = Sidekiq::MemoryLogger::Configuration.new
+    config.callback = ->(job_class, queue, memory_diff, objects_diff, args) do
+      callback_calls << [job_class, queue, memory_diff, objects_diff, args]
+    end
+
+    middleware = Sidekiq::MemoryLogger::Middleware.new(config)
+    middleware.call(nil, @job, @queue) { sleep 0.01 }
+
+    assert_equal 1, callback_calls.length
+    job_class, queue, memory_diff, _objects_diff, args = callback_calls.first
+    assert_equal "TestJob", job_class
+    assert_equal "test_queue", queue
+    assert_kind_of Float, memory_diff
+    assert_equal [123, "test_arg"], args
+  end
+
+  def test_middleware_logs_with_default_callback
+    log_output = StringIO.new
+    test_logger = Logger.new(log_output)
+    config = Sidekiq::MemoryLogger::Configuration.new
+    config.logger = test_logger
+    # Reset to default callback (which logs)
+    config.callback = config.send(:default_callback)
+
+    middleware = Sidekiq::MemoryLogger::Middleware.new(config)
+    middleware.call(nil, @job, @queue) { sleep 0.01 }
+
+    log_content = log_output.string
+    assert_includes log_content, "[MemoryLogger] job=TestJob queue=test_queue memory_mb="
+    assert_includes log_content, "objects="
+  end
+
+  def test_middleware_handles_exceptions
+    callback_calls = []
+    config = Sidekiq::MemoryLogger::Configuration.new
+    config.callback = ->(job_class, queue, memory_diff, objects_diff, args) do
+      callback_calls << [job_class, queue, memory_diff, objects_diff, args]
+    end
+
+    middleware = Sidekiq::MemoryLogger::Middleware.new(config)
+
+    assert_raises(RuntimeError) do
+      middleware.call(nil, @job, @queue) { raise "test error" }
+    end
+
+    assert_equal 1, callback_calls.length
+  end
+
+  def test_middleware_handles_callback_exceptions
+    log_output = StringIO.new
+    test_logger = Logger.new(log_output)
+    config = Sidekiq::MemoryLogger::Configuration.new
+    config.logger = test_logger
+    config.callback = ->(job_class, queue, memory_diff, objects_diff, args) do
+      raise StandardError, "callback error"
+    end
+
+    middleware = Sidekiq::MemoryLogger::Middleware.new(config)
+
+    # Middleware should not raise, but should log the error
+    middleware.call(nil, @job, @queue) { sleep 0.01 }
+
+    log_content = log_output.string
+    assert_includes log_content, "Sidekiq memory logger callback failed: callback error"
+  end
+
+  def test_middleware_passes_job_arguments_to_callback
+    callback_args = nil
+    job_with_company_id = {
+      "class" => "ProcessCompanyDataJob",
+      "args" => [42, "Acme Corp", {"priority" => "high"}]
+    }
+
+    config = Sidekiq::MemoryLogger::Configuration.new
+    config.callback = ->(job_class, queue, memory_diff, objects_diff, args) do
+      callback_args = args
+    end
+
+    # Create middleware with custom configuration
+    middleware = Sidekiq::MemoryLogger::Middleware.new(config)
+    middleware.call(nil, job_with_company_id, @queue) { sleep 0.01 }
+
+    assert_equal [42, "Acme Corp", {"priority" => "high"}], callback_args
+  end
+
+  def test_middleware_works_with_empty_job_args
+    callback_args = nil
+    job_without_args = {
+      "class" => "CleanupJob",
+      "args" => []
+    }
+
+    config = Sidekiq::MemoryLogger::Configuration.new
+    config.callback = ->(job_class, queue, memory_diff, objects_diff, args) do
+      callback_args = args
+    end
+
+    # Create middleware with custom configuration
+    middleware = Sidekiq::MemoryLogger::Middleware.new(config)
+    middleware.call(nil, job_without_args, @queue) { sleep 0.01 }
+
+    assert_equal [], callback_args
+  end
+
+  def test_middleware_works_with_nil_job_args
+    callback_args = :not_set
+    job_with_nil_args = {
+      "class" => "SpecialJob"
+      # Note: no "args" key at all
+    }
+
+    config = Sidekiq::MemoryLogger::Configuration.new
+    config.callback = ->(job_class, queue, memory_diff, objects_diff, args) do
+      callback_args = args
+    end
+
+    # Create middleware with custom configuration
+    middleware = Sidekiq::MemoryLogger::Middleware.new(config)
+    middleware.call(nil, job_with_nil_args, @queue) { sleep 0.01 }
+
+    assert_nil callback_args
+  end
+
+  def test_middleware_skips_queues_not_in_config
+    callback_calls = []
+    config = Sidekiq::MemoryLogger::Configuration.new
+    config.queues = ["important", "critical"]
+    config.callback = ->(job_class, queue, memory_diff, objects_diff, args) do
+      callback_calls << [job_class, queue, memory_diff, objects_diff, args]
+    end
+
+    middleware = Sidekiq::MemoryLogger::Middleware.new(config)
+    middleware.call(nil, @job, "unimportant_queue") { sleep 0.01 }
+
+    assert_equal 0, callback_calls.length
+  end
+
+  def test_middleware_processes_queues_in_config
+    callback_calls = []
+    config = Sidekiq::MemoryLogger::Configuration.new
+    config.queues = ["test_queue", "critical"]
+    config.callback = ->(job_class, queue, memory_diff, objects_diff, args) do
+      callback_calls << [job_class, queue, memory_diff, objects_diff, args]
+    end
+
+    middleware = Sidekiq::MemoryLogger::Middleware.new(config)
+    middleware.call(nil, @job, "test_queue") { sleep 0.01 }
+
+    assert_equal 1, callback_calls.length
+    job_class, queue, _memory_diff, _objects_diff, _args = callback_calls.first
+    assert_equal "TestJob", job_class
+    assert_equal "test_queue", queue
+  end
+
+  def test_middleware_processes_all_queues_when_empty_config
+    callback_calls = []
+    config = Sidekiq::MemoryLogger::Configuration.new
+    config.queues = []
+    config.callback = ->(job_class, queue, memory_diff, objects_diff, args) do
+      callback_calls << [job_class, queue, memory_diff, objects_diff, args]
+    end
+
+    middleware = Sidekiq::MemoryLogger::Middleware.new(config)
+    middleware.call(nil, @job, "any_queue") { sleep 0.01 }
+
+    assert_equal 1, callback_calls.length
+    job_class, queue, _memory_diff, _objects_diff, _args = callback_calls.first
+    assert_equal "TestJob", job_class
+    assert_equal "any_queue", queue
+  end
+end

data/test/sidekiq/memory_logger/rails_test.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "rails"
+
+class TestSidekiqMemoryLoggerRails < Minitest::Test
+  def test_rails_is_available_and_responds_to_logger
+    # Verify Rails constant exists and has logger method
+    assert defined?(Rails), "Rails should be defined"
+    assert Rails.respond_to?(:logger), "Rails should respond to logger"
+  end
+
+  def test_configuration_uses_rails_logger_when_rails_logger_available
+    # Create a mock Rails with a logger
+    original_logger_method = Rails.method(:logger) if Rails.respond_to?(:logger)
+    test_logger = Logger.new(StringIO.new)
+
+    Rails.define_singleton_method(:logger) { test_logger }
+
+    # Create new configuration
+    config = Sidekiq::MemoryLogger::Configuration.new
+
+    # Should use our test Rails.logger
+    assert_equal test_logger, config.logger
+  ensure
+    # Restore original logger method
+    if original_logger_method
+      Rails.define_singleton_method(:logger, &original_logger_method)
+    end
+  end
+
+  def test_configuration_falls_back_when_rails_logger_nil
+    # Ensure Rails.logger returns nil (default state)
+    Rails.define_singleton_method(:logger) { nil }
+
+    # Create new configuration
+    config = Sidekiq::MemoryLogger::Configuration.new
+
+    # Should fall back to stdout logger since Rails.logger is nil
+    assert_instance_of Logger, config.logger
+    assert_equal $stdout, config.logger.instance_variable_get(:@logdev).dev
+  end
+
+  def test_configuration_falls_back_when_rails_not_available
+    # Temporarily hide Rails constant
+    rails_backup = Object.send(:remove_const, :Rails) if defined?(Rails)
+
+    # Create new configuration instance
+    config = Sidekiq::MemoryLogger::Configuration.new
+
+    # Should fall back to stdout logger
+    assert_instance_of Logger, config.logger
+    assert_equal $stdout, config.logger.instance_variable_get(:@logdev).dev
+  ensure
+    # Restore Rails constant
+    Object.const_set(:Rails, rails_backup) if rails_backup
+  end
+
+  def test_configuration_falls_back_when_rails_logger_unavailable
+    # Create mock Rails without logger method
+    rails_backup = Object.send(:remove_const, :Rails) if defined?(Rails)
+    rails_mock = Class.new
+    Object.const_set(:Rails, rails_mock)
+
+    # Create new configuration instance
+    config = Sidekiq::MemoryLogger::Configuration.new
+
+    # Should fall back to stdout logger since Rails doesn't respond to logger
+    assert_instance_of Logger, config.logger
+    assert_equal $stdout, config.logger.instance_variable_get(:@logdev).dev
+  ensure
+    # Restore Rails constant
+    Object.send(:remove_const, :Rails)
+    Object.const_set(:Rails, rails_backup) if rails_backup
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+require "sidekiq/memory_logger"
+
+require "minitest/autorun"

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification
+name: sidekiq-memory_logger
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Nate Berkopec
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: get_process_mem
+  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: sidekiq
+  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'
+description: A Sidekiq server middleware that tracks RSS memory usage for each job
+  and provides configurable logging and reporting options
+email:
+- nate.berkopec@speedshop.co
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".custom_rubocop.yml"
+- ".github/workflows/benchmark.yml"
+- ".github/workflows/test.yml"
+- ".standard.yml"
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/rubocop/cop/sidekiq_memory_logger.rb
+- lib/rubocop/cop/sidekiq_memory_logger/no_configure_in_tests.rb
+- lib/sidekiq-memory_logger.rb
+- lib/sidekiq/memory_logger.rb
+- lib/sidekiq/memory_logger/version.rb
+- test/sidekiq/memory_logger/configuration_test.rb
+- test/sidekiq/memory_logger/configure_method_test.rb
+- test/sidekiq/memory_logger/memory_logger_test.rb
+- test/sidekiq/memory_logger/middleware_test.rb
+- test/sidekiq/memory_logger/rails_test.rb
+- test/test_helper.rb
+homepage: https://github.com/speedshop/sidekiq-memory_logger
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/speedshop/sidekiq-memory_logger
+  source_code_uri: https://github.com/speedshop/sidekiq-memory_logger
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Sidekiq server middleware for logging memory usage per job
+test_files: []