sentry-sidekiq 5.10.0 → 5.26.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e0032fc4b32f7d021cb268513357d37f6697fcae83a4d976a9b0e011e31931e9
-  data.tar.gz: f32997df5b2f5aab6430d5828f8a678eff2e3440fc3b55b64f1bea5ab7de752f
+  metadata.gz: ecef3da0594e364745ceaf67376f0acfd3d9053533f48354955716c4b0c8ea6c
+  data.tar.gz: 891089c3a64f091596ed2548cf1e90f1251b8923e7bcef71ff4dd183578545df
 SHA512:
-  metadata.gz: 36a7e7af214cfa651ab6a05c34735cb27ada4647a74c2ec3cf4e10af65eee47dd9cfd6bd8551c50971aede6315849f63c7fc44cefa7c8770504421cf24c3333d
-  data.tar.gz: a74c6e2bd56eba75ad59504c87636a4de882f890af3ae97d898d2b8c9db7ff7431cc14d55aff13e4bdf44c6b287af4ff3417afad2eaa42806da585c742097119
+  metadata.gz: a45994cf24f8b52a5a7d68017073661d6bf313e69ffd84bf22eba1527a29fdc0d42a62f6de93930a947357f78770ad518ea6449e7d167c1d5d1ffe697c23095c
+  data.tar.gz: a053fca9ea3c8b24845baf054fb774a558de78de89b1d73efd1f51162c1e3150973900ee5ce493f3d9e4a978ad657948bf805bb4d7035c4f0f7d7b9d90d48b62

data/Gemfile

@@ -1,30 +1,43 @@
+# frozen_string_literal: true
+
 source "https://rubygems.org"
 git_source(:github) { |name| "https://github.com/#{name}.git" }
 
+eval_gemfile "../Gemfile"
+
 # Specify your gem's dependencies in sentry-ruby.gemspec
 gemspec
+
 gem "sentry-ruby", path: "../sentry-ruby"
 gem "sentry-rails", path: "../sentry-rails"
 
-gem "rake", "~> 12.0"
-gem "rspec", "~> 3.0"
-gem 'simplecov'
-gem "simplecov-cobertura", "~> 1.4"
-gem "rexml"
 # https://github.com/flavorjones/loofah/pull/267
 # loofah changed the required ruby version in a patch so we need to explicitly pin it
 gem "loofah", "2.20.0" if RUBY_VERSION.to_f < 2.5
 
-sidekiq_version = ENV["SIDEKIQ_VERSION"]
-sidekiq_version = "6.0" if sidekiq_version.nil?
+if ENV["SIDEKIQ_MAIN"]
+  gem "sidekiq", github: "sidekiq/sidekiq", branch: "main"
+  sidekiq_version = "main"
+else
+  sidekiq_version = ENV["SIDEKIQ_VERSION"]
+  sidekiq_version = "7.0" if sidekiq_version.nil?
+  sidekiq_version = Gem::Version.new(sidekiq_version)
 
-gem "sidekiq", "~> #{sidekiq_version}"
-gem "rails"
+  gem "sidekiq", "~> #{sidekiq_version}"
+end
+
+if sidekiq_version == "main" || RUBY_VERSION.to_f >= 2.7 && sidekiq_version >= Gem::Version.new("6.0")
+  gem "sidekiq-cron"
 
-if RUBY_VERSION.to_f >= 2.6
-  gem "debug", github: "ruby/debug", platform: :ruby
-  gem "irb"
+  if sidekiq_version == "main" || sidekiq_version >= Gem::Version.new("8.0")
+    gem "sidekiq-scheduler", "~> 6.0.0.beta"
+  else
+    gem "sidekiq-scheduler", "~> 5.0.0"
+  end
 end
 
-gem "pry"
+gem "rails", "> 5.0.0"
+
+gem "timecop"
 
+gem "vernier", platforms: :ruby if RUBY_VERSION >= "3.2.1"

data/Makefile

@@ -1,7 +1,3 @@
 build:
 	bundle install
 	gem build sentry-sidekiq.gemspec
-
-test:
-	WITH_SENTRY_RAILS=1 bundle exec rspec spec/sentry/rails_spec.rb
-	bundle exec rspec

data/README.md

