job_enqueue_logger 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8bd89f4945224bc0c74d429110323c609a26c63f1eef1202c588d58d9a90bb13
+  data.tar.gz: 4bda89a97eb8c1afc974edf24e37b4685ea1b354a184e782bd10e80fd383c8b3
+SHA512:
+  metadata.gz: fe5c00d27ef14b4c7da8458cd3500b8dda2af19bdb56f1829588abe3f0a6634f284e8e46b5ca92cdbb2f16a4ed89e1a3be3f9cb578dbd942066b8da809cf11d0
+  data.tar.gz: cc5b8a0463f46332cb03bb5cadd3aeb4b2de8aa6b3f5cd4fbca7c9fe730e5d18f82e95a656683dc5d83daa7eb2ca664c32c63386ff99bded51f40cff1ad5e9fb

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## master (unreleased)
+
+## 0.1.0 (2023-03-29)
+
+- First release

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2023 fatkodima
+
+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,87 @@
+# JobEnqueueLogger
+
+[![Build Status](https://github.com/fatkodima/job_enqueue_logger/actions/workflows/ci.yml/badge.svg?branch=master)](https://github.com/fatkodima/job_enqueue_logger/actions/workflows/ci.yml)
+
+Log background jobs enqueued by your application (additionally with backtraces). Helps with debugging, or just generally understanding what's going on under the hood. Useful for finding where to start when making changes to a large application.
+
+This is very much a development and debugging tool; it is not recommended to use this in a production environment as it is monkey-patching the respective job queuing implementations. You have been warned - use at your own risk.
+
+## Example
+
+When the job is enqueued within the guts of the application, the log line is generated:
+
+```
+Enqueued AvatarThumbnailsJob (jid=578b3d10fc5403f97ee0a8e1) to Sidekiq(default) with arguments: 1092412064
+```
+
+Or with backtraces enabled:
+
+```
+Enqueued AvatarThumbnailsJob (jid=578b3d10fc5403f97ee0a8e1) to Sidekiq(default) with arguments: 1092412064
+↳ app/models/user.rb:421:in `generate_avatar_thumbnails'
+  app/services/user_creator.rb:21:in `call'
+  app/controllers/users_controller.rb:49:in `create'
+```
+
+## Requirements
+
+Requires ruby > 2.7.
+
+This gem supports most common job queuing backends:
+
+* [Sidekiq](https://github.com/sidekiq/sidekiq) >= 6.5.0
+* [Resque](https://github.com/resque/resque) >= 2.0.0
+* [DelayedJob](https://github.com/collectiveidea/delayed_job) >= 4.1.5
+
+If you need support for older rubies or older versions of queuing backends (or additional backends), [open an issue](https://github.com/fatkodima/job_enqueue_logger/issues/new).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+# Add this *after* your job queuing gem of choice
+gem 'job_enqueue_logger', group: :development
+```
+
+And then execute:
+
+```sh
+$ bundle
+```
+
+Or install it yourself as:
+
+```sh
+$ gem install job_enqueue_logger
+```
+
+## Configuration
+
+You can override the following default options:
+
+```ruby
+JobEnqueueLogger.configure do |config|
+  # Controls the contents of the printed backtrace.
+  # Is set to default Rails.backtrace_cleaner, when the gem is used in the Rails app.
+  config.backtrace_cleaner = ->(backtrace) { backtrace }
+
+  # Controls whether to print backtraces. Set to `true` to print backtraces, or
+  # a number to limit how many lines to print.
+  config.backtrace = false
+end
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/fatkodima/job_enqueue_logger.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/job_enqueue_logger/delayed_job_adapter.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module JobEnqueueLogger
+  module DelayedJobAdapter
+    module Job
+      def enqueue(*args)
+        job = super
+
+        # Job with arguments (instance variables of the job) are serialized
+        # into yaml. There is no easy way to get them, so just skip logging it.
+        if job.persisted?
+          message = "Enqueued #{job.name} (id=#{job.id}) to DelayedJob(#{job.queue})"
+          message += " at #{job.run_at.utc}" if job.run_at > Delayed::Job.db_time_now
+        else
+          message = "Performed inline #{job.name}"
+        end
+        Utils.log_job_enqueue(DelayedJobAdapter.logger, message)
+
+        job
+      end
+    end
+
+    module Worker
+      def start
+        # There is no easy way (compared to Sidekiq) to detect
+        # if we are in server mode.
+        JobEnqueueLogger::DelayedJobAdapter.server = true
+        super
+      end
+    end
+
+    class << self
+      attr_accessor :server
+      alias server? server
+
+      def logger
+        if !server? && defined?(Rails)
+          Rails.logger
+        else
+          Delayed::Worker.logger
+        end
+      end
+    end
+  end
+end
+
+Delayed::Job.singleton_class.prepend(JobEnqueueLogger::DelayedJobAdapter::Job)
+Delayed::Worker.prepend(JobEnqueueLogger::DelayedJobAdapter::Worker)

data/lib/job_enqueue_logger/railtie.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "rails"
+
+module JobEnqueueLogger
+  class Railtie < Rails::Railtie
+    initializer "job_enqueue_logger.backtrace_cleaner" do
+      JobEnqueueLogger.backtrace_cleaner = Rails.backtrace_cleaner
+    end
+  end
+end

data/lib/job_enqueue_logger/resque_adapter.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module JobEnqueueLogger
+  module ResqueAdapter
+    module Enqueuing
+      def enqueue_to(queue, klass, *args)
+        enqueued = super
+        if enqueued
+          message =
+            if Resque.inline?
+              "Performed inline #{klass}" + Utils.args_info(args)
+            else
+              "Enqueued #{klass} to Resque(#{queue})" + Utils.args_info(args)
+            end
+          Utils.log_job_enqueue(ResqueAdapter.logger, message)
+        end
+        enqueued
+      end
+    end
+
+    module DelayedEnqueuing
+      def delayed_push(timestamp, item)
+        super
+        message = "Enqueued #{item[:class]} to Resque(#{item[:queue]}) at #{timestamp.utc}" +
+                  Utils.args_info(item[:args])
+        Utils.log_job_enqueue(ResqueAdapter.logger, message)
+      end
+    end
+
+    module Worker
+      def work(*)
+        # There is no easy way (compared to Sidekiq) to detect
+        # if we are in server mode.
+        JobEnqueueLogger::ResqueAdapter.server = true
+        super
+      end
+    end
+
+    class << self
+      attr_accessor :server
+      alias server? server
+
+      def logger
+        if !server? && defined?(Rails)
+          Rails.logger
+        else
+          Resque.logger
+        end
+      end
+    end
+  end
+end
+
+Resque.singleton_class.prepend(JobEnqueueLogger::ResqueAdapter::Enqueuing)
+Resque::Worker.prepend(JobEnqueueLogger::ResqueAdapter::Worker)
+
+begin
+  require "resque-scheduler"
+  Resque.singleton_class.prepend(JobEnqueueLogger::ResqueAdapter::DelayedEnqueuing)
+rescue LoadError
+  # scheduling gem is not available
+end

data/lib/job_enqueue_logger/sidekiq_adapter.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module JobEnqueueLogger
+  module SidekiqAdapter
+    module Job
+      module Setter
+        def perform_inline(*args)
+          performed = super
+          if performed
+            message = "Performed inline #{@klass}" + Utils.args_info(args)
+            Utils.log_job_enqueue(SidekiqAdapter.logger, message)
+          end
+          performed
+        end
+        alias perform_sync perform_inline
+      end
+    end
+
+    module Client
+      def push(item)
+        jid = super(item)
+        if jid
+          queue = item["queue"] || "default"
+
+          message = "Enqueued #{item['class']} (jid=#{jid}) to Sidekiq(#{queue})"
+          message += " at #{Time.at(item['at']).utc}" if item.key?("at")
+          message += Utils.args_info(item["args"])
+
+          Utils.log_job_enqueue(SidekiqAdapter.logger, message)
+        end
+        jid
+      end
+
+      def push_bulk(items)
+        jids = super(items)
+        real_jids = jids.compact
+        if real_jids.any?
+          queue = items["queue"] || "default"
+          message = "Enqueued"
+          message += " #{real_jids.size}" if real_jids.size > 1
+          message += " #{items['class']} to Sidekiq(#{queue})"
+
+          Utils.log_job_enqueue(SidekiqAdapter.logger, message)
+        end
+        jids
+      end
+    end
+
+    def self.logger
+      if !Sidekiq.server? && defined?(Rails)
+        Rails.logger
+      else
+        Sidekiq.logger
+      end
+    end
+  end
+end
+
+Sidekiq::Job::Setter.prepend(JobEnqueueLogger::SidekiqAdapter::Job::Setter)
+Sidekiq::Client.prepend(JobEnqueueLogger::SidekiqAdapter::Client)

data/lib/job_enqueue_logger/utils.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module JobEnqueueLogger
+  module Utils
+    def self.log_job_enqueue(logger, message)
+      return logger.info(message) unless JobEnqueueLogger.backtrace
+
+      backtrace = caller
+      cleaned_backtrace = JobEnqueueLogger.backtrace_cleaner&.call(backtrace) || backtrace
+      lines =
+        if JobEnqueueLogger.backtrace == true
+          cleaned_backtrace
+        else
+          cleaned_backtrace[0...JobEnqueueLogger.backtrace.to_i]
+        end
+
+      logger.info("#{message}\n↳ #{lines.join("\n  ")}")
+    end
+
+    def self.args_info(args)
+      if Array(args).any?
+        " with arguments: #{Array(args).map(&:inspect).join(', ')}"
+      else
+        ""
+      end
+    end
+  end
+end

data/lib/job_enqueue_logger/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module JobEnqueueLogger
+  VERSION = "0.1.0"
+end

data/lib/job_enqueue_logger.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative "job_enqueue_logger/version"
+require_relative "job_enqueue_logger/utils"
+
+module JobEnqueueLogger
+  class << self
+    attr_reader :backtrace_cleaner
+
+    def backtrace_cleaner=(cleaner)
+      @backtrace_cleaner =
+        if cleaner.respond_to?(:clean)
+          ->(backtrace) { cleaner.clean(backtrace) }
+        else
+          cleaner
+        end
+    end
+
+    attr_accessor :backtrace
+
+    def configure
+      yield self
+    end
+  end
+
+  self.backtrace_cleaner = ->(backtrace) { backtrace }
+  self.backtrace = false
+end
+
+require_relative "job_enqueue_logger/sidekiq_adapter" if defined?(Sidekiq)
+require_relative "job_enqueue_logger/resque_adapter" if defined?(Resque)
+require_relative "job_enqueue_logger/delayed_job_adapter" if defined?(Delayed::Job)
+require_relative "job_enqueue_logger/railtie" if defined?(Rails)

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification
+name: job_enqueue_logger
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- fatkodima
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-03-30 00:00:00.000000000 Z
+dependencies: []
+description: |-
+  Log background jobs enqueued by your application (additionally with backtraces).
+                        Helps with debugging, or just generally understanding what's going on under the hood.
+                        Useful for finding where to start when making changes to a large application.
+email:
+- fatkodima123@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/job_enqueue_logger.rb
+- lib/job_enqueue_logger/delayed_job_adapter.rb
+- lib/job_enqueue_logger/railtie.rb
+- lib/job_enqueue_logger/resque_adapter.rb
+- lib/job_enqueue_logger/sidekiq_adapter.rb
+- lib/job_enqueue_logger/utils.rb
+- lib/job_enqueue_logger/version.rb
+homepage: https://github.com/fatkodima/job_enqueue_logger
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/fatkodima/job_enqueue_logger
+  source_code_uri: https://github.com/fatkodima/job_enqueue_logger
+  changelog_uri: https://github.com/fatkodima/job_enqueue_logger/blob/master/CHANGELOG.md
+post_install_message:
+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.4.7
+signing_key:
+specification_version: 4
+summary: Log background jobs enqueued by your application (additionally with backtraces).
+test_files: []