sentry-ruby-core 7.1.0 → 7.2.0

data/lib/sentry/cron/slug.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Sentry
+  module Cron
+    module Slug
+      module_function
+
+      # Returns nil when nothing usable is left.
+      def from(name)
+        slug = name.to_s.downcase.gsub(/[^a-z0-9_-]+/, "-").sub(/\A-+/, "")
+        slug = slug[0, MonitorCheckIns::MAX_SLUG_LENGTH]
+        # rindex instead of /-+\z/, which backtracks on long runs of dashes.
+        last = slug.rindex(/[^-]/)
+        last && slug[0..last]
+      end
+    end
+  end
+end

data/lib/sentry/data_collection.rb

@@ -131,6 +131,7 @@ module Sentry
     def self.backfill(configuration)
       data_collection = new
       data_collection.backfill_stack_frame_variables(configuration)
+      data_collection.backfill_frame_context_lines(configuration)
       return data_collection if configuration.send_default_pii
 
       # TODO-neel-data map to exact ruby behaviour for backwards compat behavior
@@ -146,7 +147,6 @@ module Sentry
       data_collection.graphql.variables = false
       data_collection.database_query_data = false
       data_collection.queues = false
-      data_collection.frame_context_lines = configuration.context_lines
       data_collection
     end
 
@@ -171,6 +171,11 @@ module Sentry
       self.stack_frame_variables = configuration.include_local_variables
     end
 
+    # Copies the legacy context_lines configuration.
+    def backfill_frame_context_lines(configuration)
+      self.frame_context_lines = configuration.context_lines
+    end
+
     # Returns whether stack frame local variables should be captured.
     def collect_stack_frame_variables?
       stack_frame_variables.mode != :off

data/lib/sentry/rufus_scheduler.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Sentry
+  # Sends Crons check-ins for rufus-scheduler `cron`, `every` and `interval` jobs.
+  # Enable with `config.enabled_patches << :rufus_scheduler`.
+  module RufusScheduler
+    module Job
+      protected
+
+      def do_call(time, do_rescue)
+        return super unless Sentry.initialized? && (monitor = sentry_monitor)
+
+        slug, monitor_config = monitor
+        check_in_id = Sentry.capture_check_in(slug, :in_progress, monitor_config: monitor_config)
+        start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+        begin
+          # Run without rufus's rescue so the error is seen, then handle it like Job#do_call.
+          ret = super(time, false)
+        rescue Exception => e
+          duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
+          Sentry.capture_check_in(slug, :error, check_in_id: check_in_id, duration: duration, monitor_config: monitor_config)
+
+          raise unless do_rescue && e.is_a?(StandardError)
+          return if e.is_a?(::Rufus::Scheduler::Job::KillSignal)
+
+          return @scheduler.on_error(self, e)
+        end
+
+        duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
+        Sentry.capture_check_in(slug, :ok, check_in_id: check_in_id, duration: duration, monitor_config: monitor_config)
+
+        ret
+      end
+
+      private
+
+      def sentry_monitor
+        return @sentry_monitor if defined?(@sentry_monitor)
+
+        @sentry_monitor = Sentry::RufusScheduler.monitor_for(self)
+      rescue StandardError => e
+        Sentry.sdk_logger.error(Sentry::LOGGER_PROGNAME) { "Not monitoring rufus-scheduler job #{id}: #{e.class}: #{e.message}" }
+        @sentry_monitor = nil
+      end
+    end
+
+    class << self
+      # Returns [slug, monitor_config], or nil for jobs that aren't monitored (like `at`/`in`).
+      def monitor_for(job)
+        return unless job.is_a?(::Rufus::Scheduler::RepeatJob)
+        return if job.opts[:sentry_monitor] == false
+        return if sidekiq_scheduler_job?(job)
+
+        slug = slug_for(job)
+        unless slug
+          Sentry.sdk_logger.warn(Sentry::LOGGER_PROGNAME) do
+            "Not monitoring rufus-scheduler job #{job.id} at #{job.source_location&.join(":")}: " \
+              "pass `name:` to give it a stable monitor slug."
+          end
+          return
+        end
+
+        [slug, monitor_config_for(job)]
+      end
+
+      private
+
+      # sidekiq-scheduler jobs are monitored by the :sidekiq_scheduler patch.
+      def sidekiq_scheduler_job?(job)
+        file, _ = job.callable.source_location if job.callable.respond_to?(:source_location)
+        file&.end_with?("sidekiq-scheduler/scheduler.rb")
+      end
+
+      # Job ids are random per process and block paths change between deploys,
+      # so the slug comes from `name:`, then the handler method or class.
+      def slug_for(job)
+        handler = job.handler
+        source =
+          if job.name
+            job.name.to_s
+          elsif handler.is_a?(Method)
+            # The receiver's class, not the method owner, so inherited and mixin methods get distinct slugs.
+            namespace = handler.receiver.is_a?(Module) ? handler.receiver : handler.receiver.class
+            [namespace == Object ? nil : namespace.name, handler.name].compact.join("::")
+          elsif !handler.is_a?(Proc)
+            handler.class.name
+          end
+        return unless source
+
+        Sentry::Cron::Slug.from(source)
+      end
+
+      def monitor_config_for(job)
+        case job
+        when ::Rufus::Scheduler::CronJob
+          Sentry::Cron::FugitSchedule.from_cron(job.cron_line)
+        when ::Rufus::Scheduler::EveryJob
+          Sentry::Cron::FugitSchedule.from_seconds(job.frequency)
+        end
+        # IntervalJob waits `interval` after each run ends, so it has no fixed
+        # schedule to monitor against.
+      end
+    end
+  end
+end
+
+Sentry.register_patch(:rufus_scheduler) do |config|
+  # Load rufus-scheduler in case it's required after Sentry.init.
+  begin
+    require "rufus-scheduler"
+  rescue LoadError
+  end
+
+  if defined?(::Rufus::Scheduler::RepeatJob)
+    ::Rufus::Scheduler::Job.prepend(Sentry::RufusScheduler::Job) unless ::Rufus::Scheduler::Job.ancestors.include?(Sentry::RufusScheduler::Job)
+  else
+    config.sdk_logger.warn(Sentry::LOGGER_PROGNAME) { "You tried to enable the rufus-scheduler integration but the `rufus-scheduler` gem was not detected." }
+  end
+end