@@ -11,7 +11,7 @@
 
 
 [![Gem Version](https://img.shields.io/gem/v/sentry-sidekiq.svg)](https://rubygems.org/gems/sentry-sidekiq)
-![Build Status](https://github.com/getsentry/sentry-ruby/workflows/sentry-sidekiq%20Test/badge.svg)
+![Build Status](https://github.com/getsentry/sentry-ruby/actions/workflows/sentry_sidekiq_test.yml/badge.svg)
 [![Coverage Status](https://img.shields.io/codecov/c/github/getsentry/sentry-ruby/master?logo=codecov)](https://codecov.io/gh/getsentry/sentry-ruby/branch/master)
 [![Gem](https://img.shields.io/gem/dt/sentry-sidekiq.svg)](https://rubygems.org/gems/sentry-sidekiq/)
 [![SemVer](https://api.dependabot.com/badges/compatibility_score?dependency-name=sentry-sidekiq&package-manager=bundler&version-scheme=semver)](https://dependabot.com/compatibility-score.html?dependency-name=sentry-sidekiq&package-manager=bundler&version-scheme=semver)

data/Rakefile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "bundler/gem_tasks"
 require "rspec/core/rake_task"
 
@@ -5,4 +7,4 @@ RSpec::Core::RakeTask.new(:spec).tap do |task|
   task.rspec_opts = "--order rand"
 end
 
-task :default => :spec
+task default: :spec

data/bin/console

@@ -1,4 +1,5 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
 require "bundler/setup"
 require "sentry/ruby"

data/example/Gemfile

@@ -1,8 +1,9 @@
+# frozen_string_literal: true
+
 source "https://rubygems.org"
 
 gem "sidekiq"
 gem "sentry-sidekiq", path: "../"
 gem "sentry-ruby", path: "../../sentry-ruby"
 
-gem "pry"
 gem "debug", github: "ruby/debug"

data/example/error_worker.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "sidekiq"
 require "sentry-sidekiq"
 

data/lib/sentry/sidekiq/configuration.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Sentry
   class Configuration
     attr_reader :sidekiq
@@ -9,15 +11,26 @@ module Sentry
   end
 
   module Sidekiq
-    IGNORE_DEFAULT = ["Sidekiq::JobRetry::Skip"]
+    IGNORE_DEFAULT = [
+      "Sidekiq::JobRetry::Skip",
+      "Sidekiq::JobRetry::Handled"
+    ]
 
     class Configuration
       # Set this option to true if you want Sentry to only capture the last job
       # retry if it fails.
       attr_accessor :report_after_job_retries
 
+      # Only report jobs that don't have `dead: false` set in the job's `sidekiq_options`
+      attr_accessor :report_only_dead_jobs
+
+      # Whether we should inject headers while enqueuing the job in order to have a connected trace
+      attr_accessor :propagate_traces
+
       def initialize
         @report_after_job_retries = false
+        @report_only_dead_jobs = false
+        @propagate_traces = true
       end
     end
   end

data/lib/sentry/sidekiq/context_filter.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 module Sentry
   module Sidekiq
     class ContextFilter
-      ACTIVEJOB_RESERVED_PREFIX_REGEX = /^_aj_/.freeze
-      SIDEKIQ_NAME = "Sidekiq".freeze
+      ACTIVEJOB_RESERVED_PREFIX_REGEX = /^_aj_/
+      SIDEKIQ_NAME = "Sidekiq"
 
       attr_reader :context
 

data/lib/sentry/sidekiq/cron/helpers.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Sentry
+  module Sidekiq
+    module Cron
+      module Helpers
+        # This is used by Cron::Job and Scheduler
+        def self.monitor_config(cron)
+          cron_parts = cron.strip.split(" ")
+
+          if cron_parts.length > 5
+            timezone = cron_parts.pop
+            cron_without_timezone = cron_parts.join(" ")
+
+            Sentry::Cron::MonitorConfig.from_crontab(cron_without_timezone, timezone: timezone)
+          else
+            Sentry::Cron::MonitorConfig.from_crontab(cron)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sentry/sidekiq/cron/job.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+# Try requiring sidekiq-cron to ensure it's loaded before the integration.
+# If sidekiq-cron is not available, do nothing.
+begin
+  require "sidekiq-cron"
+rescue LoadError
+  return
+end
+
+module Sentry
+  module Sidekiq
+    module Cron
+      module Job
+        def self.enqueueing_method
+          ::Sidekiq::Cron::Job.instance_methods.include?(:enque!) ? :enque! : :enqueue!
+        end
+
+        define_method(enqueueing_method) do |*args|
+          # make sure the current thread has a clean hub
+          Sentry.clone_hub_to_current_thread
+
+          Sentry.with_scope do |scope|
+            Sentry.with_session_tracking do
+              begin
+                scope.set_transaction_name("#{name} (#{klass})")
+
+                transaction = start_transaction(scope)
+                scope.set_span(transaction) if transaction
+                super(*args)
+
+                finish_transaction(transaction, 200)
+              rescue
+                finish_transaction(transaction, 500)
+                raise
+              end
+            end
+          end
+        end
+
+        def save
+          # validation failed, do nothing
+          return false unless super
+
+          # fail gracefully if can't find class
+          klass_const =
+            begin
+              if ::Sidekiq::Cron::Support.respond_to?(:safe_constantize)
+                ::Sidekiq::Cron::Support.safe_constantize(klass.to_s)
+              else
+                ::Sidekiq::Cron::Support.constantize(klass.to_s)
+              end
+            rescue NameError
+              return true
+            end
+
+          return true if klass_const.nil? # Sidekiq::Cron returns nil if class is not found
+
+          # only patch if not explicitly included in job by user
+          unless klass_const.send(:ancestors).include?(Sentry::Cron::MonitorCheckIns)
+            klass_const.send(:include, Sentry::Cron::MonitorCheckIns)
+            klass_const.send(:sentry_monitor_check_ins,
+                             slug: name.to_s,
+                             monitor_config: Sentry::Sidekiq::Cron::Helpers.monitor_config(parsed_cron.original))
+          end
+
+          true
+        end
+
+        def start_transaction(scope)
+          Sentry.start_transaction(
+            name: scope.transaction_name,
+            source: scope.transaction_source,
+            op: "queue.sidekiq-cron",
+            origin: "auto.queue.sidekiq.cron"
+          )
+        end
+
+        def finish_transaction(transaction, status_code)
+          return unless transaction
+
+          transaction.set_http_status(status_code)
+          transaction.finish
+        end
+      end
+    end
+  end
+end
+
+Sentry.register_patch(:sidekiq_cron, Sentry::Sidekiq::Cron::Job, ::Sidekiq::Cron::Job)

data/lib/sentry/sidekiq/error_handler.rb

@@ -1,11 +1,19 @@
-require 'sentry/sidekiq/context_filter'
+# frozen_string_literal: true
+
+require "sentry/sidekiq/context_filter"
 
 module Sentry
   module Sidekiq
     class ErrorHandler
       WITH_SIDEKIQ_7 = ::Gem::Version.new(::Sidekiq::VERSION) >= ::Gem::Version.new("7.0")
 
-      def call(ex, context)
+      # @param ex [Exception] the exception / error that occured
+      # @param context [Hash or Array] Sidekiq error context
+      # @param sidekiq_config [Sidekiq::Config, Hash] Sidekiq configuration,
+      #   Defaults to nil.
+      #   Sidekiq will pass the config in starting Sidekiq 7.1.5, see
+      #   https://github.com/sidekiq/sidekiq/pull/6051
+      def call(ex, context, sidekiq_config = nil)
         return unless Sentry.initialized?
 
         context_filter = Sentry::Sidekiq::ContextFilter.new(context)
@@ -13,13 +21,32 @@ module Sentry
         scope = Sentry.get_current_scope
         scope.set_transaction_name(context_filter.transaction_name, source: :task) unless scope.transaction_name
 
+        # If Sentry is configured to only report an error _after_ all retries have been exhausted,
+        # and if the job is retryable, and have not exceeded the retry_limit,
+        # return early.
         if Sentry.configuration.sidekiq.report_after_job_retries && retryable?(context)
           retry_count = context.dig(:job, "retry_count")
-          if retry_count.nil? || retry_count < retry_limit(context) - 1
+          if retry_count.nil? || retry_count < retry_limit(context, sidekiq_config) - 1
             return
           end
         end
 
+        # See if we want to ignore jobs that have dead: false
+        return if Sentry.configuration.sidekiq.report_only_dead_jobs && context.dig(:job, "dead") == false
+
+        # Check if the retry count is below the attempt_threshold
+        attempt_threshold = context.dig(:job, "attempt_threshold")
+        if attempt_threshold && retryable?(context)
+          attempt_threshold = attempt_threshold.to_i
+          retry_count = context.dig(:job, "retry_count")
+          # attempt 1 - retry_count is nil
+          # attempt 2 - this is your first retry so retry_count is 0
+          # attempt 3 - you have retried once, retry_count is 1
+          attempt = retry_count.nil? ? 1 : retry_count.to_i + 2
+
+          return if attempt < attempt_threshold
+        end
+
         Sentry::Sidekiq.capture_exception(
           ex,
           contexts: { sidekiq: context_filter.filtered },
@@ -37,7 +64,10 @@ module Sentry
         retry_option == true || (retry_option.is_a?(Integer) && retry_option.positive?)
       end
 
-      def retry_limit(context)
+      # @return [Integer] the number of retries allowed for the job
+      # Tries to fetch the retry limit from the job config first,
+      # then falls back to Sidekiq's configuration.
+      def retry_limit(context, sidekiq_config)
         limit = context.dig(:job, "retry")
 
         case limit
@@ -46,7 +76,11 @@ module Sentry
         when TrueClass
           max_retries =
             if WITH_SIDEKIQ_7
-              ::Sidekiq.default_configuration[:max_retries]
+              # Sidekiq 7.1.5+ passes the config to the error handler, so we should use that.
+              # Sidekiq 7.0 -> 7.1.5 provides ::Sidekiq.default_configuration.
+              sidekiq_config.is_a?(::Sidekiq::Config) ?
+                sidekiq_config[:max_retries] :
+                ::Sidekiq.default_configuration[:max_retries]
             else
               ::Sidekiq.options[:max_retries]
             end

data/lib/sentry/sidekiq/sentry_context_middleware.rb

@@ -1,11 +1,41 @@
-require 'sentry/sidekiq/context_filter'
+# frozen_string_literal: true
+
+require "sentry/sidekiq/context_filter"
 
 module Sentry
   module Sidekiq
+    module Helpers
+      def set_span_data(span, id:, queue:, latency: nil, retry_count: nil)
+        return unless span
+
+        span.set_data(Span::DataConventions::MESSAGING_MESSAGE_ID, id)
+        span.set_data(Span::DataConventions::MESSAGING_DESTINATION_NAME, queue)
+        span.set_data(Span::DataConventions::MESSAGING_MESSAGE_RECEIVE_LATENCY, latency) if latency
+        span.set_data(Span::DataConventions::MESSAGING_MESSAGE_RETRY_COUNT, retry_count) if retry_count
+      end
+
+      if ::Gem::Version.new(::Sidekiq::VERSION) >= ::Gem::Version.new("8.0.0")
+        def calculate_latency(job)
+          now_in_ms - job["enqueued_at"] if job["enqueued_at"]
+        end
+      else
+        def calculate_latency(job)
+          ((Time.now.to_f - job["enqueued_at"]) * 1000).round if job["enqueued_at"]
+        end
+      end
+
+      def now_in_ms
+        ::Process.clock_gettime(::Process::CLOCK_REALTIME, :millisecond)
+      end
+    end
+
     class SentryContextServerMiddleware
-      OP_NAME = "queue.sidekiq".freeze
+      include Sentry::Sidekiq::Helpers
+
+      OP_NAME = "queue.process"
+      SPAN_ORIGIN = "auto.queue.sidekiq"
 
-      def call(_worker, job, queue)
+      def call(worker, job, queue)
         return yield unless Sentry.initialized?
 
         context_filter = Sentry::Sidekiq::ContextFilter.new(job)
@@ -19,8 +49,21 @@ module Sentry
         scope.set_tags(build_tags(job["tags"]))
         scope.set_contexts(sidekiq: job.merge("queue" => queue))
         scope.set_transaction_name(context_filter.transaction_name, source: :task)
-        transaction = start_transaction(scope, job["sentry_trace"])
-        scope.set_span(transaction) if transaction
+        transaction = start_transaction(scope, job["trace_propagation_headers"])
+
+        if transaction
+          scope.set_span(transaction)
+
+          latency = calculate_latency(job)
+
+          set_span_data(
+            transaction,
+            id: job["jid"],
+            queue: queue,
+            latency: latency,
+            retry_count: job["retry_count"] || 0
+          )
+        end
 
         begin
           yield
@@ -39,9 +82,15 @@ module Sentry
         Array(tags).each_with_object({}) { |name, tags_hash| tags_hash[:"sidekiq.#{name}"] = true }
       end
 
-      def start_transaction(scope, sentry_trace)
-        options = { name: scope.transaction_name, source: scope.transaction_source, op: OP_NAME }
-        transaction = Sentry::Transaction.from_sentry_trace(sentry_trace, **options) if sentry_trace
+      def start_transaction(scope, env)
+        options = {
+          name: scope.transaction_name,
+          source: scope.transaction_source,
+          op: OP_NAME,
+          origin: SPAN_ORIGIN
+        }
+
+        transaction = Sentry.continue_trace(env, **options)
         Sentry.start_transaction(transaction: transaction, **options)
       end
 
@@ -54,14 +103,23 @@ module Sentry
     end
 
     class SentryContextClientMiddleware
-      def call(_worker_class, job, _queue, _redis_pool)
+      include Sentry::Sidekiq::Helpers
+
+      def call(worker_class, job, queue, _redis_pool)
         return yield unless Sentry.initialized?
 
         user = Sentry.get_current_scope.user
-        transaction = Sentry.get_current_scope.get_transaction
         job["sentry_user"] = user unless user.empty?
-        job["sentry_trace"] = transaction.to_sentry_trace if transaction
-        yield
+
+        if Sentry.configuration.sidekiq.propagate_traces
+          job["trace_propagation_headers"] ||= Sentry.get_trace_propagation_headers
+        end
+
+        Sentry.with_child_span(op: "queue.publish", description: worker_class.to_s) do |span|
+          set_span_data(span, id: job["jid"], queue: queue)
+
+          yield
+        end
       end
     end
   end

data/lib/sentry/sidekiq/version.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module Sentry
   module Sidekiq
-    VERSION = "5.10.0"
+    VERSION = "5.26.0"
   end
 end

data/lib/sentry/sidekiq-scheduler/scheduler.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+# Try to require sidekiq-scheduler to make sure it's loaded before the integration.
+begin
+  require "sidekiq-scheduler"
+rescue LoadError
+  return
+end
+
+# If we've loaded sidekiq-scheduler, but the API changed,
+# and the Scheduler class is not there, fail gracefully.
+return unless defined?(::SidekiqScheduler::Scheduler)
+
+module Sentry
+  module SidekiqScheduler
+    module Scheduler
+      def new_job(name, interval_type, config, schedule, options)
+        # Schedule the job upstream first
+        # SidekiqScheduler does not validate schedules
+        # It will fail with an error if the schedule in the config is invalid.
+        # If this errors out, let it fall through.
+        rufus_job = super
+
+        klass = config.fetch("class")
+        return rufus_job unless klass
+
+        # Constantize the job class, and fail gracefully if it could not be found
+        klass_const =
+          begin
+            Object.const_get(klass)
+          rescue NameError
+            return rufus_job
+          end
+
+        # For cron, every, or interval jobs — grab their schedule.
+        # Rufus::Scheduler::EveryJob stores it's frequency in seconds,
+        # so we convert it to minutes before passing in to the monitor.
+        monitor_config =
+          case interval_type
+          when "cron"
+            Sentry::Sidekiq::Cron::Helpers.monitor_config(schedule)
+          when "every", "interval"
+            Sentry::Cron::MonitorConfig.from_interval(rufus_job.frequency.to_i / 60, :minute)
+          end
+
+        # If we couldn't build a monitor config, it's either an error, or
+        # it's a one-time job (interval_type is in, or at), in which case
+        # we should not make a monitof for it automaticaly.
+        return rufus_job if monitor_config.nil?
+
+        # only patch if not explicitly included in job by user
+        unless klass_const.send(:ancestors).include?(Sentry::Cron::MonitorCheckIns)
+          klass_const.send(:include, Sentry::Cron::MonitorCheckIns)
+          slug = klass_const.send(:sentry_monitor_slug, name: name)
+          klass_const.send(:sentry_monitor_check_ins,
+                           slug: slug,
+                           monitor_config: monitor_config)
+
+          ::Sidekiq.logger.info "Injected Sentry Crons monitor checkins into #{klass}"
+        end
+
+        rufus_job
+      end
+    end
+  end
+end
+
+Sentry.register_patch(:sidekiq_scheduler, Sentry::SidekiqScheduler::Scheduler, ::SidekiqScheduler::Scheduler)

data/lib/sentry-sidekiq.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "sidekiq"
 require "sentry-ruby"
 require "sentry/integrable"
@@ -39,3 +41,8 @@ Sidekiq.configure_client do |config|
     chain.add Sentry::Sidekiq::SentryContextClientMiddleware
   end
 end
+
+# patches
+require "sentry/sidekiq/cron/helpers"
+require "sentry/sidekiq/cron/job"
+require "sentry/sidekiq-scheduler/scheduler"

data/sentry-sidekiq.gemspec

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative "lib/sentry/sidekiq/version"
 
 Gem::Specification.new do |spec|
@@ -7,21 +9,27 @@ Gem::Specification.new do |spec|
   spec.description = spec.summary = "A gem that provides Sidekiq integration for the Sentry error logger"
   spec.email = "accounts@sentry.io"
   spec.license = 'MIT'
-  spec.homepage = "https://github.com/getsentry/sentry-ruby"
 
   spec.platform = Gem::Platform::RUBY
   spec.required_ruby_version = '>= 2.4'
   spec.extra_rdoc_files = ["README.md", "LICENSE.txt"]
-  spec.files = `git ls-files | grep -Ev '^(spec|benchmarks|examples)'`.split("\n")
+  spec.files = `git ls-files | grep -Ev '^(spec|benchmarks|examples|\.rubocop\.yml)'`.split("\n")
+
+  github_root_uri = 'https://github.com/getsentry/sentry-ruby'
+  spec.homepage = "#{github_root_uri}/tree/#{spec.version}/#{spec.name}"
 
-  spec.metadata["homepage_uri"] = spec.homepage
-  spec.metadata["source_code_uri"] = spec.homepage
-  spec.metadata["changelog_uri"] = "#{spec.homepage}/blob/master/CHANGELOG.md"
+  spec.metadata = {
+    "homepage_uri" => spec.homepage,
+    "source_code_uri" => spec.homepage,
+    "changelog_uri" => "#{github_root_uri}/blob/#{spec.version}/CHANGELOG.md",
+    "bug_tracker_uri" => "#{github_root_uri}/issues",
+    "documentation_uri" => "http://www.rubydoc.info/gems/#{spec.name}/#{spec.version}"
+  }
 
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "sentry-ruby", "~> 5.10.0"
+  spec.add_dependency "sentry-ruby", "~> 5.26.0"
   spec.add_dependency "sidekiq", ">= 3.0"
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: sentry-sidekiq
 version: !ruby/object:Gem::Version
-  version: 5.10.0
+  version: 5.26.0
 platform: ruby
 authors:
 - Sentry Team
-autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-07-04 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sentry-ruby
@@ -16,14 +15,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 5.10.0
+        version: 5.26.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 5.10.0
+        version: 5.26.0
 - !ruby/object:Gem::Dependency
   name: sidekiq
   requirement: !ruby/object:Gem::Requirement
@@ -43,8 +42,8 @@ email: accounts@sentry.io
 executables: []
 extensions: []
 extra_rdoc_files:
-- README.md
 - LICENSE.txt
+- README.md
 files:
 - ".gitignore"
 - ".rspec"
@@ -61,20 +60,24 @@ files:
 - example/config/sidekiq.yml
 - example/error_worker.rb
 - lib/sentry-sidekiq.rb
+- lib/sentry/sidekiq-scheduler/scheduler.rb
 - lib/sentry/sidekiq/configuration.rb
 - lib/sentry/sidekiq/context_filter.rb
+- lib/sentry/sidekiq/cron/helpers.rb
+- lib/sentry/sidekiq/cron/job.rb
 - lib/sentry/sidekiq/error_handler.rb
 - lib/sentry/sidekiq/sentry_context_middleware.rb
 - lib/sentry/sidekiq/version.rb
 - sentry-sidekiq.gemspec
-homepage: https://github.com/getsentry/sentry-ruby
+homepage: https://github.com/getsentry/sentry-ruby/tree/5.26.0/sentry-sidekiq
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://github.com/getsentry/sentry-ruby
-  source_code_uri: https://github.com/getsentry/sentry-ruby
-  changelog_uri: https://github.com/getsentry/sentry-ruby/blob/master/CHANGELOG.md
-post_install_message: 
+  homepage_uri: https://github.com/getsentry/sentry-ruby/tree/5.26.0/sentry-sidekiq
+  source_code_uri: https://github.com/getsentry/sentry-ruby/tree/5.26.0/sentry-sidekiq
+  changelog_uri: https://github.com/getsentry/sentry-ruby/blob/5.26.0/CHANGELOG.md
+  bug_tracker_uri: https://github.com/getsentry/sentry-ruby/issues
+  documentation_uri: http://www.rubydoc.info/gems/sentry-sidekiq/5.26.0
 rdoc_options: []
 require_paths:
 - lib
@@ -89,8 +92,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
-signing_key: 
+rubygems_version: 3.6.7
 specification_version: 4
 summary: A gem that provides Sidekiq integration for the Sentry error logger
 test_files: []