data/lib/sentry/transport/debug_transport.rb

@@ -27,6 +27,11 @@ module Sentry
       backend.send_event(event)
     end
 
+    def send_envelope(envelope)
+      log_envelope(envelope)
+      backend.send_envelope(envelope)
+    end
+
     def log_envelope(envelope)
       envelope_json = {
         timestamp: Time.now.utc.iso8601,
@@ -36,13 +41,13 @@ module Sentry
         end
       }
 
-      File.open(log_file, "a") { |file| file << JSON.dump(envelope_json) << "\n" }
+      File.open(log_file, "a") { |file| file.write("#{JSON.dump(envelope_json)}\n") }
     end
 
     def logged_envelopes
       return [] unless File.exist?(log_file)
 
-      File.readlines(log_file).map do |line|
+      File.readlines(log_file).select { |line| fully_written?(line) }.map do |line|
         JSON.parse(line)
       end
     end
@@ -54,6 +59,10 @@ module Sentry
 
     private
 
+    def fully_written?(line)
+      line.end_with?("\n")
+    end
+
     def initialize_backend(configuration)
       backend = configuration.dsn.local? ? DummyTransport : HTTPTransport
       backend.new(configuration)

data/lib/sentry/transport/dummy_transport.rb

@@ -8,22 +8,25 @@ module Sentry
       super
       @events = []
       @envelopes = []
+      @mutex = Mutex.new
     end
 
     def send_event(event)
-      @events << event
+      @mutex.synchronize { @events << event }
       super
     end
 
     def send_envelope(envelope)
-      @envelopes << envelope
+      @mutex.synchronize { @envelopes << envelope }
     end
 
     # Empties the captured events and envelopes so `TestHelper.clear_sentry_events`
     # also clears the dummy transport instance
     def clear
-      @events.clear
-      @envelopes.clear
+      @mutex.synchronize do
+        @events.clear
+        @envelopes.clear
+      end
     end
   end
 end

data/lib/sentry/transport/spotlight_transport.rb

@@ -39,11 +39,11 @@ module Sentry
       @failed += 1
     end
 
-    # Similar to HTTPTransport connection, but does not support Proxy and SSL
+    # Similar to HTTPTransport connection, but does not support Proxy
     def conn
       sidecar = URI(@sidecar_url)
       connection = ::Net::HTTP.new(sidecar.hostname, sidecar.port, nil)
-      connection.use_ssl = false
+      connection.use_ssl = sidecar.scheme == "https"
       connection
     end
   end

data/lib/sentry/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Sentry
-  VERSION = "7.1.0"
+  VERSION = "7.2.0"
 end

data/lib/sentry-ruby.rb

@@ -27,6 +27,8 @@ require "sentry/threaded_periodic_worker"
 require "sentry/session_flusher"
 require "sentry/backpressure_monitor"
 require "sentry/cron/monitor_check_ins"
+require "sentry/cron/fugit_schedule"
+require "sentry/cron/slug"
 require "sentry/vernier/profiler"
 require "sentry/metrics"
 
@@ -793,3 +795,4 @@ require "sentry/graphql"
 require "sentry/faraday"
 require "sentry/excon"
 require "sentry/std_lib_logger"
+require "sentry/rufus_scheduler"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sentry-ruby-core
 version: !ruby/object:Gem::Version
-  version: 7.1.0
+  version: 7.2.0
 platform: ruby
 authors:
 - Sentry Team
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 7.1.0
+        version: 7.2.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 7.1.0
+        version: 7.2.0
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
   requirement: !ruby/object:Gem::Requirement
@@ -102,9 +102,11 @@ files:
 - lib/sentry/core_ext/object/deep_dup.rb
 - lib/sentry/core_ext/object/duplicable.rb
 - lib/sentry/cron/configuration.rb
+- lib/sentry/cron/fugit_schedule.rb
 - lib/sentry/cron/monitor_check_ins.rb
 - lib/sentry/cron/monitor_config.rb
 - lib/sentry/cron/monitor_schedule.rb
+- lib/sentry/cron/slug.rb
 - lib/sentry/data_collection.rb
 - lib/sentry/data_collection/key_value_collection.rb
 - lib/sentry/debug_structured_logger.rb
@@ -146,6 +148,7 @@ files:
 - lib/sentry/redis.rb
 - lib/sentry/release_detector.rb
 - lib/sentry/rspec.rb
+- lib/sentry/rufus_scheduler.rb
 - lib/sentry/scope.rb
 - lib/sentry/sequel.rb
 - lib/sentry/session.rb